コード例 #1
0
        /*
         *  Veranschaulichung wie LINQ funktioniert.
         */
        public Schuelerliste Where(Func <Schueler, bool> filterFunction)
        {
            Schuelerliste result = new Schuelerliste();

            foreach (Schueler s in liste)
            {
                if (filterFunction(s) == true)
                {
                    result.Add(s);
                }
            }
            return(result);
        }
コード例 #2
0
        static void Main(string[] args)
        {
            List <Schueler> sl   = new List <Schueler>();
            Schuelerliste   mySl = new Schuelerliste();

            /*
             * mySl.Add(new Schueler { Id = 1, Name = "xxx" });
             * mySl.Add(new Schueler { Id = 2, Name = "xxx" });
             * mySl.Add(new Schueler { Id = 3, Name = "xxx" });
             *
             * //Ruft eigenen FunctionDelegate auf
             * Schuelerliste result = mySl.Where(s => s.Id == 3);
             *
             * //Schuelerliste result = mySl.Where(s => s.Id == 3 && s.Name = "xxx");
             *
             * //Das gleiche wie oben, zuerst suche ich nach der Id 3 UND DANN nach dem Namen, gibt aber eh nur "einen" zurück
             * //(vgl. .First() bzw. Id sollte j eindeutig sein)
             * //Schuelerliste result = mySl.Where(s => s.Id == 3).Where(s => s.Name == "xxx");
             *
             *
             * Brauche aber keine eigene .Where oder allgemein Filter Functions, gibt es schon: System.Linq
             */



            Schueler sch = new Schueler {
                Id = 1, Name = "Mustermann"
            };

            sch.Pruefungen.Add(new Pruefung {
                Gegenstand = "POS", Punkte = 12, Note = 5
            });
            sch.Pruefungen.Add(new Pruefung {
                Gegenstand = "DBI", Punkte = 14, Note = 4
            });
            sch.Pruefungen.Add(new Pruefung {
                Gegenstand = "D", Punkte = 16, Note = 3
            });
            sl.Add(sch);
            sch = new Schueler {
                Id = 2, Name = "Musterfrau"
            };
            sch.Pruefungen.Add(new Pruefung {
                Gegenstand = "POS", Punkte = 14, Note = 4
            });
            sch.Pruefungen.Add(new Pruefung {
                Gegenstand = "DBI", Punkte = 24, Note = 1
            });
            sch.Pruefungen.Add(new Pruefung {
                Gegenstand = "E", Punkte = 20, Note = 2
            });
            sl.Add(sch);


            // *************************************************************************************
            // Welche Prüfungen hat der Schüler mit der Id 1? Überlege dir dafür, ob die Where
            // Klausel einen Schüler oder eine Liste von Schülern liefert.
            // *************************************************************************************

            //Am besten .FirstOrDefault nutzen damit das Exception Handling besser ist.
            Schueler s       = sl.Where(s2 => s2.Id == 1).FirstOrDefault();
            var      result1 = s.Pruefungen;

            //select Keyword ist die Projektion
            result1 = (from s2 in sl
                       where s2.Id == 1
                       select s2.Pruefungen).FirstOrDefault();

            result1 = sl.Where(s2 => s2.Id == 1).Select(s3 => s3.Pruefungen).FirstOrDefault();

            //Erst mit .ToList() wird das SQL Statement ausgeführt (vgl. mit einer DB)
            result1.ToList().ForEach(p => Console.WriteLine(p));
            // *************************************************************************************
            // Welchen Notendurchschnitt hat der Schüler mit der ID 2? Hinweis: Verwende Average
            // *************************************************************************************

            var pruefungen = (from s2 in sl
                              where s2.Id == 2
                              select s2.Pruefungen).FirstOrDefault();

            double avg = (from p in pruefungen
                          select p.Note).Average();

            double avg2 = (from s2 in sl
                           where s2.Id == 2
                           select s2.Pruefungen).FirstOrDefault().Average(p => p.Note);

            //Holt sich Schueler mit Id2, sagt im Ergebnis ich will gleich den mittelwert und dann eben nur einen schüler
            //FirstOrDefault
            //Hätte ich kein s2.Id == 2 UND kein .FirstOrDefault() hätte ich eine Liste von Mittelwerten
            double avg3 = (from s2 in sl
                           where s2.Id == 2
                           select s2.Pruefungen.Average(p => p.Note)).FirstOrDefault();

            double avg4 = sl
                          .Where(s2 => s2.Id == 2)
                          .Select(s3 => s3.Pruefungen
                                  .Average(p => p.Note))
                          .FirstOrDefault();

            Console.WriteLine("{ 0, 1, 2, 3}", avg, avg2, avg3, avg4);

            // *************************************************************************************
            // Welche Schüler hatten in D eine Prüfung? Hinweis: Verwende Any
            // *************************************************************************************

            IEnumerable <Schueler> result3 = (from s2 in sl
                                              where s2.Pruefungen.Any(p => p.Gegenstand == "D")
                                              select s2);

            //Fluid Syntax
            result3 = sl.Where(s2 => s2.Pruefungen.Any(p => p.Gegenstand == "D"));

            result3.ToList().ForEach(p => Console.WriteLine(p));

            // *************************************************************************************
            // Welche Schüler hatten schlechtere Noten als Befriedigend? Hinweis: Verwende Any
            // *************************************************************************************

            var result4 = from s2 in sl
                          where s2.Pruefungen.Any(p => p.Note > 3)
                          select s2;

            //Fluid Syntax
            result4 = sl.Where(s2 => s2.Pruefungen.Any(p => p.Note > 3));

            result4.ToList().ForEach(p => Console.WriteLine(p));

            // *************************************************************************************
            // Gibt es Schüler mit mehr als 3 Prüfungen? Verwende die Längeneigenschaft der Liste.
            // *************************************************************************************

            var result5 = from s2 in sl
                          where s2.Pruefungen.Count() > 3
                          select s2;

            //Fluid Syntax
            result5 = sl.Where(s2 => s2.Pruefungen.Count() > 3);

            result5.ToList().ForEach(p => Console.WriteLine(p));

            // *************************************************************************************
            // Liste alle Prüfungen auf, die mehr als 12 Punkte ergaben. Verwende dafür 2 mal
            // die from Klausel, indem du die Schülerliste mit den Prüfungen jedes
            // Schülers verknüpft. Unter http://stackoverflow.com/a/6429081 findest du ein Beispiel.
            // Sortiere sie nach der Anzahl der Punkte in absteigender Reihenfolge.
            // *************************************************************************************
            result6.ToList().ForEach(p => Console.WriteLine(p));

            // *************************************************************************************
            // Welches Punktemittel hatten alle POS Prüfungen? Ermittle diesen Wert mit Average,
            // wobei jedoch diese Funktion eine Lambda Expression mitgegeben werden muss.
            // *************************************************************************************
            result7.ToList().ForEach(p => Console.WriteLine(p));

            Console.ReadKey();
        }
