Pourquoi ne pas null false?

Quelle est la raison null n'est pas évalué à false dans des conditions?

J'ai d'abord pensé à des affectations pour éviter le bug de l'aide = au lieu de ==, mais cela pourrait facilement être rejetée par le compilateur.

if (someClass = someValue) //cannot convert someClass to bool. Ok, nice

if (someClass) //Cannot convert someClass to bool. Why?

if (someClass != null) //More readable?

Je pense que c'est assez raisonnable de supposer que null signifie false. Il y a d'autres langues que l'utilisation trop, et je n'ai pas eu un bug à cause de cela.

Edit: Et je suis sûr référence à des types référence.

Un bon commentaire par Daniel Earwicker sur la cession de bug... Cette compile sans un avertissement parce qu'il évalue à bool:

bool bool1 = false, bool2 = true;
if (bool1 = bool2)
{
    //oops... false == true, and bool1 became true...
}
  • La réponse est simple: "c'est ainsi Que le C# concepteurs voulaient." Pourtant, ce n'est pas vraiment répondre à la question. Quelqu'un aurait-il aperçu des raisons pour lesquelles la langue, les designers n'aiment pas automatiquement casting des références à des valeurs booléennes (comme le C/C++/Python)?
  • Je suis en train de traquer une référence - je crois que j'ai de parler à l'un de la langue équipe a tout à l'arrière, ce qui n'aide pas vraiment
  • Je pense que C les programmeurs pense qu'il est raisonnable que, null false. Le faux est une valeur, la valeur null est l'absence de valeur. C# est bon je pense. D'autres langues qui ont été construites sans type booléen ou un concept d'un pointeur (ou type nullable) juste surchargé int dire toutes ces choses différentes. Pourquoi devrait-NULL==faux et faux==0 ? Ils ne devraient pas.
