c# - bool - Operador ''?? no se puede aplicar a operandos de tipo ''T'' y ''T''

el operador== no se puede aplicar a operandos del tipo string

Question

Tengo el siguiente método genérico, pero VS me da un error de compilación sobre eso. (El operador ''??'' no se puede aplicar a operandos de tipo ''T'' y ''T'')

public static T Method<T>(T model) where T : new()
{
    var m = model ?? new T();
}

¿Alguien tiene alguna idea de por qué?

Editar: ¿Es posible que la razón sea que T puede ser una estructura en mi caso, y una estructura es un tipo que no admite nulos?

Answer 1

Como T puede ser de cualquier tipo, ¿no hay garantía de que T tendrá una estática? operador o que el tipo T es nulo.

?? Operador (referencia de C #)

Los ?? el operador se denomina operador de coalescencia nula y se usa para definir un valor predeterminado para tipos de valores o tipos de referencia que admiten valores nulos.

Answer 2

Debe especificar que su tipo T es una clase con una restricción en el tipo genérico:

public static T Method<T>(T model) where T : class, new()
{
    return model ?? new T();
}

Answer 3

Debería agregar class restricción de class :

public static T Method<T>(T model) where T : class, new()
{
    var m = model ?? new T();

    return m;
}

¡Y tú también debes regresar!

Nota: Como @KristofDegrave mencionó en su comentario, la razón por la que tenemos que agregar restricción de class es porque T puede ser un tipo de valor, como int y desde ?? verificación del operador (nulo-coalescente) en los tipos que pueden ser nulos, por lo que debemos agregar class restricción de class para excluir tipos de valores.

Editar: La respuesta de Alvin Wong también cubrió el caso de los tipos que aceptan nulos. que son estructuras en realidad, pero pueden ser operandos de ?? operador. Solo tenga en cuenta que Method devolvería null sin la versión sobrecargada de Alvin, para tipos que aceptan null .

Answer 4

Marca T como "clase" y estás listo para ir.

Answer 5

Muchos ya han señalado que agregar el límite de class para el genérico resolverá el problema.

Si desea que su método sea aplicable también a Nullable<T> , puede agregarle una sobrecarga:

// For reference types
public static T Method<T>(T model) where T : class, new()
{
    return model ?? new T();
}

// For Nullable<T>
public static T Method<T>(T? model) where T : struct
{
    return model ?? new T(); // OR
    return model ?? default(T);
}

Answer 6

Por alguna razón, el ?? El operador no puede usarse en tipos que no admiten model == null ? new T() : model , aunque se supone que es equivalente a model == null ? new T() : model model == null ? new T() : model , y se le permite una comparación nula con un tipo que no admite nulos.

Puede obtener exactamente lo que está buscando sin ninguna restricción adicional mediante el uso del operador ternario en su lugar, o una instrucción if:

public static T Method<T>(T model) where T : new()
{
   var m = model == null ? new T() : model;
}

Answer 7

?? es el operador nulo-coalescente. No se puede aplicar a tipos que no admiten nulos. Como T puede ser cualquier cosa, puede ser un tipo int u otro tipo primitivo que no admite nulos.

Si agrega la condición where T : class (debe especificarse antes de new() ) fuerza a T a ser una instancia de clase, que es anulable.

Answer 8

model ?? new T() model ?? new T() significa model == null ? new T() : model model == null ? new T() : model . No se garantiza que el modelo no sea null y no se puede aplicar == para un objeto null y no nulo. Cambiar la restricción a where T : class, new() debería funcionar.