Feedback

C# - Filtern mit dem Blacklist - Whitelist Verfahren

Veröffentlicht von am 25.06.2007
(3 Bewertungen)
Mit dieser Klasse können Listen mit Hilfe der Black and Whitelist gefiltert werden.

Dank IList können z.B. List<String> Objekte oder Arrays übergeben werden.
Die Listenelemente müssen sich als Key für ein Dictionary eignen, das ist bei String immer der Fall.

Danke an herbivore für das das Feintuning.
using System.Collections.Generic;

namespace Filter
{
    internal class BlackWhite<T>
    {
        private Dictionary<T, bool> black = new Dictionary<T, bool>();
        private Dictionary<T, bool> white = new Dictionary<T, bool>();

        public BlackWhite(IList<T> black, IList<T> white)
        {
            foreach (T t in black) {
               this.black [t] = true;
            }
            foreach (T t in white) {
               this.white [t] = true;
            }
        }

        public List<T> GetGoodList(IList<T> inputList)
        {
            List<T> goodList = new List<T>();

            foreach (T t in inputList)
            {
                if (white.ContainsKey(t) || !black.ContainsKey(t)) {
                    goodList.Add(t);
                }
            }
            return goodList;
        }
    }
}

1 Kommentare zum Snippet

Jan Welker schrieb am 17.01.2010:
Der Code könte dadurch vereinfacht werden, dass auf die Umwandlung in ein Dictionary<T, bool> verzichtet wird, weil IList<T> bereits über eine Contains-Methode verfügt. Damit können black und white als IList<T> deklariert werden und können im Konstruktor direkt zugewiesen werden. Damit erspart man sich die unbenötigten bool-Werte des Dictionarys. Dadurch entfallen weiter die Foreach-Schleifen im Konstruktor, die zudem fehleranfällig sind, weil in den übergebenen IList-Colletions identische Einträge vorhanden sein können, die Key-Werte in einem Dictionary aber eindeutig sein müssen. In GetGoodList ist dann beim Schleifendurchlauf lediglich der Methodenaufruf "white.ContainsKey(t)" durch "white.Contains(t)" zu ersetzen.
Die Funktionalität lässt sich auch etwas anders implementieren (Beispiel in VB:

Friend Class BlackWhiteEx(Of T)
Private _black As New HashSet(Of T)
Private _white As New HashSet(Of T)

Public Sub New(black As IList(Of T), white As IList(Of T))
Me._black.UnionWith(black.AsEnumerable)
Me._white.UnionWith(white.AsEnumerable)
End Sub

Public Function GetGoodList(inputList As IList(Of T)) As List(Of T)
Dim goodList As New List(Of T)
Dim htResult As New HashSet(Of T), htWhite As New HashSet(of T)
htWhite.UnionWith(_white.AsEnumerable)
htResult.UnionWith(inputList.AsEnumerable)
htWhite.IntersectWith(inputList.AsEnumerable)
htResult.ExceptWith(_black.AsEnumerable)
htResult.UnionWith(htWhite.AsEnumerable)
goodList = htResult.ToList
Return goodList
End Function
End Class

Der Unterschied: In der zurückgegebenen "GoodList" sind alle mehrfach enthaltenen Einträge der Ausgangsliste bis auf einen entfernt, d. h. die Ergebnisliste enthält keine doppelten oder mehrfachen Werte mehr.
 

Logge dich ein, um hier zu kommentieren!