В чем разница между dynamic (C# 4) и var?

переменные, объявленные с var неявно, но статически наберется. Переменные, объявленные с помощью динамический динамически типизированный. Эта возможность была добавлена в CLR для поддержки динамических языков, таких как Ruby и Python.

Я должен добавить, что это означает, что динамический заявления разрешаются во время выполнения, var заявления разрешаются во время компиляции.

Я собираюсь объяснить разницу между динамический и ВАР.

dynamic d1;
d1 = 1;
d1 = "http://mycodelogic.com";

это будет работать. компилятор может повторно создать тип динамический переменной.
сначала он создает тип как целое и после этого компилятор воссоздаст тип как строка
но в случае ВАР

var v1;  // Compiler will throw error because we have to initialized at the time of declaration  
var v2 = 1; // Compiler will create v1 as **integer**
v2 = "Suneel Gupta"; // Compiler will throw error because, compiler will not recreate the type of variable 

---

при использовании ‘ВАР’ ключевое слово, тип решается компилятором во время компиляции, тогда как при использовании ‘динамический’ ключевое слово, тип определяется средой выполнения.

---

'ВАР’ ключевое слово, сильно неявно типизированная локальная переменная, для которой компилятор может определить тип из выражения инициализации-очень полезно при выполнении программирования LINQ.

---

компилятор не имеет никакой информации о динамический тип переменной. так что компилятор не покажет никакого интеллекта .
компилятор имеет всю информацию о хранимой стоимостью ВАР введите так компилятор покажет интеллект.

---

динамический тип может быть передан в качестве аргумента функции, а функция также может возвращать тип объекта
но
ВАР тип не может быть передан в качестве аргумента функции, и функция не может возвращать тип объекта. Этот тип переменной может работать в области, где она определена.

var означает, что применяется статическая проверка типа (ранняя привязка). динамический подразумевает, что применяется динамическая проверка типа (поздняя привязка). С точки зрения кода, condsider следующее:

class Junk
{
    public void Hello()
    {
        Console.WriteLine("Hello");
    }
}

class Program
{
    static void Main(String[] args)
    {
        var a = new Junk();
        dynamic b = new Junk();

        a.Hello();

        b.Hello();
    }
}

Если вы скомпилируете это и проверите результаты с помощью ILSpy, вы обнаружите, что компилятор добавил некоторый поздний код привязки, который будет обрабатывать вызов Hello() из b, тогда как из-за того, что ранняя привязка была применена к a, a может вызвать Hello() напрямую.

например, (Разборка ILSpy)

using System;
namespace ConsoleApplication1
{
    internal class Junk
    {
        public void Hello()
        {
            Console.WriteLine("Hello");
        }
    }
}

using Microsoft.CSharp.RuntimeBinder;
using System;
using System.Runtime.CompilerServices;
namespace ConsoleApplication1
{
    internal class Program
    {
        [CompilerGenerated]
        private static class <Main>o__SiteContainer0
        {
            public static CallSite<Action<CallSite, object>> <>p__Site1;
        }
        private static void Main(string[] args)
        {
            Junk a = new Junk();      //NOTE: Compiler converted var to Junk
            object b = new Junk();    //NOTE: Compiler converted dynamic to object
            a.Hello();  //Already Junk so just call the method.

                          //NOTE: Runtime binding (late binding) implementation added by compiler.
            if (Program.<Main>o__SiteContainer0.<>p__Site1 == null)
            {
                Program.<Main>o__SiteContainer0.<>p__Site1 = CallSite<Action<CallSite, object>>.Create(Binder.InvokeMember(CSharpBinderFlags.ResultDiscarded, "Hello", null, typeof(Program), new CSharpArgumentInfo[]
                {
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null)
                }));
            }
            Program.<Main>o__SiteContainer0.<>p__Site1.Target(Program.<Main>o__SiteContainer0.<>p__Site1, b);
        }
    }
}

лучшее, что вы можете сделать, чтобы обнаружить разницу оставить себе немного консольное приложение, и проверить его самостоятельно с помощью ILSpy.

одна большая разница - вы можете иметь динамический тип возвращаемого значения.

dynamic Foo(int x)
{
    dynamic result;

    if (x < 5)
      result = x;
    else
      result = x.ToString();

    return result;
}

вот простой пример, который демонстрирует разницу между Dynamic (4.0) и Var

dynamic  di = 20;
dynamic ds = "sadlfk";
var vi = 10;
var vsTemp= "sdklf";

Console.WriteLine(di.GetType().ToString());          //Prints System.Int32
Console.WriteLine(ds.GetType().ToString());          //Prints System.String
Console.WriteLine(vi.GetType().ToString());          //Prints System.Int32
Console.WriteLine(vsTemp.GetType().ToString());      //Prints System.String

**ds = 12;**   //ds is treated as string until this stmt now assigning integer.

