Язык программирования C#9 и платформа .NET5

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 = &quot;Wake up!&quot;;
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 = &quot;This variable can only hold string data!&quot;;
  s = &quot;This is fine...&quot;;
  // Можно обращаться к любому члену лежащего в основе типа.
  string upper = s.ToUpper();
  // Ошибка! Присваивание числовых данных строке не допускается!
  s = 44;
}
  
Полезность неявно типизированных локальных переменных
 
Теперь, когда вы видели синтаксис, используемый для объявления неявно типизируемых локальных переменных, вас наверняка интересует, в каких ситуациях его следует применять. Прежде всего, использование 
var
 для объявления локальных переменных просто ради интереса особой пользы не принесет. Такой подход может вызвать путаницу у тех, кто будет изучать код, поскольку лишает возможности быстро определить лежащий в основе тип данных и, следовательно, затрудняет понимание общего назначения переменной. Поэтому если вы знаете, что переменная должна относиться к типу 
int
, то сразу и объявляйте ее с типом 
int
!