Зачем нужна упаковка в си шарп
Перейти к содержимому

Зачем нужна упаковка в си шарп

  • автор:

Упаковка-преобразование и распаковка-преобразование (Руководство по программированию на C#)

Упаковка представляет собой процесс преобразования типа значения в тип object или в любой другой тип интерфейса, реализуемый этим типом значения. Когда тип значения упаковывается общеязыковой средой выполнения (CLR), он инкапсулирует значение внутри экземпляра System.Object и сохраняет его в управляемой куче. Операция распаковки извлекает тип значения из объекта. Упаковка является неявной; распаковка является явной. Понятия упаковки и распаковки лежат в основе единой системы типов C#, в которой значение любого типа можно рассматривать как объект.

В следующем примере выполнена операция i упаковки целочисленной переменной, которая присвоена объекту o .

int i = 123; // The following line boxes i. object o = i; 

Затем можно выполнить операцию распаковки объекта o и присвоить его целочисленной переменной i :

o = 123; i = (int)o; // unboxing 

Следующий пример иллюстрирует использование упаковки в C#.

// String.Concat example. // String.Concat has many versions. Rest the mouse pointer on // Concat in the following statement to verify that the version // that is used here takes three object arguments. Both 42 and // true must be boxed. Console.WriteLine(String.Concat("Answer", 42, true)); // List example. // Create a list of objects to hold a heterogeneous collection // of elements. List mixedList = new List(); // Add a string element to the list. mixedList.Add("First Group:"); // Add some integers to the list. for (int j = 1; j < 5; j++) < // Rest the mouse pointer over j to verify that you are adding // an int to a list of objects. Each element j is boxed when // you add j to mixedList. mixedList.Add(j); >// Add another string and more integers. mixedList.Add("Second Group:"); for (int j = 5; j < 10; j++) < mixedList.Add(j); >// Display the elements in the list. Declare the loop variable by // using var, so that the compiler assigns its type. foreach (var item in mixedList) < // Rest the mouse pointer over item to verify that the elements // of mixedList are objects. Console.WriteLine(item); >// The following loop sums the squares of the first group of boxed // integers in mixedList. The list elements are objects, and cannot // be multiplied or added to the sum until they are unboxed. The // unboxing must be done explicitly. var sum = 0; for (var j = 1; j < 5; j++) < // The following statement causes a compiler error: Operator // '*' cannot be applied to operands of type 'object' and // 'object'. //sum += mixedList[j] * mixedList[j]; // After the list elements are unboxed, the computation does // not cause a compiler error. sum += (int)mixedList[j] * (int)mixedList[j]; >// The sum displayed is 30, the sum of 1 + 4 + 9 + 16. Console.WriteLine("Sum: " + sum); // Output: // Answer42True // First Group: // 1 // 2 // 3 // 4 // Second Group: // 5 // 6 // 7 // 8 // 9 // Sum: 30 

Производительность

По сравнению с простыми операциями присваивания операции упаковки и распаковки являются весьма затратными процессами с точки зрения вычислений. При выполнении упаковки типа значения необходимо создать и разместить новый объект. Объем вычислений при выполнении операции распаковки, хотя и в меньшей степени, но тоже весьма значителен. Дополнительные сведения см. в разделе Производительность.

Упаковка

Упаковка используется для хранения типов значений в куче со сбором мусора. Упаковка представляет собой неявное преобразование типа значения в тип object или в любой другой тип интерфейса, реализуемый этим типом значения. При упаковке типа значения в куче выделяется экземпляр объекта и выполняется копирование значения в этот новый объект.

Рассмотрим следующее объявление переменной типа значения.

int i = 123; 

Следующий оператор неявно применяет операцию упаковки к переменной i .

// Boxing copies the value of i into object o. object o = i; 

Результат этого оператора создает ссылку на объект o в стеке, которая ссылается на значение типа int в куче. Это значение является копией значения типа значения, присвоенного переменной i . Разница между этими двумя переменными, i и o , показана на рисунке упаковки-преобразования ниже:

Можно также выполнять упаковку явным образом, как в следующем примере, однако явная упаковка не является обязательной.

int i = 123; object o = (object)i; // explicit boxing 

Пример

В этом примере целочисленная переменная i преобразуется в объект o при помощи упаковки. Затем значение, хранимое переменной i , меняется с 123 на 456 . В примере показано, что исходный тип значения и упакованный объект используют отдельные ячейки памяти, а значит могут хранить разные значения.

class TestBoxing < static void Main() < int i = 123; // Boxing copies the value of i into object o. object o = i; // Change the value of i. i = 456; // The change in i doesn't affect the value stored in o. System.Console.WriteLine("The value-type value = ", i); System.Console.WriteLine("The object-type value = ", o); > > /* Output: The value-type value = 456 The object-type value = 123 */ 

Распаковка-преобразование

Распаковка является явным преобразованием из типа object в тип значения или из типа интерфейса в тип значения, реализующего этот интерфейс. Операция распаковки состоит из следующих действий:

  • проверка экземпляра объекта на то, что он является упакованным значением заданного типа значения;
  • копирование значения из экземпляра в переменную типа значения.

В следующем коде показаны операции по упаковке и распаковке.

int i = 123; // a value type object o = i; // boxing int j = (int)o; // unboxing 

На рисунке ниже представлен результат выполнения этого кода.

Для успешной распаковки типов значений во время выполнения необходимо, чтобы экземпляр, который распаковывается, был ссылкой на объект, предварительно созданный с помощью упаковки экземпляра этого типа значения. Попытка распаковать null создает исключение NullReferenceException. Попытка распаковать ссылку на несовместимый тип значения создает исключение InvalidCastException.

Пример

В следующем примере показан случай недопустимой распаковки, в результате чего создается исключение InvalidCastException . В случае использования try и catch при возникновении ошибки выводится сообщение.

class TestUnboxing < static void Main() < int i = 123; object o = i; // implicit boxing try < int j = (short)o; // attempt to unbox System.Console.WriteLine("Unboxing OK."); >catch (System.InvalidCastException e) < System.Console.WriteLine("Error: Incorrect unboxing.", e.Message); > > > 

При выполнении этой программы выводится следующий результат:

Specified cast is not valid. Error: Incorrect unboxing.

При изменении оператора:

int j = (short)o; 
int j = (int)o; 

будет выполнено преобразование со следующим результатом:

Спецификация языка C#

Дополнительные сведения см. в спецификации языка C#. Спецификация языка является предписывающим источником информации о синтаксисе и использовании языка C#.

См. также

  • Руководство по программированию на C#
  • Ссылочные типы
  • Типы значений

Совместная работа с нами на GitHub

Источник этого содержимого можно найти на GitHub, где также можно создавать и просматривать проблемы и запросы на вытягивание. Дополнительные сведения см. в нашем руководстве для участников.

C#. Упаковка и распаковка. Необходимость (преимущества) применения обобщений

Упаковка и распаковка. Необходимость (преимущества) применения обобщений. Повышение типовой безопасности с помощью обобщений

Поиск на других ресурсах:

1. Понятие упаковки (boxing) и распаковки (unboxing)

Как известно, в .NET Framework все базовые типы ( int , double , char и т.д.) представлены соответствующим классом или структурой ( Integer , Double , Char и т.п.) в общей иерархической структуре классов. В вершине этой структуры лежит тип Object , к которому также можно обращаться по имени object . Это означает, что допускается объявлять переменную типа Object и использовать ее для работы с любым типом как показано ниже

. // Можно работать также через базовый класс Object Object a; object b; a = 25; // присваивание значения типа int b = "bestprog"; // присваивание значения типа string Console.WriteLine("a = ", a); // a = 25 Console.WriteLine("b = ", b); // b = bestprog // Переменной a опять присваивается значение другого типа double a = 2.88; Console.WriteLine("a = ", a); // a = 2.88 .

Допускается также использовать переменную типа object в правой части оператора присваивания:

. // Переменная типа object object c; c = 'A'; // присваивается значение char char cc; // Переменная типа char cc = (char)c; // здесь нужно явное приведение типов, иначе ошибка на этапе компиляции Console.WriteLine("cc = ", cc); // cc = A .

Но в этом случае нужно указывать явное приведение типов, как видно из строки

. cc = (char)c; .

иначе будет ошибка на этапе компиляции.

Если переменная типа object используется в левой части оператора присваивания, то компилятор выполняет так называемую упаковку. Если переменная или значение типа object используется в правой части оператора присваивания, то компилятор выполняет распаковку.

Таким образом можно дать следующие определения. Упаковка — это процесс сохранения значения простого типа ( int , char , double …) в экземпляре объекта (object). Распаковка — это процесс вытягивания упакованного значения ( int , double , char …) из объекта ( object ). Следующий пример демонстрирует различие между этими терминами:

. object a; // тип int упаковывается в тип object a = 300; // упаковка: object int b; b = (int)a; // распаковка: int .
2. Какая разница между использованием обобщений и приведением к типу object ? Демонстрация преимуществ применения обобщений. Пример

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

Исходя из вышесказанного, можно сделать вывод, что использование типа Object может заменить обобщения. Тогда возникает резонный вопрос: зачем использовать обобщения, если они целиком могут быть заменены типом object ?

Использование обобщений вместо использования типа object дает следующие преимущества:

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

В следующих пунктах эти преимущества рассматриваются более подробно.

2.1. Преимущество 1. Отсутствие явного приведения типа

Если используется обобщение, то не нужно выполнять явное приведение типов в операции присваивания как показано на рисунке 1.

C#. Обобщения. Отличие в явном приведении к типу int между обобщением и типом object

Рисунок 1. Отличие в явном приведении к типу int между обобщением и типом object

2.2. Преимущество 2. Обеспечение типовой безопасности в обобщениях

При использовании класса object в качестве типа можно допустить ошибку, которая на этапе компиляции не будет обнаружена. Эта ошибка окажется на этапе выполнения, что неприемлемо.

На рисунке 2 реализованы такие же классы как на рисунке 1. Однако, в функции main() , для обоих классов осуществляется попытка установить значение типа double .

В случае с классом ObjectClass ошибки на этапе компиляции не возникает. Эта ошибка вызовет исключительную ситуацию на этапе выполнения.

В случае с классом GenClass ошибка будет определена на этапе компиляции. Это связано с тем, что создается типизированный код с привязкой к типу int . В этом коде ошибки определяются на этапе компиляции. Это является основным преимуществом обобщений, которые повышают типовую безопасность.

C#. Обобщения. Особенности выявления ошибки компилятором

Рисунок 2. Особенности выявления ошибки компилятором для обобщенного и необобщенных класса

2.3. Преимущество 3. Повышение производительности

Использование обобщенных классов дает большую производительность (быстродействие) по сравнению с необобщенными. При присвоении значения типа object другим типам и наоборот, компилятор выполняет упаковку и распаковку (смотрите п. 1). Этот процесс требует больше временных затрат чем использование обобщений. В случае с обобщениями формируется типизированный код с привязкой к конкретному типу, который выполняется быстрее.

Рисунок 3 отражает объявление двух классов ObjectClass и GenClass . В функции main() выделены фрагменты кода, в которых проявляется различие в производительности между объектами ( object ) и обобщениями.

C#. Обобщения. Производительность

Рисунок 3. Отличие в производительности выполнения кода между обобщенным классом и классом типа object . Операция присваивания для обобщенных классов выполняется быстрее

Связанные темы

  • Обобщения. Основные понятия. Обобщенные классы и структуры
  • Обобщенные интерфейсы. Синтаксис объявления. Реализация обобщенных интерфейсов в классах. Примеры
  • Обобщенные методы в классах. Синтаксис объявления. Способы вызова
  • Обобщенные делегаты

Зачем нужна упаковка в си шарп

Кроме обычных типов фреймворк .NET также поддерживает обобщенные типы (generics), а также создание обобщенных методов. Чтобы разобраться в особенности данного явления, сначала посмотрим на проблему, которая могла возникнуть до появления обобщенных типов. Посмотрим на примере. Допустим, мы определяем класс для хранения данных пользователя:

class Person < public int Id < get;>public string Name < get;>public Person(int id, string name) < Name = name; >>

Класс Person определяет два свойства: Id — уникальный идентификатор пользователя и Name — имя пользователя.

Здесь идентификатор пользователя задан как числовое значение, то есть это будут значения 1, 2, 3, 4 и так далее.

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

И на первый взгляд, чтобы выйти из подобной ситуации, мы можем определить свойство Id как свойство типа object. Так как тип object является универсальным типом, от которого наследуется все типы, соответственно в свойствах подобного типа мы можем сохранить и строки, и числа:

class Person < public object Id < get;>public string Name < get;>public Person(object id, string name) < Name = name; >>

Затем этот класс можно было использовать для создания пользователей в программе:

Person tom = new Person(546, "Tom"); Person bob = new Person("abc123", "Bob"); int tomId = (int)tom.Id; string bobId = (string) bob.Id; Console.WriteLine(tomId); // 546 Console.WriteLine(bobId); // abc123

Все вроде замечательно работает, но такое решение является не очень оптимальным. Дело в том, что в данном случае мы сталкиваемся с такими явлениями как упаковка (boxing) и распаковка (unboxing) .

Так, при передаче в конструктор значения типа int, происходит упаковка этого значения в тип Object:

Person tom = new Person(546, "Tom"); // упаковка в значения int в тип Object

Чтобы обратно получить данные в переменную типов int, необходимо выполнить распаковку:

int tomId = (int)tom.Id; // Распаковка в тип int

Упаковка (boxing) предполагает преобразование объекта значимого типа (например, типа int) к типу object. При упаковке общеязыковая среда CLR обертывает значение в объект типа System.Object и сохраняет его в управляемой куче (хипе). Распаковка (unboxing), наоборот, предполагает преобразование объекта типа object к значимому типу. Упаковка и распаковка ведут к снижению производительности, так как системе надо осуществить необходимые преобразования.

Кроме того, существует другая проблема — проблема безопасности типов. Так, мы получим ошибку во время выполнения программы, если напишем следующим образом:

Person tom = new Person(546, "Tom"); string tomId = (string)tom.Id; // !Ошибка - Исключение InvalidCastException Console.WriteLine(tomId); // 546

Мы можем не знать, какой именно объект представляет Id, и при попытке получить число в данном случае мы столкнемся с исключением InvalidCastException. Причем с исключением мы столкнемся на этапе выполнения программы.

Для решения этих проблем в язык C# была добавлена поддержка обобщенных типов (также часто называют универсальными типами). Обобщенные типы позволяют указать конкретный тип, который будет использоваться. Поэтому определим класс Person как обощенный:

class Person  < public T Id < get; set; >public string Name < get; set; >public Person(T id, string name) < Name = name; >>

Угловые скобки в описании class Person указывают, что класс является обобщенным, а тип T, заключенный в угловые скобки, будет использоваться этим классом. Необязательно использовать именно букву T, это может быть и любая другая буква или набор символов. Причем сейчас на этапе написания кода нам неизвестно, что это будет за тип, это может быть любой тип. Поэтому параметр T в угловых скобках еще называется универсальным параметром , так как вместо него можно подставить любой тип.

Например, вместо параметра T можно использовать объект int, то есть число, представляющее номер пользователя. Это также может быть объект string, либо или любой другой класс или структура:

Person tom = new Person(546, "Tom"); // упаковка не нужна Person bob = new Person("abc123", "Bob"); int tomId = tom.Id; // распаковка не нужна string bobId = bob.Id; // преобразование типов не нужно Console.WriteLine(tomId); // 546 Console.WriteLine(bobId); // abc123

Поскольку класс Person является обобщенным, то при определении переменной после названия типа в угловых скобках необходимо указать тот тип, который будет использоваться вместо универсального параметра T. В данном случае объекты Person типизируются типами int и string :

Person tom = new Person(546, "Tom"); // упаковка не нужна Person bob = new Person("abc123", "Bob");

Поэтому у первого объекта tom свойство Id будет иметь тип int, а у объекта bob — тип string. И в случае с типом int упаковки происходить не будет.

При попытке передать для параметра id значение другого типа мы получим ошибку компиляции:

Person tom = new Person("546", "Tom"); // ошибка компиляции

А при получении значения из Id нам больше не потребуется операция приведения типов и распаковка тоже применяться не будет:

int tomId = tom.Id; // распаковка не нужна

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

При этом универсальный параметр также может представлять обобщенный тип:

// класс компании class Company  < public P CEO < get; set; >// президент компании public Company(P ceo) < CEO = ceo; >> class Person  < public T Id < get;>public string Name < get;>public Person(T id, string name) < Name = name; >>

Здесь класс компании определяет свойство CEO, которое хранит президента компании. И мы можем передать для этого свойства значение типа Person, типизированного каким-нибудь типом:

Person tom = new Person(546, "Tom"); Company microsoft = new Company(tom); Console.WriteLine(microsoft.CEO.Id); // 546 Console.WriteLine(microsoft.CEO.Name); // Tom

Статические поля обобщенных классов

При типизации обобщенного класса определенным типом будет создаваться свой набор статических членов. Например, в классе Person определено следующее статическое поле:

class Person  < public static T? code; public T Id < get; set; >public string Name < get; set; >public Person(T id, string name) < Name = name; >>

Теперь типизируем класс двумя типами int и string:

Person tom = new Person(546, "Tom"); Person.code = 1234; Person bob = new Person("abc", "Bob"); Person.code = "meta"; Console.WriteLine(Person.code); // 1234 Console.WriteLine(Person.code); // meta

В итоге для Person и для Person будет создана своя переменная code.

Использование нескольких универсальных параметров

Обобщения могут использовать несколько универсальных параметров одновременно, которые могут представлять одинаковые или различные типы:

class Person  < public T Id < get;>public K Password < get; set; >public string Name < get;>public Person(T id, K password, string name) < Name = name; Password = password; >>

Здесь класс Person использует два универсальных параметра: один параметр для идентификатора, другой параметр — для свойства-пароля. Применим данный класс:

Person tom = new Person(546, "qwerty", "Tom"); Console.WriteLine(tom.Id); // 546 Console.WriteLine(tom.Password);// qwerty

Здесь объект Person типизируется типами int и string. То есть в качестве универсального параметра T используется тип int , а для параметра K — тип string .

Обобщенные методы

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

int x = 7; int y = 25; Swap(ref x, ref y); // или так Swap(ref x, ref y); Console.WriteLine($»x= y=»); // x=25 y=7 string s1 = «hello»; string s2 = «bye»; Swap(ref s1, ref s2); // или так Swap(ref s1, ref s2); Console.WriteLine($»s1= s2=»); // s1=bye s2=hello void Swap(ref T x, ref T y)

Здесь определен обощенный метод Swap, который принимает параметры по ссылке и меняет их значения. При этом в данном случае не важно, какой тип представляют эти параметры.

При вызове метода Swap типизируем его определенным типом и передаем ему соответствующие этому типу значения.

  • Вопросы для самопроверки
  • Упражнения

Тонкие моменты C#

C Sharp

Не секрет, что C# сегодня популярный и динамично развывающийся язык, в отличие от своего прямого конкурента — языка Java, который в плане функциональности переживает период застоя. Основное неоспоримое преимущество Java — настоящая кросплатформенность, а не унылая и ограниченная, как у C#.

C# — простой язык, благодаря простоте живёт и PHP. Но в то же время он весьма функциональный, и имеет статус «гибридного» языка, совмещая в себе различные парадигмы, встроенную поддержку как императивного стиля программирования, так и функционального.

Как и любой язык, шарп имеет свои тонкости, особенности, «подводные камни» и малоизвестные возможности. Что я имею ввиду? Читайте под катом…

Упаковка и распаковка — знают все, да не каждый

Ссылочные типы (object, dynamic, string, class, interface, delegate) хранятся в управляемой куче, типы значений (struct, enum; bool, byte, char, int, float, double) — в стеке приложения (кроме случая, когда тип значения является полем класса). Преобразование типа значений к ссылочному типу сопровождается неявной операцией упаковки (boxing) — помещение копии типа значений в класс-обёртку, экземпляр которого сохраняется в куче. Упаковочный тип генерируется CLR и реализует интерфейсы сохраняемого типа значения. Преобразование ссылочного типа к типу значений вызывает операцию распаковки (unboxing) — извлечение из упаковки копии типа значения и помещение её в стек.

class Program
static void Main()
int val = 5;
object obj = val; // присваивание сопровождается упаковкой
int valUnboxed = ( int )obj; // приведение вызовет распаковку
>
>

.locals init ([0] int32 val, [1] object obj, [2] int32 valUnboxed)
IL_0000: nop
IL_0001: ldc.i4.5
IL_0002: stloc.0
IL_0003: ldloc.0
IL_0004: box [mscorlib]System.Int32
IL_0009: stloc.1
IL_000a: ldloc.1
IL_000b: unbox.any [mscorlib]System.Int32
IL_0010: stloc.2
IL_0011: ret

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

class Program
static void Main()
// 1. Преобразование типа значений в ссылку на реализуемый им интерфейс
IComparable < int >iComp = 1;
// 2. Преобразование типа enum в ссылку на System.Enum
Enum format = UriFormat.Unescaped;
// 3. Преобразование типа значений к типу dynamic
dynamic d = 1;
>
>

В msdn рекомендуется избегать типов значений в случаях, когда они должны быть упакованы много раз, например в не универсальных классах коллекций (ArrayList). Упаковки-преобразования типов значений можно избежать с помощью универсальных коллекций (System.Collections.Generic namespace). Также следует помнить, что dynamic на уровне IL-кода — это тот же object, только (не всегда) помеченный атрибутами.

Рекурсия в лямбдах — о зловредном замыкании

Обратимся к классической реализации рекурсивного вычисления факториала при помощи лямбда-выражений:

class Program
static void Main()
Func < int , BigInteger>fact = null ;
fact = x => x > 1 ? x * fact(x — 1) : 1;
>
>

Мы знаем, что лямбда способна ссылаться на саму себя благодаря способности захватывать переменные окружения (замыкание). Мы знаем, что захваченные объекты могут быть изменены вне контекста лямбда-выражения, и не существует встроенной в язык возможности переопределить такое поведение. Понятно, что в большинстве ряде случаев такой подход не будет приемлемым, и хотелось бы как-то ограничить возможность изменять захваченную переменную вне контекста лямбды.

В общем случае представленная проблема решается реализацией комбинатора неподвижной точки:

class Program
static void Main()
var fact = YPointCombinator.Create< int , BigInteger>(f => (n) => n > 1 ? n * f(n — 1) : 1);
var power = YPointCombinator.Create< int , int , BigInteger>(f => (x, y) => y > 0 ? x * f(x, y — 1) : 1);
>
>
public static class YPointCombinator
public static Func Create(Func f)
return f(r => Create( f )( r ));
>
public static Func Create(Func f)
return f((r1, r2) => Create(f)(r1, r2));
>
>

Поля private и рефлексия, или плевали мы на ваше ООП

При помощи механизма отражения можно изменить значение даже private-поля класса.
Понятно, что применять это строить только в случае крайней необходимости, соблюдая принцип инкапсуляции.

class Sample
private string _x = «No change me!» ;
public override string ToString()
return _x;
>
>
class Program
static void Main()
var sample = new Sample();
typeof (Sample).GetField( «_x» , BindingFlags.NonPublic | BindingFlags.Instance)
.SetValue(sample, «I change you. » );
Console .Write(sample);
Console .ReadKey();
>
>

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

С системой безопасности .NET не всё просто, причём в .NET 4 она претерпела серьёзные изменения.

«Утиная» типизация и цикл foreach

Чтобы иметь возможность итерировать по элементам экземпляра некоторого класса при помощи foreach, достаточно реализовать в нём метод GetEnumerator().

using System;
using System.Collections.Generic;

class Sample
public IEnumerator < int >GetEnumerator()
for ( var i = 0; i < 10; ++i)
yield return i;
>
>
class Program
static void Main()
foreach ( var t in new Sample())
Console .WriteLine(t);
Console .ReadKey();
>
>

Это небольшое проявление так называемой «утиной» типизации, обычно применяемой в динамических языках, имеет место и в C#.

Анонимные типы — можно больше

Переменные анонимного типа можно сохранять в коллекции. Убедитесь сами:

Console .Write(list.Find(x => x.Name == «Petr» ));
Console .ReadKey();
>
>

Переменные анонимного типа можно передавать в другую область видимости:

ref иногда можно опустить

Начиная с версии C# 4.0 ключевое слово ref можно опускать при вызове метода через COM Interop. В сочетании с именованными аргументами выглядит весьма эффектно:

using System;
using Word = Microsoft.Office.Interop.Word;

class Program
static void Main()
var app = new Word.Application();
Word.Document doc = null ;

// C# 2.0 — 3.5
object
filename = «test.doc» ,
visible = true ,
missing = Type.Missing;

doc = app.Documents.Open(
ref filename, ref missing, ref missing, ref missing, ref missing, ref missing,
ref missing, ref missing, ref missing, ref missing, ref missing, ref visible,
ref missing, ref missing, ref missing, ref missing);

// C# 4.0
doc = app.Documents.Open(FileName: «test.doc» , Visible: true );
>
>

Заметьте: именованные параметры и возможность опускать ref — это средства языка, поэтому в качестве базового фреймворка приложения может быть выбран как .NET Framework 4.0, так и .NET Framework 2.0, 3.0, 3.5.

Что осталось за кадром

Среди всех прочих «тонкостей» языка я бы выделил проблему детерминированного уничтожения объектов, сложность обработки асинхронных исключений типа ThreadAbortException. Интерес представляют мощные средства синхронизации потоков и грядущие изменения в C# 5.0, связанные со встраиванием в язык поддержки асинхронных операций.

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

Ваш адрес email не будет опубликован. Обязательные поля помечены *