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#
// 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#
// 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#
// 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#
// 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.
Publicación traducida automáticamente
Artículo escrito por ankita_saini y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA