Tipos nulos de C# (Nullable)

Es conocido que no se puede asignar un valor null a tipos de valor. Por ejemplo,int i = null lanzará un error en tiempo de compilación.

Definición de tipos nullable

Nullable<int> i = null;

Los tipos nullable pueden representar el rango de valores correctos de su tipo base, más un valor adicional de nulo. Por ejemplo, Nullable<int> puede asignar desde -2147483648 hasta 2147483647 cualquier valor o un valor null.

El tipo Nullable es una instancia de System.Nullable<t> struct.

[Serializable]
public struct Nullable<T> where T : struct
{　　　　　　　　
　　　　public bool HasValue { get; }
　　　　　　
　　　　public T Value { get; }
　　　　　　　　
　　　　//　Otras implementaciones
}

El tipo Int de nullable es idéntico al tipo int común, con una marca que indica si el int tiene un valor (si es null).... El resto es magia del compilador, que considera a "null" como un valor válido.

static void Main(string[] args)
{
　　　　Nullable<int> i = null;
　　　　if o i.HasValue
　　　　　　　　Console.WriteLine(i.Value);　//　o o Console.WriteLine(i)
　　　　else
　　　　　　　　Console.WriteLine("Null");
}

Null

Si el objeto tiene un valor asignado, devuelve true; si no se ha asignado ningún valor o se ha asignado un valor null, devuelve false.

Si el tipo NullableType.value es null o no se ha asignado ningún valor, el acceso al valor utilizando NullableType.value lanzará una excepción en tiempo de ejecución. Por ejemplo, si i es null, el valor lanzará una excepción:

Si no es null, Use el método GetValueOrDefault() para obtener el valor real; si es null, utilice el valor por defecto. Por ejemplo:

static void Main(string[] args)
{
　　　　Nullable<int> i = null;
　　　　Console.WriteLine(i.GetValueOrDefault());　
}

Sintaxis abreviada de tipo nullable

Puede usar el operador '?' para simplificar la sintaxis, por ejemplo int ?, long? en lugar de usar Nullable <T>.

int? i = null;
double? D = null;

Operador de combinación de null (??)

Utilice el operador '??' para asignar tipos nullable a tipos no nullable.

int? i = null;
　　　　　　　　　　　　
int j = i ?? 0;
Console.WriteLine(j);

0

En el ejemplo anterior, i es un int nullable, si se asigna a un int no nullable j, si i es null, lanzará una excepción en tiempo de ejecución. Por lo tanto, para reducir el riesgo de excepciones, utilizamos el operador "??", si i es null, se asigna 0 a j.

using System;
namespace CalculatorApplication
{
　　　class NullablesAtShow
　　　{
　　　　　　　　　
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　　
　　　　　　　　　double? num1　= null;
　　　　　　　　　double? num2　=　3.14157;
　　　　　　　　　double num3;
　　　　　　　　　num3　= num1　??　5.34;　　　　　　//　num1　si es un valor nulo, se devuelve　5.34
　　　　　　　　　Console.WriteLine("num3　El valor: {0}3);
　　　　　　　　　num3　= num2　??　5.34;
　　　　　　　　　Console.WriteLine("num3　El valor: {0}3);
　　　　　　　　　Console.ReadLine();
　　　　　　}
　　　}
}

Resultados de salida:

num3　El valor:　5.34
num3　El valor:　3.14157

Reglas de asignación

Las reglas de asignación de tipos nullable son las mismas que las de los tipos de valor. Si declara un tipo nullable como variable local en una función, debe asignarle un valor antes de usarlo. Si es un campo de cualquier clase, tendrá un valor nulo por defecto.

Por ejemplo, declare y utilice el siguiente tipo de int nullable sin asignar ningún valor. El compilador proporcionará“Uso de variable local no asignada 'i'”Error:

En el siguiente ejemplo, el nullable de tipo int es un campo de la clase, por lo que no se produce ningún error.

class MyClass
{
　　　　public Nullable<int> i;
}
class Program
{
　　　　static void Main(string[] args)
　　　　{
　　　　　　　　MyClass mycls = new MyClass();
　　　　　　　　if (mycls.i == null)
　　　　　　　　　　　　Console.WriteLine("Null");
　　　　}
}

Null

Métodos de comparación de la clase Nullable

Null se considera menor que cualquier valor. Por lo tanto, los operadores de comparación no se pueden usar con null. Vea el siguiente ejemplo, donde i ni es menor ni mayor ni igual que j:

static void Main(string[] args)
{
　　　　int? i = null;
　　　　int j =　10;
　　　　if (i < j)
　　　　　　　　Console.WriteLine("i < j");
　　　　else if (i >　10)
　　　　　　　　Console.WriteLine("i > j");
　　　　else if (i ==　10)
　　　　　　　　Console.WriteLine("i == j");
　　　　else
　　　　　　　　Console.WriteLine("Imposible comparar");
}

Imposible comparar

La clase estática Nullable es una clase auxiliar para el tipo Nullable. Proporciona métodos para comparar tipos nulos. También tiene el método GetUnderlyingType, que devuelve el tipo de parámetro base del tipo que puede ser null.

static void Main(string[] args)
{
　　　　int? i = null;
　　　　int j =　10;
　　　　if (Nullable.Compare<int>(i, j) < 0)
　　　　　　　　Console.WriteLine("i < j");
　　　　else if (Nullable.Compare<int>(i, j) > 0)
　　　　　　　　Console.WriteLine("i > j");
　　　　else
　　　　　　　　Console.WriteLine("i = j");
}

i < j

Características del tipo nulo

1. Los tipos nulos solo se pueden usar con tipos de valor.

2. Si Value es null, la propiedad Value lanzará un InvalidOperationException; de lo contrario, devolverá el valor.

3. Si la variable contiene un valor, la propiedad HasValue devuelve true; si es null, devuelve false.

4. Sólo se pueden usar los operadores de == y != con tipos que pueden ser nulos. Para otras comparaciones, utilice la clase estática Nullable.

5. No se permite el uso de tipos nulos anidados. Nullable <Nullable <int>> i; dará un error en tiempo de compilación.