InformationsquelleAutor simendsjo | 2010-07-07
  1. 23

    C'est une conception spécifique de la fonctionnalité dans le langage C#: if états n'accepter qu'un boolean.

    Autant que je me souvienne c'est pour la sécurité: plus spécifiquement, de sorte que votre première if (someClass = someValue) ne parvient pas à compiler.

    Edit: Un des avantages est qu'il permet l' if (42 == i) convention ("yoda comparaisons") inutiles.

    • Mais au lieu de dire "accepte uniquement bool" il pourrait dire "ne pas accepter l'affectation"...
    • Ouais, je trouve que C#dans le comportement préférable ici, précisément parce qu'elle vous protège de la commune de bug
    • Affectation en tant que condition est utile, mais pas tellement dans if états: while ((line = Console.ReadLine()) != null)
    • Le if (a = b) bug n'est pas arrêté par la présente, parce que a et b peut être de type bool.
    • Sauf que vous pouvez attribuer à cette expression, il serait attribuer d'abord, puis à tenter de convertir implicitement l'objet d'un bool et (généralement) l'échec.
    • C'est vraiment terrible de comportement. Je reçois ce que null n'est pas une valeur, mais une instruction if doit accepter une référence unique et si ce n'est pas une valeur de faire la même chose que se passerait-il lorsqu'il est évalué à false.

    InformationsquelleAutor Tim Robinson
  2. 22

    "Je pense que c'est assez raisonnable de supposer que, null false"

    Pas en C#. le faux est un booléen struct, un type de valeur. Types de valeur ne peut pas avoir une valeur nulle. Si vous vouliez faire ce que vous avez réalisé, vous aurez à créer des convertisseurs de votre type boolean:

    public class MyClass
{
    public static implicit operator bool(MyClass instance)
    {
        return instance != null;
    }
}

    Ci-dessus, je pourrais alors faire:

    if (instance) {

}

    etc.

    • Vous pouvez également utiliser le vrai ou faux les opérateurs, s'ils sont un peu obscurs: msdn.microsoft.com/en-us/library/6x6y6z4d%28VS.80%29.aspx
    • Sur une note de côté, dont l'une des conséquences de l'utilisation de la vraie et de la fausse opérateurs est qu'un état particulier pourrait être vrai, faux, ni ou les deux. Cela signifie un type de mise en œuvre de la vrai et le faux, les opérateurs pourraient satisfaire l'expression Debug.Assert(x && !x)
    • C'est ce que je cherchais, j'ai un statut d'objet, et je voulais être capable de faire if (status) {} au lieu de if (status.isSuccess()){}. Je ne sais pas encore si c'est une bonne idée, mais maintenant j'ai maintenant, je peux le faire.
    InformationsquelleAutor Matthew Abbott
  3. 14

    "Je pense que c'est assez raisonnable de supposer que, null false"

    Je ne suis pas d'accord. À mon humble avis, le plus souvent, false signifie "non". Null signifie "je ne sais pas"; c'est à dire complètement indéterminée.

    • +1 - t NULL jamais de la fausse? Je ne peux pas penser à des exemples d'une technologie qui est mise en œuvre de cette façon. Il peut y avoir certains qui, implicitement, de permettre des comparaisons, mais autant que je sache, nul n'est jamais faux.
    • Alors que je ne suis pas un expert sur de nombreuses langues différentes, je pense NULL probablement jamais "signifie" faux dans une langue qui ne gère pas correctement la valeur NULL dans la première place.
    InformationsquelleAutor Rob Levine
  4. 5

    Une chose qui vient à l'esprit ce sujet dans l'instance d'un type de données, comme les int? Int ne peut pas être null, font-ils toujours évaluer à vrai? On pourrait supposer que int = 0 est faux, mais qui commence à devenir vraiment compliqué, parce que 0 est une valeur valide (où peut-être 0 doit avoir la valeur true parce que le progammer définir), et pas seulement une valeur par défaut.

    Il y a beaucoup de cas où la valeur null n'est pas une option, ou parfois, c'est une option, et d'autres fois elle ne l'est pas.

    Ils ont mis dans ce genre de choses pour protéger le programmeur de faire des erreurs. Il va le long de la même ligne de pourquoi vous ne pouvez pas le faire tomber en cas de déclarations.

    • +1 NULL signifie que la valeur est inconnue ou la valeur est manquante ou de la valeur n'a pas encore été attribué etc. cela ne veut pas dire FAUX, du point de vue sémantique, ils ne sont pas les mêmes. Je pense toujours à traiter NULL, FALSE est un mauvais langage de conception.
    • Je suis d'accord. Sur la surface, il semble que cela pourrait faire sens, mais il y a trop de possibilités là où nul et faux diffèrent.
    • Mais un valuetype n'est pas un type de référence et ne peut pas être null. Je ne dis pas que chaque type de possibles autres que false true...
    • Droit, mais qu'est ce que je dis. si(objet) une évaluation quant à savoir si c'est nul, ce sont les règles autour de quelque chose qui ne peut pas être null? Il est juste vraiment harry contourner les règles de faire une hypothèse quant à ce que vous souhaitez évaluer, dans un if(objet) scénario.
    InformationsquelleAutor kemiller2002
  5. 5

    Suffit d'utiliser si(Convertir.ToBoolean(someClass))

    http://msdn.microsoft.com/en-us/library/wh2c31dd.aspx

    Paramètres

    valeur de Type: Système.Un objet Un objet qui implémente l'
    IConvertible interface, ou la valeur null.
    Valeur De Retour

    Type: System.La valeur booléenne true ou false,
    qui reflète la valeur retournée par
    l'invocation de la IConvertible.ToBoolean
    méthode pour le type sous-jacent de
    de la valeur. Si la valeur est null, la méthode
    renvoie la valeur false

    InformationsquelleAutor Gage
  6. 4

    Pour autant que je sais, c'est une fonctionnalité que vous voyez dans la dynamique des langues, que le C# n'est pas (conformément à la spécification du langage if accepte uniquement bool ou une expression qui correspond à bool).

    Je ne pense pas que c'est raisonnable de supposer que null est false dans chaque cas. Il est logique, dans certains cas, mais pas dans d'autres. Par exemple, supposons que vous avez un drapeau qui peut avoir trois valeurs: ensemble, unset, et de l'onu-initialisé. Dans ce cas, ensemble serait true, unset serait false et de l'onu-initialisé serait null. Comme vous pouvez le voir, dans ce cas, le sens de l' null n'est pas false.

    • Losely tapé ≠ typées dynamiquement. C++ évalue NULL (macro) pour 0 qui évalue ensuite à false dans le if déclaration.
    • Je ne parlait pas de NULL. Je parlais null. Je ne vois pas comment ma déclaration d'origine est mauvais. Normalement, vous ne voyez if(someVarThatCouldBeNull) dans la dynamique des langues.
    • Je suis d'accord, Vivin. Je dirais que le concept de la valeur null n'existe pas en C++. Ou plutôt, le concept d'une variable sans valeur (null en C#) n'existe pas en C++. Une variable aura toujours une valeur, vous ne savez pas ce que c'est, sauf si vous initialisez-le vous-même. Comme strager souligne, NULL en C++ est juste une macro pour représenter 0, rien de plus. Il n'y a pas de compilateur de règles autour d'elle.
    • Wily Apprenti. J'ai essayé de dire la même chose 🙂 Merci pour l'explication si. J'ai aussi n'était pas sûr de savoir pourquoi strager parle de C++, la question est sur C#?
    InformationsquelleAutor Vivin Paliath
  7. 3

    Car nul et faux sont des choses différentes.

    Est un exemple parfait bool? foo

    Si foo valeur est true, alors que sa valeur est true.

    Si foo valeur est false, alors sa valeur est false

    Si toto n'a rien d'affecté, sa valeur est null.

    Ces trois logiquement conditions distinctes.

    Penser d'une autre façon

    "Combien d'argent dois-je vous dois?"

    "Rien" et "je n'ai pas cette information" sont deux distinctes réponses.

    • +1 pour le bon point, mais encore.. Si vous essayez d'évaluer un bool? vous a de le jeter à un bool et potentionally obtenir une erreur d'exécution, ou de l'utiliser == true / false pour l'évaluer... bool? n'est pas un type de référence que ma question, c'est toujours un valuetype
    • Comme une note de côté, un ordinateur est censé connaître les réponses aux questions sur les données, et devrait probablement le signal d'une erreur si quelque chose "ne peut pas être déterminé".
    InformationsquelleAutor diadem
  8. 3

    Qu'est-ce que la raison n'est pas null
    la valeur false dans le conditionnel?

    J'ai d'abord pensé à des affectations à
    éviter le bug de l'aide = au lieu de
    ==

    Qui n'est pas la raison. Nous le savons parce que si les deux variables comparées arriver à être de type bool puis le code compiler tout à fait heureux:

    bool a = ...
