ಆಬ್ಜೆಕ್ಟ್ ರೆಪೊಸಿಟರಿ - ನಿಮ್ಮ ಹೋಮ್ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಿಗಾಗಿ .NET ಇನ್-ಮೆಮೊರಿ ರೆಪೊಸಿಟರಿ ಪ್ಯಾಟರ್ನ್

ಎಲ್ಲಾ ಡೇಟಾವನ್ನು ಮೆಮೊರಿಯಲ್ಲಿ ಏಕೆ ಸಂಗ್ರಹಿಸಬೇಕು?

ವೆಬ್‌ಸೈಟ್ ಅಥವಾ ಬ್ಯಾಕೆಂಡ್ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು, ಹೆಚ್ಚಿನ ಬುದ್ಧಿವಂತ ಜನರ ಮೊದಲ ಆಸೆ SQL ಡೇಟಾಬೇಸ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು. 

ಆದರೆ ಕೆಲವೊಮ್ಮೆ ಡೇಟಾ ಮಾದರಿಯು SQL ಗೆ ಸೂಕ್ತವಲ್ಲ ಎಂದು ಆಲೋಚನೆಯು ಮನಸ್ಸಿಗೆ ಬರುತ್ತದೆ: ಉದಾಹರಣೆಗೆ, ಹುಡುಕಾಟ ಅಥವಾ ಸಾಮಾಜಿಕ ಗ್ರಾಫ್ ಅನ್ನು ನಿರ್ಮಿಸುವಾಗ, ನೀವು ವಸ್ತುಗಳ ನಡುವಿನ ಸಂಕೀರ್ಣ ಸಂಬಂಧಗಳನ್ನು ಹುಡುಕಬೇಕಾಗಿದೆ. 

ನೀವು ತಂಡದಲ್ಲಿ ಕೆಲಸ ಮಾಡುವಾಗ ಮತ್ತು ಸಹೋದ್ಯೋಗಿಗೆ ತ್ವರಿತ ಪ್ರಶ್ನೆಗಳನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸುವುದು ಎಂದು ತಿಳಿದಿಲ್ಲದಿದ್ದಾಗ ಕೆಟ್ಟ ಪರಿಸ್ಥಿತಿ. N+1 ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು ಮತ್ತು ಹೆಚ್ಚುವರಿ ಸೂಚಿಕೆಗಳನ್ನು ನಿರ್ಮಿಸಲು ನೀವು ಎಷ್ಟು ಸಮಯವನ್ನು ವ್ಯಯಿಸಿದ್ದೀರಿ ಇದರಿಂದ ಮುಖ್ಯ ಪುಟದಲ್ಲಿನ SELECT ಸಮಂಜಸವಾದ ಸಮಯದಲ್ಲಿ ಪೂರ್ಣಗೊಳ್ಳುತ್ತದೆ?

ಮತ್ತೊಂದು ಜನಪ್ರಿಯ ವಿಧಾನವೆಂದರೆ NoSQL. ಹಲವಾರು ವರ್ಷಗಳ ಹಿಂದೆ ಈ ವಿಷಯದ ಬಗ್ಗೆ ಸಾಕಷ್ಟು ಪ್ರಚೋದನೆ ಇತ್ತು - ಯಾವುದೇ ಅನುಕೂಲಕರ ಸಂದರ್ಭಕ್ಕಾಗಿ ಅವರು ಮೊಂಗೊಡಿಬಿಯನ್ನು ನಿಯೋಜಿಸಿದರು ಮತ್ತು json ದಾಖಲೆಗಳ ರೂಪದಲ್ಲಿ ಉತ್ತರಗಳೊಂದಿಗೆ ಸಂತೋಷಪಟ್ಟರು. (ಅಂದಹಾಗೆ, ದಾಖಲೆಗಳಲ್ಲಿನ ವೃತ್ತಾಕಾರದ ಲಿಂಕ್‌ಗಳ ಕಾರಣದಿಂದ ನೀವು ಎಷ್ಟು ಊರುಗೋಲುಗಳನ್ನು ಸೇರಿಸಬೇಕಾಗಿತ್ತು?).

