В то время как многие согласятся с тем, что явное указание типа данных для каждой переменной является рекомендуемой практикой, язык C# поддерживает возможность неявной типизации локальных переменных с использованием ключевого слова
var
. Ключевое слово
var
может применяться вместо указания конкретного типа данных (такого как
int
,
bool
или
string
). Когда
вы поступаете подобным образом, компилятор будет автоматически выводить лежащий в основе тип данных на основе начального значения, используемого для инициализации локального элемента данных.
Чтобы прояснить роль неявной типизации, создайте новый проект консольного приложения по имени
ImplicitlyTypedLocalVars
и добавьте его в свое решение. Обновите код в
Program.cs
, как показано ниже:
using System;
using System.Linq;
Console.WriteLine("***** Fun with Implicit Typing *****");
Добавьте следующую функцию, которая демонстрирует неявные объявления:
static void DeclareImplicitVars
{
// Неявно типизированные локальные переменные
// объявляются следующим образом:
// var имяПеременной = начальноеЗначение;
var myInt = 0;
var myBool = true;
var myString = "Time, marches on...";
}
На заметку! Строго говоря,
var
не является ключевым словом языка С#. Вполне допустимо объявлять переменные, параметры и поля по имени
var
, не получая ошибок на этапе компиляции. Однако когда лексема
var
применяется в качестве типа данных, то в таком контексте она трактуется компилятором как ключевое слово.
В таком случае, основываясь на первоначально присвоенных значениях, компилятор способен вывести для переменной
myInt
тип
System.Int32
, для переменной
myBool
— тип
System.Boolean
, а для переменной
myString
— тип
System.String
. В сказанном легко убедиться за счет вывода на консоль имен типов с помощью рефлексии. Как будет показано в главе 17, рефлексия представляет собой действие по определению состава типа во время выполнения. Например, с помощью рефлексии можно определить тип данных неявно типизированной локальной переменной. Модифицируйте метод
DeclareImplicitVars
:
static void DeclareImplicitVars
{
// Неявно типизированные локальные переменные,
var myInt = 0;
var myBool = true;
var myString = "Time, marches on...";
// Вывести имена лежащих в основе типов.
Console.WriteLine("myInt is a: {0}", myInt.GetType.Name);
// Вывод типа myInt
Console.WriteLine("myBool is a: {0}", myBool.GetType.Name);
// Вывод типа myBool
Console.WriteLine("myString is a: {0}", myString.GetType.Name);
// Вывод типа myString
}
На
заметку! Имейте в виду, что такую неявную типизацию можно использовать для любых типов, включая массивы, обобщенные типы (см. главу 10) и собственные специальные типы. В дальнейшем вы увидите и другие примеры неявной типизации. Вызов метода
DeclareImplicitVars
в операторах верхнего уровня дает следующий вывод:
***** Fun with Implicit Typing *****
myInt is a: Int32
myBool is a: Boolean
myString is a: String
Неявное объявление чисел
Неявное объявление Как утверждалось ранее, целые числа по умолчанию получают тип
int
, а числа с плавающей точкой — тип
double
. Создайте новый метод по имени
DeclareImplicitNumerics
и поместите в него показанный ниже код, в котором демонстрируется неявное объявление чисел:
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
{
// Ошибка! Ключевое слово var не может применяться к полям!
private var myInt = 10;
// Ошибка! Ключевое слово var не может применяться
// к возвращаемому значению или типу параметра!
public var MyMethod(var x, var y){}
}
Кроме того, локальным переменным, которые объявлены с ключевым словом
var
, обязано присваиваться начальное значение в самом объявлении, причем присваивать
null
в качестве начального значения невозможно. Последнее ограничение должно быть рациональным, потому что на основании только
null
компилятору не удастся вывести тип, на который бы указывала переменная.