Compartir a través de

Resolución de advertencias relacionadas con el tipo dinámico y el enlace dinámico

En este artículo se tratan los siguientes errores del compilador:

  • CS1962: el typeof operador no se puede usar en el dynamic tipo .
  • CS1964: No se puede aplicar la conversión dinámica a una expresión.
  • CS1965: no se puede derivar del dynamic tipo .
  • CS1966: No se puede derivar de un tipo dinámico construido.
  • CS1967: no se puede usar el dynamic tipo como una restricción de tipo.
  • CS1968: no se puede usar un tipo dinámico construido como una restricción de tipo.
  • CS1969: no se encuentra uno o varios tipos necesarios para compilar una expresión dinámica.
  • CS1970: No usar 'System.Runtime.CompilerServices.DynamicAttribute'. Use la palabra clave 'dynamic' en su lugar.
  • CS1971: La llamada al miembro necesita ser despachada dinámicamente, pero no puede serlo porque es parte de una expresión de acceso base. Considere la posibilidad de castear los argumentos dinámicos o eliminar el acceso base.
  • CS1972: el acceso al indexador necesita enviarse dinámicamente, pero no puede hacerse porque forma parte de una expresión de acceso base. Considere la posibilidad de realizar un cast de los argumentos dinámicos o eliminar la expresión de acceso base.
  • CS1973: el tipo de argumento dinámico no coincide con el tipo de parámetro de destino para el método de extensión.
  • CS1974: el envío dinámico a un método condicional producirá un error en tiempo de ejecución.
  • CS1975: La llamada al constructor debe enviarse dinámicamente, pero no puede deberse a que forma parte de un inicializador de constructor. Considere la posibilidad de convertir los argumentos dinámicos.
  • CS1976: No se puede usar un grupo de métodos como argumento para una operación enviada dinámicamente.
  • CS1977: No se puede usar una expresión lambda como argumento para una operación enviada dinámicamente.
  • CS1978: No se puede usar una expresión como argumento para una operación enviada dinámicamente.
  • CS1979: no se permiten expresiones de consulta con una secuencia de origen o combinación de tipo dinámico.
  • CS1980: no se puede definir una clase o miembro que use "dynamic" porque falta el tipo necesario del compilador.
  • CS1981: El patrón "is dynamic" es engañoso. Use 'is object' en su lugar.
  • CS7083: La expresión debe convertirse implícitamente en "System.Object" o el tipo "dynamic" no está disponible.
  • CS8133: No se pueden deconstruir objetos dinámicos.
  • CS8364: un argumento para 'nameof' no puede usar ninguna operación dinámica.
  • CS8416: el modificador asincrónico no se puede usar en la expresión de un atributo dinámico.
  • CS9230: No se puede realizar una invocación dinámica en una expresión con tipo .

Uso de dynamic en declaraciones de tipo y restricciones

  • CS1962: el operador typeof no se puede usar en el dynamic tipo .
  • CS1965: No se puede derivar del tipo dynamic.
  • CS1966: No se puede derivar de un tipo dinámico construido.
  • CS1967: no se puede usar el dynamic tipo como una restricción de tipo.
  • CS1968: no se puede usar un tipo dinámico construido como una restricción de tipo.
  • CS1970: No usar 'System.Runtime.CompilerServices.DynamicAttribute'. Use la palabra clave 'dynamic' en su lugar.

El dynamic tipo proporciona enlace dinámico para las operaciones en tiempo de ejecución. Use tipos concretos en contextos en los que el compilador necesita información de tipos en tiempo de compilación, como declaraciones de tipos, restricciones, herencia o operaciones de reflexión:

  • Use tipos concretos para las operaciones de reflexión. Usar tipos específicos en lugar de dynamic con el typeof operador (CS1962)
  • Use tipos concretos para la herencia. Especifique una clase base concreta en lugar de dynamic (CS1965, CS1966):
  • Use restricciones de tipo concreto. Especifique restricciones de tipo concretas en parámetros genéricos en lugar de dynamic (CS1967, CS1968):
  • Use la dynamic palabra clave para variables. Use siempre la dynamic palabra clave para declarar variables dinámicas. No aplique DynamicAttribute directamente (CS1970):

Para obtener más información sobre el dynamic tipo y su uso adecuado, consulte Uso dinámico de tipos.

Restricciones de operación dinámica

  • CS1964: No se puede aplicar la conversión dinámica a una expresión.
  • CS1971: la llamada al miembro debe enviarse dinámicamente, pero no puede deberse a que forma parte de una expresión de acceso base. Considere la posibilidad de convertir los argumentos dinámicos o eliminar el acceso base.
  • CS1972: el acceso del indexador debe despacharse dinámicamente, pero no puede hacerse porque forma parte de una expresión de acceso base. Considere convertir los argumentos dinámicos o eliminar el acceso base.
  • CS1973: el tipo de argumento dinámico no coincide con el tipo de parámetro de destino para el método de extensión.
  • CS1975: La llamada al constructor debe enviarse dinámicamente, pero no puede deberse a que forma parte de un inicializador de constructor. Considere la posibilidad de convertir los argumentos dinámicos.
  • CS1976: No se puede usar un grupo de métodos como argumento para una operación enviada dinámicamente.
  • CS1977: No se puede usar una expresión lambda como argumento para una operación enviada dinámicamente.
  • CS1978: No se puede usar una expresión como argumento para una operación enviada dinámicamente.
  • CS1979: no se permiten expresiones de consulta con una secuencia de origen o combinación de tipo dinámico.
  • CS8133: No se pueden deconstruir objetos dinámicos.
  • CS8364: un argumento para 'nameof' no puede usar ninguna operación dinámica.
  • CS8416: el modificador asincrónico no se puede usar en la expresión de un atributo dinámico.
  • CS9230: No se puede realizar una invocación dinámica en una expresión con tipo .

