Archiv

Archive for Dezember 2010

Rückblick 2010 und Ziele 2011

31. Dezember 2010 3 Kommentare

Ein ereignisreiches Jahr 2010 geht zu Ende. Ich konnte in diesem Jahr meine Kenntnisse in C# massiv ausbauen, was mir auch beruflich neue Möglichkeiten eröffnete: seit Ende November leite ich das Kompetenzzentrum .Net bei AKROS. Diese zusätzliche Aufgabe wird mich vor allem im 2011 fordern und sicher zu einigen Blogeinträgen führen.

 
Ziele 2010 fast alle erreicht
1 Iteration durch alle Grade von Clean Code Developer: Obwohl ich mehrmals einen Grad zurückging, habe ich mich durch alle Grade durchgearbeitet. So bin ich nun bereit für eine weitere Iteration. Ich finde eine der wichtigsten Lehren war das tägliche Reflektieren. Dies ist eine kleine Sache die aber eine sehr grosse Wirkung hat.

Verteilte Versionierungssysteme für 1 bis 2 Projekte benutzen: Ich habe mich dieses Jahr intensiv mit Mercurial und GIT beschäftigt. Für einen Blogeintrag hat die Zeit bisher noch nicht gereicht, aber das wird in den nächsten Wochen nachgeholt. Mercurial finde ich ein tolles System und derart einfach, das ich es sogar für die kleinen Beispielprojekte nutze.

Mehr als 2 Wochen Ferien: Im Juli war ich rund 4 Wochen an der Ostküste der USA. Dies war eine super Sache und bedarf dringend einer Wiederholung. 4 Wochen ohne zu Programmieren und ohne ständig online zu sein geht wunderbar und ist als Abwechslung sehr empfehlenswert.

Route meiner USA Reise 2010

Neue Programmiersprache: Dieses Ziel habe ich nicht erreicht. Ich habe mich sowohl in Ruby wie auch in Grails eingelesen, aber mir fehlte es an Zeit mich auch wirklich darauf einzulassen.

 
Ziele 2011
Fürs 2011 setzte ich mir diese 5 Ziele:

  • Mein Wissen über Silverlight weiter ausbauen und die dazugehörige Microsoft-Prüfung 70-506 erfolgreich abschliessen.
  • Mit dem so gewonnenen Wissen eine kommerzielle Anwendung für Windows Phone 7 in den Marketplace bringen.
  • Mich in Ruby on Rails soweit einarbeiten, dass ich damit eine meiner bestehenden PHP-Anwendungen ablösen kann.
  • Wiederum mindestens 4 Wochen Ferien fern ab von irgendeiner IDE.
  • Bei PostAWeek mitmachen und jede Woche mindestens einen Blogeintrag schreiben.
Schlagworte:

Mengenoperationen mit LINQ

28. Dezember 2010 6 Kommentare

Wie weithin bekannt ist, kann man mit LINQ (Language Integrated Query) beliebige Datenquellen abfragen. Ich bin vor kurzem auf eine weitere interessante Anwendungsmöglichkeit gestossen, die wohl nicht allen bekannt ist: Mengenoperationen.

Ich fand diese Möglichkeit als ich nach einer optimierten Version für so ein Stück Code suchte:

private static List<int> ValuesNotInSecondList(List<int> first, List<int> second)
{
    List<int> result = new List<int>();

    foreach (var i in first)
    {
        if(!second.Contains(i))
        {
            result.Add(i);
        }
    }

    return result;
}

Aus einer Liste A sollen alle Werte zurückgeliefert werden, die nicht in Liste B vorhanden sind. Diese an sich einfache Aufgabe braucht nach meinem Geschmack zu viel Code.

ReSharper hat mir diese optimierte Version vorgeschlagen:

private static List<int> ValuesNotInSecondList(List<int> first, List<int> second)
{
    return first.Where(i => !second.Contains(i)).ToList();
}

Der Code wurde schon massiv reduziert, aber irgendwie genügte mir dies noch nicht. Da in meinem konkreten Anwendungsfall in meiner ersten Liste die Werte immer nur 1x vorkommen, suchte ich weiter.

 
Differenz zweier Mengen
In Wikipedia wird die (mathematische) Differenz zweier Mengen wie folgt beschrieben:

Die Differenzmenge (auch Restmenge) von A und B ist die Menge der Elemente, die in A, aber nicht in B enthalten sind.

Und das ist eigentlich genau das, was die Methode machen soll. LINQ erweitert IEnumerable um die Methode Except, die genau dieses Verhalten implementiert:

List<int> listOdd = new List<int> { 1, 3, 5, 7, 9 };
List<int> listFibonacci = new List<int> { 1, 2, 3, 5, 8 };

List<int> resultExcept = listOdd.Except(listFibonacci).ToList();
PrintList(resultExcept); // Resultat: 7,9

In diesem Beispiel werden die Zahlen zurückgegeben, die zwar ungerade aber nicht teil meiner reduzierten Fibonacci-Folge sind.

 
Schnittmenge und Vereinigung
LINQ bietet ebenfalls eine Methode für die Schnittmenge (Intersect) und die Vereinigung (Union) an:

List<int> resultIntersect = listOdd.Intersect(listFibonacci).ToList();
PrintList(resultIntersect); // Resultat: 1,3,5

List<int> resultUnion = listOdd.Union(listFibonacci).OrderBy(i => i).ToList();
PrintList(resultUnion); // Resultat: 1,2,3,5,7,8,9 (Reihenfolge durch die Sortierung)

 
Auch mit Strings möglich
Was so schön mit Integer funktionierte, geht übrigens genauso auch mit Strings (oder jedem anderen Typ der mit EqualityComparer.Default verglichen werden kann IEquatable implementiert):

List<string> listAD = new List<string> { "A", "B", "C", "D" };
List<string> listCF = new List<string> { "C", "D", "E", "F", };


List<string> resultADexceptCF = listAD.Except(listCF).ToList();
PrintList(resultADexceptCF); // Resultat: A,B

List<string> resultADintersectCF = listAD.Intersect(listCF).ToList();
PrintList(resultADintersectCF); // Resultat: C,D

List<string> resultADunionCF = listAD.Union(listCF).ToList();
PrintList(resultADunionCF); // Resultat: A,B,C,D,E,F

 
Fazit
Für Mengenoperationen bietet LINQ spezielle Operationen an, die einem viel eigenen Code ersparen. Wichtig ist dabei aber, dass die Listen nicht mehrmals den gleichen Wert enthalten. Sonst sind es keine Mengen mehr und LINQ filtert die doppelten Werte in der Resultatmenge selber heraus.

Schlagworte: ,
Folgen

Erhalte jeden neuen Beitrag in deinen Posteingang.

Schließe dich 278 Followern an