Tuple c что это
Кортежи предоставляют удобный способ для работы с набором значений, который был добавлен в версии C# 7.0.
Кортеж представляет набор значений, заключенных в круглые скобки:
var tuple = (5, 10);
В данном случае определен кортеж tuple, который имеет два значения: 5 и 10. В дальнейшем мы можем обращаться к каждому из этих значений через поля с названиями:
Item[порядковый_номер_поля_в_кортеже]
var tuple = (5, 10); Console.WriteLine(tuple.Item1); // 5 Console.WriteLine(tuple.Item2); // 10 tuple.Item1 += 26; Console.WriteLine(tuple.Item1); // 31
В данном случае тип определяется неявно. Но мы также можем явным образом указать для переменной кортежа тип:
(int, int) tuple = (5, 10);
Так как кортеж содержит два числа, то в определении типа нам надо указать два числовых типа. Или другой пример определения кортежа:
(string, int, double) person = ("Tom", 25, 81.23);
Первый элемент кортежа в данном случае представляет строку, второй элемент — тип int, а третий — тип double.
Мы также можем дать названия полям кортежа:
var tuple = (count:5, sum:10); Console.WriteLine(tuple.count); // 5 Console.WriteLine(tuple.sum); // 10
Теперь чтобы обратиться к полям кортежа используются их имена, а не названия Item1 и Item2.
Мы даже можем выполнить декомпозицию кортежа на отдельные переменные:
var (name, age) = ("Tom", 23); Console.WriteLine(name); // Tom Console.WriteLine(age); // 23
Одной из задач, которую позволяет элегантно решить кортеж — это обмен значениями:
string main = "Java"; string second = "C#"; (main, second) = (second, main); Console.WriteLine(main); // C# Console.WriteLine(second); // Java
Что можно использовать, например, при простейшей сортировке массива:
int[] nums = < 54, 7, -41, 2, 4, 2, 89, 33, -5, 12 >; // сортировка for (int i = 0; i < nums.Length - 1; i++) < for (int j = i + 1; j < nums.Length; j++) < if (nums[i] >nums[j]) (nums[i], nums[j]) =(nums[j], nums[i]); > > // вывод Console.WriteLine(«Вывод отсортированного массива»); for (int i = 0; i
Кортеж как результат метода
Кортежи могут выступать в качестве результата функции. Например, одной из распространенных ситуаций является возвращение из функции двух и более значений, в то время как функция может возвращать только одно значение. И кортежи представляют оптимальный способ для решения этой задачи:
var tuple = GetValues(); Console.WriteLine(tuple.Item1); // 1 Console.WriteLine(tuple.Item2); // 3 (int, int) GetValues()
Здесь определен метод GetValues() , который возвращает кортеж. Кортеж определяется как набор значений, помещенных в круглые скобки. И в данном случае мы возвращаем кортеж из двух элементов типа int, то есть два числа.
var tuple = GetValuesData(new int[] < 1, 2, 3, 4, 5, 6, 7 >); Console.WriteLine(tuple.count); Console.WriteLine(tuple.sum); (int sum, int count) GetValuesData(int[] numbers) < var result = (sum: 0, count: numbers.Length); foreach(var n in numbers) < result.sum += n; >return result; >
Кортеж как параметр метода
И также кортеж может передаваться в качестве параметра в метод:
PrintPerson(("Tom", 37)); // Tom - 37 PrintPerson(("Bob", 41)); // Bob - 41 void PrintPerson((string name, int age) person) < Console.WriteLine($"- "); >
Здесь в метод PrintPerson передается кортеж из двух элементов, первый из которых предоставляет строку, а второй — значение типа int.
Кортежи std::tuple в C++
Этот пост долгое время лежал в черновиках и, по всей видимости, это был вольный перевод одной из статей(ссылки ниже) о классе std::tuple<> C++. Идея перевода возникла спонтанно, в необходимости понимания сложности работы с этим классом. До C++0x неплохим, но все-таки усложняющим решением являлось использование более сложных структур в качестве хранилища для многих переменных(вдобавок, написание таких структур).
Текущее решение с кортежами и связкой tie/make_tuple выглядит более красиво и, для начала, с успехом позволит прототипировать код, в котором появляется необходимость в использовании кортежей.
Кортеж — коллекция элементов с фиксированным размером. Любая связанная пара, тройка, четверка и т.д элементов является кортежем. В качестве элементов кортежа могут выступать переменные произвольного типа.
Кортежи можно создавать, сравнивать, распаковывать. Фактически это всё что нужно для работы с кортежами. Но некоторые языки позволяют менять значения в элементах кортежей.
Во многих случаях удобно использование кортежи. Например, кортежи позволяют легко определять и работать с функциями, возвращающими одно или более значений.
Многие языки программирования, такие как Python, Haskell, Erlang и др. имеют встроенные кортежи. Однако, C++ не имеет встроенных кортежей.
Кортежи в C++
Первая реализация кортежей для C++ появилась в библиотеке boost в 2003 году.
Необходимость включения кортежей в основной стандарт подтверждается и тем, что они были включены в состав Technical Report 1 C++(TR1), реализация tr1 появилась в VS 2008 в составе Visual C++ 2008 Feature Pack Release в пространстве имен std::tr1, в VS 2010 кортежи уже включены по умолчанию и входят в стандартное пространство имен std. В стандарте C++0X кортежи входят в пространство имен std.
В C++ сохранились основные свойства, присущие кортежам — их можно создавать, сравнивать и распаковывать. Кроме того, значения C++ кортежей можно менять. Кортежи описываются шаблонным классом std::tuple<> в заголовочном файле , параметры специализации которого — перечисление всех типов переменных кортежа.
Создание кортежа
Путем инстанцирования шаблона std::tuple<> можно создавать кортежи :
std::tupleint> t1; std::tupleint, std::string> t2;Можно также задавать значения у элементов кортежа путем их последовательного перечисления в конструкторе :
std::tupleint> t1(1); std::tupleint, std::string> t2(1, "hello");Если элемент кортежа является ссылочным типом, то его значение должно быть определено :
std::tupledouble&> t(); // error double d = 5; std::tupledouble&> t(d); // okФункция make_tuple упрощает создание кортежей, причем специализацию шаблона возвращаемого кортежа в ряде случаев можно указать один раз :
std::tupleint, int, double> add_multiply_divide(int a, int b) return std::make_tuple(a+b, a*b, double(a)/double(b)); >Если функция make_tuple принимает ссылочное значение, то оно приводится к обычному нессылочному значению
const A& a; B& a; std::make_tuple(a, b); // результат - tupleA, B>При помощи использования функций cref и ref в make_tuple можно добиться создания кортежа, в котором элементы являются ссылками :
const A& a; B& a; std::make_tuple(cref(a), ref(b)); // результат - tupleconst A&, B&>Доступ к элементам кортежа
Получить n-й элемент кортежа t можно двумя способами
t.getn>(); // или getn>(t);В C++ также допустимо изменение значений элементов кортежа, хотя в ряде языков это запрещено
get1>(t) = 3.14; // ok t.get1>() = 3.14; // okСтоит не забывать, что тип изменяемого элемента должен быть изменяемым, т.е. не содержать модификатор const и иметь открытый оператор =.
Шаблонный класс std::tuple<> позволяет менять содержимое кортежа путем использования оператора равенства(operator =), но количество параметров в специализациях копируемых кортежей должно строго совпадать :
class A <>; class B : public A <>; struct C C(); C(const B&); >; struct D operator C() const; >; std::tuplechar, B*, B, D> t; . std::tupleint, A*, C, C> a; . a = t; // okВ примере выше произойдет конвертация int -> char и B* -> A(т.к. A является полиморфным). Если конвертация типа не возможна, произойдет ошибка на этапе компиляции.
Старый кортеж можно скопировать в новый кортеж путем использования конструктора копий :
std::tuplechar, int> t; . std::tuplechar, int> a(t); // okРаспаковка кортежа и получение значений некоторых элементов
Распаковка(unpacking) — одна из основных, часто используемых функциональных возможностей кортежей. Распаковка позваоляет получать из кортежа сразу несколько значений в отдельные переменные, с которыми дальше проще работать.
Для распаковки используется специальная шаблонная функция std::tie, которой передаются переменные, которым необходимо присвоить значения из кортежа.
Для примера, теперь мы можем написать функцию swap в одну строчку :
int a = 10, b = 0; std::tie(a, b) = std::make_tuple(b, a);В принципе, в использовании подобной конструкции и заключается преимущество кортежей — посколько с правой стороны мог стоять вызов какой-то другой функции, возвращающей тип tuple. Нужно это или нет — другой вопрос, зависящий от конкретного кода, потому что всегда были и будут альтернативные подходы — изменяемые параметры функций вида pass by reference, а также какие-то внешние обертки для сохранения внутреннего состояния(структуры, классы, пространства имён).
- blog.. not another yet
This is not an awesome description fot dat site.
Функции для работы с кортежами
Функция, позволяющая сгруппировать несколько столбцов. Для столбцов, имеющих типы T1, T2, … возвращает кортеж типа Tuple(T1, T2, …), содержащий эти столбцы. Выполнение функции ничего не стоит. Кортежи обычно используются как промежуточное значение в качестве аргумента операторов IN, или для создания списка формальных параметров лямбда-функций. Кортежи не могут быть записаны в таблицу.
С помощью функции реализуется оператор (x, y, …) .
Синтаксис
tuple(x, y, …) tupleElement
Функция, позволяющая достать столбец из кортежа. N — индекс столбца начиная с 1. N должно быть константой. N должно быть целым строго положительным числом не большим размера кортежа. Выполнение функции ничего не стоит.
С помощью функции реализуется оператор x.N .
Синтаксис
tupleElement(tuple, n) untuple
Выполняет синтаксическую подстановку элементов кортежа в место вызова.
Синтаксис
untuple(x) Чтобы пропустить некоторые столбцы в результате запроса, вы можете использовать выражение EXCEPT .
Аргументы
- x — функция tuple , столбец или кортеж элементов. Tuple.
Возвращаемое значение
Примеры
┌─key─┬─v1─┬─v2─┬─v3─┬─v4─┬─v5─┬─v6────────┐ │ 1 │ 10 │ 20 │ 40 │ 30 │ 15 │ (33,'ab') │ │ 2 │ 25 │ 65 │ 70 │ 40 │ 6 │ (44,'cd') │ │ 3 │ 57 │ 30 │ 20 │ 10 │ 5 │ (55,'ef') │ │ 4 │ 55 │ 12 │ 7 │ 80 │ 90 │ (66,'gh') │ │ 5 │ 30 │ 50 │ 70 │ 25 │ 55 │ (77,'kl') │ └─────┴────┴────┴────┴────┴────┴───────────┘ Пример использования столбца типа Tuple в качестве параметра функции untuple :
SELECT untuple(v6) FROM kv; ┌─_ut_1─┬─_ut_2─┐ │ 33 │ ab │ │ 44 │ cd │ │ 55 │ ef │ │ 66 │ gh │ │ 77 │ kl │ └───────┴───────┘ Пример использования выражения EXCEPT :
SELECT untuple((* EXCEPT (v2, v3),)) FROM kv; ┌─key─┬─v1─┬─v4─┬─v5─┬─v6────────┐ │ 1 │ 10 │ 30 │ 15 │ (33,'ab') │ │ 2 │ 25 │ 40 │ 6 │ (44,'cd') │ │ 3 │ 57 │ 10 │ 5 │ (55,'ef') │ │ 4 │ 55 │ 80 │ 90 │ (66,'gh') │ │ 5 │ 30 │ 25 │ 55 │ (77,'kl') │ └─────┴────┴────┴────┴───────────┘ Смотрите также
tupleHammingDistance
Возвращает расстояние Хэмминга между двумя кортежами одинакового размера.
Синтаксис
tupleHammingDistance(tuple1, tuple2) Аргументы
- tuple1 — первый кортеж. Tuple.
- tuple2 — второй кортеж. Tuple.
Кортежи должны иметь одинаковый размер и тип элементов.
Возвращаемое значение
- Расстояние Хэмминга.
Примеры
SELECT tupleHammingDistance((1, 2, 3), (3, 2, 1)) AS HammingDistance; ┌─HammingDistance─┐ │ 2 │ └─────────────────┘ Может быть использовано с функциями MinHash для проверки строк на совпадение:
SELECT tupleHammingDistance(wordShingleMinHash(string), wordShingleMinHashCaseInsensitive(string)) as HammingDistance FROM (SELECT 'Clickhouse is a column-oriented database management system for online analytical processing of queries.' AS string); ┌─HammingDistance─┐ │ 2 │ └─────────────────┘ tupleToNameValuePairs
Приводит именованный кортеж к списку пар (имя, значение). Для Tuple(a T, b T, . c T) возвращает Array(Tuple(String, T), . ) , где Strings — это названия именованных полей, а T — это соответствующие значения. Все значения в кортеже должны быть одинакового типа.
Синтаксис
tupleToNameValuePairs(tuple) Аргументы
- tuple — именованный кортеж. Tuple с любым типом значений.
Возвращаемое значение
- Список пар (имя, значение).
Пример
CREATE TABLE tupletest (`col` Tuple(user_ID UInt64, session_ID UInt64) ENGINE = Memory; INSERT INTO tupletest VALUES (tuple( 100, 2502)), (tuple(1,100)); SELECT tupleToNameValuePairs(col) FROM tupletest; ┌─tupleToNameValuePairs(col)────────────┐ │ [('user_ID',100),('session_ID',2502)] │ │ [('user_ID',1),('session_ID',100)] │ └───────────────────────────────────────┘ С помощью этой функции можно выводить столбцы в виде строк:
CREATE TABLE tupletest (`col` Tuple(CPU Float64, Memory Float64, Disk Float64)) ENGINE = Memory; INSERT INTO tupletest VALUES(tuple(3.3, 5.5, 6.6)); SELECT arrayJoin(tupleToNameValuePairs(col))FROM tupletest; ┌─arrayJoin(tupleToNameValuePairs(col))─┐ │ ('CPU',3.3) │ │ ('Memory',5.5) │ │ ('Disk',6.6) │ └───────────────────────────────────────┘ Если в функцию передается обычный кортеж, ClickHouse использует индексы значений в качестве имен:
SELECT tupleToNameValuePairs(tuple(3, 2, 1)); Зачем нужны кортежи: как работать с tuple в C#
Кортеж или tuple — это простой способ представить набор данных, который имеет несколько связанных или не связанных друг с другом значений.
Ефективний курс від robotdreams: Software Architect.
Від ідеї до коду.
По сути, это структуры данных, состоящих из нескольких частей.
«Скажи “кортеж” еще разок»
Содержание статьи:
Динамічний курс від skvot: Візуалізація екстер’єрів у 3DS MAX.
Мистецтво в 3DS MAX.
Свойства кортежа
Представим ситуацию, когда вам нужно в одном объекте сохранить данные сотрудника, например, имя, фамилию, ID работника, группу крови и т.д. С помощью кортежа можно создать общую структуру данных, куда будут входить все элементы. До появления кортежей было три основных варианта возврата нескольких значений из метода: использовался тип Class или Struct , или же данные возвращались через параметр out
В отличие от других структур данных, кортеж может хранить элементы любого типа, но только в ограниченном количестве. В кортежи можно добавлять до восьми элементов.
Если вы попытаетесь добавить девятый, то компилятор выдаст ошибку.
Другие структуры данных, такие как Array или List могут хранить бесконечное количество элементов, но они будут относиться только к определенному типу данных.
Практичний курс від skvot: Артменеджер.
Управляйте творчим процесом.
Например, tuple может быть очень полезен при обработке регистрационной формы пользователя. Он позволяет обработать до восьми элементов и не придется создавать отдельную структуру для элементов разного типа.
Еще раз перечислим основные особенности кортежа:
- он позволяет объединять несколько элементов в один набор данных;
- с его помощью можно создавать, обрабатывать и получать доступ к набору данных;
Общий синтаксис кортежа выглядит следующим образом:
Создание кортежа
В C# существует два основных способа создания кортежей. Давайте познакомимся с ними поближе.
Ефективний курс від skvot: Основи 3D-моделювання в ZBrush.
Звільніть свою творчість.
Конструктор класса tuple
Можно использовать класс Tuple для создания кортежа с определенной длиной и типом элементов, которые нужно сохранить.
В этом случае синтаксис кортежа будет выглядеть вот так:
// Конструктор для одного элемента Tuple (T1) // Конструктор для двух элементов Tuple (T1, T2) . . . // Конструктор для восьми элементов Tuple (T1, T2, T3, T4, T5, T6, T7, TRest)
Теперь рассмотрим пример использования кортежа в программном коде:
using System; namespace tuples < class Tupling < static void Main(string[] args) < TupleMyStringTuple = new Tuple("Pluralsight"); Tuple MyCustomTuple = new Tuple("Daniel",28); Tuple> MyMaxTuple = new Tuple>(1, 2, 3, 4, 5, 6, 7, new Tuple(8)); Console.WriteLine($"The has the following elements: "); Console.WriteLine($"The has the following elements: "); Console.WriteLine($"The has the following elements: "); Console.ReadKey(); ; > > >
Результат выполнения этих строк кода будет выглядеть так:
The MyStringTuple has the following elements: (Pluralsight) The MyCustomTuple has the following elements: (Daniel, 28) The MyMaxTuple has the following elements: (1, 2, 3, 4, 5, 6, 7, 8)
На примере видно, что код содержит три кортежа: первый — MyStringTuple , второй — MyCustomTuple и третий — MyMaxTuple .
Главное, что нужно запомнить при создании кортежа с большим количеством элементов: в кортеже состоящем из восьми элементов, последний элемент всегда должен быть кортежем.
Метод create
Прошлый пример кода перегружен. Это произошло из-за того, что при использовании класса-конструктора нужно указать тип каждого элемента для кортежа. Получается, что чем длиннее кортеж, тем больше текста будет в вашем коде. Чтобы сделать код простым и читабельным, для класса tuple был создан метод create . В его основе методы, которые позволяют создавать экземпляр без указания типа каждого элемента.
Рассмотрим синтаксис кортежа, созданного через create :
// Method for 1-tuple Create(T1) // Method for 2-tuple Create(T1, T2) . . . // Method for 8-tuple Create(T1, T2, T3, T4, T5, T6, T7, T8)
Уже на уровне синтаксиса все выглядит намного понятнее. Обратите внимание, что пример с кодом теперь стал легче, нет бесконечного повторения ( int ) в программе:
using System; namespace tuples < class Tupling < static void Main(string[] args) < var MyStringTuple = Tuple.Create("Pluralsight"); var MyCustomTuple = Tuple.Create("Daniel",28); var MyMaxTuple = Tuple.Create(1, 2, 3, 4, 5, 6, 7, Tuple.Create(8)); Console.WriteLine($"The has the following elements: "); Console.WriteLine($"The has the following elements: "); Console.WriteLine($"The has the following elements: "); Console.ReadKey(); > > >
Результат выполнения программы будет выглядеть точно так же, как и в примере с конструктором. Метод создания кортежа не влияет на его работоспособность: первый и второй вариант выполняют код одинаково.
Доступ к элементам кортежа
Отобразить элементы кортежа можно с помощью свойства Item . Например, Item1 , Item2 , Item3 — вплоть до Item7 . Свойство Item1 возвращает первый элемент, Item2 возвращает второй и так далее. Восьмой элемент возвращается с помощью свойства Rest . Например:
// C# программа для доступа к кортежам using System; public class GFG < static public void Main() < // Создаем кортеж с одним элементом // Используем метод create var My_Tuple1 = Tuple.Create("GeeksforGeeks"); // Получаем доступ к элементам кортежа // Используем свойство Item Console.WriteLine("Element of My_Tuple1: " + My_Tuple1.Item1); Console.WriteLine(); // Создаем кортеж с 4 элементами var My_Tuple2 = Tuple.Create(12, 30, 40, 50); // Получаем доступ к элементам кортежа // Используем свойство Item Console.WriteLine("Element of My_Tuple2: " + My_Tuple2.Item1); Console.WriteLine("Element of My_Tuple2: " + My_Tuple2.Item2); Console.WriteLine("Element of My_Tuple2: " + My_Tuple2.Item3); Console.WriteLine("Element of My_Tuple2: " + My_Tuple2.Item4); Console.WriteLine(); // Создаем кортеж с 8 элементами var My_Tuple3 = Tuple.Create(13, "Geeks", 67, 89.90, 'g', 39939, "geek", 10); // Получаем доступ к элементам кортежа // Используем свойство Item // Печатаем 8 элементов кортежа // Используем свойство Rest Console.WriteLine("Element of My_Tuple3: " + My_Tuple3.Item1); Console.WriteLine("Element of My_Tuple3: " + My_Tuple3.Item2); Console.WriteLine("Element of My_Tuple3: " + My_Tuple3.Item3); Console.WriteLine("Element of My_Tuple3: " + My_Tuple3.Item4); Console.WriteLine("Element of My_Tuple3: " + My_Tuple3.Item5); Console.WriteLine("Element of My_Tuple3: " + My_Tuple3.Item6); Console.WriteLine("Element of My_Tuple3: " + My_Tuple3.Item7); Console.WriteLine("Element of My_Tuple3: " + My_Tuple3.Rest); >
Результат выполнения кода:
Element of My_Tuple1: GeeksforGeeks Element of My_Tuple2: 12 Element of My_Tuple2: 30 Element of My_Tuple2: 40 Element of My_Tuple2: 50 Element of My_Tuple3: 13 Element of My_Tuple3: Geeks Element of My_Tuple3: 67 Element of My_Tuple3: 89.9 Element of My_Tuple3: g Element of My_Tuple3: 39939 Element of My_Tuple3: geek Element of My_Tuple3: (10)
В результате мы получаем не одну строку с перечислением всех элементов кортежа, а перепись каждого отдельного элемента. Таким образом, с помощью Item можно выводить в консоль не все элементы, а только необходимые.
Вложенные кортежи
Вложение используется, когда нужно добавить в кортеж больше восьми элементов. Для этого один кортеж вкладывают в другой. Лучше всего делать это в последнем элементе кортежа, но не обязательно.
Если вы выполняете вложение в конце, то можно получить доступ ко вложенному кортежу через свойство Rest . Если вложенный кортеж находится в другом месте среди элементов, то придется использовать свойство Item для доступа к нему.
Рассмотрим, как работают вложенные кортежи на примере:
using System; namespace tuples < class Tupling < static void Main(string[] args) < var MyMaxTupleNested = Tuple.Create(1, 2, 3, 4, 5, 6, 7, Tuple.Create(8, 9, 10, 11, 12, 13, 14, Tuple.Create(15, 16, 17, 18, 19, 20, 21))); Console.WriteLine($"My original tuple: "); Console.WriteLine($"First element of the outest tuple: "); Console.WriteLine($"First level of nesting: "); Console.WriteLine($"Second level of nesting: "); Console.ReadKey(); > > >
My original tuple: (1, 2, 3, 4, 5, 6, 7, (8, 9, 10, 11, 12, 13, 14, (15, 16, 17, 18, 19, 20, 21))) First element of the outest tuple: 1 First level of nesting: (8, 9, 10, 11, 12, 13, 14, (15, 16, 17, 18, 19, 20, 21)) Second level of nesting: (15, 16, 17, 18, 19, 20, 21)
Конечно, вложение кортежа в последний элемент выглядит лучше и чище, чем использование свойства Item . В примере мы видим два вложенных кортежа, но в целом их количество неограничено.
Присваивание кортежей
В C# можно присвоить свойства одного кортежа другому. Фактически мы меняем значение кортежа. Для того чтобы провести такую операцию, кортежи должны:
- Иметь одинаковое количество элементов. Не получится присвоить свойства одного кортежа другому, если они выглядят вот так Tuple.Create(12, 30, 40, 50) = Tuple.Create(7, 5); .
- Типы элементов в кортеже должны соответствовать друг другу. Нельзя заменить числа на элементы с буквами и наоборот.
Пример присвоения кортежа:
(int, double) t1 = (17, 3.14); (double First, double Second) t2 = (0.0, 1.0); t2 = t1; Console.WriteLine($": and "); // Output: // t2: 17 and 3.14 (double A, double B) t3 = (2.0, 3.0); t3 = t2; Console.WriteLine($": and "); // Output: // t3: 17 and 3.14
Как мы видим в разделе output , в первом случае кортеж t1 передал свои свойства кортежу t2 . Обратите внимание на то, что в случае присвоения кортежа первым в строке кода идет элемент, которому присваиваются свойства. А вот после знака = стоит элемент, свойства которого переходят в левую часть уравнения.
Деконструкция кортежей
Кортежи можно деконструировать — разделить на части и присвоить эти части новым переменным. Таким образом можно получить доступ к отдельному полю или значению свойства. Деконструировать кортежи можно несколькими способами.
1 Объявить тип каждой переменной в круглых скобках. Всегда используйте скобки, даже если все элементы в кортеже имеют один и тот же тип. Программа выдаст ошибку, если вы попытаетесь совершить деконструкцию без скобок:
var t = ("post office", 3.6); (string destination, double distance) = t; Console.WriteLine($"Distance to is kilometers."); // Результат: // Distance to post office is 3.6 kilometers.
2 Использовать ключевое слово var . С его помощью C# сам определит тип каждой переменной. Вы можете использовать ключевое слово var двумя разными способами:
- вынести var за скобки;
- поместить var в скобки с некоторыми или всеми переменными.
var(type1, name1, height1, age1, color1) = g.PetDetails("Dog", "Dollar", 124, 3, "White"); Console.WriteLine("Pet Details:"); Console.WriteLine("Type: " + type1); Console.WriteLine("Name: " + name1); Console.WriteLine("Height: " + height1); Console.WriteLine("Age: " + age1); Console.WriteLine("Color: " + color1); (var type2, var name2, var height2, var age2, var color2) = g.PetDetails("Cat", "Poo", 104, 1, "Black&White"); Console.WriteLine("\nPet Details:"); Console.WriteLine("Type: " + type2); Console.WriteLine("Name: " + name2); Console.WriteLine("Height: " + height2); Console.WriteLine("Age: " + age2); Console.WriteLine("Color: " + color2); Console.ReadLine();
3 Деконструировать кортеж в уже существующую переменную. Например:
var destination = string.Empty; var distance = 0.0; var t = ("post office", 3.6); (destination, distance) = t; Console.WriteLine($"Distance to is kilometers."); // Результат: // Distance to post office is 3.6 kilometers.
4 Можно игнорировать некоторые элементы кортежа. На C# 7.0 можно воспользоваться функцией discards или сброса, чтобы игнорировать значения выбранных переменных. Чтобы пропустить ненужные элементы, используется знак нижнего подчеркивания _ . Синтаксис такого выражения выглядит так:
(var1, _, var3, _, var5) = method_name(var1_values, var2_values, var3_value, var4_values, var5_value);
Пример кода с discards :
using System; public class ExampleDiscard < public static void Main() < var (_, _, _, pop1, _, pop2) = QueryCityDataForYears("New York City", 1960, 2010); Console.WriteLine($"Population change, 1960 to 2010: "); > private static (string, double, int, int, int, int) QueryCityDataForYears(string name, int year1, int year2) < int population1 = 0, population2 = 0; double area = 0; if (name == "New York City") < area = 468.48; if (year1 == 1960) < population1 = 7781984; >if (year2 == 2010) < population2 = 8175133; >return (name, area, year1, population1, year2, population2); > return ("", 0, 0, 0, 0, 0); > > // Результат: // Population change, 1960 to 2010: 393,149
В этом примере метод QueryCityDataForYears возвращает кортеж из шести элементов с названием города, площадью, годом, населением города за этот год, второй год и численностью населения этот год. Нам нужно узнать, как изменилась численность населения за эти два года. Получается, что из данных кортежа нас интересуют только два значения. Остальные элементы мы просто отбрасываем и получаем выражение var (_, _, _, pop1, _, pop2) .
Отличия System.ValueTuple от SystemTuple
ValueTuple — это структура, которая отображает кортеж так же, как класс System.Tuple .
Различия между элементами System.ValueTuple и SystemTuple
| х | System.ValueTuple | System.Tuple |
| Тип | Значение (структура) | Ссылочный тип (класс) |
| Свойства структуры | Изменяемая | Неизменная |
| Предоставление элементов | С помощью полей | С помощью свойств |
Подводя итог
Кортежи удобно использовать для работы с элементами данных разного типа данных и для обеспечения простого доступа к этим данным. Кортежи помогут, когда необходимо:
- вернуть несколько значений из метода без использования параметров ref или out ;
- передать несколько значений методу через один параметр;
- сохранить запись в базе данных или другие значения без создания отдельного класса.
Главный минус кортежей — они поддерживают не больше восьми элементов. Но этот недостаток можно обойти с помощью вложенности.
Видеоурок по кортежам в C#