bool b = ...

if (a = b)
    Console.WriteLine("Weird, I expected them to be different");

    Si b est vrai, le message est imprimé (et a est maintenant vrai, de décisions ultérieures de débogage de l'expérience cohérente avec le message, donc de confondre encore plus...)

    La raison null n'est pas convertible à bool est tout simplement que C# évite la conversion implicite sauf si requis par le concepteur d'un type défini par l'utilisateur. Le C++ livre d'histoire est pleine d'histoires douloureuses causées par des conversions implicites.

    • J'ai déjà mis à jour ma question avec ce à partir de votre précédent commentaire. La conversion implicite argument est le meilleur que j'ai entendu de loin.
    InformationsquelleAutor Daniel Earwicker
  9. 3

    Structurellement, la plupart des gens qui "ne peut pas penser à tout technologique raison null doit être égale à false" se tromper.

    Code est exécuté par le Cpu.
    La plupart (si pas tous) Processeurs ont bits, groupes de bits et interprétations de groupes de bits. Cela dit, quelque chose peut être 0, 1, un byte, un word, un dword, un qword et ainsi de suite.

    Noter que sur plate-forme x86, les octets sont octets (8 bits), et les mots sont habituellement de 16 bits, mais ce n'est pas une nécessité. Les Processeurs plus anciens avaient des mots de 4 bits, et même aujourd'hui' les bas de gamme de contrôleurs embarqués utilisent souvent comme 7 ou 12 bits par mot.

    Cela dit, quelque chose est "égal", "zéro", "plus", "moins", "supérieur ou égal", ou "inférieur ou égal" en code machine. Il n'y a pas une telle chose comme null, false ou true.

    De la convention, true est 1, false est 0, et un null pointeur est soit 0x00, 0x0000, 0x00000000, ou 0x0000000000000000, selon bus d'adresse largeur.

    C# est une exception, car c'est un type indirect, où les deux valeurs possibles 0 et 1 ne sont pas une valeur immédiate, mais une indice d'une structure (pensez enum en C, ou PTR en x86 assemblée).

    C'est par la conception.

    Il est important de noter, cependant, que de telles décisions de conception sont élaborer décisions, tandis que le traditionnelle, simple moyen est de supposer que 0, null et false sont égaux.

    InformationsquelleAutor Victor
  10. 2

    C# ne pas faire une conversion du paramètre, comme le C++ n'. Vous avez besoin de convertir explicitement la valeur en une valeur de type boolean si vous souhaitez que le if déclaration pour accepter la valeur.

    InformationsquelleAutor kiamlaluno
  11. 1

    C'est tout simplement le type de système de c# par rapport à des langages comme PHP, Perl, etc.

    Un état accepte uniquement Boolean valeurs, la valeur null n'est pas le type de Boolean afin de ne pas y travailler.

    Comme pour les NULS exemple en C/C++ que vous avez mentionné dans un autre commentaire, il faut dire que ni C ni C++ ont un type booléen (afair C++ a généralement un transtypage pour le type bool qui renvoie un int, mais c'est une autre question) et ils n'ont pas non null références, seulement NULL(=> 0)-pointeurs.

    Bien sûr, le compilateur concepteurs ont pu mettre en œuvre une conversion automatique pour tout type nullable à booléen mais que serait la cause d'autres problèmes, à savoir:

    En supposant que foo est pas null:

    if (foo)
{
  //do stuff
}

    Dont l'état de foo est vrai?

    Toujours si elle n'est pas nulle?

    Mais que faire si vous voulez que votre type convertible pour booléenne (c'est à dire à partir de votre tri-state ou quantique, la logique de la classe)?

    Qui signifierait que vous pourriez avoir besoin de deux différentes conversions bool, de l'implicite et de l'explicite, ce qui permettrait à la fois de se comporter différemment.

    Je n'osais même pas imaginer ce qui se passerait si vous ne

    if (!!foo) //common pattern in C to normalize a value used as boolean,
           //in this case might be abused to create a boolean from an object
{
}

    Je pense que le travail forcé (foo == null) est bonne, puisqu'elle ajoute de la clarté à votre code, il est plus facile de comprendre ce que vous avez vraiment vérifier.

    InformationsquelleAutor Morfildur