parameter - ¿Cuál es la diferencia entre dynamic(C#4) y var?

object c#

Question

Había leído un montón de artículos sobre esa nueva palabra clave que se enviará con C # v4, pero no pude distinguir la diferencia entre un "dinámico" y "var".

Este artículo me hizo pensar en ello, pero todavía no puedo ver ninguna diferencia.

¿Es que puede usar "var" solo como una variable local, pero dinámica como local y global?

Lo siento por mi ignorancia, pero ¿podría mostrar algún código sin palabra clave dinámica y luego mostrar el mismo código con la palabra clave dinámica?

Answer 1

1. La palabra clave Var (variable local tipeada implícita) se utiliza para definir variables locales. En el caso de Var, el tipo de datos subyacente se determina en tiempo de compilación según la asignación inicial. Una vez que la asignación inicial se ha realizado con el tipo Var, se se escribirá fuertemente. Si intenta almacenar cualquier valor incompatible con el tipo Var, se producirá un error de tiempo de compilación.

Ejemplo:

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.

Pero en tipo dinámico, el tipo subyacente se determina solo en tiempo de ejecución. El tipo de datos dinámicos no se comprueba en tiempo de compilación y tampoco está tipeado con fuerza. Podemos asignar cualquier valor inicial para el tipo dinámico y luego se puede reasignar a cualquier nuevo valor durante su tiempo de vida.

Ejemplo:

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]

Tampoco proporciona soporte de IntelliSense. No da mejor soporte cuando también proporcionamos trabajo con linq. Porque no admite expresiones lambda, métodos de extensión y métodos anónimos.

Answer 2

1. Var y tipo de definición dinámica.
2. var en el tiempo de compilación mientras dinámico está en tiempo de ejecución.
3. en la declaración var y la inicialización ambos son obligatorios como variable constante mientras
4. en inicialización dinámica puede estar en tiempo de ejecución como variables de solo lectura.
5. en el tipo var cualquier tipo que se decida en el momento de la inicialización no puede cambiar a continuación, pero
6. dinámico puede adoptar cualquier tipo incluso usuario definir tipo de datos también.

Answer 3

Aquí están las diferencias

• var está estáticamente estátizado (tiempo de compilación), dinámico está tipeado dinámicamente (tiempo de ejecución)

• Una variable declarada como var solo se puede usar localmente, las variables dinámicas se pueden pasar como parámetros a la función (la firma de la función puede definir un parámetro como dinámico pero no var).

• con la resolución dinámica de las propiedades ocurre en tiempo de ejecución y ese no es el caso con var, lo que significa que en tiempo de compilación cualquier variable declarada como dinámica puede llamar a un método que puede existir o no y por lo tanto el compilador no lanzará un error.

• No es posible realizar la conversión de tipos con var pero con dinámica (puede convertir un objeto en dinámico pero no en var).

Arun Vijayraghavan

Answer 4

Aquí hay un ejemplo simple que demuestra la diferencia entre Dynamic (4.0) y 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.

Shiva Mamidi

Answer 5

El tipo de variable declarada con var está determinada por el compilador, es un atajo para especificar el nombre del tipo, nada más.

Sin embargo, la dinámica se determina en tiempo de ejecución, el compilador no tiene idea del tipo real y todos los accesos de método / campo / propiedad con esa variable se resolverán en el tiempo de ejecución.

Answer 6

La variable dinámica y la variable var pueden almacenar cualquier tipo de valor, pero es necesario para inicializar ''var'' en el momento de la declaración.

El compilador no tiene ninguna información sobre el tipo de variable "dinámica". var es compilador seguro, es decir, el compilador tiene toda la información sobre el valor almacenado, para que no cause ningún problema en tiempo de ejecución.

El tipo dinámico se puede pasar como argumento de función y la función también puede devolverlo. El tipo Var no se puede pasar como argumento de función y la función no puede devolver el tipo de objeto. Este tipo de variable puede funcionar en el ámbito donde se define.

En caso de Casting dinámico no es necesario, pero necesita conocer la propiedad y los métodos relacionados con el tipo almacenado, mientras que para var No es necesario realizar el colado porque el compilador tiene toda la información para realizar la operación.

dynamic: Útil cuando se codifica utilizando el soporte de reflexión o lenguaje dinámico o con los objetos COM, porque necesitamos escribir menos cantidad de código.

var: Útil al obtener el resultado de las consultas de linq. En el marco 3.5 introduce la función de soporte linq.

Referencia: Counsellingbyabhi

Answer 7

Las variables declaradas con var están implícita pero estáticamente tipadas. Las variables declaradas con dinámica son tipadas dinámicamente. Esta capacidad se agregó al CLR para admitir lenguajes dinámicos como Ruby y Python.

Debo agregar que esto significa que las declaraciones dinámicas se resuelven en tiempo de ejecución, las declaraciones de var se resuelven en tiempo de compilación.

Answer 8

