Intro #
C # ha introducido tipos de referencia que aceptan valores NULL desde 8.0. Podemos habilitar los tipos de referencia que aceptan valores NULL para que el proyecto use el compilador para ayudarnos a lidiar mejor con el manejo de referencias nulas en el código, lo que puede evitar que escribamos muchas verificaciones nulas innecesarias Para mejorar nuestra eficiencia
Por qué #
¿Por qué necesitamos habilitar tipos de referencia que aceptan valores NULL? En primer lugar, podemos ver el proyecto principal de asp.net. Los proyectos principales de Asp.net utilizan una gran cantidad de tipos de referencia que aceptan valores NULL. Para obtener más información, consulte:
https://github.com/ dotnet / aspnetcore / issues / 5680
Actualizar ASP.NET Core para usar los tipos de referencia anulables de C # 8 haría lo siguiente:
Ayude a las bibliotecas de ASP.NET Core a evitar las excepciones de referencia nula internamente. Nos ayudará a encontrar y prevenir nuestros errores y a aumentar la productividad de los desarrolladores.
Proporcionar orientación a los desarrolladores que utilizan ASP.NET Core sobre qué API pueden aceptar y devolver una referencia nula y qué API. No se puede. Esto mejoraría la experiencia del desarrollador al usar ASP.NET Core se
divide principalmente en dos aspectos, uno es el código interno, para el código interno, podemos usar el tipo de referencia anulable para comprender claramente una variable con la ayuda del compilador Ya sea que sea nula, la variable que no será nula ya no necesita verificación nula. Por otro lado, para el código utilizado, el compilador puede proporcionar un mejor soporte de verificación nula para el uso de la biblioteca de clases que habilita tipos de referencia nulos. Los desarrolladores pueden entender claramente qué API pueden ser nulas y qué API no pueden ser nulas, lo que es más amigable para los desarrolladores.
Cómo #
A continuación, veamos cómo habilitar tipos de referencia que aceptan valores NULL para nuestros proyectos. La documentación de Microsoft proporciona instrucciones más detalladas. Para obtener más información, consulte el enlace de referencia al final del artículo.
Para habilitar el tipo de referencia que acepta valores NULL, solo necesita agregar enable al archivo del proyecto y LangVersion debe establecerse en 8 o superior.
El contexto que admite valores NULL contiene dos contextos, uno es el contexto de anotación que admite valores NULL (admite? Para tipos de referencia que aceptan valores NULL) y el otro es un contexto de advertencia que admite valores NULL (admite advertencias del compilador para tipos de referencia que aceptan valores NULL)
El contexto que acepta valores NULL tiene 4 configuraciones, la configuración es la siguiente
habilitar
advertencias
anotaciones
deshabilitar
Configuración Advertencia Contexto Estado Anotación Estado de contexto
habilitar habilitado habilitado
advertencia habilitado inhabilitado
anotaciones inhabilitado habilitado
inhabilitado inhabilitado inhabilitado Se
recomienda usar directamente habilitar para habilitar tipos de referencia que aceptan valores NULL, y solo habilitar el contexto de anotación. El compilador no buscará tipos de referencia que admitan valores NULL. Una advertencia no tiene mucha importancia. Habilite solo el contexto de advertencia. Puede usar esta configuración si no desea habilitar el tipo de referencia que acepta valores NULL en su propia aplicación. Si no configura el tipo de referencia que admite valores NULL o inhabilita, puede inhabilitar completamente el tipo de referencia que admite valores NULL.
Además de la configuración global del proyecto, también podemos cambiar la configuración del contexto local que acepta valores NULL mediante #nullable en el código fuente del proyecto y restaurar la configuración predeterminada del contexto de referencia que admite valores NULL mediante la restauración #nullable
#nullable enable: 设置 nullable annotation context 和 nullable warning context 为 enabled.
#nullable disable: 设置 nullable annotation context 和 nullable warning context 为 disabled.
#nullable restore: 恢复 nullable annotation context 和 nullable warning context 为项目默认的配置.
#nullable disable warnings: 设置 nullable warning context 为 disabled.
#nullable enable warnings: 设置 nullable warning context 为 enabled.
#nullable restore warnings: 恢复 nullable warning context 为项目配置
#nullable disable annotations: 设置 nullable annotation context 为 disabled.
#nullable enable annotations: 设置 nullable annotation context 为 enabled.
#nullable restore annotations: 恢复 annotation warning context 为项目配置
Después de habilitar el tipo de referencia anulable, no se permite que el tipo de referencia se establezca en nulo. Si desea establecerlo en nulo, puede agregar un? Después del tipo para establecerlo en un tipo de referencia anulable como cadena? O usar! Para permitir que el compilador asigne valores, Tales como: string a = null !; (Este también es un lugar al que debemos prestar atención. Los tipos de referencia que aceptan valores NULL solo son verificados por el compilador y no se puede garantizar estrictamente que no se asignen a null. Para proyectos de biblioteca de clases, si la API pública El parámetro esperado es un tipo de referencia que no admite valores NULL. Además de utilizar un tipo de referencia que no admite valores NULL, aún debe mantener la verificación nula)
El número de muestra
primero puede mirar una interfaz:
public interface IPropertyConfiguration<out TEntity, TProperty>
{
IPropertyConfiguration<TEntity, TProperty> HasColumnTitle(string title);
IPropertyConfiguration<TEntity, TProperty> HasColumnFormatter(string? formatter);
IPropertyConfiguration<TEntity, TProperty> HasColumnInputFormatter(Func<string?, TProperty?>? formatterFunc);
}
Mira la implementación:
internal sealed class PropertyConfiguration<TEntity, TProperty> : PropertyConfiguration, IPropertyConfiguration<TEntity, TProperty>
{
private readonly PropertyInfo _propertyInfo;
public PropertyConfiguration(PropertyInfo propertyInfo)
{
_propertyInfo = propertyInfo;
PropertyName = propertyInfo.Name;
ColumnTitle = propertyInfo.Name;
}
public IPropertyConfiguration<TEntity, TProperty> HasColumnTitle(string title)
{
ColumnTitle = title ?? throw new ArgumentNullException(nameof(title));
return this;
}
public IPropertyConfiguration<TEntity, TProperty> HasColumnFormatter(string? formatter)
{
ColumnFormatter = formatter;
return this;
}
public IPropertyConfiguration<TEntity, TProperty> HasInputFormatter(
Func<TEntity?, TProperty?, TProperty?>? formatterFunc)
{
InternalCache.InputFormatterFuncCache.AddOrUpdate(_propertyInfo, formatterFunc);
return this;
}
}
Puede ver que el título en el parámetro de HasColumnTitle es un tipo de referencia que no acepta valores NULL. Aun así, el código de implementación aún se verifica para ver si es nulo y el tipo de referencia que admite valores NULL no generará una advertencia cuando se lanza una nueva ArgumentNullException ()
Ejemplo de advertencia:
Si asigna nulo a un tipo de referencia que no acepta valores NULL, el compilador dará una advertencia. Un ejemplo es el siguiente:
En una referencia no nula al tipo de la lista de agregar tiempo extra nulo del tutorial basado en Python , el compilador dará una advertencia:
Si una variable de tipo de referencia que acepta valores NULL no está marcada como nula, habrá una advertencia:
Como se puede ver en la figura anterior, cuando se usa var para declarar una variable, será un tipo de referencia anulable
Más # El
uso de tipos de referencia que aceptan valores NULL puede ayudarnos hasta cierto punto en el tutorial de c # para reducir las comprobaciones nulas innecesarias, pero para los proyectos de biblioteca de clases, debería haber algunas comprobaciones nulas
Para las aplicaciones, con la ayuda de tipos de referencia que aceptan valores NULL, también puede comprender claramente dónde debe verificar si hay nulos y dónde no, lo que puede mejorar la calidad del código.
Para el operador de contención nulo, puede asignar un objeto anulable a una variable de tipo de referencia no anulable, intente no usarlo, use esto para enterrar el mío en el código, y las variables y atributos que no serían nulos también aparecerán En el caso de nulo, si aún no hay una verificación de nulo necesaria, está cavando completamente por sí mismo.
Pero en el proceso de uso, siento que en algunos casos todavía no es lo suficientemente inteligente y no funciona muy bien cuando Assert en el proyecto de prueba. Veamos un ejemplo:
En el ejemplo anterior, Assert.NotNull (importList [i]) se usó antes de importList [i] .Id / Title. En teoría, importList [i] no será nulo, pero el compilador sigue siendo No es tan inteligente, debe ir al tutorial de vb.net
para optimizar un paso. Para esta situación, puede declarar una variable por separado y usar! Para declarar un tipo de referencia que no admite valores NULL. Si desea deshabilitar la advertencia en el proyecto de prueba, también puede establecer nullable El nivel es de anotaciones o deshabilitado
Finalmente, quiero decir que, en vista de que el núcleo actual de asp.net está adoptando vigorosamente tipos de referencia que aceptan valores NULL, aún puede comprender
Referencia #
https://docs.microsoft.com/en-us/dotnet/csharp/nullable-references
https://docs.microsoft.com/en-us/dotnet/csharp/tutorials/upgrade-to-nullable-references
https://docs.microsoft.com/en-us/dotnet/csharp/nullable-migration-strategies
https://github.com/dotnet/aspnetcore/issues/5680
https://github.com/WeihanLi/WeihanLi. Npoi / pull / 98
https://github.com/WeihanLi/DbTool
https://github.com/dotnet/samples/tree/master/csharp/NullableIntroduction/NullableIntroduction
https://stackoverflow.com/questions/54526652/when -to-null-comprobar-argumentos-con-tipos-de-referencia-nulos-habilitados
https://headspring.com/2020/06/02/applying-nullable-reference-types-in-fixie/
作者 ： WeihanLi
Fuente: https://www.cnblogs.com/weihanli/p/14290642.html