tipo - palabras reservadas en c# y para que sirven

¿Por qué no debería usar siempre los tipos que aceptan nulos en C#

Question

He estado buscando una buena guía sobre esto desde que el concepto fue presentado en .net 2.0.

¿Por qué querría usar tipos de datos que no admiten nulos en c #? (Una mejor pregunta es por qué no elegiría los tipos que aceptan nulos por defecto, y solo usaré los tipos que no aceptan nulos cuando eso tenga sentido explícitamente).

¿Hay un golpe de rendimiento "significativo" al elegir un tipo de datos que admite valores nulos a través de su par no anulable?

Prefiero comprobar mis valores con null en lugar de Guid.empty, string.empty, DateTime.MinValue, <= 0, etc., y trabajar con tipos anulables en general. Y la única razón por la que no elijo tipos nullable con más frecuencia es la sensación de picazón en la parte posterior de la cabeza que me hace sentir que es más que la compatibilidad con versiones anteriores lo que obliga a ese extra ''?'' carácter para permitir explícitamente un valor nulo.

¿Hay alguien por ahí que siempre (la mayoría de las veces) elige tipos que aceptan nulos en lugar de tipos que no admiten nulos?

Gracias por tu tiempo,

Answer 1

Aunque los valores nulos pueden ser convenientes para usar como valores "no inicializados-aún" o "no-especificados", hacen que el código sea más complejo, principalmente porque está sobrecargando el significado de null así como también la variable (número-o -null vs. just-a-number).

Los valores NULL son preferidos por muchos diseñadores de bases de datos y programadores de bases de datos SQL, pero con un pequeño cambio al pensar en el problema puede eliminar valores nulos y tener un código más simple y confiable (por ejemplo, sin preocuparse por NullReferenceException ).

En realidad, hay una gran demanda de un "T". operador que hace que cualquier tipo de referencia no sea nulo, similar a cómo "T"? hace que los tipos de valor sean nulos, y Anders Hejlsberg, el inventor de C #, deseó haber incluido la habilidad.

Ver también la pregunta: ¿Por qué está "nulo" presente en C # y java?

Answer 2

Creo que los diseñadores de idiomas consideran que "los tipos de referencia que se pueden anular de forma predeterminada" fueron un error, y que los que no aceptan nulos son los únicos valores predeterminados razonables, y debes optar por la nulidad. (Así es como lo es en muchos lenguajes funcionales modernos.) "Nulo" suele ser un montón de problemas.

Answer 3

La única vez que se debe usar un Tipo Nullable, es en el caso de que un determinado campo en una tabla de la base de datos requiera absolutamente que la aplicación envíe o reciba un nulo en algún momento. Incluso en tal caso, siempre se debe tratar de encontrar una forma de evitar el uso del Tipo Nullable. Bool no siempre es tu mejor amigo.

Answer 4

La razón por la que no siempre debe usar tipos que aceptan nulos es que a veces puede garantizar que se inicialice un valor. Y debe intentar diseñar su código para que este sea el caso con la mayor frecuencia posible. Si no hay forma de que un valor pueda posiblemente no inicializarse, entonces no hay ninguna razón por la cual el valor nulo sea legal. Como un ejemplo muy simple, considere esto:

List<int> list = new List<int>()
int c = list.Count;

Esto siempre es válido No hay una forma posible en la que c podría estar sin inicializar. Si se convirtió en un int? , estaría diciendo efectivamente a los lectores del código "este valor podría ser nulo. Asegúrese de verificarlo antes de usarlo". Pero sabemos que esto nunca puede suceder, ¿por qué no exponer esta garantía en el código?

Tiene toda la razón en los casos en que un valor es opcional. Si tenemos una función que puede o no devolver una cadena, entonces devuelve nulo. No devuelva string.Empty (). No devuelvas "valores mágicos".

Pero no todos los valores son opcionales. Y al hacer que todo sea opcional, el resto del código es mucho más complicado (agrega otra ruta de código que debe manejarse).

Si puede garantizar específicamente que este valor siempre será válido, ¿por qué desechar esta información? Eso es lo que haces al convertirlo en un tipo que admite nulos. Ahora el valor puede o no existir, y cualquiera que use el valor deberá manejar ambos casos. Pero sabes que solo uno de estos casos es posible en primer lugar. Entonces, hagan un favor a los usuarios de su código y reflejen este hecho en su código. Cualquier usuario de su código puede entonces confiar en que el valor sea válido, y solo debe manejar un solo caso en lugar de dos.

Answer 5

Parece que tienes 2 preguntas diferentes ...

¿Por qué querría usar tipos de datos que no admiten nulos en C #?

¡Simple, porque el compilador garantiza que los datos de tipo de valor en los que confía tienen realmente un valor!

¿Por qué no elegiría los tipos que aceptan nulos por defecto, y solo usaré tipos que no aceptan nulos cuando eso tenga sentido explícitamente?

Como Joel ya ha mencionado, un tipo solo puede ser nulo si es un tipo de referencia. El compilador garantiza que los tipos de valor tienen un valor. Si su programa depende de una variable para tener un valor, entonces este es el comportamiento que querrá al no elegir un tipo que admite nulos.

Por supuesto, cuando sus datos provienen de cualquier lugar que no sea su programa, entonces todas las apuestas están desactivadas. El mejor ejemplo es de una base de datos. Los campos de base de datos pueden ser null , por lo que querrá que su variable de programa imite este valor, no solo crear un valor "mágico" (es decir, -1, 0 o lo que sea) que "represente" null . Usted hace esto con tipos que aceptan nulos.

Answer 6

Porque es inconveniente tener que comprobar siempre si el tipo que admite null es null .

Obviamente, hay situaciones en las que un valor es genuinamente opcional, y en esos casos tiene sentido usar un tipo de nullable en lugar de números mágicos, etc., pero cuando sea posible, trataría de evitarlos.

// nice and simple, this will always work
int a = myInt;
// compiler won''t let you do this
int b = myNullableInt;
// compiler allows these, but causes runtime error if myNullableInt is null
int c = (int)myNullableInt;
int d = myNullableInt.Value;
// instead you need to do something like these, cumbersome and less readable
int e = myNullableInt ?? defaultValue;
int f = myNullableInt.HasValue ? myNullableInt : GetValueFromSomewhere();

Answer 7

Tiendo a usar los tipos anulables donde sea que tengan sentido. No me importará el rendimiento hasta que sea un problema, luego arreglaré las pocas áreas donde se encuentra y terminaré con eso.

Sin embargo, también encuentro que, en general, la mayoría de mis valores terminan siendo nulos. De hecho, hay muchas veces en las que realmente me gustaría un NotNullable que puedo usar con tipos de referencia para descubrir un problema nulo cuando obtengo el valor nulo, no más tarde cuando intento usarlo.