Tipo anulable generando advertencias ya que el proyecto ha habilitado tipos de referencia anulables.
Solo obtengo las advertencias después de habilitar los tipos de referencia anulables, pero el ejemplo específico es en realidad el buen y viejo tipo Nullable<T>:
var nullableItems = new List<int?>();
var actualNonNullValues = nullableItems.Where(x => x.HasValue)
.Select(x => x.Value)
.ToList();
Entonces, descarto todos los nulos y solo quiero los elementos reales que no son nulos. Sin embargo, la parte .Select(x => x.Value) me dará una advertencia del compilador sobre x que puede ser nulo aquí. Lógicamente, no lo es, pero para el compilador, el tipo aún no ha cambiado y sigue siendo un int?.
Sé que puedo decirle al compilador que se calle simplemente aplicando un ! al x, pero parece que hice trampa. En otros lenguajes que uso, tener que recurrir a esto se considera una mala práctica y significa que hiciste algo mal.
¿Cuáles son mis otras opciones? ¿Puedo hacer mejor que solo usar un ! aquí?
davy.ai
Como experto en TI especializado en c#, nullable y nullable-reference-types, tiene otras opciones para manejar la advertencia del compilador sobre
xposiblemente siendo nulo en la parte del código.Select(x => x.Value). Una opción es usar el operador de olvido de nulo (!) después deValue, así:.Select(x => x!.Value).ToList(). Sin embargo, esta solución puede no ser ideal porque esencialmente está diciéndole al compilador que ignore los tipos de referencia nulos y asuma quexno es nulo, lo que puede llevar a errores en tiempo de ejecución sixes nulo en realidad.Una opción mejor es usar el operador de coalescencia nula (
??) para proporcionar un valor predeterminado sixes nullo, así:.Select(x => x.HasValue ? x.Value : defaultValue).ToList(). Aquí,defaultValuepuede ser cualquier valor que elija para representar nulo. Esta solución es más segura porque tiene en cuenta la posibilidad de quexsea nulo y proporciona un valor de respaldo para evitar errores en tiempo de ejecución.Otra opción es usar el método de extensión
WhereNotNulldel espacio de nombresSystem.Linq, así:var actualNonNullValues = nullableItems.WhereNotNull().ToList(). Este método de extensión filtra todos los valores nulos y devuelve solo los valores no nulos, eliminando la necesidad de la parte del código.Where(x => x.HasValue). Esta solución es concisa y legible, y hace que su intención sea más clara.En resumen, como experto en TI especializado en c#, nullable y nullable-reference-types, tiene varias opciones para manejar la advertencia del compilador sobre
xposiblemente siendo nulo. Puede usar el operador de olvido de nulo, el operador de coalescencia nula o el método de extensiónWhereNotNullpara asegurarse de que su código sea seguro y legible.