मोंगोडीबी के साथ रिपोजिटरी पैटर्न: डेटाबेस

Question

को प्रारंभ करने के लिए मैंने अभी मोंगोडीबी (सी #) के साथ खेलना शुरू कर दिया और इकाई ढांचे से एक भंडार बंद करने की कोशिश की। मैं आधिकारिक सी # ड्राइवर 1.0 का उपयोग कर रहा हूँ।

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; } } 
} 

मैं तो पर जाने के लिए और इस तरह भंडार को लागू करेंगे::

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... 

    } 

} 

अब मैं अगर यह एक अच्छा एक का दृष्टांत का निर्णय जानना चाहते हैं अब मैं कुछ इस तरह किया प्रदर्शन के संदर्भ में इस तरह "संदर्भ"। क्या वहां बोसन क्लास मैप्स डालने का अर्थ है? आपके इनपुट के लिए धन्यवाद।

Answer 1

मुझे लगता है कि जब आप अपनी रिपोजिटरी कक्षा बनाते हैं तो प्रत्येक बार कक्षा मैपिंग पंजीकृत करना समझ में नहीं आता है। चूंकि MongoDB C# ड्राइवर आंतरिक रूप से मोंगोडीबी से कनेक्शन प्रबंधित करता है, ऐसा लगता है कि MongoServer बनाना बेहतर है और एप्लिकेशन शुरू होने के दौरान केवल एक बार कक्षा मैपिंग पंजीकृत करें और फिर इसका उपयोग करें।

मैं क्रम में सिंगलटन का उपयोग कर रहा MongoServer बनाने के लिए केवल एक बार

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; 
    } 

} 

तो तुम भी वर्ग के ऊपर अपने भंडार में उपयोग कर सकते हैं:

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... 
    } 

} 

Answer 2

// 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"); 

Answer 3

this भी दिलचस्प है अगर आप चाहते हैं भंडार पैटर्न का उपयोग करने के लिए।