1. C# / Говнокод #12153

    +119

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    public static Tuple<t1, t2,="" t3,="" t4,="" t5,="" t6,="" t7,="" tuple=""><t8>> Create<t1, t2,="" t3,="" t4,="" t5,="" t6,="" t7,="" t8="">(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, T8 item8) {
            return new Tuple<t1, t2,="" t3,="" t4,="" t5,="" t6,="" t7,="" tuple=""><t8>>(item1, item2, item3, item4, item5, item6, item7, new Tuple<t8>(item8));

   Int32 IStructuralEquatable.GetHashCode(IEqualityComparer comparer) {
            // We want to have a limited hash in this case.  We'll use the last 8 elements of the tuple
            ITuple t = (ITuple) m_Rest;
            if(t.Size >= 8) { return t.GetHashCode(comparer); }
 
            // In this case, the rest memeber has less than 8 elements so we need to combine some our elements with the elements in rest
            int k = 8 - t.Size;
            switch(k) {
                case 1:
                return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item7), t.GetHashCode(comparer));
                case 2:
                return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item6), comparer.GetHashCode(m_Item7), t.GetHashCode(comparer));
                case 3:
                return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item5), comparer.GetHashCode(m_Item6), comparer.GetHashCode(m_Item7), t.GetHashCode(comparer));
                case 4:
                return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item4), comparer.GetHashCode(m_Item5), comparer.GetHashCode(m_Item6), comparer.GetHashCode(m_Item7), t.GetHashCode(comparer));
                case 5:
                return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item3), comparer.GetHashCode(m_Item4), comparer.GetHashCode(m_Item5), comparer.GetHashCode(m_Item6), comparer.GetHashCode(m_Item7), t.GetHashCode(comparer));
                case 6:
                return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item2), comparer.GetHashCode(m_Item3), comparer.GetHashCode(m_Item4), comparer.GetHashCode(m_Item5), comparer.GetHashCode(m_Item6), comparer.GetHashCode(m_Item7), t.GetHashCode(comparer));
                case 7:
                return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item1), comparer.GetHashCode(m_Item2), comparer.GetHashCode(m_Item3), comparer.GetHashCode(m_Item4), comparer.GetHashCode(m_Item5), comparer.GetHashCode(m_Item6), comparer.GetHashCode(m_Item7), t.GetHashCode(comparer));
            }
            Contract.Assert(false, "Missed all cases for computing Tuple hash code");
            return -1;
        }
 
        Int32 ITuple.GetHashCode(IEqualityComparer comparer) {
            return ((IStructuralEquatable) this).GetHashCode(comparer);
        }
        public override string ToString() {
            StringBuilder sb = new StringBuilder();
            sb.Append("(");
            return ((ITuple)this).ToString(sb);
        }
 
        string ITuple.ToString(StringBuilder sb) {
            sb.Append(m_Item1);
            sb.Append(", ");
            sb.Append(m_Item2);
            sb.Append(", ");
            sb.Append(m_Item3);
            sb.Append(", ");
            sb.Append(m_Item4);
            sb.Append(", ");
            sb.Append(m_Item5);
            sb.Append(", ");
            sb.Append(m_Item6);
            sb.Append(", ");
            sb.Append(m_Item7);
            sb.Append(", ");
            return ((ITuple)m_Rest).ToString(sb);
        }

    Давно заприметил в C# кортежи. За них отвечаёт чудесный класс System.Tuple
    http://msdn.microsoft.com/en-us/library/system.tuple.aspx
    Вот стало интересно - как они там это дело реализовали, ведь постоянно вводит новые плюшки в язык.
    Посмотрел и ужаснулся - решили "в лоб" и кортежи обошлись в 1000 строк.
    http://reflector.webtropy.com/default.aspx/4@0/4@0/untmp/DEVDIV_TFS/Dev10/Releases/RTMRel/ndp/clr/src/BCL/System/Tuple@cs/1305376/Tuple@cs

    Хотел запостить в #12129. Но он утонул.

    Запостил: 3.14159265, 19 Ноября 2012

    Комментарии (5) RSS

    • ava LispGovno 20.11.2012 00:30 # +3

      Самые отвратительные туплы, что я когда-либо видел в стандартной библиотеке. Думаю майкросовтовцам до сих пор стыдно... я надеюсь.
      Ответить

      • ava 3.14159265 20.11.2012 15:43 # +2

        Просто интересно - неужели нельзя было сделать чуточку умнее. Ведь в C# есть анонимные типы и много других плюшек.
        Та даже просто - сделать метод toArray() и заменить всю копипасту обработкой массивов.
        Ответить

        • ava phoenixx 20.11.2012 18:42 # 0

          Анонимные типы на то и анонимные, их типизировано дальше одного метода не передашь.

          Копипаста забавная, хотя она вполне может быть сгенеренной через T4 шаблоны
          Ответить

      • ava 3.14159265 21.11.2012 00:13 # +3

        >майкросовтовцам до сих пор стыдно...
        Так они сравнительно недавно фичу добавили - .NET 4.
        >Анонимные типы на то и анонимные, их типизировано дальше одного метода не передашь.
        Я плохо знаю решетку, но разве нет способа (хака) чтобы сделать туплы более-менее кошерно, а не в стиле "джавист-копипастер, пересевший с пхп".
        Ответить

    Добавить комментарий