Console.WriteLine("sb has {0} chars.", sb.Length);
Console.WriteLine;
}
Здесь создается объект
StringBuilder
с начальным значением
"**** Fantastic Games ****"
. Как видите, можно добавлять строки в конец внутреннего буфера, а также заменять или удалять любые символы. По умолчанию
StringBuilder
способен хранить строку только длиной 16 символов или меньше (но при необходимости будет автоматически расширяться): однако стандартное начальное значение длины можно изменить посредством дополнительного аргумента конструктора:
// Создать экземпляр StringBuilder с исходным размером в 256 символов.
StringBuilder sb = new StringBuilder("**** Fantastic Games ****", 256);
При добавлении большего количества символов, чем в указанном лимите, объект
StringBuilder
скопирует свои данные в новый экземпляр и увеличит размер буфера на заданный лимит.
Сужающие и расширяющие преобразования типов данных
Теперь, когда вы понимаете, как работать с внутренними типами данных С#, давайте рассмотрим связанную тему преобразования типов данных. Создайте новый проект консольного приложения по имени
TypeConversions
и добавьте его в свое решение. Приведите код к следующему виду:
using System;
Console.WriteLine("***** Fun with type conversions *****");
// Сложить две переменные типа short и вывести результат.
short numb1 = 9, numb2 = 10;
Console.WriteLine("{0} + {1} = {2}",
numb1, numb2, Add(numb1, numb2));
Console.ReadLine;
static int Add(int x, int y)
{
return x + y;
}
Легко заметить, что метод
Add
ожидает передачи двух параметров
int
. Тем не менее, в вызывающем коде ему на самом деле передаются две переменные типа
short
. Хотя это может выглядеть похожим на несоответствие типов данных, программа компилируется и выполняется без ошибок, возвращая ожидаемый результат 19.
Причина, по которой компилятор считает такой код синтаксически корректным, связана с тем, что потеря данных в нем невозможна. Из-за того, что максимальное значение для типа
short
(32 767) гораздо меньше максимального значения для типа
int
(2 147 483 647), компилятор неявно расширяет каждое значение
short
до типа
int
. Формально термин расширение используется для определения неявного восходящего приведения которое не вызывает потерю данных.
На заметку! Разрешенные расширяющие и сужающие (обсуждаются далее) преобразования, поддерживаемые для каждого типа данных С#, описаны в разделе "Type Conversion Tables in .NET" ("Таблицы преобразования типов в .NET") документации по .NET Core.
Несмотря
на то что неявное расширение типов благоприятствовало в предыдущем примере, в других ситуациях оно может стать источником ошибок на этапе компиляции. Например, пусть для переменных
numb1
и
numb2
установлены значения, которые (при их сложении) превышают максимальное значение типа
short
. Кроме того, предположим, что возвращаемое значение метода
Add
сохраняется в новой локальной переменной
short
, а не напрямую выводится на консоль.
static void Main(string[] args)
{
Console.WriteLine("***** Fun with type conversions *****");
// Следующий код вызовет ошибку на этапе компиляции!
short numb1 = 30000, numb2 = 30000;
short answer = Add(numb1, numb2);
Console.WriteLine("{0} + {1} = {2}",
numb1, numb2, answer);
Console.ReadLine;
}
В данном случае компилятор сообщит об ошибке:
Cannot implicitly convert type 'int' to 'short'. An explicit conversion exists (are you missing a cast?)
He удается неявно преобразовать тип int в short. Существует явное преобразование (возможно, пропущено приведение)
Проблема в том, что хотя метод
Add
способен возвратить значение
int
, равное 60 000 (которое умещается в допустимый диапазон для
System.Int32
), это значение не может быть сохранено в переменной
short,
потому что выходит за пределы диапазона допустимых значений для типа
short
. Выражаясь формально, среде CoreCLR не удалось применить сужающую операцию. Нетрудно догадаться, что сужающая операция является логической противоположностью расширяющей операции, поскольку предусматривает сохранение большего значения внутри переменной типа данных с меньшим диапазоном допустимых значений.
Важно отметить, что все сужающие преобразования приводят к ошибкам на этапе компиляции, даже когда есть основание полагать, что такое преобразование должно пройти успешно. Например, следующий код также вызовет ошибку при компиляции:
// Снова ошибка на этапе компиляции!
static void NarrowingAttempt
{
byte myByte = 0;
int myInt = 200;
myByte = myInt;
Console.WriteLine("Value of myByte: {0}", myByte);
}
Здесь значение, содержащееся в переменной типа
int(myInt)
, благополучно умещается в диапазон допустимых значений для типа
byte
; следовательно, можно было бы ожидать, что сужающая операция не должна привести к ошибке во время выполнения. Однако из-за того, что язык C# создавался с расчетом на безопасность в отношении типов, все-таки будет получена ошибка на этапе компиляции.
