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

}
 
Использование неявной типизации лишь потому, что она возможна, некоторые считают плохим стилем (если известно, что необходима переменная типа 
List<int>
, то так и следует ее объявлять). Однако, как было показано в главе 13, неявная типизация удобна в сочетании с LINQ, поскольку многие запросы LINQ возвращают перечисления анонимных классов (через проецирование), которые напрямую объявлять в коде C# невозможно. Тем не менее, даже в таких случаях неявно типизированная переменная фактически будет строго типизированной.
В качестве связанного замечания: в главе 6 упоминалось, что 
System.Object
 является изначальным родительским классом внутри инфраструктуры .NET Core и может представлять все, что угодно. Опять-таки, объявление переменной типа 
object
 в результате дает строго типизированный фрагмент данных, но то, на что указывает эта переменная в памяти, может отличаться в зависимости от присваиваемой ссылки. Чтобы получить доступ к членам объекта, на который указывает ссылка в памяти, понадобится выполнить явное приведение.
Предположим, что есть простой класс по имени 
Person
, в котором определены два автоматических свойства (
FirstName
 и 
LastName
), инкапсулирующие данные 
string
. Взгляните на следующий код:
static void UseObjectVariable()
{
<b>  // Пусть имеется класс по имени Person.</b>
  object o = new Person() { FirstName = &quot;Mike&quot;, LastName = &quot;Larson&quot; };
<b>  // Для получения доступа к свойствам Person</b>
<b>.</b>
<b>  // переменную о потребуется привести к Person</b>
  Console.WriteLine(&quot;Person's first name is {0}&quot;, ((Person)o).FirstName);
}
 
А теперь возвратимся к ключевому слову 
dynamic
. С высокоуровневой точки значения ключевое слово 
dynamic
 можно трактовать как специализированную форму типа 
System.Object
 — в том смысле, что переменной динамического типа данных может быть присвоено любое значение. На первый взгляд это может привести к серьезной путанице, поскольку теперь получается, что доступны три способа определения данных, внутренний тип которых явно не указан в кодовой базе. Например, следующий метод:
static void PrintThreeStrings()
{
  var s1 = &quot;Greetings&quot;;
  object s2 = &quot;From&quot;;
  dynamic s3 = &quot;Minneapolis&quot;;
  Console.WriteLine(&quot;s1 is of type: {0}&quot;, s1.GetType());
  Console.WriteLine(&quot;s2 is of type: {0}&quot;, s2.GetType());
  Console.WriteLine(&quot;s3 is of type: {0}&quot;, s3.GetType());
}
 
в случае вызова приведет к такому выводу:
s1 is of type: System.String
s2 is of type: System.String
s3 is of type: System.String
Динамическая переменная и переменная, объявленная неявно или через ссылку на 
System.Object
, существенно отличаются тем, что динамическая переменная не является строго типизированной. Выражаясь по-другому, динамические данные не типизированы статически. Для компилятора C# ситуация выглядит так, что элементу данных, объявленному с ключевым словом 
dynamic
, можно присваивать вообще любое начальное значение, и на протяжении периода его существования взамен начального значения может быть присвоено любое новое (возможно, не связанное) значение. Рассмотрим показанный ниже метод и результирующий вывод:
static void ChangeDynamicDataType()
{
  // Объявить одиночный динамический элемент данных по имени t
.
  dynamic t = &quot;Hello!&quot;;
  Console.WriteLine(&quot;t is of type: {0}&quot;, t.GetType());
  t = false;
  Console.WriteLine(&quot;t is of type: {0}&quot;, t.GetType());
  t = new List&lt;int&gt;();
  Console.WriteLine(&quot;t is of type: {0}&quot;, t.GetType());
}
 
Вот вывод:
t is of type: System.String
t is of type: System.Boolean
t is of type: System.Collections.Generic.List`1[System.Int32]
Имейте в виду, что приведенный выше код успешно скомпилировался и дал бы идентичный результат, если бы переменная 
t
 была объявлена с типом 
System.Object
. Однако, как вскоре будет показано, ключевое слово 
dynamic
 предлагает много дополнительных возможностей.
  
Вызов членов на динамически объявленных данных
 
Учитывая то, что динамическая переменная способна принимать идентичность любого типа на лету (подобно переменной типа 
System.Object
), у вас может возникнуть вопрос о способе обращения к членам такой переменной (свойствам, методам, индексаторам, событиям и т.п.). С точки зрения синтаксиса отличий нет. Нужно просто применить операцию точки к динамической переменной, указать открытый член и предоставить любые аргументы (если они требуются).
Но (и это очень важное "но") допустимость указываемых членов компилятор проверять не будет! Вспомните, что в отличие от переменной, определенной с типом 
System.Object
, динамические данные не являются статически типизированными. Вплоть до времени выполнения не будет известно, поддерживают ли вызываемые динамические данные указанный член, переданы ли корректные параметры, правильно ли записано имя члена, и т.д. Таким образом, хотя это может показаться странным, следующий метод благополучно скомпилируется: