static void DeclareImplicitNumerics ( )
{
// Неявно типизированные числовые переменные.
var myUInt = 0u;
var myInt = 0;
var myLong = 0L;
var myDouble = 0.5;
var myFloat = 0.5F;
var myDecimal = 0.5M;
// Вывод лежащего в основе типа.
Console.WriteLine("myUInt is a: {0}", myUInt.GetType().Name);
Console.WriteLine("myInt is a: {0}", myInt.GetType().Name);
Console.WriteLine("myLong is a: {0}", myLong.GetType().Name);
Console.WriteLine("myDouble is a: {0}", myDouble.GetType().Name);
Console.WriteLine("myFloat is a: {0}", myFloat.GetType().Name);
Console.WriteLine("myDecimal is a: {0}", myDecimal.GetType().Name);
}
Ограничения неявно типизированных переменных
С использованием ключевого слова
var
связаны разнообразные ограничения. Прежде всего, неявная типизация применима только к локальным переменным внутри области видимости метода или свойства. Использовать ключевое слово
var
для определения возвращаемых значений, параметров или данных полей в специальном типе не допускается. Например, показанное ниже определение класса приведет к выдаче различных сообщений об ошибках на этапе компиляции:
class ThisWillNeverCompile
{
<b>// Ошибка! Ключевое слово var не может применяться к полям!</b>
private var myInt = 10;
<b>// Ошибка! Ключевое слово var не может применяться</b>
<b> // к возвращаемому значению или типу параметра!</b>
public var MyMethod(var x, var y){}
}
Кроме того, локальным переменным, которые объявлены с ключевым словом
var
,
обязано присваиваться начальное значение в самом объявлении, причем присваивать
null
в качестве начального значения
невозможно. Последнее ограничение должно быть рациональным, потому что на основании только
null
компилятору не удастся вывести тип, на который бы указывала переменная.
// Ошибка! Должно быть присвоено значение!
var myData;
// Ошибка! Значение должно присваиваться в самом объявлении!
var myInt;
myInt = 0;
// Ошибка! Нельзя присваивать null в качестве начального значения!
var myObj = null;
Тем не менее, присваивать
null
локальной переменной, тип которой выведен в результате начального присваивания, разрешено (при условии, что это ссылочный тип):
// Допустимо, если SportsCar имеет ссылочный тип!
var myCar = new SportsCar();
myCar = null;
Вдобавок значение неявно типизированной локальной переменной допускается присваивать другим переменным, которые типизированы как неявно, так и явно:
// Также нормально!
var myInt = 0;
var anotherlnt = myInt;
string myString = "Wake up!";
var myData = myString;
Кроме того, неявно типизированную локальную переменную разрешено возвращать вызывающему коду при условии, что возвращаемый тип метода и выведенный тип переменной, определенной посредством
var
, совпадают:
static int GetAnlntO
{
var retVal = 9;
return retVal;
}
Неявно типизированные данные строго типизированы
Имейте в виду, что неявная типизация локальных переменных дает в результате строго типизированные данные. Таким образом, применение ключевого слова
var
в языке C# — не тот же самый прием, который используется в сценарных языках (вроде JavaScript или Perl). Кроме того, ключевое слово
var
— это не тип данных
Variant
в СОМ, когда переменная на протяжении своего времени жизни может хранить значения разных типов (что часто называют
динамической типизацией).
На заметку! В C# поддерживается возможность динамической типизации с применением ключевого слова
dynamic
. Вы узнаете о таком аспекте языка в главе 18.
Взамен средство выведения типов сохраняет аспект строгой типизации языка C# и воздействует только на объявление переменных при компиляции. Затем данные трактуются, как если бы они были объявлены с выведенным типом; присваивание такой переменной значения другого типа будет приводить к ошибке на этапе компиляции.
static void ImplicitTypingIsStrongTyping()
{
// Компилятору известно, что s имеет тип System.String.
var s = "This variable can only hold string data!";
s = "This is fine...";
// Можно обращаться к любому члену лежащего в основе типа.
string upper = s.ToUpper();
// Ошибка! Присваивание числовых данных строке не допускается!
s = 44;
}
Полезность неявно типизированных локальных переменных
Теперь, когда вы видели синтаксис, используемый для объявления неявно типизируемых локальных переменных, вас наверняка интересует, в каких ситуациях его следует применять. Прежде всего, использование
var
для объявления локальных переменных просто ради интереса особой пользы не принесет. Такой подход может вызвать путаницу у тех, кто будет изучать код, поскольку лишает возможности быстро определить лежащий в основе тип данных и, следовательно, затрудняет понимание общего назначения переменной. Поэтому если вы знаете, что переменная должна относиться к типу
int
, то сразу и объявляйте ее с типом
int
!