ಮತ್ತೊಂದು ಪರ್ಯಾಯ ವಿಧಾನವನ್ನು ಪ್ರಯತ್ನಿಸಲು ನಾನು ಸಲಹೆ ನೀಡುತ್ತೇನೆ - ಅಪ್ಲಿಕೇಶನ್ ಮೆಮೊರಿಯಲ್ಲಿ ಎಲ್ಲಾ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಏಕೆ ಪ್ರಯತ್ನಿಸಬಾರದು, ನಿಯತಕಾಲಿಕವಾಗಿ ಅದನ್ನು ಯಾದೃಚ್ಛಿಕ ಸಂಗ್ರಹಣೆಗೆ (ಫೈಲ್, ರಿಮೋಟ್ ಡೇಟಾಬೇಸ್) ಉಳಿಸಿ? 

ಮೆಮೊರಿ ಅಗ್ಗವಾಗಿದೆ ಮತ್ತು ಹೆಚ್ಚಿನ ಸಣ್ಣ ಮತ್ತು ಮಧ್ಯಮ ಗಾತ್ರದ ಯೋಜನೆಗಳಿಗೆ ಯಾವುದೇ ಸಂಭವನೀಯ ಡೇಟಾವು 1 GB ಮೆಮೊರಿಗೆ ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆ. (ಉದಾಹರಣೆಗೆ, ನನ್ನ ನೆಚ್ಚಿನ ಮನೆ ಯೋಜನೆ ಹಣಕಾಸು ಟ್ರ್ಯಾಕರ್, ಇದು ದೈನಂದಿನ ಅಂಕಿಅಂಶಗಳು ಮತ್ತು ನನ್ನ ವೆಚ್ಚಗಳು, ಬಾಕಿಗಳು ಮತ್ತು ವಹಿವಾಟುಗಳ ಇತಿಹಾಸವನ್ನು ಒಂದೂವರೆ ವರ್ಷಗಳವರೆಗೆ ಇರಿಸುತ್ತದೆ, ಇದು ಕೇವಲ 45 MB ಮೆಮೊರಿಯನ್ನು ಬಳಸುತ್ತದೆ.)

ಒಳಿತು:

• ಡೇಟಾಗೆ ಪ್ರವೇಶ ಸುಲಭವಾಗುತ್ತದೆ - ನೀವು ಪ್ರಶ್ನೆಗಳು, ಸೋಮಾರಿಯಾದ ಲೋಡಿಂಗ್, ORM ವೈಶಿಷ್ಟ್ಯಗಳ ಬಗ್ಗೆ ಚಿಂತಿಸಬೇಕಾಗಿಲ್ಲ, ನೀವು ಸಾಮಾನ್ಯ C# ಆಬ್ಜೆಕ್ಟ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತೀರಿ;
• ವಿವಿಧ ಥ್ರೆಡ್‌ಗಳಿಂದ ಪ್ರವೇಶಕ್ಕೆ ಸಂಬಂಧಿಸಿದ ಯಾವುದೇ ಸಮಸ್ಯೆಗಳಿಲ್ಲ;
• ಅತ್ಯಂತ ವೇಗವಾಗಿ - ಯಾವುದೇ ನೆಟ್‌ವರ್ಕ್ ವಿನಂತಿಗಳಿಲ್ಲ, ಪ್ರಶ್ನೆ ಭಾಷೆಗೆ ಕೋಡ್‌ನ ಅನುವಾದವಿಲ್ಲ, ವಸ್ತುಗಳ (ಡಿ)ಸರಣಿಕರಣದ ಅಗತ್ಯವಿಲ್ಲ;
• ಯಾವುದೇ ರೂಪದಲ್ಲಿ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಇದು ಸ್ವೀಕಾರಾರ್ಹವಾಗಿದೆ - ಇದು ಡಿಸ್ಕ್ನಲ್ಲಿ XML ನಲ್ಲಿ, ಅಥವಾ SQL ಸರ್ವರ್ನಲ್ಲಿ ಅಥವಾ ಅಜುರೆ ಟೇಬಲ್ ಸಂಗ್ರಹಣೆಯಲ್ಲಿ.

ಕಾನ್ಸ್:

• ಸಮತಲ ಸ್ಕೇಲಿಂಗ್ ಕಳೆದುಹೋಗಿದೆ, ಮತ್ತು ಪರಿಣಾಮವಾಗಿ, ಶೂನ್ಯ ಅಲಭ್ಯತೆಯ ನಿಯೋಜನೆಯನ್ನು ಮಾಡಲಾಗುವುದಿಲ್ಲ;
• ಅಪ್ಲಿಕೇಶನ್ ಕ್ರ್ಯಾಶ್ ಆಗಿದ್ದರೆ, ನೀವು ಭಾಗಶಃ ಡೇಟಾವನ್ನು ಕಳೆದುಕೊಳ್ಳಬಹುದು. (ಆದರೆ ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಎಂದಿಗೂ ಕ್ರ್ಯಾಶ್ ಆಗುವುದಿಲ್ಲ, ಸರಿ?)

ಇದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ?

ಅಲ್ಗಾರಿದಮ್ ಹೀಗಿದೆ:

• ಪ್ರಾರಂಭದಲ್ಲಿ, ಡೇಟಾ ಸಂಗ್ರಹಣೆಯೊಂದಿಗೆ ಸಂಪರ್ಕವನ್ನು ಸ್ಥಾಪಿಸಲಾಗಿದೆ ಮತ್ತು ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡಲಾಗುತ್ತದೆ;
• ವಸ್ತುವಿನ ಮಾದರಿ, ಪ್ರಾಥಮಿಕ ಸೂಚಿಗಳು ಮತ್ತು ಸಂಬಂಧಿತ ಸೂಚಿಕೆಗಳನ್ನು (1:1, 1:ಹಲವು) ನಿರ್ಮಿಸಲಾಗಿದೆ;
• ವಸ್ತುವಿನ ಗುಣಲಕ್ಷಣಗಳಲ್ಲಿನ ಬದಲಾವಣೆಗಳಿಗಾಗಿ (INotifyPropertyChanged) ಮತ್ತು ಸಂಗ್ರಹಣೆಗೆ ಅಂಶಗಳನ್ನು ಸೇರಿಸಲು ಅಥವಾ ತೆಗೆದುಹಾಕಲು ಚಂದಾದಾರಿಕೆಯನ್ನು ರಚಿಸಲಾಗಿದೆ (INotifyCollectionChanged);
• ಚಂದಾದಾರಿಕೆಯನ್ನು ಪ್ರಚೋದಿಸಿದಾಗ, ಬದಲಾದ ವಸ್ತುವನ್ನು ಡೇಟಾ ಸಂಗ್ರಹಣೆಗೆ ಬರೆಯಲು ಸರದಿಯಲ್ಲಿ ಸೇರಿಸಲಾಗುತ್ತದೆ;
• ಹಿನ್ನೆಲೆ ಥ್ರೆಡ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಣೆಗೆ ಬದಲಾವಣೆಗಳನ್ನು ನಿಯತಕಾಲಿಕವಾಗಿ (ಟೈಮರ್‌ನಲ್ಲಿ) ಉಳಿಸಲಾಗುತ್ತದೆ;
• ನೀವು ಅಪ್ಲಿಕೇಶನ್‌ನಿಂದ ನಿರ್ಗಮಿಸಿದಾಗ, ಬದಲಾವಣೆಗಳನ್ನು ಸಹ ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ಉಳಿಸಲಾಗುತ್ತದೆ.

ಉದಾಹರಣೆ ಕೋಡ್

ಅಗತ್ಯ ಅವಲಂಬನೆಗಳನ್ನು ಸೇರಿಸಲಾಗುತ್ತಿದೆ

// Основная библиотека
Install-Package OutCode.EscapeTeams.ObjectRepository
    
// Хранилище данных, в котором будут сохраняться изменения
// Используйте то, которым будете пользоваться.
Install-Package OutCode.EscapeTeams.ObjectRepository.File
Install-Package OutCode.EscapeTeams.ObjectRepository.LiteDb
Install-Package OutCode.EscapeTeams.ObjectRepository.AzureTableStorage
    
// Опционально - если нужно хранить модель данных для Hangfire
// Install-Package OutCode.EscapeTeams.ObjectRepository.Hangfire

ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುವ ಡೇಟಾ ಮಾದರಿಯನ್ನು ನಾವು ವಿವರಿಸುತ್ತೇವೆ

public class ParentEntity : BaseEntity
{
    public ParentEntity(Guid id) => Id = id;
}
    
public class ChildEntity : BaseEntity
{
    public ChildEntity(Guid id) => Id = id;
    public Guid ParentId { get; set; }
    public string Value { get; set; }
}

ನಂತರ ವಸ್ತು ಮಾದರಿ:

public class ParentModel : ModelBase
{
    public ParentModel(ParentEntity entity)
    {
        Entity = entity;
    }
    
    public ParentModel()
    {
        Entity = new ParentEntity(Guid.NewGuid());
    }
    
