Pourquoi ne devrais-je pas toujours utiliser des types nullables en C #

Question

J'ai été la recherche de quelques bons conseils sur ce que le concept a été introduit en .net 2.0.

Pourquoi aurais-je besoin d'utiliser non nullable types de données en c#? (Une meilleure question est: pourquoi n'aurais-je pas choisir les types nullables par défaut, et n'utilisez pas les valeurs null types explicitement de sens.)

Est-il un "significative" de performances pour le choix d'un nullable type de données de plus de son non nullable par les pairs?

Je le préfère nettement à vérifier à l'encontre de mes valeurs null au lieu de Guid.vide, chaîne.vide, DateTime.MinValue,<= 0, etc, et de travailler avec des types nullables en général. Et la seule raison pour laquelle je n'ai pas de choisir les types nullables plus souvent est la sensation de picotement dans le dos de ma tête qui me donne l'impression que c'est plus que la rétro-compatibilité, les forces extra caractère '?' pour autoriser explicitement une valeur null.

Est-ce que quelqu'un là-bas qui toujours (presque toujours) choisit les types nullables plutôt que les non-types nullables?

Merci pour votre temps,

Answer 1

La raison pourquoi vous ne devriez pas toujours utiliser des types nullables, c'est que parfois vous êtes en mesure de garantir qu'une valeur va être initialisé. Et vous devriez essayer de la conception de votre code, de sorte que c'est le cas aussi souvent que possible. Si il n'existe aucun moyen d'une valeur peut éventuellement être initialisée, alors il n'ya aucune raison pourquoi null doit être une valeur juridique pour cela. Comme un exemple très simple, considérez ceci:

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

C'est toujours valide. Il n'est pas possible en ce qui c pourrait être initialisée. Si elle a été transformée en une int?, cela reviendrait à dire les lecteurs de code "cette valeur peut être null. Assurez-vous de vérifier avant de l'utiliser". Mais nous savons que cela ne peut pas arriver, alors pourquoi ne pas exposer cette garantie dans le code?

Vous avez absolument raison dans les cas où une valeur est facultative. Si nous avons une fonction qui peut ou ne peut pas retourner une chaîne de caractères, puis retourner la valeur null. Ne pas la chaîne de retour.Empty(). Ne pas retourner "la magie des valeurs".

Mais pas toutes les valeurs sont en option. Et de faire tout option rend le reste de votre code beaucoup plus compliqué (il ajoute un autre chemin d'accès du code qui doit être traitée).

Si vous pouvez garantir que cette valeur sera toujours valable, alors pourquoi jeter cette information? C'est ce que vous faites en faisant d'elle un type nullable. Maintenant, la valeur peut ou peut ne pas exister, et de toute personne utilisant la valeur aura à gérer les deux cas. Mais vous savez que seulement l'un de ces cas est possible en premier lieu. Si les utilisateurs de votre code une faveur, et de tenir compte de ce fait dans votre code. Tous les utilisateurs de votre code peut ensuite s'appuyer sur la valeur en cours de validité, et ils n'ont qu'à gérer un cas unique au lieu de deux.

Answer 2

Parce qu'il n'est pas pratique de toujours vérifier si le type nullable est null .

Évidemment, il existe des situations où une valeur est vraiment facultative, et dans ces cas, il est logique d'utiliser un type nullable plutôt que des nombres magiques, etc., mais si possible, j'essayerais de les éviter.

 // 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 3

Vous semblez avoir 2 questions différentes...

Pourquoi aurais-je besoin d'utiliser non nullable types de données en C#?

Simple, parce que la valeur de type de données que vous êtes en s'appuyant sur garanti par le compilateur pour vraiment avoir une valeur!

Pourquoi n'aurais-je pas choisir les types nullables par défaut, et n'utilisez pas les valeurs null types explicitement sens?

Comme Joel l'a déjà mentionné, un type ne peut être null si c'est un type de référence. Types de valeur sont garantis par le compilateur pour avoir une valeur. Si votre programme dépend d'une variable à une valeur, alors c'est le comportement que vous voulez par de ne pas choisir un type nullable.

Bien sûr, lorsque vos données sont à venir de n'importe où ce n'est pas votre programme, alors tous les paris sont éteints. Le meilleur exemple est à partir d'une base de données. Champs de base de données peuvent être null, de sorte que vous voudriez que votre variable de programme pour imiter cette valeur - et pas seulement de créer une "magique" de la valeur (-1, 0, ou quoi que ce soit) qui "représente" null. Vous faites cela avec des types nullables.

Answer 4

Je pense que les concepteurs de langage estiment que «les types de référence étant annulables par défaut» était une erreur, et que non nullable est le seul défaut raisonnable, et vous devriez avoir à opter pour la nullité. (C'est ainsi dans de nombreux langages fonctionnels modernes.) "Null" est généralement un tas de problèmes.

Answer 5

J'ai tendance à utiliser les types Nullable partout où cela a du sens - je ne me soucierai pas des performances jusqu'à ce que ce soit un problème, alors je corrigerai les quelques zones où elles se trouvent et j'en finirai avec.

Cependant, je trouve également qu'en général, la plupart de mes valeurs finissent par être non nulles. En fait, il y a de nombreuses fois que j'aimerais un NotNullable que je peux utiliser avec des types de référence pour découvrir un problème nul lorsque j'obtiens le null, pas plus tard lorsque j'essaie de l'utiliser.