Упаковка-преобразование и распаковка-преобразование (Руководство по программированию на 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#
Не секрет, что 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
return f(r => Create( f )( r ));
>
public static Func Create(Func
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, связанные со встраиванием в язык поддержки асинхронных операций.
Зачем нужна упаковка в си шарп
Кроме обычных типов фреймворк .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"); Companymicrosoft = 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# (boxing unboxing)
В этой статье мы коротко пройдемся по малоизвестным особенностям boxing/unboxing.
Типичный вопрос на собеседовании об упаковке и распаковке выглядит следующим образом — «Что будет при запуске данного кода, и если он не будет работать то как его исправить?».
object box = (int)42; long unbox = (long)box; Ответ может быть следующий — «При распаковке первый оператор является не приведением типов а распаковкой типа, соответственно он должен соответствовать типу значения находящегося в запакованном виде.».
object box = (int)42; long unbox = (long)(int)box; Обычно это считается правильным ответом, но это не совсем так…
Unboxing и Enum
Представьте себе удивление человека, когда вы ему напишете другой правильный вариант.
Второй правильный ответ:
public enum EnumType < None >. object box = (int)42; long unbox = (long)(EnumType)box; Напомню, enum не является фундаментальным типом и не наследует его, он является структурой содержащей фундаментальный тип (базовый). Это говорит о том что в .NET есть явная поддержка такой распаковки. Так же легко проверить что распаковка не использует операторы явного и неявного преобразования и интерфейс IConvertible и свой тип не получится развернуть из чужого типа.
При распаковке enum’а используется его базовый тип и следующая распаковка не будет работать.
public enum EnumType : short < None >. object box = (int)42; long unbox = (long)(EnumType)box; Распаковка для enum’ов ослаблена предельно.
Распаковываем int из enum’а:
public enum EnumType < None >. object box = EnumType.None; long unbox = (long)(int)box; Распаковываем один enum из другого:
public enum EnumType < None >public enum EnumType2 < None >. object box = EnumType.None; long unbox = (long)(EnumType2)box; Unboxing и Nullable
Распаковка поддерживает и Nullable типы, что кажется более логичным.
Распаковка Nullable типа из обычного:
object box = (int)42; long unbox = (long)(int?)box; Распаковка обычного типа из Nullable:
object box = (int?)42; long unbox = (long)(int)box; Напомню что Nullable это структура с одним обобщенным типом значения и предназначена для хранения данных и флага присутствия данных. Это говорит о том что в C# есть явная поддержка распаковки Nullable типов. В новых версиях C# для этой структуры появился alias «?».
public struct Nullable where T : struct < public bool HasValue < get; >public T Value < get; >> Равнозначные записи:
Nullable value; int? value;