Будет ли будущая версия of.NET поддержка кортежей в C#?

#region tuples

    public class Tuple<T>
    {
        public Tuple(T first)
        {
            First = first;
        }

        public T First { get; set; }
    }

    public class Tuple<T, T2> : Tuple<T>
    {
        public Tuple(T first, T2 second)
            : base(first)
        {
            Second = second;
        }

        public T2 Second { get; set; }
    }

    public class Tuple<T, T2, T3> : Tuple<T, T2>
    {
        public Tuple(T first, T2 second, T3 third)
            : base(first, second)
        {
            Third = third;
        }

        public T3 Third { get; set; }
    }

    public class Tuple<T, T2, T3, T4> : Tuple<T, T2, T3>
    {
        public Tuple(T first, T2 second, T3 third, T4 fourth)
            : base(first, second, third)
        {
            Fourth = fourth;
        }

        public T4 Fourth { get; set; }
    }

    #endregion

и сделать объявления красивее:

public static class Tuple
{
    //Allows Tuple.New(1, "2") instead of new Tuple<int, string>(1, "2")
    public static Tuple<T1, T2> New<T1, T2>(T1 t1, T2 t2)
    {
        return new Tuple<T1, T2>(t1, t2);
    }
    //etc...
}

есть правильный (не быстрая) Кортеж C# реализации в Lokad Shared Libraries (С открытым исходным кодом, конечно), который включает в себя следующие необходимые функции:

• 2-5 неизменных реализаций кортежа!--10-->
• Правильный DebuggerDisplayAttribute
• правильное хэширование и проверка равенства
• помощники для генерации кортежей из предоставленных параметров (обобщения выводятся компилятором) и расширений для операций на основе сбора данных.
• производство-испытания.

реализация классов кортежей или повторное использование классов F# в C# - это только половина истории-они дают вам возможность создавать кортежи с относительной легкостью, но не совсем синтаксический сахар, который делает их такими приятными для использования в таких языках, как F#.

например, в F# вы можете использовать сопоставление шаблонов для извлечения обеих частей кортежа в состоянии let, например

let (a, b) = someTupleFunc

к сожалению, сделать то же самое с помощью классов F# из C# было бы намного меньше элегантный:

Tuple<int,int> x = someTupleFunc();
int a = x.get_Item1();
int b = x.get_Item2();

кортежи представляют собой мощный метод для возврата нескольких значений из вызова функции без необходимости засорять ваш код одноразовыми классами или прибегать к уродливым параметрам ref или out. Однако, на мой взгляд, без некоторого синтаксического сахара, чтобы сделать их создание и доступ более элегантными, они имеют ограниченное применение.

на мой взгляд, функция анонимных типов-это не Кортеж, а очень похожая конструкция. Выходные данные некоторых запросов LINQ-это коллекции анонимных типов, которые ведут себя как кортежи.

вот оператор, который создает типизированный Кортеж : -) на лету:

var p1 = new {a = "A", b = 3};

см.:http://www.developer.com/net/csharp/article.php/3589916

в C# 7 поддерживает кортежи изначально:

var unnamedTuple = ("Peter", 29);
var namedTuple = (Name: "Peter", Age: 29);
(string Name, double Age) typedTuple = ("Peter", 29);

My open source .NET библиотека Sasa имеет кортежи в течение многих лет (наряду с большим количеством других функций, таких как полный анализ MIME). Я использую его в производственном коде уже несколько лет.

C# поддерживает простые кортежи через дженерики довольно легко (согласно более раннему ответу), и с "Mumble typing" (одним из многих возможных улучшений языка C#) для улучшения вывода типа они могут быть очень, очень мощными.

для чего это стоит, F# поддерживает кортежи изначально, и, сыграв с ним, я не уверен, что (анонимные) кортежи добавляют много... то, что вы получаете в краткости вы теряете очень быстро в ясности кода.

для кода в одном методе, существуют анонимные типы; для кода, выходящего за пределы метода, я думаю, что буду придерживаться простых именованных типов. Конечно, если будущий C# облегчит создание этих неизменяемых (в то время как с ними все еще легко работать), я буду счастлив.

вот мой набор кортежей, они автоматически генерируются скриптом Python, поэтому я, возможно, немного переборщил:

ссылка на репозиторий Subversion

вам понадобится имя пользователя / пароль, они оба гость

они основаны на наследство, но Tuple<Int32,String> не будет сравнивать равным Tuple<Int32,String,Boolean> даже если они имеют одинаковые значения для двух первых членов.

они также реализуют GetHashCode и ToString и и так далее, и множество мелких вспомогательных методов.

пример использования:

Tuple<Int32, String> t1 = new Tuple<Int32, String>(10, "a");
Tuple<Int32, String, Boolean> t2 = new Tuple<Int32, String, Boolean>(10, "a", true);
if (t1.Equals(t2))
    Console.Out.WriteLine(t1 + " == " + t2);
else
    Console.Out.WriteLine(t1 + " != " + t2);

вывод:

10, a != 10, a, True

Если я правильно помню мои классы информатики кортежи-это просто данные.

Если вы хотите сгруппировать данные-создайте классы, содержащие свойства. Если вам нужно что-то вроде KeyValuePair то есть это.

Я был бы удивлен-C# является строго типизированным языком, в то время как кортежи подходят для более динамически типизированных языков. C# дрейфует более динамично с течением времени, но это синтаксический сахар, а не реальный сдвиг в базовых типах данных.

Если вы хотите два значения в одном экземпляре, KeyValuePair является достойной заменой, хотя и неуклюжей. Вы также можете создать структуру или класс, который будет делать то же самое и расширяться.

чтобы сделать их полезными в хеш-таблице или словаре, вы, вероятно, захотите предоставить перегрузки для GetHashCode и Equals.