コード例 #3
0
        static void Main(string[] args)
        {
            List <Schueler> sl   = new List <Schueler>();
            Schuelerliste   mySl = new Schuelerliste();

            mySl.Add(new Schueler {
                Id = 1, Name = "XXX"
            });
            mySl.Add(new Schueler {
                Id = 2, Name = "XXX"
            });
            mySl.Add(new Schueler {
                Id = 3, Name = "XXX"
            });

            Schuelerliste result = mySl.Where(xx => xx.Id == 1);

            Schueler sch = new Schueler {
                Id = 1, Name = "Mustermann"
            };

            sch.Pruefungen.Add(new Pruefung {
                Gegenstand = "POS", Punkte = 12, Note = 5
            });
            sch.Pruefungen.Add(new Pruefung {
                Gegenstand = "DBI", Punkte = 14, Note = 4
            });
            sch.Pruefungen.Add(new Pruefung {
                Gegenstand = "D", Punkte = 16, Note = 3
            });
            sl.Add(sch);
            sch = new Schueler {
                Id = 2, Name = "Musterfrau"
            };
            sch.Pruefungen.Add(new Pruefung {
                Gegenstand = "POS", Punkte = 14, Note = 4
            });
            sch.Pruefungen.Add(new Pruefung {
                Gegenstand = "DBI", Punkte = 24, Note = 1
            });
            sch.Pruefungen.Add(new Pruefung {
                Gegenstand = "E", Punkte = 20, Note = 2
            });
            sl.Add(sch);

            // *************************************************************************************
            // Welche Prüfungen hat der Schüler mit der Id 1? Überlege dir dafür, ob die Where
            // Klausel einen Schüler oder eine Liste von Schülern liefert.
            // *************************************************************************************
            var result1 = (from s in sl
                           where s.Id == 1
                           select s.Pruefungen).FirstOrDefault();

            result1 = sl.Where(s => s.Id == 1).Select(s => s.Pruefungen).FirstOrDefault();

            result1.ToList().ForEach(p => Console.WriteLine(p));
            // *************************************************************************************
            // Welchen Notendurchschnitt hat der Schüler mit der ID 2? Hinweis: Verwende Average
            // *************************************************************************************
            double result2 = (from s in sl
                              where s.Id == 2
                              select s.Pruefungen.Average(p => p.Note)).FirstOrDefault();

            Console.WriteLine(result2);

            // *************************************************************************************
            // Welche Schüler hatten in D eine Prüfung? Hinweis: Verwende Any
            // *************************************************************************************
            var result3 = (from s in sl
                           where s.Pruefungen.Any(p => p.Gegenstand == "D") == true
                           select s);

            result3 = sl.Where(s => s.Pruefungen.Any(p => p.Gegenstand == "D"));
            result3.ToList().ForEach(p => Console.WriteLine(p));

            // *************************************************************************************
            // Welche Schüler hatten schlechtere Noten als Befriedigend? Hinweis: Verwende Any
            // *************************************************************************************
            var result4 = (from s in sl
                           where s.Pruefungen.Any(p => p.Note > 3)
                           select s);

            result4 = sl.Where(s => s.Pruefungen.Any(p => p.Note > 3));
            result4.ToList().ForEach(p => Console.WriteLine(p));

            // *************************************************************************************
            // Gibt es Schüler mit mehr als 3 Prüfungen? Verwende die Längeneigenschaft der Liste.
            // *************************************************************************************
            IEnumerable <Schueler> result5 = (from s in sl
                                              where s.Pruefungen.Count > 3
                                              select s);

            result5 = sl.Where(s => s.Pruefungen.Count > 3);
            result5.ToList().ForEach(p => Console.WriteLine(p));

            // *************************************************************************************
            // Liste alle Prüfungen auf, die mehr als 12 Punkte ergaben. Verwende dafür 2 mal
            // die from Klausel, indem du die Schülerliste mit den Prüfungen jedes
            // Schülers verknüpft. Unter http://stackoverflow.com/a/6429081 findest du ein Beispiel.
            // Sortiere sie nach der Anzahl der Punkte in absteigender Reihenfolge.
            // *************************************************************************************
            /* Ich muss von sl starten, da ich keine Liste aller Prüfungen habe */

            /* Mit foreach müsste ich
             * foreach (Schueler s in sl) {
             *   foreach (Pruefung p in s.Pruefungen) {
             *      ...
             *    }
             *  }
             *  schreiben.
             */
            IEnumerable <Pruefung> result6 = (from s in sl
                                              from p in s.Pruefungen
                                              where p.Punkte > 12
                                              select p);

            result6.ToList().ForEach(p => Console.WriteLine(p));

            // *************************************************************************************
            // Welches Punktemittel hatten alle POS Prüfungen? Ermittle diesen Wert mit Average,
            // wobei jedoch diese Funktion eine Lambda Expression mitgegeben werden muss.
            // *************************************************************************************
            /* Hier generiere ich eine Liste von int Werten. Average funktioniert auch so */
            double result7 = (from s in sl
                              from p in s.Pruefungen
                              where p.Gegenstand == "POS"
                              select p.Punkte).Average();

            /* Wenn ich die ganzen Prüfungen nehme, muss ich Average sagen, welches Feld es
             * mitteln soll */
            result7 = (from s in sl
                       from p in s.Pruefungen
                       where p.Gegenstand == "POS"
                       select p).Average(p => p.Punkte);

            Console.WriteLine(result7);
            Console.ReadKey();
        }