Console.WriteLine(ds.GetType().ToString());          **//Prints System.Int32**

**vs = 12**; //*Gives compile time error* - Here is the difference between Var and Dynamic. var is compile time bound variable.

Шива Mamidi

var Это просто сокращение для обычного объявления типа, где вы позволяете компилятору угадать правильный тип.

dynamic - это новый (статический) тип, где все проверки выполняются во время выполнения, а не компилятором.

тип переменной, объявленной с помощью var, определяется компилятором, это ярлык для указания имени типа, не более того.

однако динамика определяется во время выполнения, компилятор не имеет представления о фактическом типе, и все методы/поля/свойства доступа с этой переменной будут разработаны во время выполнения.

этой это хороший youtube видео, которое говорит о var VS Dynamic С практической демонстрацией.

ниже более подробное объяснение с моментальным снимком.

Var ранняя привязка (статически проверяется), а динамическая-поздняя привязка (динамически оценивается).

ключевое слово Var смотрит на ваши данные правой стороны, а затем во время компиляции он решает левые данные type.In другие слова var ключевое слово просто экономит вам набрав много вещей. Посмотрите на изображение ниже, где, когда мы дали строковые данные и переменная x показывает строковый тип данных в моей подсказке.

С другой стороны динамическое ключевое слово для совершенно другой цели. Динамические объекты оцениваются во время выполнения. Например, в приведенном ниже коде свойство "Length" существует или не оценивается во время выполнения.Я намеренно набрал небольшой "l", поэтому эта программа скомпилирована нормально, но когда она фактически выполнялась, она выбрасывала ошибку когда было вызвано свойство " length "(малый"l").

динамическая переменная и переменная var могут хранить любой тип значения, но его необходимо инициализировать "var" во время объявления.

компилятор не имеет никакой информации о "динамическом" типе переменной. VAR является безопасным компилятором, т. е. компилятор имеет всю информацию о сохраненном значении, так что он не вызывает никаких проблем во время выполнения.

динамический тип может быть передан как аргумент функции и функция также может вернуть его. Тип Var не может быть передан как функция аргумент и функция не могут возвращать тип объекта. Этот тип переменной может работать в области, где она определена.

в случае динамического приведения не требуется, но вам нужно знать свойство и методы , связанные с сохраненным типом, в то время как для var нет необходимости в приведении, потому что компилятор имеет всю информацию для выполнения операции.

dynamic: полезно при кодировании с использованием отражения или поддержки динамического языка или с объектами COM, потому что нам требуется писать меньше кода.

var: полезно при получении результата из запросов linq. В 3.5 framework он вводит для поддержки функции linq.

ссылки : Counsellingbyabhi

1. Var и dynamic определяют тип.
2. var во время компиляции, а динамические-во время выполнения.
3. в объявлении и инициализации var оба обязательны, как постоянная переменная while
4. в динамической инициализации может быть во время выполнения, такие как переменные только для чтения.
5. в типе var любой тип решается в момент инициализации не может измениться далее, но
6. динамический может принять любой тип даже пользователь определяет тип данных также.

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

1. ключевое слово Var(неявная типизированная локальная переменная) используется для определения локальной переменной variables.In в случае Var базовый тип данных определяется во время компиляции на основе начального назначения.После того , как начальное назначение было сделано с типом Var, он станет строго типизированным.Если вы попытаетесь сохранить любое несовместимое значение с типом Var, это приведет к ошибке времени компиляции.

пример:

Var strNameList=new List<string>(); By using this statement we can store list of names in the string format. 
strNameList.add("Senthil");
strNameList.add("Vignesh");

strNameList.add(45); // This statement will cause the compile time error.

но в динамическом типе, базовый тип определяется только во время выполнения.Динамический тип данных не проверяется во время компиляции, а также не является строго типизированным.Мы можем назначить любое начальное значение для динамического типа, а затем оно может быть переназначено на любое новое значение в течение его срока службы.

пример:

dynamic test="Senthil";
Console.Writeline(test.GetType())  // System.String

test=1222;
Console.Writeline(test.GetType())  // System.Int32

test=new List<string>();
Console.Writeline(test.GetType())  //System.Collections.Generic.List'1[System.String]

он не обеспечивает поддержку IntelliSense also.It не дает лучшей поддержки, когда мы даем работу с linq также.Потому что он не поддерживает лямбда-выражения ,методы расширения и анонимный методы.

вот различия

• var статически типизирован (время компиляции), динамический динамически типизирован (время выполнения)

• переменная, объявленная как var, может использоваться только локально, динамично переменные могут быть переданы в качестве параметров функции (сигнатура функции можно определить параметр как динамический, но не ВАР).

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

• приведение типа с var невозможно, но с динамическим его возможным (вы можете привести объект как динамический, но не как var).

Vijayraghavan Арун