Erfahren Sie die vollständigen Schritte zur Integration von MongoDB in den asp.net-Kern

1. Einführung und Einführung in MongoDB

Kürzlich Bei der Integration meines eigenen Frameworks habe ich das einfachste CRUD von MongoDBD als Komponente umgestaltet und in das asp.net-Kernprojekt integriert. Natürlich wird in diesem Artikel die Clusterbereitstellung von Mongodb nicht erläutert .

Zunächst sehen wir in der offiziellen Dokumentation von MongoDB, dass MongoDb 2.4 und höher für .Net-Treiber .Net Core 2.0 unterstützt.

Ich denke, jeder sollte mit MongoDB vertraut sein, egal ob er es verwendet oder davon gehört hat.

Verwandte Lernempfehlungen: ASP.NET-Video-Tutorial

1. Was ist Mongodb?

MongoDB ist eine Datenbank, die auf verteilter Dateispeicherung basiert. Sie bietet skalierbare und leistungsstarke Datenspeicherlösungen für Webanwendungen. Sie ist ein Produkt zwischen relationaler Datenbank und nicht relationaler Datenbank. relational. Die funktionsreichste Datenbank. Es ist ein leistungsstarkes Werkzeug zur Datenverarbeitung.

2. Was sind relationale Datenbanken und nicht-relationale Datenbanken?

Relationale Datenbank: Unter den von uns verwendeten SQL Servern, MySQL usw. handelt es sich alle um relationale Datenbanken, und relationale Datenbanken folgen dem ACID-Prinzip und weisen eine strikte Konsistenz auf.

Nicht-relationale Datenbank: Auch NoSQL genannt, wird zum Speichern sehr großer Datenmengen verwendet. Diese Arten der Datenspeicherung erfordern kein festes Modell und können ohne redundante Vorgänge horizontal erweitert werden.

3. RDBMS VS NoSQL

RDBMS:

Hoch organisierte strukturierte Daten

Strukturierte Abfragesprache

Daten und Beziehungen werden in separaten Tabellen gespeichert

Strikte Konsistenz

Grundlegende Transaktionen

NoSQL:

Keine deklarative Abfragesprache

　Schlüssel- Wertepaarspeicher, Spaltenspeicher, Dokumentenspeicher usw.

　Eventuelle Konsistenz

　Unstrukturierte und unvorhersehbare Daten

　CAP-Theorem, hohe Verfügbarkeit, hohe Leistung, hohe Skalierbarkeit

Ich glaube, dass scharfsichtige Schüler, wenn sie darüber sprechen, das CAP-Theorem und die letztendliche Konsistenz bemerkt haben sollten und auf jeden Fall an verteilte Systeme denken werden. Ich gebe Ihnen hier ein großes Lob. Es kann perfekt mit nosql in einem verteilten System kombiniert werden, um unsere Leistung zu verbessern.

4. Stellen Sie einige Konzepte von RDBMS und Mongodb vor, die jedem helfen, es zu verstehen

Übersetzen Sie es wie folgt:

2. Der Asp.net-Kern integriert mongoDB

1 Die Windows-Version des MongoDB-Servers

können Sie von der offiziellen Website herunterladen. Für die visuelle Oberfläche habe ich dann das Tool Robo 3T verwendet. Ein sehr einfaches und schönes Visualisierungstool. Für jeden zu empfehlen.

Nachdem die Installation abgeschlossen ist, sehen Sie den Mongodb-Server im Windows-Dienst

Dann öffnen wir Robo 3T und verbinden unseren Mongodb.

2. Beginnen Sie mit der Konfiguration unseres Mongodb im Projekt

Schritt 1: Ich erstelle eine neue Core2 .0-Klasse Bibliothek

stellt das Nuget-Paket „MongoDB.Driver“ vor.

Erweitern Sie dann die Erweiterungsmethode von Services in Startup.cs

//扩展方法public static class ServiceCollectionExtensions
 {
 public static void AddMongoDB(this IServiceCollection services, IConfiguration configuration)
 {
  services.Configure<Settings>(options =>
  {
  options.ConnectionString = configuration.GetSection("MongoConnection:ConnectionString").Value;
  options.Database = configuration.GetSection("MongoConnection:Database").Value;
  });
 }
 }

Schritt 2: Refaktorieren Sie die CRUD-Klasse, die Mongodb kapselt, und zeigen Sie sie nur in der Suche an und hinzufügen.

public class MongoDBBase
 {
 private readonly IMongoDatabase _database = null;
 public MongoDBBase(string connectionString, string databaseName)
 {
  var client = new MongoClient(connectionString);
  if (client != null)
  {
  _database = client.GetDatabase(databaseName);
  }
 }

 #region SELECT
 /// <summary>
 /// 根据查询条件，获取数据
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="id"></param>
 /// <returns></returns>
 public List<T> GetList<T>(Expression<Func<T, bool>> conditions = null)
 {
  var collection = _database.GetCollection<T>(typeof(T).Name);
  if (conditions != null)
  {
  return collection.Find(conditions).ToList();
  }
  return collection.Find(_ => true).ToList();
 }#endregion

 #region INSERT/// <summary>
 /// 插入多条数据，数据用list表示
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="list"></param>
 /// <returns></returns>
 public List<T> InsertMany<T>(List<T> list)
 {
  var collection = _database.GetCollection<T>(typeof(T).Name);
  collection.InsertMany(list);
  return list;
 }
 #endregion
 }

