Évitez d'ajouter des éléments en double à une liste C #

string[] lines3 = new string[100];
List<string> lines2 = new List<string>();
lines3 = Regex.Split(s1, @"\s*,\s*");

if (!lines2.Contains(lines3.ToString()))
{
    lines2.AddRange(lines3.Distinct().ToArray());
}

J'ai vérifié tous les espaces, etc, mais je reçois encore des valeurs en double dans mon lines2 List

Je dois enlever mes valeurs en double ici lui-même

source d'informationauteur vini

  1. 19

    Votre cette case: 

    if (!lines2.Contains(lines3.ToString()))

    est pas valide. Vous de vérifier si votre lines2 contient System.String[] depuis lines3.ToString() vous donnera. Vous devez vérifier si l'élément de lines3 existe dans lines2 ou pas.

    Vous pouvez parcourir chaque élément dans lines3 vérifier s'il existe dans le lines2puis l'ajouter. Quelque chose comme. 

    foreach (string str in lines3)
{
    if (!lines2.Contains(str))
        lines2.Add(str);
}

    Ou si votre lines2 est toute la liste est vide, alors vous pouvez simplement ajouter le lines3 valeurs distinctes de la liste comme: 

    lines2.AddRange(lines3.Distinct());

    alors votre lines2 contiendra des valeurs distinctes.

  2. 27

    Vous pouvez utiliser Énumérable.Sauf pour obtenir des articles distincts de lines3 qui n'est pas dans lines2:

    lines2.AddRange(lines3.Except(lines2));

    Si lines2 contient tous les éléments de lines3 alors rien ne sera ajouté. BTW, en interne, à l'Exception des utilisations Set<string> pour obtenir des articles distincts de la deuxième séquence et de vérifier ces éléments présents dans la première séquence. Donc, c'est plutôt rapide.

  3. 20

    Utiliser un HashSet<string> au lieu d'un List<string>. Il est prêt à procéder à une meilleure performance parce que vous n'avez pas besoin de fournir des contrôles pour tous les articles. La collection sera gérer pour vous. C'est la différence entre un list et un set. Pour l'échantillon:

    HashSet<string> set = new HashSet<string>();

set.Add("a");
set.Add("a");
set.Add("b");
set.Add("c");
set.Add("b");
set.Add("c");
set.Add("a");
set.Add("d");
set.Add("e");
set.Add("e");

var total = set.Count;

    Total est 5 et les valeurs sont abcde.

    La mise en œuvre de l' List<T> ne vous donne pas nativelly. Vous pouvez le faire, mais vous devez fournir à ce contrôle. Pour l'échantillon, ce extension method:

    public static class CollectionExtensions
{
    public static void AddItem<T>(this List<T> list, T item)
    {
       if (!list.Contains(item))
       {
          list.Add(item);
       }
    }
}

    et de l'utiliser:

    var list = new List<string>();
list.AddItem(1);
list.AddItem(2);
list.AddItem(3);
list.AddItem(2);
list.AddItem(4);
list.AddItem(5);
  4. 3

    Si vous ne voulez pas de doublons dans une liste, utilisez une HashSet. De cette façon, il sera clair pour quelqu'un d'autre lecture de votre code, ce que votre intention était, et vous aurez moins de code à écrire depuis HashSet déjà les poignées de ce que vous essayez de faire.

  5. 2

    Vous pouvez utiliser un simple Union + Distinct:

    var lines = lines2.Union(lines3).Distinct();

    Qui va ajouter tous les éléments de la deuxième liste dans la première liste, et puis le retour de toutes les chaînes dans la liste. Pas de chances de bien performer avec de grandes listes, mais c'est simple.

    Référence: http://msdn.microsoft.com/en-us/library/bb341731.aspx

  6. 1

    Si votre chèque aurait fonctionné, il aurait ajouté tous les éléments, ou rien du tout. Toutefois, l'appel de la ToString méthode sur un tableau retourne le nom du type de données, et non pas le contenu de la matrice, et la Contains méthode ne peut regarder pour un seul article, ce n'est pas une collection d'articles de toute façon.

    Vous devez vérifier chaque chaîne dans le tableau:

    string[] lines3;
List<string> lines2 = new List<string>();

lines3 = Regex.Split(s1, @"\s*,\s*");

foreach (string s in lines3) {
  if (!lines2.Contains(s)) {
    lines2.Add(s);
  }
}

    Toutefois, si vous commencez avec une liste vide, vous pouvez utiliser le Distinct méthode pour supprimer les doublons, et vous avez seulement besoin d'une seule ligne de code:

    List<string> lines2 = Regex.Split(s1, @"\s*,\s*").Distinct().ToList();
  7. 1

    Si vous souhaitez enregistrer les valeurs distinctes dans une collection, vous pourriez essayer La Classe HashSet. Il sera automatiquement supprimer les valeurs en double et enregistrer votre temps de codage. 🙂

  8. 0

    utilisation HashSet c'est mieux

    prendre un coup d'oeil ici : http://www.dotnetperls.com/hashset

  9. 0

    Utiliser un HashSet avec votre List:

    List<string> myList = new List<string>();
HashSet<string> myHashSet = new HashSet<string>();

public void addToList(string s) {
    if (myHashSet.Add(s)) {
        myList.Add(s);
    }
}

    myHashSet.Add(s) sera de retour true si s est de ne pas exister en elle.

  10. 0

    pas une bonne façon mais genre de solution rapide,
    prendre un bool pour vérifier si dans la liste il n'y a aucun doublon.

    bool containsKey;
string newKey;

    public void addKey(string newKey){

         foreach(string key in MyKeys){
           if(key == newKey){
             containsKey = true;
          }
         }

      if(!containsKey){
       MyKeys.add(newKey);
     }else{
       containsKey = false;
     }

    }