Форум   Статьи   Новости   Файлы   Bugtraq   Сниффер   Друзья   О Клубе
Вернуться   HPC / Кодинг / .NET / C#
   
  Страница 1
  , 09:38   #1
Местный
 
Локация: Cyberspace
Регистрация: 01.07.2008
Сообщений: 122

Репутация: 75 / 1
Post Создание объектов динамического типа

C# является строго типизированным языком программирования. Вообще говоря, это означает, что все операции проверяются во время компиляции на соответствие типов, и поэтому действия, не поддерживаемые конкретным типом, не подлежат компиляции. И хотя строгий контроль типов дает немало преимуществ программирующему, помогая создавать устойчивые и надежные программы, он может вызвать определенные осложнения в тех случаях, когда тип объекта остается неизвестным вплоть до времени выполнения. Нечто подобное может произойти при использовании рефлексии, доступе к COM-объекту или же в том случае, если требуется возможность взаимодействия с таким динамическим языком, как, например, IronPython. До появления версии C# 4.0 подобные ситуации были трудноразрешимы. Поэтому для выхода из столь затруднительного положения в версии C# 4.0 был внедрен новый тип данных под названием dynamic.

За одним важным исключением, тип dynamic очень похож на тип object, поскольку его можно использовать для ссылки на объект любого типа. А отличается он от типа object тем, что вся проверка объектов типа dynamic на соответствие типов откладывает до времени выполнения, тогда как объекты типа object подлежат этой проверке во время компиляции. Преимущество откладывания подобной проверки до времени выполнения состоит в том, что во время компиляции предполагается, что объект типа dynamic поддерживает любые операции, включая применение операторов, вызовы методов, доступ к полям и т.д. Это дает возможность скомпилировать код без ошибок. Конечно, если во время выполнения фактический тип, присваиваемый объекту, не поддерживает ту или иную операцию, то возникнет исключительная ситуация во время выполнения.

В приведенном ниже примере программы применение типа dynamic демонстрируется на практике.

C# highlight
// Продемонстрировать применение типа dynamic. 

using System;
using System.Globalization; 

class DynDemo 
{
  static void Main() 
  {
    // Объявить две динамические переменные.
    dynamic str;
    dynamic val;
    // Поддерживается неявное преобразование в динамические типы. 
    // Поэтому следующие присваивания вполне допустимы. 
    str = "Это строка"; 
    val = 10; 

    Console.WriteLine("Переменная str содержит: " + str); 
    Console.WriteLine("Переменная val содержит: " + val + '\n'); 

    str = str.ToUpper(CultureInfo.CurrentCulture); 
    Console.WriteLine("Переменная str теперь содержит: " + str); 

    val = val + 2; 
    Console.WriteLine("Переменная val теперь содержит: " + val + '\n'); 

    string str2 = str.ToLower(CultureInfo.CurrentCulture); 
    Console.WriteLine("Переменная str2 содержит: " + str2); 

    // Поддерживаются неявные преобразования из динамических типов.
    int x = val * 2;
    Console.WriteLine("Переменная x содержит: " + x);
  }
}
Выполнение этой программы дает следующий результат.

source:
Переменная str содержит: Это строка 
Переменная val содержит: 10 

Переменная str теперь содержит: ЭТО СТРОКА 
Переменная val теперь содержит: 12 

Переменная str2 содержит: это строка 
Переменная x содержит: 24
Обратите внимание в этой программе на две переменные str и val, объявляемые с помощью типа dynamic. Это означает, что проверка на соответствие типов операций с участием обеих переменных не будет произведена во время компиляции. В итоге для них оказывается пригодной любая операция. В данном случае для переменной str вызываются методы ToUpper() и ToLower() класса String, а переменная участвует в операциях сложения и умножения. И хотя все перечисленные выше действия совместимы с типами объектов, присваиваемых обеим переменным в рассматриваемом здесь примере, компилятору об этом ничего не известно — он просто принимает. И это, конечно, упрощает программирование динамических процедур, хотя и допускает возможность появления ошибок в подобных действиях во время выполнения.