Schritt 3: Erstellen Sie ein neues asp.net-Core-Webapi-Projekt und verweisen Sie zur Demonstration auf diese Art von Bibliothek

Fügen Sie mongodb zu appsetting.json im hinzu Projektverbindungszeichenfolge: Ich verwende hier einen benutzerdefinierten Datennamen testdb. Beim Einfügen in mongodb werden die Datenbank, die Sammlung und das Dokument automatisch erstellt. Schauen Sie dann nach unten

 "MongoConnection": { //mongodb数据库连接
 "ConnectionString": "mongodb://127.0.0.1:27017",
 "Database": "testdb",
 "IsSSL": true
 },

Schritt 4: Erstellen Sie einen neuen Mongodb-Testcontroller, der die Schnittstelle zum Einfügen einzelner und mehrerer Elemente und zum Abfragen zeigt.

[Produces("application/json")]
 [Route("api/MongoDB/[action]")]
 public class MongoDBController : Controller
 {
  private readonly MongoDBBase _context = null;
  public MongoDBController(IOptions<Settings> settings)
  {
   _context = new MongoDBBase(settings.Value.ConnectionString, settings.Value.Database);
  }
  [HttpGet]
  public IActionResult AddList()
  {
   List<MongoDBPostTest> list = new List<MongoDBPostTest>()
   {
    new MongoDBPostTest()
    {
     Id = "2",
     Body = "Test note 3",
     UpdatedOn = DateTime.Now,
     UserId = 1,
     HeaderImage = new NoteImage
     {
      ImageSize = 10,
      Url = "http://localhost/image1.png",
      ThumbnailUrl = "http://localhost/image1_small.png"
     }
    },
    new MongoDBPostTest()
    {
     Id = "3",
     Body = "Test note 4",
     UpdatedOn = DateTime.Now,
     UserId = 1,
     HeaderImage = new NoteImage
     {
      ImageSize = 14,
      Url = "http://localhost/image3.png",
      ThumbnailUrl = "http://localhost/image3_small.png"
     }
    }
   };

   try
   {
    _context.InsertMany(list);
   }
   catch (Exception ex)
   {

    throw;
   }

   return Ok("成功");
  }

  [HttpGet]
  public Result<List<MongoDBPostTest>> SelectSingle()
  {
   //无条件
   var list = _context.GetList<MongoDBPostTest>();

   //有条件
   //var list = _context.GetList<MongoDBPostTest>(a => a.Id == "1");

   //得到单条数据,无条件
   //var list = _context.GetSingle<MongoDBPostTest>();

   //得到单条数据,有条件
   //var list = _context.GetSingle<MongoDBPostTest>(a => a.Id == "3");

   ObjectId internalId = _context.GetInternalId("5bbf41651d3b66668cbb5bfc");

   var a = _context.GetSingle<MongoDBPostTest>(note => note.Id == "5bbf41651d3b66668cbb5bfc" || note.InternalId == internalId);

   return ResHelper.Suc(1, list, "成功");
  }
}

Testklasse

public class MongoDBPostTest
 {
  [BsonId]
  // standard BSonId generated by MongoDb
  public ObjectId InternalId { get; set; }
  public string Id { get; set; }

  public string Body { get; set; } = string.Empty;

  [BsonDateTimeOptions]
  public DateTime UpdatedOn { get; set; } = DateTime.Now;

  public NoteImage HeaderImage { get; set; }

  public int UserId { get; set; } = 0;
 }

public class NoteImage
 {
  public string Url { get; set; } = string.Empty;
  public string ThumbnailUrl { get; set; } = string.Empty;
  public long ImageSize { get; set; } = 0L;
 }

Schritt 5: Führen Sie das Projekt aus und führen Sie es aus.

Fügen wir mehrere Datenelemente ein und die Ausführung war erfolgreich.

Dann haben wir uns die Datenbank angesehen und festgestellt, dass eine testdb-Datenbank generiert wurde, die unseren Dateninhalt enthält

Dann führen wir die folgende Prüfoperation durch: Geben Sie die Daten zurück, die wir gerade eingefügt haben.

Hinweis: Hier muss eine Falle gelöst werden, nämlich dass die von mongodb gespeicherte Zeit UTC ist wird sich von unserem lokalen unterscheiden. Der Zeitunterschied beträgt 8 Stunden. Daher ist hier eine besondere Bearbeitungszeit erforderlich.

3. Zusammenfassung

An diesem Punkt wurde die einfache Verwendung von Mongodb demonstriert, Sie können es laut offiziellen Angaben erweitern Dokumente und erweitern Sie sie dann auf Folgendes. Sie werden es immer interessanter finden. Vielen Dank an alle für Ihre Unterstützung. Danke schön.

Das obige ist der detaillierte Inhalt vonErfahren Sie die vollständigen Schritte zur Integration von MongoDB in den asp.net-Kern. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!