No confundas dinámicas y var. Declarar una variable local usando var es solo un atajo sintáctico que hace que el compilador infiera el tipo de datos específico de una expresión. La palabra clave var se puede usar solo para declarar variables locales dentro de un método, mientras que la palabra clave dinámica se puede usar para variables locales, campos y argumentos. No puede convertir una expresión en var, pero puede convertir una expresión en dinámica. Debe inicializar explícitamente una variable declarada utilizando var, mientras que no tiene que inicializar una variable declarada con dynamic.

Answer 9

Una gran diferencia: puede tener un tipo de devolución dinámica.

dynamic Foo(int x)
{
    dynamic result;

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

    return result;
}

Answer 10

Voy a explicar la diferencia entre dinámico y var .

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

Esto funcionará el compilador puede volver a crear el tipo de variable dinámica .
primero crea tipo como un entero y luego el compilador recreará el tipo como una cadena
pero en el caso de var

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 

Cuando se utiliza la palabra clave '' var '', el compilador decide el tipo en el momento de la compilación, mientras que cuando usa la palabra clave '' dinámica '', el tipo de ejecución lo decide el tiempo de ejecución. La palabra clave '' var '', una variable local fuertemente implícitamente tipada para la cual el compilador puede determinar el tipo a partir de la expresión de inicialización, muy útil cuando se hace la programación LINQ. El compilador no tiene ninguna información sobre el tipo dinámico de variable. entonces el compilador no mostrará ninguna inteligencia.
el compilador tiene toda la información sobre el valor almacenado de tipo var para que el compilador muestre inteligencia. El tipo dinámico se puede pasar como argumento de función y la función también puede devolver el tipo de objeto
Pero
El tipo var no se puede pasar como argumento de función y la función no puede devolver el tipo de objeto. Este tipo de variable puede funcionar en el ámbito donde se define.

Answer 11

var implica que se aplica la comprobación de tipos estáticos (vinculación anticipada). dinámico implica que se aplica la comprobación dinámica de tipos (enlace tardío). En términos del código, condsider lo siguiente:

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();
    }
}

Si compila esto e inspecciona los resultados con ILSpy, encontrará que el compilador ha agregado algún código de enlace tardío que manejará la llamada a Hello () desde b, mientras que debido a que el enlace temprano se aplicó a a, a es capaz de llamar a Hello () directamente.

por ejemplo, (desmontaje 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);
        }
    }
}

Lo mejor que puede hacer para descubrir la diferencia es escribirse una pequeña aplicación de consola como esta, y probarla usted mismo con ILSpy.

Answer 12

This es un buen video de youtube que habla de var VS Dynamic con demostración práctica.

A continuación hay una explicación más detallada con una instantánea.

Var es enlazado temprano (comprobado estáticamente) mientras que dinámico es enlazado tarde (evaluado dinámicamente).

La palabra clave Var mira los datos del lado derecho y luego, durante el tiempo de compilación, decide el tipo de datos de la mano izquierda. En otras palabras, la palabra clave var te ahorra escribir muchas cosas. Eche un vistazo a la imagen de abajo donde, cuando hemos dado datos de cadena y la variable x muestra el tipo de datos de cadena en mi información sobre herramientas.

Por otro lado, la palabra clave dinámica tiene un propósito completamente diferente. Los objetos dinámicos se evalúan durante el tiempo de ejecución. Por ejemplo, en el código siguiente la propiedad "Length" existe o no se evalúa durante el tiempo de ejecución. He escrito a propósito una pequeña "l", por lo que este programa compiló bien pero cuando realmente se ejecutó arrojó un error cuando la propiedad "length" fue llamado (PEQUEÑO "l").

Answer 13

var es solo una abreviatura de una declaración de tipo normal, donde le permite al compilador adivinar el tipo correcto.

dynamic es un tipo nuevo (estático), donde todas las comprobaciones se realizan en tiempo de ejecución, no por el compilador.

Answer 14

var está estáticamente tipado - el compilador y el tiempo de ejecución conocen el tipo - solo le ahorran algo de tipeo ... los siguientes son 100% idénticos:

var s = "abc";
Console.WriteLine(s.Length);

y

string s = "abc";
Console.WriteLine(s.Length);

Todo lo que sucedió fue que el compilador descubrió que s debe ser una cadena (del inicializador). En ambos casos, sabe (en la IL) que en la s.Length significa la propiedad (instancia) string.Length . string.Length .

dynamic es una bestia muy diferente; es más similar al object , pero con despacho dinámico:

dynamic s = "abc";
Console.WriteLine(s.Length);

Aquí, s está escrito como dinámico . No sabe sobre string.Length , porque no sabe nada de s en tiempo de compilación. Por ejemplo, lo siguiente sería compilar (pero no ejecutar) también:

dynamic s = "abc";
Console.WriteLine(s.FlibbleBananaSnowball);

En tiempo de ejecución (solo), comprobaría la propiedad FlibbleBananaSnowball , no lo encontraría y explotaría en una lluvia de chispas.

Con dynamic , propiedades / métodos / operadores / etc se resuelven en tiempo de ejecución , en función del objeto real. Muy útil para hablar con COM (que puede tener propiedades solo de tiempo de ejecución), DLR u otros sistemas dinámicos, como javascript .