В разбираемом здесь примере программа ведет себя “правильно” во время выполнения, поскольку объекты, присваиваемые упомянутым выше переменным, поддерживают действия, выполняемые в программе. В частности, переменной val присваивается целое значение, и поэтому она поддерживает такие целочисленные операции, как сложение. А переменной str присваивается символьная строка, и поэтому она поддерживает строковые операции. Следует, однако, иметь в виду, что ответственность за фактическую поддержку типом объекта, на который делается ссылка, всех операций над данными типа dynamic возлагается на самого программирующего. В противном случае выполнение программы завершится аварийным сбоем.

В приведенном выше примере обращает на себя внимание еще одно обстоятельство: переменной типа dynamic может быть присвоен любой тип ссылки на объект благодаря неявному преобразованию любого типа в тип dynamic. Кроме того, тип dynamic автоматически преобразуется в любой другой тип. Разумеется, если во время выполнения такое преобразование окажется неправильным, то произойдет ошибка при выполнении. Так, если добавить в конце рассматриваемой здесь программы следующую строку кода:
C# highlight
bool b = val;
то возникнет ошибка при выполнении из-за отсутствия неявного преобразования типа int (который оказывается типом переменной val во время выполнения) в тип bool. Поэтому данная строка кода приведет к ошибке при выполнении, хотя она и будет скомпилирована безошибочно.

Прежде чем оставить данный пример программы, попробуйте поэкспериментировать с ней. В частности, измените тип переменных str и val на object, а затем попытайтесь скомпилировать программу еще раз. В итоге появятся ошибки при компиляции, поскольку тип object не поддерживает действия, выполняемые над обеими переменными, что и будет обнаружено во время компиляции. В этом, собственно, и заключается основное отличие типов object и dynamic. Несмотря на то, что оба типа могут использоваться для ссылки на объект любого другого типа, над переменной типа object можно производить только те действия, которые поддерживаются типом object. Если же вы используете тип dynamic, то можете указать какое угодно действие, при условии что это действие поддерживается конкретным объектом, на который делается ссылка во время выполнения.

Для того чтобы стало понятно, насколько тип dynamic способен упростить решение некоторых задач, рассмотрим простой пример его применения вместе с рефлексией. Как пояснялось в главе 17, чтобы вызвать метод для объекта класса, получаемого во время выполнения с помощью рефлексии, можно, в частности, обратиться к методу Invoke(). И хотя такой способ оказывается вполне работоспособным, нужный метод намного удобнее вызвать по имени в тех случаях, когда его имя известно. Например, вполне возможна такая ситуация, когда в некоторой сборке содержится конкретный класс, поддерживающий методы, имена и действия которых заранее известны. Но поскольку эта сборка подвержена изменениям, то приходится постоянно убеждаться в том, что используется последняя ее версия. Для проверки текущей версии сборки можно, например, воспользоваться рефлексией, сконструировать объект искомого класса, а затем вызвать методы, определенные в этом классе. Теперь эти методы можно вызвать по имени с помощью типа dynamic, а не метода Invoke(), поскольку их имена известны.

Разместите сначала приведенный ниже код в файле с именем MyClass.cs. Этот код будет динамически загружаться посредством рефлексии.
C# highlight
public class DivBy 
{
  public bool IsDivBy(int a, int b) 
  {
    if((a % b) == 0) return true;
      return false
  ;}
  public bool IsEven(int a) 
  {
    if((a % 2) == 0) return true;
      return false;
  }
}
Затем скомпилируйте этот файл в библиотеку DLL под именем MyClass.dll. Если вы пользуетесь компилятором командной строки, введите в командной строке следующее.

DOS Batch File highlight
csc /t:library MyClass.cs
Далее составьте программу, в которой применяется библиотека MyClass.dll, как показано ниже.

C# highlight
// Использовать тип dynamic вместе с рефлексией. 

using System;
using System.Reflection; 

