dictionary: rechercher des chaînes de caractères avec une fonctionnalité similaire

Je recherche mes clés dans le Dictionnaire avec une fonction comme. Je veux les clés commencent par "a" ou leur 3ème lettre "e" ou leur 4rt lettre n'est pas "d"

en sql, il est possible d'écrire des requêtes "où (clé comme" un') et (clé aime pas 'd__') " je veux avoir cette fonctionnalité pour le Dictionnaire . Tout algorithme de suggestion que vous avez ?

Merci !

source d'informationauteur softwaremonster

  1. 11

    Alors que ce sera le SQL équivalent d'un scan de table, vous pouvez utiliser LINQ ou la IEnumerable<T> les méthodes d'extension à la recherche de votre dictionnaire pour toutes les valeurs dont les touches correspondent à un modèle:

    Méthode D'Extension:

    var values = dictionary.Where(pv => 
             pv.Key.StartsWith("A") || 
             (pv.Key.Length >= 3 && pv.Key[2] == 'e') || 
             pv.Key.Length < 4 || 
             pv.Key[3] != 'd').Select(pv => pv.Value);

    LINQ:

    var values = (from pv in dictionary
              where pv.Key.StartsWith("A") ||
                    (pv.Key.Legnth >= 3 && pv.Key[2] == 'e') ||
                    pv.Length < 4 ||
                    pv.Key[3] != 'd'
                    select pv.Value);

    Noter que la dernière partie de ces deux prédicats qui a trait à votre "quatrième lettre n'est pas "d". J'ai pris ça pour dire qu'une chaîne de trois caractères (ou moins) de long serait ce match. Si vous voulez dire que la chaîne est d'au moins quatre caractères ET de sa quatrième personnage n'est pas "d", le changement devrait être évident.

    Être conscient que le primaire (de la performance) des prestations à la Dictionary classe est à l'aide de base de hachage de la clé des recherches, qui, dans le moyen et dans le meilleur des cas) est O(1). À l'aide d'une recherche linéaire comme c'est O(n), donc quelque chose comme cela, en général, être plus lente qu'une clé ordinaire de recherche.

  2. 11

    Vous pouvez accéder à la propriété Clés du Dictionnaire et ensuite utiliser une requête Linq pour évaluer vos clés:

    var dictionary = new Dictionary<string,string>();

dictionary.Keys.Where( key => key.Contains("a")).ToList();
  3. 2

    Vous pouvez utiliser LINQ

    Quelque chose comme cela

    myDic.Where(d=>d.Key.StartWith("a")).ToDictionary(d=>d.Key,d=>d.Value)

    Ou

    myDic.Where(d=>d.Key.Contains("b")).ToDictionary(d=>d.Key,d=>d.Value)

    Ou

    myDic.Where(d=>some other condition with d.Key).ToDictionary(d=>d.Key,d=>d.Value)
  4. 2

    Suffit d'utiliser Linq:

    var query = myDict.Where(x => x.Key.IndexOf('a') > -1 && x.Key.IndexOf("d_") == -1);
  5. 1

    Voici une petite extension je fouettée:

    public static IList<string> KeysLikeAt(this Dictionary<string, object> dictionary, char letter, int index)
{
    return dictionary.Where(k => k.Key.Length > index && k.Key[index] == letter)
        .Select(k => k.Key).ToList();
}

public static IList<string> KeysNotLikeAt(this Dictionary<string, object> dictionary, char letter, int index)
{
    return dictionary.Where(k => k.Key.Length > index && k.Key[index] != letter)
        .Select(k => k.Key).ToList();
}

    et vous pouvez l'utiliser comme ceci:

    IList<string> keysStartingWithA = dictionary.KeysLikeAt('a', 0);

IList<string> keysNotStartingWithD = dictionary.KeysNotLikeAt('d', 0);