Aunque el enlace dinámico proporciona flexibilidad en tiempo de ejecución, convierta valores dinámicos en tipos específicos cuando necesite información de tipos en tiempo de compilación para determinadas operaciones.

  • Convertir argumentos dinámicos antes de llamar a miembros base: Convierta argumentos dinámicos a sus tipos específicos antes de llamar a miembros base, indexadores o constructores (CS1971, CS1972, CS1975):

    class Base
{
    public virtual void Method(object obj) { }
    public virtual int this[int index] => 0;
    public Base(int value) { }
}

class Derived : Base
{
    public Derived(dynamic value) : base((int)value) { }  // Cast before calling base constructor

    public override void Method(object obj)
    {
        dynamic d = obj;
        base.Method((object)d);  // Cast before calling base method
    }

    public override int this[int index]
    {
        get
        {
            dynamic d = index;
            return base[(int)d];  // Cast before accessing base indexer
        }
    }
}

  • Realice una conversión de tipo a tipos específicos antes de pasar delegados o lambdas: Realice una conversión de tipo del objeto dinámico a su tipo concreto antes de pasar Grupos de Métodos, Expresiones Lambda o Delegados (CS1976, CS1977, CS1978):

    dynamic d = GetDynamicObject();

// Avoid:
d.ProcessData(Console.WriteLine);  // CS1976
d.ProcessData(x => x * 2);         // CS1977

// Recommended:
((IProcessor)d).ProcessData(Console.WriteLine);  // Cast first
((IProcessor)d).ProcessData(x => x * 2);         // Cast first

  • Use tipos concretos para consultas LINQ: Use un tipo concreto en lugar de dynamic para fuentes de consulta LINQ y secuencias de combinación (CS1979):

    dynamic data = GetData();

// Avoid:
var query = from item in data  // CS1979
            select item;

// Recommended:
IEnumerable<MyType> typedData = data;
var query = from item in typedData
            select item;

  • Acceda a los elementos de una tupla de manera individual: Acceda a los elementos de una tupla de manera individual en vez de utilizar la deconstrucción con tuplas dinámicas (CS8133):

    dynamic tuple = (1, 2);

// Avoid:
var (a, b) = tuple;  // CS8133

// Recommended:
var a = tuple.Item1;
var b = tuple.Item2;

  • Use expresiones en tiempo de compilación para las operaciones que requieren información de tipo: Use tipos concretos para las operaciones que necesitan información de tipo en tiempo de compilación (CS1964, CS1973, CS8364, CS8416, CS9230):

    dynamic value = GetValue();

// Avoid:
var name = nameof(value.Property);  // CS8364

// Recommended:
MyType typedValue = value;
var name = nameof(typedValue.Property);  // Use concrete type

Para obtener más información sobre el enlace dinámico y sus limitaciones, consulte Uso de tipo dinámico.

Falta soporte en tiempo de ejecución para elementos dinámicos.

  • CS1969: no se encuentra uno o varios tipos necesarios para compilar una expresión dinámica. ¿Falta una referencia a "Microsoft.CSharp.dll"?
  • CS1980: no se puede definir una clase o miembro que use "dynamic" porque no se encuentra el tipo necesario del compilador. ¿Falta una referencia?
  • CS7083: La expresión debe convertirse implícitamente en "System.Object" o el tipo "dynamic" no está disponible.

El compilador necesita tipos del espacio de nombres System.Runtime y del Dynamic Language Runtime (DLR) para generar código para operaciones dinámicas (CS1969, CS1980, CS7083). Asegúrese de que el proyecto incluye las referencias necesarias. Los tipos necesarios se incluyen en todos los proyectos modernos de .NET (.NET 5 y versiones posteriores). En el caso de los proyectos de .NET Framework, agregue una referencia a Microsoft.CSharp.dll en el archivo del proyecto.

Para obtener más información sobre los requisitos de tipos dinámicos, consulte Uso de tipos dinámicos.

Advertencias de distribución dinámica

  • CS1974: La llamada enviada dinámicamente al método puede producir un error en tiempo de ejecución porque una o varias sobrecargas aplicables son métodos condicionales.
  • CS1981: El patrón "is dynamic" es engañoso. El tipo en tiempo de ejecución de la subexpresión nunca es "dynamic". Considere la posibilidad de usar 'object' en su lugar.

Al llamar a métodos que tienen el [Conditional] atributo , evite usar el envío dinámico. El compilador no puede comprobar los atributos del método condicional con enlace dinámico, lo que puede provocar errores en tiempo de ejecución (CS1974). Convierta primero la expresión dinámica en su tipo real:

dynamic d = GetObject();

// Avoid:
d.ConditionalMethod(); // CS1974 - can fail at runtime

// Recommended:
MyClass obj = (MyClass)d;
obj.ConditionalMethod(); // Compile-time checks ensure correctness

Al comprobar si un valor no es NULL, use is object en lugar de is dynamic. La palabra clave dynamic es una construcción en tiempo de compilación y el tipo de tiempo de ejecución de ningún objeto es nunca dynamic (CS1981):

// Avoid:
if (someValue is dynamic) // CS1981 - always evaluates to false
{
    // This code never executes
}

// Recommended:
if (someValue is object) // Correctly checks if non-null
{
    // This code executes for non-null values
}

Para obtener más información sobre el comportamiento dinámico de distribución y tiempo de ejecución, consulte Uso de tipo dinámico.

  • Last updated on