Liste Comte vs Liste condition null, modifier les résultats

Je vais avoir un programme qui serait d'abord parcourir le Fichier de données, puis de les convertir au format JSON () les données d'un Objet. Objet dépend du format de Fichier que je suis en train d'accéder aux données. C'est à peu près sans rapport avec à la question que je vais poser.

Quand j'ai terminé le projet, et j'étais prêt à les envoyer à mes amis, j'ai trouvé qu'il y avait une chose que je ne comprends pas au sujet de la List<>s de C#.

Voici le code que j'utilise:

//File is not empty!
string file = File.ReadAllText(new MainWindow().getFileName("events"));
List<Event> events = JsonConvert.DeserializeObject<List<Event>>(file);

Après cela, je suis en train de remplir le ListView par chaque événement que je vais avoir, ou je suis en train de remplir un TextBlock avec un texte disant, il n'y a aucun cas de créer un maintenant.

Je suis en utilisant cette condition.

if(events != null) {
   //goes well
} else {
   //populate the code text view 
}

Dans ce code, le bloc else ne pas se déclencher. Si il y a des événements, il remplit la liste sinon ça ne saute le textView code de mise à jour.

Liste Comte vs Liste condition null, modifier les résultats

Mais, si j'utilise ce code au lieu de cela,

if(events.Count != 0) {
   //listview code..
} else { 
   //populate text view
}

À l'aide de cette manière, je peux remplir le textView et je vois le message d'erreur dans la Page.

Liste Comte vs Liste condition null, modifier les résultats

J'ai ajouté le code de l'image, et l'exemple pour que. J'espère que quelqu'un peut me dire la différence

(List.Count == 0) || (List == null) 
/* irrelevant piece of code, I'm trying to ask, should I use 
 * List Count == 0 OR List is equal to null */

tu veux dire que la différence de certains de la liste List<SomeType> list; entre les deux conditions list.Count == 0 et list == null, ou je me trompe? Parce que la question des états de la capitalisation des List dans des conditions tout à la fin, ce qui est un peu déroutant.

InformationsquelleAutor Afzaal Ahmad Zeeshan | 2014-06-20

c#count

6

Pour certains variable de liste
```
List<SomeType> list = //initialization
```
il peut arriver que la variable list pourraient ne pas être initialisé correctement et qu'aucun objet n'est mis en place. Dans de tels cas, la valeur de la variable est null. Si
- list == null évalue à true et
- list.Count jette un NullReferenceException
Sur l'autre main, si une liste a pu être obtenu. Ensuite, vous serez en mesure d'appeler Count sur la liste qui indique le nombre d'éléments dans cette liste. Si
- list == null évalue à false et
- list.Count == 0 évalue à true si la liste ne contient pas les éléments et false si elle contient au moins un des éléments.
Pour être sur le côté sécuritaire (pas seulement pour la programmation de paranoïaques) il est bon de vérifier si une variable peut être null ou pas. Par cela, je veux dire vérifiez la documentation de l'API que vous êtes l'obtention de l'objet.

Si vous le connaissez peut-être, éventuellement, null, vous aurez besoin pour remédier à cette situation en vérifiant list == null premier. Si vous ne savez pas, vous devriez probablement vérifier null. Je suggère de vérifier pour null et si oui, - d'attribuer une liste vide à votre liste.
```
List<SomeType> list = //initialization
list = (list == null) ? new List<SomeType>() : list;

if(list.Count == 0) 
  //do whatever you like here
else
  //or even here
```
Bien mettre l'initialisation en une autre méthode qui est seulement dédié à récupérer votre liste. Si de toute façon il échoue, il renvoie une liste vide. De cette façon, vous pouvez gérer tous le code suivant en cochant une seule condition. La condition si la list.Count == 0.
```
List<SomeType> RetrieveList()
{
    List<SomeType> list = //initialization possibly null
    return (list == null) ? new List<SomeType>() : list;
}
```
Espère que cette aide
- +1, c'est utile 🙂
- mise à jour de la réponse à l'adresse de la question des modifications
- Ouais, qui ont un sens beaucoup plus maintenant 🙂 merci et encore Merci pour votre soutien 🙂
- Votre accueil 😉
InformationsquelleAutor isaias-b
2

La la documentation ne dit rien sur la valeur de retour de JsonConvert.DeserializeObject .

Mais il semble que List<Event> events = JsonConvert.DeserializeObject<List<Event>>(file); ne définit jamais des événements de null, c'est pourquoi votre code
```
if(events != null) {
   //goes well
} else {
   //populate the code text view 
}
```
n'est pas ce qu'il est censé faire.

Mais c'(JsonConvert) peut renvoyer une liste vide. C'est pourquoi ces code fait ce qu'il est censé accomplir:
```
if(events.Count != 0) {
   //listview code..
} else { 
   //populate text view
}
```
parce que dans le cas de l'échec de l'analyse JsonConvert.DeserializeObject renvoie la Liste vide.

Bien, (List.Count == 0) || (List == null) devrait être écrit comme (List == null) || (List .Count == 0) parce que si la liste en quelque sorte, devenir nulle, vous avez un imprévu NulReferenceException. Pour plus de détails, lire L'ordre d'exécution des conditions en C# Si la déclaration

Il est possible que le comportement de JsonConvert pourrait changer, de sorte qu'il serait préférable d'utiliser
```
if ((events == null) || (events.Count == 0)) {
   //Error handling - populate text view
} else { 
   //Everything is ok - listview code..
}
```
- C'est utile morceau de vous! 🙂 Cependant, la dernière partie, vous pouvez le retirer. Je suis désolé, je n'étais pas capable d'écrire que la partie était unrelative à la question de trop. Beaucoup Désolé.
InformationsquelleAutor Eugene Podskal

Vous devez vous connecter pour publier un commentaire.