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

Question

.Net 3.5 не поддерживает кортежи. Жаль, но не уверен, будет ли будущая версия .net поддерживать кортежи или нет?

Answer 1

Я только что прочитал эту статью из журнала MSDN: Building Tuple

Вот выдержки:

Предстоящий 4.0 выпуск Microsoft .NET Framework представляет новый тип называется System.Tuple. System.Tuple является коллекция фиксированного размера неоднородно типизированные данные.

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

1017 *

Уже есть один пример кортеж плавает вокруг Microsoft .NET Framework, в System.Collections.Generic namespace: KeyValuePair. Хотя KeyValuePair можно рассматривать как одно и то же как Tuple, так как они оба типы, которые содержат две вещи, KeyValuePair чувствует себя отличным от Кортеж, потому что это вызывает отношения между двумя значениями, которые он хранит (и не без оснований, поскольку он поддерживает Словарный класс).

Кроме того, кортежи могут быть произвольно размер, тогда как KeyValuePair содержит только две вещи: ключ и значение.

---

Хотя некоторые языки, такие как F #, имеют специальный синтаксис для кортежей, вы можете использовать новый общий тип кортежа из любого языка. Возвращаясь к первому примеру, мы видим, что, несмотря на полезность, кортежи могут быть слишком многословными в языках без синтаксиса для кортежа:

class Program {
    static void Main(string[] args) {
        Tuple<string, int> t = new Tuple<string, int>("Hello", 4);
        PrintStringAndInt(t.Item1, t.Item2);
    }
    static void PrintStringAndInt(string s, int i) {
        Console.WriteLine("{0} {1}", s, i);
    }
}

Используя ключевое слово var из C # 3.0, мы можем удалить сигнатуру типа в переменной tuple, что позволяет получить несколько более читаемый код.

var t = new Tuple<string, int>("Hello", 4);

Мы также добавили некоторые фабричные методы в статический класс Tuple, который облегчает создание кортежей на языке, который поддерживает вывод типов, например C #.

var t = Tuple.Create("Hello", 4);

Answer 2

#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...
}

Answer 3

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

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

Answer 4

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

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

let (a, b) = someTupleFunc

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

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

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

Answer 5

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

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

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

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

Answer 6

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

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

Answer 7

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

Answer 8

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

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

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

Answer 9

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

Ссылка на хранилище Subversion

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

Они основаны на наследовании, но 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

Answer 10

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

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