Встроенные типы данных языка C#

Все встроенные типы данных являются синонимами для соответствующих структур (в некоторых случаях классов), определенных в пространстве имен System. Это означает, что каждая объявленная переменная является объектом соответствующей структуры или класса. Например, каждый числовой тип данных имеет поля MinValue и MaxValue, хранящие соответственно минимальное и максимальное возможные значения для данного типа.

В таблице представлены встроенные типы данных языка C# и соответствующие им структуры или классы пространства имен System.

C# тип	.NET Framework тип	Количество бит	Суффикс, используемый в литералах	Описание
object	System.Object	-	-	Базовый тип данных, все остальные типы являются производными от него
bool	System.Boolean	8	-	Логический тип, может принимать только два значения: true и false
byte	System.Byte	8	-	Беззнаковый байт
sbyte	System.SByte	8	-	Знаковый байт
char	System.Char	16	-	Символ Unicode 16 бит
decimal	System.Decimal	128	m, M	Десятичное число с фиксированной точностью
double	System.Double	64	d, D	Число с плавающей запятой
float	System.Single	32	f, F	Число с плавающей запятой
int	System.Int32	32	-	Целое знаковое число
uint	System.UInt32	32	u, U	Целое беззнаковое число
long	System.Int64	64	l, L	Целое знаковое число
ulong	System.UInt64	64	ul, uL, UL, Ul, lu, lU, LU, Lu	Целое беззнаковое число
short	System.Int16	16	-	Целое знаковое число
ushort	System.UInt16	16	-	Целое беззнаковое число
string	System.String	-	-	Строка символов Unicode

Из перечисленных имен System.Object и System.String являются классами, остальные структурами. Поэтому объекты типа string и object называются ссылочными типами, а остальные структурными.

Преобразования типов

 

Термин «преобразование типов» означает преобразование значений одного типа в значения другого типа.

 

Любые данные, независимо от своего типа, представляют собой последовательность двоичных битов, т. е. последовательность, состоящую из нулей и единиц. Собственно значение переменной зависит от того, каким образом эти биты интерпретируются. Простейшим примером такого подхода может служить тип char, который содержит номер символа из множества символов Unicode. Этот номер хранится абсолютно так же, как и число типа ushort: в обоих случаях это число, лежащее в диапазоне от 0 до 65 535.

 

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

Существует два вида преобразования типов:

Неявное преобразование — когда преобразование типа А в тип В возможно при любых обстоятельствах, а правила проведения такого преобразования достаточно просты, чтобы доверить его компилятору.

Явное преобразование — когда преобразование типа А в тип В возможно только при определенных обстоятельствах либо правила преобразования настолько сложны, что возникает необходимость выполнения каких-либо дополнительных действий.

 

Неявные преобразования типов

 

Неявное преобразование не требует со стороны программиста никакой дополнительной работы и никакого дополнительного кода. Рассмотрим пример кода:

 

var1 = var2;

 

Такое присваивание может включать в себя проведение неявного преобразования типов в том случае, если тип переменной var2 допускает проведение неявного преобразования в тип переменной var1.

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

 

Рассмотрим другой пример.

Значения типов ushort и char являются фактически взаимозаменяемыми, поскольку оба они предполагают хранение чисел в диапазоне между 0 и 65 535. Можно осуществлять преобразования этих типов друг в друга неявно, что иллюстрируется следующим кодом:

 

ushort Code;

char Symbol = 'a';

Code = Symbol;

Console.WriteLine("Символ: {0}", Symbol);

Console.WriteLine("Код символа: {0}", Code);

 

В этом коде значение, хранящееся в переменной Symbol, переносится в переменную Code. Затем две команды Console.WriteLine() дают следующий выходной поток:

 

Символ: а

Код символа: 97

 

Хотя в обеих переменных хранится одна и та же информация, она интерпретируется совершенно по-разному в зависимости от типа переменной.

 

Для простых типов существует большое количество неявных преобразований; для типов bool и string неявных преобразований не существует, зато они имеются у численных типов. В таблице показаны преобразования численных типов, которые могут выполняться компилятором неявно (значения типа char хранятся в виде чисел, поэтому мы рассматриваем char как численный тип).

Тип данных	неявно приводится к
byte	short, ushort, int, uint, long, ulong, float, double, decimal
sbyte	short, int, long, float, double, decimal
short	int, long, float, double, decimal
ushort	int, uint, long, ulong, float, double, decimal
int	long, float, double, decimal
uint	long, ulong, float, double, decimal
long	float, double, decimal
ulong	float, double, decimal
float	double
char	ushort, int, uint, long, ulong, float, double, decimal

 

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

 