class DynRefDemo 
{
  static void Main() 
  {
    Assembly asm = Assembly.LoadFrom("MyClass.dll");

    Type[] all = asm.GetTypes();

    // Найти класс DivBy. 
    int i; 
    for(i = 0; i < all.Length; i++) 
      if(all[i].Name == "DivBy") break;

    if(i == all.Length) 
    { 
      Console.WriteLine("Класс DivBy не найден в сборке."); 
      return; 
    }

    Type t = all[i];

    // А теперь найти используемый по умолчанию конструктор. 
    ConstructorInfo[] ci = t.GetConstructors(); 

    int j; 
    for(j = 0; j < ci.Length; j++) 
      if(ci[j].GetParameters().Length == 0) break; 

    if(j == ci.Length) 
    {
      Console.WriteLine("Используемый по умолчанию конструктор не найден.");
      return;
    }

    // Создать объект класса DivBy динамически. 
    dynamic obj = ci[j].Invoke(null); 

    // Далее вызвать по имени методы для переменной obj. Это вполне допустимо,
    // поскольку переменная obj относится к типу dynamic, а вызовы методов
    // проверяются на соответствие типов во время выполнения, а не компиляции.
    if(obj.IsDivBy(15, 3))
      Console.WriteLine("15 делится нацело на 3."); 
    else 
      Console.WriteLine("15 НЕ делится нацело на 3."); 

      if(obj.IsEven(9))
        Console.WriteLine("9 четное число.");
      else 
        Console.WriteLine("9 НЕ четное число.");
  }
}
Как видите, в данной программе сначала динамически загружается библиотека MyClass.dll, а затем используется рефлексия для построения объекта класса DivBy. Построенный объект присваивается далее переменной obj типа dynamic. А раз так, то методы IsDivBy() и IsEven()могут быть вызваны для переменной obj по имени, а не с помощью метода Invoke(). В данном примере это вполне допустимо, поскольку переменная obj на самом деле ссылается на объект класса DivBy. В противном случае выполнение программы завершилось бы неудачно.

Приведенный выше пример сильно упрощен и несколько надуман. Тем не менее, он наглядно показывает главное преимущество, которое дает тип dynamic в тех случаях, когда типы получаются во время выполнения. Когда характеристики искомого типа, в том числе методы, операторы, поля и свойства, заранее известны, эти характеристики могут быть получены по имени с помощью типа dynamic, как следует из приведенного выше примера. Благодаря этому код становится проще, короче и понятнее.

Применяя тип dynamic, следует также иметь в виду, что при компиляции программы тип dynamic фактически заменяется объектом, а для описания его применения во время выполнения предоставляется соответствующая информация. И поскольку тип dynamic компилируется в тип object для целей перегрузки, то оба типа, dynamic и object, расцениваются как одно и то же. Поэтому при компиляции двух следующих перегружаемых методов возникнет ошибка.

C# highlight
static void f(object v) 
{ 
// ... 
}
static void f(dynamic v) 
{ 
// ... 
} // Ошибка!
И последнее замечание: тип dynamic поддерживается компонентом DLR (Dynamic Language Runtime — средство создания динамических языков во время выполнения), внедренным в .NET 4.0.
__________________
Live long and prosper.
[SIGPIC][/SIGPIC]
Пользователь вне форума    
Наши Спонсоры
 

Метки
dynamic

Похожие темы
Тема Автор Раздел Ответов Последнее сообщение
Ключи для NOD xakel Антивирусы, Файрволы 436 07.06.2017 21:13
создание модификаций stalker dfdfy Gaming Zone 3 09.12.2012 17:32
Пошаговое Создание Учетки на Деде+Видео Урок Kontik Windows 3 14.04.2012 12:05
[Статья] Создание страниц сайта с помощью Web Builder wampire Новичкам 0 26.11.2010 15:14
Все о игре Fallout 3 Kiss Gaming Zone 29 01.11.2010 15:12



Часовой пояс GMT +2
Powered by vBulletin® 3.x.x Copyright ©2000 - 2012, Jelsoft Enterprises Ltd.

Copyright © 2008 - 2013 «HPC» Реклама на сайте Правила Форума Пользовательское соглашение Работа на сайте
При копировании материалов ставьте ссылку на источник
Все материалы представлены только в ознакомительных целях, администрация за их использование ответственности не несет.