C# | Tipos anulables – Part 1

En C#, el compilador no le permite asignar un valor nulo a una variable. Por lo tanto, C# 2.0 proporciona una característica especial para asignar un valor nulo a una variable que se conoce como tipo Nullable. El tipo Anulable le permite asignar un valor nulo a una variable. Los tipos que aceptan valores NULL introducidos en C#2.0 solo pueden funcionar con Value Type , no con Reference Type . 

Los tipos que aceptan valores NULL para el tipo de referencia se introducen más adelante en C# 8.0 en 2019 para que podamos definir explícitamente si un tipo de referencia puede contener o no un valor nulo. Esto nos ayudó a abordar el problema de NullReferenceException sin usar condicionales. En este artículo, la discusión gira en torno a los tipos que aceptan valores NULL para los tipos de valor.

El tipo Nullable es una instancia de System.Nullable<T> struct . Aquí T es un tipo que contiene tipos de valores que no aceptan valores NULL como tipo entero, tipo de punto flotante, un tipo booleano, etc. Por ejemplo, en NULL de tipo entero puede almacenar valores desde -2147483648 a 2147483647, o valor nulo. 

Sintaxis: 

Nullable<data_type> variable_name = null;

¿O también puede usar un atajo que incluye ? operador con el tipo de datos.

datatype? variable_name = null;

Ejemplo:  

// this will give compile time error
int j = null;           

// Valid declaration
Nullable<int> j = null;   

// Valid declaration
int? j = null;           

¿Cómo acceder al valor de las variables de tipo anulable?
No puede acceder directamente al valor del tipo Nullable. Debe usar el método GetValueOrDefault() para obtener un valor asignado original si no es nulo. Obtendrá el valor predeterminado si es nulo. El valor predeterminado para nulo será cero.

Ejemplo: 

// C# program to illustrate Nullable Types
using System;
 
class Geeks {
 
    // Main Method
    static void Main(string[] args)
    {
         
        // defining Nullable type
        Nullable<int> n = null;
 
        // using the method
        // output will be 0 as default
        // value of null is 0
        Console.WriteLine(n.GetValueOrDefault());
         
        // defining Nullable type
        int? n1 = null;
 
        // using the method
        // output will be 0 as default
        // value of null is 0
        Console.WriteLine(n1.GetValueOrDefault());
         
          
        // using Nullable type syntax
        // to define non-nullable
        int? n2 = 47;
 
        // using the method
        Console.WriteLine(n2.GetValueOrDefault());
         
        // using Nullable type syntax
        // to define non-nullable
        Nullable<int> n3 = 457;
 
        // using the method
        Console.WriteLine(n3.GetValueOrDefault());
         
    }
     
}

Producción: 

0
0
47
457

Características de los tipos anulables

• Con la ayuda del tipo anulable, puede asignar un valor nulo a una variable sin crear un tipo anulable basado en el tipo de referencia.
• En los tipos que aceptan valores NULL, también puede asignar valores al tipo que acepta valores NULL. Como se muestra en el siguiente ejemplo.

Ejemplo:

// C# program to illustrate the
// use of Nullable type
using System;
 
class GFG {
 
    // Main Method
    static public void Main()
    {
 
        // a is nullable type
        // and contains null value
        int ? a = null;
 
        // b is nullable type int
        // and behave as a normal int
        int ? b = 2345;
 
        // this will not print
        // anything on console
        Console.WriteLine(a);
         
        // gives 2345 as output
        Console.WriteLine(b);
    }
}

Producción: 

2345

• Puede usar Nullable.HasValue y Nullable.Value para comprobar el valor. Si el objeto se asigna con un valor, devolverá «Verdadero» y si el objeto se asigna a nulo, devolverá «Falso». Si al objeto no se le asigna ningún valor, dará un error en tiempo de compilación.

Ejemplo:

// C# program to illustrate the
// use of Nullable<L>.Hasvalue
using System;
 
class GFG {
 
    // Main Method
    static void Main()
    {
         
        // a is nullable type
        // and contains null value
        Nullable<int> a = null;
 
        // check the value of object
        Console.WriteLine(a.HasValue);
         
        // b is nullable type
        // and contains a value
        Nullable<int> b = 7;
 
        // check the value of object
        Console.WriteLine(b.HasValue);
 
    }
}

Producción: 

False
True

• También puedes usar == y ! operadores con tipo anulable.
• También puede utilizar el método GetValueOrDefault(T) para obtener el valor asignado o el valor predeterminado proporcionado, si el valor del tipo anulable es nulo.
• También puede usar el operador de fusión nula (??) para asignar un valor al tipo subyacente que se origina a partir del valor del tipo que acepta valores NULL.

Ejemplo:

// C# program to illustrate the
// use of  null-coalescing operator(??)
using System;
 
class GFG {
     
    // Main Method
    static public void Main()
    {
         
        // a is nullable type
        // and contains null value
        int ? a = null;
         
         
        // it means if a is null
        // then assign 3 to b
        int b = a ?? 3;
         
        // It will print 3
        Console.WriteLine(b);
    }
}

Producción: 

3

• Los tipos anulables no admiten tipos anidados anidados.
• Los tipos anulables no admiten el tipo var. Si usa Nullable con var, entonces el compilador le dará un error de tiempo de compilación.

Ventaja de los tipos anulables: 

• El uso principal del tipo anulable es en aplicaciones de bases de datos. Supongamos que, en una tabla, una columna requiere valores nulos, luego puede usar el tipo que acepta valores nulos para ingresar valores nulos.
• El tipo anulable también es útil para representar un valor indefinido.
• También puede usar el tipo que acepta valores NULL en lugar de un tipo de referencia para almacenar un valor nulo.