Например, константы типа int можно присваивать переменным типов sbyte, byte, short, ushort, uint, или ulong, в случае, если они могут их принять, то есть, если присваиваемое значение не превышает предельное значение для типа данных переменной-приемника.

 

Явные преобразования типов

 

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

 

Рассмотрим модифицированный предыдущий пример:

 

short Code1 = 7;

byte Code2;

Code2 = Code1;

Console.WriteLine("Код 1: {0}, Code1);

Console.WriteLine("Код 2: {0}, Code2);

 

При попытке выполнить компиляцию этого кода будет выведено следующее сообщение об ошибке:

«Невозможно неявно преобразовать тип 'short' в 'byte'»

 

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

 

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

 

{ destinationType) sourceVar

 

Эта запись приведет к преобразованию значения переменной sourceVar к типу destinationType.

 

Модифицированный код, выполняющий преобразования из типа short в тип byte:

 

short Code1 = 7;

byte Code2;

Code2 = (byte)Code1;

Console.WriteLine("Код 1: {0}, Code1);

Console.WriteLine("Код 2: {0}, Code2);

 

Результатом будет:

 

Код 1: 7

Код 2: 7

 

В случае, если переменной-приемнику путем явного преобразования присваивается значение переменной-источника, которое там не помещается, имеет место «аномалия обрезанных данных». Рассмотрим пример:

 

short Code1 = 281;

byte Code2;

Code2 = (byte)Code1;

Console.WriteLine("Код 1: {0}, Code1);

Console.WriteLine("Код 2: {0}, Code2);

 

В этом случае мы получим следующий результат:

 

Код 1: 281

Код 2: 25

Чтобы понять суть этой аномалии, рассмотрим двоичное представление этих двух чисел, а также максимально допустимого значения для типа byte, равное 255:

 

281d = 100011001b

25d  = 000011001b

255d = 011111111b

 

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

 

Выполнение явных преобразований с помощью команд преобразования

 

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

 

Команда коллекции Convert	val преобразовано в
.ToBoolean(val)	bool
.ToByte(val)	byte
.ToChar(val)	char
. ToDecimal(val)	decimal
.ToDouble(val)	double
.ToInt16(val)	short
.ToInt32(val)	int
.ToInt64(val)	long
.ToSByte(val)	sbyte
.ToSingle(val)	float
.ToString(val)	string
.ToUInt16(val)	ushort
.ToUInt32(val)	uint
.ToUInt64(val)	ulong

 

Здесь имена команд преобразования несколько отличаются от названий типов, принятых в С#; например, для того чтобы произвести преобразование в тип int, следует использовать команду Convert.Tolnt32(). Это объясняется тем, что имена в командах Пространства Имен System.NET Framework и не являются родными для С#. Зато благодаря этому их можно использовать из любых других языков, совместимых с.NET.

 

Рассмотрим пример использования всех видов преобразований типов:

 

static void Main(string[] args)

{

short shortResult, shortVal = 4;

int integerVal = 67;

long longResult;

float floatVal = 10.5F;

double doubleResult, doubleVal = 99.999;

string stringResult, stringVal = "17";

bool boolVal = true;

 

doubleResult = floatVal * shortVal;

Console.WriteLine("Неявно -> double: {0} * {1} -> {2}", floatVal, shortVal, doubleResult);

shortResult = (short)floatVal;

Console.WriteLine("Явно -> short: {0} -> {1}", floatVal, shortResult);

stringResult = Convert.ToString(boolVal) + Convert.ToString(doubleVal);

Console.WriteLine("Явно -> string: \"{0}\" + \"{1}\" -> {2}", boolVal, doubleVal, stringResult);

longResult = integerVal + Convert.ToInt64(stringVal);

Console.WriteLine("Смешанно -> long: {0} + {1} -> {2}", integerVal, stringVal, longResult);

Console.ReadKey();

}

 

 

Результат выполнения программы:

 

Неявно -> double: 10,5 * 4 -> 42

Явно -> short: 10,5 -> 10

Явно -> string: "True" + "99,999" -> True99,999

Смешанно -> long: 67 + 17 -> 84

Здесь видно, что преобразования типов выполняются:

­ при определении литералов-констант (10.5F);

­ при выполнении операции присваивания;

­ при вычислении значений выражений (floatVal * shortVal).

 

Выполнение любого не унарного оператора может привести к преобразованию типов.

 

В приведенном примере перемножаются значения типа short и типа float. В подобных ситуациях, когда выполнение преобразования явно не указано, если это возможно, будет выполняться неявное преобразование. В данном примере выполняется преобразование short в значение типа float, поскольку преобразование из float в short должно задаваться явно, например, так: (short)floatVal * shortVal.