Repository-Muster mit MongoDB: Wo zum initialisieren der Datenbank

Ich habe gerade angefangen zu spielen, um mit MongoDB (C#) und versucht port ein repository, über das von entity framework. Ich bin mit der offiziellen C - # - Treiber 1.0. Jetzt habe ich so etwas wie dieses:

internal class MongoContext
{
    public MongoContext(string constring)
    {
        MongoServer server = MongoServer.Create(constring);
        this.myDB = server.GetDatabase("MyDB");

        BsonClassMap.RegisterClassMap<VoyageNumber>(cm =>
            { cm.MapField<string>(p => p.Id); });
        BsonClassMap.RegisterClassMap<Schedule>(cm =>
        { cm.MapField<DateTime>(p => p.EndDate); cm.MapField<DateTime>(p => p.StartDate); });
        BsonClassMap.RegisterClassMap<Voyage>(cm =>
            { cm.MapIdField<VoyageNumber>(p => p.VoyageNumber); cm.MapField<Schedule>(p => p.Schedule); });

    }

    private MongoDatabase myDB;
    public MongoDatabase MyDB
    { get { return this.myDB; } }
}

Ich würde dann gehen Sie auf und implementieren Sie das Repository wie diese:

public class MongoVoyageRepository : IVoyageRepository
{
    private readonly MongoContext context;

    public MongoVoyageRepository(string constring)
    {
        this.context = new MongoContext(constring);
    }

    public void Store(Domain.Model.Voyages.Voyage voyage)
    {

        MongoCollection<Voyage> mongoVoyages = context.MyDB.GetCollection<Voyage>("Voyages");

        //store logic...

    }

}

Nun würde ich gerne wissen, ob es eine gute Entscheidung zu instanziieren Sie ein "Kontext", wie dies in Bezug auf Leistung. Macht es Sinn um die BsonClass Karten drin?
Vielen Dank für Ihre Eingabe.

InformationsquelleAutor hoetz | 2011-04-10
  1. 1

    Ich denke, es macht keinen Sinn, sich zu registrieren-Klassen mapping jedes mal, wenn Sie erstellen Sie Ihre repository-Klasse. Da MongoDB C# driver verwaltet die verbindungen zu den MongoDB intern, scheint es mir, dass es besser ist, zu erstellen MongoServer - und register-Klassen-mapping nur einmal, beim start der Anwendung und verwenden Sie es dann.

    Ich bin mit singleton, um MongoServer nur einmal

    public class MongoRead : MongoBase
{
  public MongoRead(MongoServer server)
            : base(server)
  {

  }


  public override MongoDatabase Database
  {
     get { return Server.GetDatabase("myDb"); }
  }

  public MongoCollection Logs
  {
    get { return Database.GetCollection("logs"); }
  }

  private static MongoRead _instance = null;

  public static MongoRead Instance
  {
    get
      {
        if (_instance == null)
        {
          _instance = RegisterMongoDb();

        }

        return _instance;
      }

  }

  private static MongoRead RegisterMongoDb()
  {
      var readServer = MongoServer.Create(connectionString);
      var read = new MongoRead(readServer);

      var myConventions = new ConventionProfile();
      myConventions.SetIdMemberConvention(new NoDefaultPropertyIdConvention());
      BsonClassMap.RegisterConventions(myConventions, t => true);

      return read;
  }

}

    So können Sie auch vor der Klasse in Ihrem Repository:

    public class MongoVoyageRepository : IVoyageRepository
{
    private readonly MongoRead context
    {
      get { return MongoRead.Instance; }
    };

    public MongoVoyageRepository()
    {
    }

    public void Store(Domain.Model.Voyages.Voyage voyage)
    {
            MongoCollection<Voyage> mongoVoyages = 
                  context.Database.GetCollection<Voyage>("Voyages");
            //store logic...
    }

}
    • Das funktioniert, aber ich umgewandelt haben, die Instanz-Eigenschaft in eine Methode, die akzeptiert, dass eine Verbindungszeichenfolge, da ich möchte, injizieren Sie die Verbindungszeichenfolge in das repository (IoC).
    • Ich habe auch mit IoC-adn DI, nur Instance da viele dev ' s nicht kennen, IoC, DI-oder scheint es schwer zu undestand 😉
    • was ist die Klasse NoDefaultPropertyIdConvention?
    InformationsquelleAutor Andrew Orsich
  2. 10
    //entity base
public class MongoEntity {
    public ObjectId _id { get; set; }
}

//user entity
public class Users : MongoEntity {
    public string UserName { get; set; }
    public string Password { get; set; }
}


//simple repository
public class Repository {

    private MongoDatabase _db;
    public MongoDatabase Database { get; private set; }
    public Repository(string constr, string dbname) {
        var server = MongoServer.Create(constr);
        _db = server.GetDatabase(dbname);
        Database = _db;
    }

    private MongoCollection<T> GetCollection<T>() where T : MongoEntity {
        return _db.GetCollection<T>(typeof(T).Name);
    }

    public IEnumerable<T> List<T>() where T : MongoEntity {
        return GetCollection<T>().FindAll();
    }

    public IEnumerable<T> List<T>(Expression<Func<T, bool>> exp) where T : MongoEntity {
        return GetCollection<T>().AsQueryable<T>().Where(exp);
    }

    public T Single<T>(Expression<Func<T, bool>> exp) where T : MongoEntity {
        return List<T>(exp).SingleOrDefault();
    }

    public void Insert<T>(T entity) where T : MongoEntity {
        GetCollection<T>().Insert<T>(entity);
    }

    public void Insert<T>(ICollection<T> entities) where T : MongoEntity {
        GetCollection<T>().InsertBatch(entities);
    }

    //Update, Delete method etc ...



}



//example
var repository = new Repository("mongodb://localhost", "test");
repository.Single<Users>(u => u.UserName == "myUserName");
    InformationsquelleAutor Ebubekir Dirican
  3. 0

    diese ist auch interessant, wenn Sie verwenden möchten, repository-pattern.

    InformationsquelleAutor Govind KamalaPrakash Malviya
Schreibe einen Kommentar