MongoDB

MongoDB ist die führende Open-Source, Document Datenbank die für einfache Entwicklung und Skalierung aber auch für Big Data Szenarien entwickelt wurde.

C# und MongoDB - Leseoperationen

Experte
Heute befassen wir uns mit dem zweiten Buchstaben von CRUD. R steht für Lesen (Read).

  • Datensätze erstellen

    • Um es noch einmal zusammenzufassen: Im vorherigen Beitrag haben wir das folgende BSONDocument aus dem MongoDB-Beispieldatensatz in die Collection "sample_training.grades" eingefügt.
      var document = new BsonDocument
      {
      { "student_id", 10000 },
      { "scores", new BsonArray
      {
      new BsonDocument{ {"type", "exam"}, {"score", 88.12334193287023 } },
      new BsonDocument{ {"type", "quiz"}, {"score", 74.92381029342834 } },
      new BsonDocument{ {"type", "homework"}, {"score", 89.97929384290324 } },
      new BsonDocument{ {"type", "homework"}, {"score", 82.12931030513218 } }
      }
      },
      { "class_id", 480}
      };


      • Leseoperationen, Read Operations

        • Um Dokumente in MongoDB zu lesen, verwenden wir die Methode "find()". Mit dieser Methode können wir eine Vielzahl von Methoden verknüpfen, von denen wir einige in diesem Beitrag sehen werden. Um das erste Dokument in der Auflistung abzurufen, können Sie die "FirstOrDefault"- oder "FirstOrDefaultAsync"-Methode verwenden und das Ergebnis auf der Konsole ausgeben.
          var firstDocument = collection.Find(new BsonDocument()).FirstOrDefault();
          Console.WriteLine(firstDocument.ToString());

          gibt zurück ...
          { "_id" : ObjectId("56d5f7eb604eb380b0d8d8ce"), 
          "student_id" : 0.0,
          "scores" : [
          { "type" : "exam", "score" : 78.404463095042658 },
          { "type" : "quiz", "score" : 73.362247832313386 },
          { "type" : "homework", "score" : 46.980982486720535 },
          { "type" : "homework", "score" : 76.675561386562222 }
          ],
          "class_id" : 339.0 }

          Sie fragen sich vielleicht, warum wir "Single" nicht verwenden, da dies auch ein Dokument zurückgibt. Diese Funktion muss auch sicherstellen, dass das zurückgegebene Dokument das einzige Dokument dieser Art in der Collection ist, und das bedeutet, dass die gesamte Collection gescannt wird.

          • Lesen mit einem Filter

            • Suchen wir das von uns erstellte Dokument und geben es auf der Konsole aus. Der erste Schritt besteht darin, einen Filter für die Abfrage unseres spezifischen Dokuments zu erstellen.
              var filter = Builders<BsonDocument>.Filter.Eq("student_id", 10000);
              Hier setzen wir einen Filter, um nach einem Dokument zu suchen, bei dem die "student_id" gleich 10000 ist. Wir können den Filter an die "find()"-Methode übergeben, um das erste Dokument zu erhalten, das der Abfrage entspricht.
              var studentDocument = collection.Find(filter).FirstOrDefault();
              Console.WriteLine(studentDocument.ToString());

              gibt zurück ...
              { "_id" : ObjectId("5d88f88cec6103751b8a0d7f"), 
              "student_id" : 10000,
              "scores" : [
              { "type" : "exam", "score" : 88.123341932870233 },
              { "type" : "quiz", "score" : 74.923810293428346 },
              { "type" : "homework", "score" : 89.979293842903246 },
              { "type" : "homework", "score" : 82.129310305132179 }
              ],
              "class_id" : 480 }

              Wenn kein Dokument gefunden wird, das der Abfrage entspricht, gibt die "find()"-Methode "null" zurück. Das erste Dokument in einer Sammlung oder mit einer Abfrage zu finden, kommt relativ häufig vor. Was ist jedoch mit Situationen, in denen alle Dokumente entweder in einer Sammlung oder aus einer Abfrage zurückgegeben werden müssen?

              • Alle Dokumente lesen

                • In Situationen, in denen die erwartete Ergebnismenge klein ist, können mit den Methoden "ToList()" oder "ToListAsync()" alle Dokumente aus einer Abfrage oder einer Auflistung abgerufen werden.
                  var documents = collection.Find(new BsonDocument()).ToList();

                  Wir können diese Liste durchlaufen und die Ergebnisse folgendermaßen ausgeben:
                   foreach(BsonDocument doc in documents)
                  {
                  Console.WriteLine(doc.ToString());
                  }

                  Hier können auch Filter übergeben werden, um beispielsweise Dokumente mit Prüfungsergebnissen über 95 zu erhalten. Der Filter sieht hier etwas komplizierter aus, ist aber dank der MongoDB-Treibersyntax relativ einfach zu befolgen. Wir filtern nach Dokumenten, in denen sich innerhalb des Scores-Arrays ein Prüfungs-Filialdokument mit einem Score-Wert größer oder gleich 95 befindet.
                  var highExamScoreFilter = Builders<BsonDocument>.Filter.ElemMatch<BsonValue>(
                  "scores", new BsonDocument { { "type", "exam" },
                  { "score", new BsonDocument { { "$gte", 95 } } }
                  });
                  var highExamScores = collection.Find(highExamScoreFilter).ToList();

                  Wenn mehr als eine kleine Liste von Ergebnissen vorhanden ist, die abgerufen werden müssen, kann mit der "find()"-Methode ein Cursor mit "ToCursor" zurückgegeben werden, der auf die abzurufenden Datensätze verweist. Dieser Cursor kann in einer foreach-Anweisung in synchronen Situationen mithilfe der ToEnumerable-Adaptermethode verwendet werden.
                  var cursor = collection.Find(highExamScoreFilter).ToCursor();
                  foreach (var document in cursor.ToEnumerable())
                  {
                  Console.WriteLine(document);
                  }

                  Dies kann asynchron mit der "ForEachAsync"-Methode erfolgen:
                  await collection.Find(highExamScoreFilter)
                  .ForEachAsync(document => Console.WriteLine(document));


                  • Sortieren

                    • Wenn viele Dokumente im Result-Set zurückgegeben werden, ist es oft hilfreich, die Ergebnisse zu sortieren. Wir können die "sort()"-Methode verwenden, um festzustellen, welcher Schüler die höchste Prüfungspunktzahl hatte. Beachten Sie, dass die Sortiermethode die Datenbank auffordert, die Sortierung durchzuführen.
                      Es wird nicht vom Treiber oder der Anwendung ausgeführt.
                      var sort = Builders<BsonDocument>.Sort.Descending("student_id");

                      var highestScores = collection.Find(highExamScoreFilter).Sort(sort);

                      Und wir können die "first()"-Methode daran anhängen, um nur den besten Schüler zu erhalten.
                      var highestScore = collection.Find(highExamScoreFilter).Sort(sort).First();

                      Console.WriteLine(highestScore);

                      Basierend auf dem Atlas-Beispieldatensatz sollte das Dokument mit einer student_id von 9997 mit einem Prüfungsergebnis von 95,441609472871946 zurückgegeben werden.

                      Sie können den vollständigen Code für die Erstellungs- und Leseoperationen unter folgendem Link herunterladen.
                      https://gist.github.com/kenwalger/37299af2b43cfe548e4d3a3154a31e6d

                      • Zusammenfassung

                        • Der C#-Treiber für MongoDB bietet viele Möglichkeiten zum Lesen von Daten aus der Datenbank und unterstützt sowohl synchrone als auch asynchrone Methoden zum Abfragen der Daten. Durch Übergabe eines Filters an die "find()"-Methode können wir nach bestimmten Datensätzen suchen. Die Syntax zum Erstellen von Filtern und zum Abfragen der Datenbank ist unkompliziert und einfach zu lesen, sodass dieser Schritt der CRUD-Operationen in C# und MongoDB einfach zu verwenden ist.

Neueste Mitgliederaktivitäten

Tags

Diesen Community Beitrag weiterempfehlen