    public Guid? NullableId => null;
    
    // Пример связи 1:Many
    public IEnumerable<ChildModel> Children => Multiple<ChildModel>(x => x.ParentId);
    
    protected override BaseEntity Entity { get; }
}
    
public class ChildModel : ModelBase
{
    private ChildEntity _childEntity;
    
    public ChildModel(ChildEntity entity)
    {
        _childEntity = entity;
    }
    
    public ChildModel() 
    {
        _childEntity = new ChildEntity(Guid.NewGuid());
    }
    
    public Guid ParentId
    {
        get => _childEntity.ParentId;
        set => UpdateProperty(() => _childEntity.ParentId, value);
    }
    
    public string Value
    {
        get => _childEntity.Value;
        set => UpdateProperty(() => _childEntity.Value, value
    }
    
    // Доступ с поиском по индексу
    public ParentModel Parent => Single<ParentModel>(ParentId);
    
    protected override BaseEntity Entity => _childEntity;
}

ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಡೇಟಾವನ್ನು ಪ್ರವೇಶಿಸಲು ರೆಪೊಸಿಟರಿ ವರ್ಗ ಸ್ವತಃ:

public class MyObjectRepository : ObjectRepositoryBase
{
    public MyObjectRepository(IStorage storage) : base(storage, NullLogger.Instance)
    {
        IsReadOnly = true; // Для тестов, позволяет не сохранять изменения в базу
    
        AddType((ParentEntity x) => new ParentModel(x));
        AddType((ChildEntity x) => new ChildModel(x));
    
        // Если используется Hangfire и необходимо хранить модель данных для Hangfire в ObjectRepository
        // this.RegisterHangfireScheme(); 
    
        Initialize();
    }
}

ಆಬ್ಜೆಕ್ಟ್ ರೆಪೊಸಿಟರಿ ನಿದರ್ಶನವನ್ನು ರಚಿಸಿ:

var memory = new MemoryStream();
var db = new LiteDatabase(memory);
var dbStorage = new LiteDbStorage(db);
    
var repository = new MyObjectRepository(dbStorage);
await repository.WaitForInitialize();

ಯೋಜನೆಯು HangFire ಅನ್ನು ಬಳಸಿದರೆ

public void ConfigureServices(IServiceCollection services, ObjectRepository objectRepository)
{
    services.AddHangfire(s => s.UseHangfireStorage(objectRepository));
}

ಹೊಸ ವಸ್ತುವನ್ನು ಸೇರಿಸಲಾಗುತ್ತಿದೆ:

var newParent = new ParentModel()
repository.Add(newParent);

ಈ ಕರೆಯೊಂದಿಗೆ, ವಸ್ತು ಪೋಷಕ ಮಾದರಿ ಸ್ಥಳೀಯ ಸಂಗ್ರಹ ಮತ್ತು ಡೇಟಾಬೇಸ್‌ಗೆ ಬರೆಯಲು ಕ್ಯೂ ಎರಡಕ್ಕೂ ಸೇರಿಸಲಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ, ಈ ಕಾರ್ಯಾಚರಣೆಯು O (1) ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಮತ್ತು ಈ ವಸ್ತುವು ತಕ್ಷಣವೇ ಕೆಲಸ ಮಾಡಬಹುದು.

ಉದಾಹರಣೆಗೆ, ಈ ವಸ್ತುವನ್ನು ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಹುಡುಕಲು ಮತ್ತು ಹಿಂತಿರುಗಿದ ವಸ್ತುವು ಅದೇ ನಿದರ್ಶನವಾಗಿದೆ ಎಂದು ಪರಿಶೀಲಿಸಲು:

var parents = repository.Set<ParentModel>();
var myParent = parents.Find(newParent.Id);
Assert.IsTrue(ReferenceEquals(myParent, newParent));

ಏನಾಗುತ್ತಿದೆ? ಹೊಂದಿಸಿ () ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಕೋಷ್ಟಕ ನಿಘಂಟು, ಇದು ಒಳಗೊಂಡಿದೆ ಸಮಕಾಲೀನ ನಿಘಂಟು ಮತ್ತು ಪ್ರಾಥಮಿಕ ಮತ್ತು ದ್ವಿತೀಯಕ ಸೂಚಿಕೆಗಳ ಹೆಚ್ಚುವರಿ ಕಾರ್ಯವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಎಲ್ಲಾ ವಸ್ತುಗಳ ಮೇಲೆ ಸಂಪೂರ್ಣವಾಗಿ ಪುನರಾವರ್ತನೆ ಮಾಡದೆಯೇ ಐಡಿ (ಅಥವಾ ಇತರ ಅನಿಯಂತ್ರಿತ ಬಳಕೆದಾರ ಸೂಚಿಕೆಗಳು) ಮೂಲಕ ಹುಡುಕುವ ವಿಧಾನಗಳನ್ನು ಹೊಂದಲು ಇದು ನಿಮ್ಮನ್ನು ಅನುಮತಿಸುತ್ತದೆ.

ವಸ್ತುಗಳನ್ನು ಸೇರಿಸುವಾಗ ಆಬ್ಜೆಕ್ಟ್ ರೆಪೊಸಿಟರಿ ಅವುಗಳ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಬದಲಾಯಿಸಲು ಚಂದಾದಾರಿಕೆಯನ್ನು ಸೇರಿಸಲಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಗುಣಲಕ್ಷಣಗಳಲ್ಲಿನ ಯಾವುದೇ ಬದಲಾವಣೆಯು ಈ ವಸ್ತುವನ್ನು ಬರೆಯುವ ಸರತಿಗೆ ಸೇರಿಸುತ್ತದೆ. 
ಹೊರಗಿನಿಂದ ಗುಣಲಕ್ಷಣಗಳನ್ನು ನವೀಕರಿಸುವುದು POCO ವಸ್ತುವಿನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಂತೆಯೇ ಕಾಣುತ್ತದೆ:

myParent.Children.First().Property = "Updated value";

ನೀವು ಈ ಕೆಳಗಿನ ವಿಧಾನಗಳಲ್ಲಿ ವಸ್ತುವನ್ನು ಅಳಿಸಬಹುದು:

repository.Remove(myParent);
repository.RemoveRange(otherParents);
repository.Remove<ParentModel>(x => !x.Children.Any());

ಇದು ಅಳಿಸುವಿಕೆ ಸರತಿಗೆ ವಸ್ತುವನ್ನು ಕೂಡ ಸೇರಿಸುತ್ತದೆ.

ಉಳಿತಾಯ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ?

ಆಬ್ಜೆಕ್ಟ್ ರೆಪೊಸಿಟರಿ ಮಾನಿಟರ್ ಮಾಡಲಾದ ವಸ್ತುಗಳು ಬದಲಾದಾಗ (ಒಂದೋ ಸೇರಿಸುವುದು ಅಥವಾ ಅಳಿಸುವುದು, ಅಥವಾ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಬದಲಾಯಿಸುವುದು), ಈವೆಂಟ್ ಅನ್ನು ಹುಟ್ಟುಹಾಕುತ್ತದೆ ಮಾದರಿಯನ್ನು ಬದಲಾಯಿಸಲಾಗಿದೆಗೆ ಚಂದಾದಾರರಾಗಿದ್ದಾರೆ ಸಂಗ್ರಹಣೆ. ಅನುಷ್ಠಾನಗಳು ಸಂಗ್ರಹಣೆ ಒಂದು ಘಟನೆ ಸಂಭವಿಸಿದಾಗ ಮಾದರಿಯನ್ನು ಬದಲಾಯಿಸಲಾಗಿದೆ ಬದಲಾವಣೆಗಳನ್ನು 3 ಕ್ಯೂಗಳಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ - ಸೇರಿಸಲು, ನವೀಕರಿಸಲು ಮತ್ತು ಅಳಿಸಲು.

ಸಹ ಅನುಷ್ಠಾನಗಳು ಸಂಗ್ರಹಣೆ ಪ್ರಾರಂಭದ ನಂತರ, ಅವರು ಟೈಮರ್ ಅನ್ನು ರಚಿಸುತ್ತಾರೆ ಅದು ಪ್ರತಿ 5 ಸೆಕೆಂಡುಗಳಲ್ಲಿ ಬದಲಾವಣೆಗಳನ್ನು ಉಳಿಸುತ್ತದೆ. 

ಹೆಚ್ಚುವರಿಯಾಗಿ, ಕರೆಯನ್ನು ಉಳಿಸಲು ಒತ್ತಾಯಿಸಲು API ಇದೆ: ObjectRepository.Save().

ಪ್ರತಿ ಉಳಿಸುವ ಮೊದಲು, ಅರ್ಥಹೀನ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಮೊದಲು ಕ್ಯೂಗಳಿಂದ ತೆಗೆದುಹಾಕಲಾಗುತ್ತದೆ (ಉದಾಹರಣೆಗೆ, ನಕಲಿ ಈವೆಂಟ್‌ಗಳು - ವಸ್ತುವನ್ನು ಎರಡು ಬಾರಿ ಬದಲಾಯಿಸಿದಾಗ ಅಥವಾ ವಸ್ತುಗಳ ತ್ವರಿತ ಸೇರ್ಪಡೆ/ತೆಗೆದುಹಾಕಿದಾಗ), ಮತ್ತು ನಂತರ ಮಾತ್ರ ಉಳಿಸಲಾಗುತ್ತದೆ. 

ಎಲ್ಲಾ ಸಂದರ್ಭಗಳಲ್ಲಿ, ಸಂಪೂರ್ಣ ಪ್ರಸ್ತುತ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಉಳಿಸಲಾಗಿದೆ, ಆದ್ದರಿಂದ ವಸ್ತುಗಳನ್ನು ಸರದಿಯಲ್ಲಿ ಸೇರಿಸಿದ ಸಮಯಕ್ಕಿಂತ ಹೊಸ ಆವೃತ್ತಿಯ ವಸ್ತುಗಳನ್ನೂ ಒಳಗೊಂಡಂತೆ ಅವುಗಳನ್ನು ಬದಲಾಯಿಸಿದ್ದಕ್ಕಿಂತ ವಿಭಿನ್ನ ಕ್ರಮದಲ್ಲಿ ಉಳಿಸುವ ಸಾಧ್ಯತೆಯಿದೆ.

ಇನ್ನೇನು ಇದೆ?

• ಎಲ್ಲಾ ಲೈಬ್ರರಿಗಳು .NET ಸ್ಟ್ಯಾಂಡರ್ಡ್ 2.0 ಅನ್ನು ಆಧರಿಸಿವೆ. ಯಾವುದೇ ಆಧುನಿಕ .NET ಯೋಜನೆಯಲ್ಲಿ ಬಳಸಬಹುದು.
• API ಥ್ರೆಡ್ ಸುರಕ್ಷಿತವಾಗಿದೆ. ಆಂತರಿಕ ಸಂಗ್ರಹಣೆಗಳನ್ನು ಆಧರಿಸಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ ಸಮಕಾಲೀನ ನಿಘಂಟು, ಈವೆಂಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳು ಲಾಕ್‌ಗಳನ್ನು ಹೊಂದಿರುತ್ತಾರೆ ಅಥವಾ ಅವುಗಳ ಅಗತ್ಯವಿಲ್ಲ. 
  ನೆನಪಿಡುವ ಏಕೈಕ ವಿಷಯವೆಂದರೆ ಕರೆ ಮಾಡುವುದು ObjectRepository.Save();
• ಅನಿಯಂತ್ರಿತ ಸೂಚ್ಯಂಕಗಳು (ವಿಶಿಷ್ಟತೆಯ ಅಗತ್ಯವಿದೆ):

repository.Set<ChildModel>().AddIndex(x => x.Value);
repository.Set<ChildModel>().Find(x => x.Value, "myValue");

ಅದನ್ನು ಯಾರು ಬಳಸುತ್ತಾರೆ?

ವೈಯಕ್ತಿಕವಾಗಿ, ನಾನು ಈ ವಿಧಾನವನ್ನು ಎಲ್ಲಾ ಹವ್ಯಾಸ ಯೋಜನೆಗಳಲ್ಲಿ ಬಳಸಲು ಪ್ರಾರಂಭಿಸಿದೆ ಏಕೆಂದರೆ ಇದು ಅನುಕೂಲಕರವಾಗಿದೆ ಮತ್ತು ಡೇಟಾ ಪ್ರವೇಶ ಪದರವನ್ನು ಬರೆಯಲು ಅಥವಾ ಭಾರೀ ಮೂಲಸೌಕರ್ಯವನ್ನು ನಿಯೋಜಿಸಲು ದೊಡ್ಡ ವೆಚ್ಚಗಳ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ. ವೈಯಕ್ತಿಕವಾಗಿ, ಲಿಟೆಡ್‌ಬಿ ಅಥವಾ ಫೈಲ್‌ನಲ್ಲಿ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುವುದು ಸಾಮಾನ್ಯವಾಗಿ ನನಗೆ ಸಾಕು. 

ಆದರೆ ಹಿಂದೆ, ಈಗ ಕಾರ್ಯನಿರ್ವಹಿಸದ ಸ್ಟಾರ್ಟ್‌ಅಪ್ ಎಸ್ಕೇಪ್‌ಟೀಮ್ಸ್ (ನಾನು ಇಲ್ಲಿ ಯೋಚಿಸಿದೆ, ಹಣ - ಆದರೆ ಇಲ್ಲ, ಮತ್ತೆ ಅನುಭವ) - ಅಜೂರ್ ಟೇಬಲ್ ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.

ಭವಿಷ್ಯದ ಯೋಜನೆಗಳು

ಈ ವಿಧಾನದ ಮುಖ್ಯ ಅನಾನುಕೂಲಗಳಲ್ಲಿ ಒಂದನ್ನು ನಾನು ಸರಿಪಡಿಸಲು ಬಯಸುತ್ತೇನೆ - ಸಮತಲ ಸ್ಕೇಲಿಂಗ್. ಇದನ್ನು ಮಾಡಲು, ನಿಮಗೆ ವಿತರಿಸಿದ ವಹಿವಾಟುಗಳ ಅಗತ್ಯವಿದೆ (sic!), ಅಥವಾ ವಿಭಿನ್ನ ನಿದರ್ಶನಗಳಿಂದ ಒಂದೇ ಡೇಟಾ ಬದಲಾಗಬಾರದು ಎಂಬ ಬಲವಾದ ಇಚ್ಛಾಶಕ್ತಿಯ ನಿರ್ಧಾರವನ್ನು ತೆಗೆದುಕೊಳ್ಳಿ ಅಥವಾ "ಕೊನೆಯವರು ಯಾರು ಸರಿ" ಎಂಬ ತತ್ವದ ಪ್ರಕಾರ ಅವುಗಳನ್ನು ಬದಲಾಯಿಸಲಿ.

ತಾಂತ್ರಿಕ ದೃಷ್ಟಿಕೋನದಿಂದ, ನಾನು ಈ ಕೆಳಗಿನ ಯೋಜನೆಯನ್ನು ಸಾಧ್ಯವಾದಷ್ಟು ನೋಡುತ್ತೇನೆ:

• ವಸ್ತು ಮಾದರಿಯ ಬದಲಿಗೆ EventLog ಮತ್ತು Snapshot ಅನ್ನು ಸಂಗ್ರಹಿಸಿ
• ಇತರ ನಿದರ್ಶನಗಳನ್ನು ಹುಡುಕಿ (ಸೆಟ್ಟಿಂಗ್‌ಗಳಿಗೆ ಎಲ್ಲಾ ನಿದರ್ಶನಗಳ ಅಂತಿಮ ಬಿಂದುಗಳನ್ನು ಸೇರಿಸಿ? udp ಡಿಸ್ಕವರಿ? ಮಾಸ್ಟರ್/ಸ್ಲೇವ್?)
• RAFT ನಂತಹ ಯಾವುದೇ ಒಮ್ಮತದ ಅಲ್ಗಾರಿದಮ್ ಮೂಲಕ EventLog ನಿದರ್ಶನಗಳ ನಡುವೆ ಪುನರಾವರ್ತಿಸಿ.

ನನಗೆ ಚಿಂತೆ ಮಾಡುವ ಇನ್ನೊಂದು ಸಮಸ್ಯೆಯೂ ಇದೆ - ಕ್ಯಾಸ್ಕೇಡ್ ಅಳಿಸುವಿಕೆ, ಅಥವಾ ಇತರ ವಸ್ತುಗಳಿಂದ ಲಿಂಕ್‌ಗಳನ್ನು ಹೊಂದಿರುವ ವಸ್ತುಗಳ ಅಳಿಸುವಿಕೆಯ ಪ್ರಕರಣಗಳ ಪತ್ತೆ. 

ಮೂಲ ಕೋಡ್

ನೀವು ಇಲ್ಲಿಗೆ ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಓದಿದ್ದರೆ, ಕೋಡ್ ಅನ್ನು ಓದುವುದು ಮಾತ್ರ ಉಳಿದಿದೆ; ಅದನ್ನು GitHub ನಲ್ಲಿ ಕಾಣಬಹುದು:
https://github.com/DiverOfDark/ObjectRepository

ಮೂಲ: www.habr.com