ObjectRepository - គំរូឃ្លាំងក្នុងអង្គចងចាំ .NET សម្រាប់គម្រោងផ្ទះរបស់អ្នក។

ហេតុអ្វីត្រូវទុកទិន្នន័យទាំងអស់ក្នុងអង្គចងចាំ?

ដើម្បីរក្សាទុកគេហទំព័រ ឬទិន្នន័យផ្នែកខាងក្រោយ បំណងប្រាថ្នាដំបូងរបស់មនុស្សដែលមានប្រាជ្ញាភាគច្រើនគឺជ្រើសរើសមូលដ្ឋានទិន្នន័យ SQL ។ 

ប៉ុន្តែពេលខ្លះការគិតមកក្នុងចិត្តថាគំរូទិន្នន័យមិនសមរម្យសម្រាប់ SQL ទេ៖ ឧទាហរណ៍ នៅពេលបង្កើតការស្វែងរក ឬក្រាហ្វសង្គម អ្នកត្រូវស្វែងរកទំនាក់ទំនងស្មុគ្រស្មាញរវាងវត្ថុ។ 

ស្ថានភាពដ៏អាក្រក់បំផុតគឺនៅពេលដែលអ្នកធ្វើការជាក្រុម ហើយមិត្តរួមការងារមិនដឹងពីរបៀបបង្កើតសំណួររហ័ស។ តើអ្នកចំណាយពេលប៉ុន្មានក្នុងការដោះស្រាយបញ្ហា N+1 និងបង្កើតលិបិក្រមបន្ថែមដើម្បីឱ្យ SELECT នៅលើទំព័រមេនឹងបញ្ចប់ក្នុងបរិមាណសមហេតុផល?

វិធីសាស្រ្តដ៏ពេញនិយមមួយទៀតគឺ NoSQL ។ ប៉ុន្មានឆ្នាំមុនមានការឃោសនាបំផ្លើសជាច្រើនជុំវិញប្រធានបទនេះ - សម្រាប់ឱកាសងាយស្រួលណាមួយដែលពួកគេបានដាក់ពង្រាយ MongoDB ហើយរីករាយជាមួយនឹងចម្លើយក្នុងទម្រង់ជាឯកសារ json (ដោយវិធីនេះ តើអ្នកត្រូវដាក់ឈើច្រត់ចំនួនប៉ុន្មាន ដោយសារតំណភ្ជាប់រង្វង់នៅក្នុងឯកសារ?).

ខ្ញុំស្នើឱ្យសាកល្បងវិធីសាស្ត្រជំនួសមួយផ្សេងទៀត - ហេតុអ្វីមិនព្យាយាមរក្សាទុកទិន្នន័យទាំងអស់នៅក្នុងអង្គចងចាំកម្មវិធី ដោយរក្សាទុកវាជាទៀងទាត់ទៅកន្លែងផ្ទុកចៃដន្យ (ឯកសារ មូលដ្ឋានទិន្នន័យពីចម្ងាយ)? 

អង្គចងចាំបានក្លាយទៅជាថោក ហើយទិន្នន័យដែលអាចធ្វើទៅបានសម្រាប់គម្រោងខ្នាតតូច និងមធ្យមភាគច្រើននឹងសមនឹងអង្គចងចាំ 1 GB ។ (ឧទាហរណ៍ គម្រោងផ្ទះដែលខ្ញុំចូលចិត្តគឺ កម្មវិធីតាមដានហិរញ្ញវត្ថុដែលរក្សាស្ថិតិប្រចាំថ្ងៃ និងប្រវត្តិនៃការចំណាយ សមតុល្យ និងប្រតិបត្តិការរបស់ខ្ញុំសម្រាប់រយៈពេលមួយឆ្នាំកន្លះ ប្រើប្រាស់អង្គចងចាំត្រឹមតែ 45 MB ប៉ុណ្ណោះ។

ប្រុស:

• ការចូលប្រើទិន្នន័យកាន់តែងាយស្រួល - អ្នកមិនចាំបាច់ព្រួយបារម្ភអំពីសំណួរ ការផ្ទុកខ្ជិល លក្ខណៈពិសេស ORM អ្នកធ្វើការជាមួយវត្ថុ C# ធម្មតា។
• មិនមានបញ្ហាទាក់ទងនឹងការចូលប្រើពីខ្សែស្រឡាយផ្សេងគ្នាទេ។
• លឿនណាស់ - គ្មានសំណើបណ្តាញ គ្មានការបកប្រែកូដទៅជាភាសាសំណួរ មិនត្រូវការ (de) សៀរៀលនៃវត្ថុ។
• វា​អាច​ទទួល​យក​បាន​ក្នុង​ការ​រក្សា​ទុក​ទិន្នន័យ​ក្នុង​ទម្រង់​ណា​មួយ - មិន​ថា​ជា XML នៅ​លើ​ថាស ឬ​ក្នុង SQL Server ឬ​ក្នុង Azure Table Storage។

គុណវិបត្តិ:

• ការ​ធ្វើ​មាត្រដ្ឋាន​ផ្ដេក​ត្រូវ​បាន​បាត់បង់ ហើយ​ជា​លទ្ធផល ការ​ដាក់​ពង្រាយ​ពេល​វេលា​មិន​អាច​ធ្វើ​បាន​ទេ។
• ប្រសិនបើកម្មវិធីគាំង អ្នកអាចបាត់បង់ទិន្នន័យមួយផ្នែក។ (ប៉ុន្តែកម្មវិធីរបស់យើងមិនដែលគាំងទេមែនទេ?)

តើវាដំណើរការយ៉ាងដូចម្តេច?

ក្បួនដោះស្រាយមានដូចខាងក្រោម៖

• នៅពេលចាប់ផ្តើម ការតភ្ជាប់ត្រូវបានបង្កើតឡើងជាមួយនឹងការផ្ទុកទិន្នន័យ ហើយទិន្នន័យត្រូវបានផ្ទុក។
• គំរូវត្ថុ សន្ទស្សន៍បឋម និងសន្ទស្សន៍ទំនាក់ទំនង (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();
    }
}

បង្កើត ObjectRepository ឧទាហរណ៍៖

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

ជាមួយនឹងការហៅនេះវត្ថុ ម៉ូដែល Parent ត្រូវបានបន្ថែមទៅទាំងឃ្លាំងសម្ងាត់មូលដ្ឋាន និងជួរសម្រាប់សរសេរទៅមូលដ្ឋានទិន្នន័យ។ ដូច្នេះ ប្រតិបត្តិការនេះត្រូវការ O(1) ហើយវត្ថុនេះអាចដំណើរការបានភ្លាមៗ។

ឧទាហរណ៍ ដើម្បីស្វែងរកវត្ថុនេះនៅក្នុងឃ្លាំង ហើយផ្ទៀងផ្ទាត់ថាវត្ថុដែលបានត្រឡប់មកវិញគឺជាឧទាហរណ៍ដូចគ្នា៖

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

មាន​អ្វី​កើតឡើង? កំណត់ () ត្រឡប់មកវិញ វចនានុក្រមតារាង, ដែលមាន វចនានុក្រមស្របគ្នា។ និងផ្តល់នូវមុខងារបន្ថែមនៃលិបិក្រមបឋម និងអនុវិទ្យាល័យ។ វាអនុញ្ញាតឱ្យអ្នកមានវិធីសាស្រ្តក្នុងការស្វែងរកដោយ Id (ឬលិបិក្រមអ្នកប្រើប្រាស់បំពានផ្សេងទៀត) ដោយមិនចាំបាច់ធ្វើម្តងទៀតទាំងស្រុងលើវត្ថុទាំងអស់។

នៅពេលបន្ថែមវត្ថុទៅ ObjectRepository ការជាវត្រូវបានបន្ថែមដើម្បីផ្លាស់ប្តូរលក្ខណៈសម្បត្តិរបស់ពួកគេ ដូច្នេះការផ្លាស់ប្តូរណាមួយនៅក្នុងលក្ខណៈសម្បត្តិក៏បណ្តាលឱ្យវត្ថុនេះត្រូវបានបន្ថែមទៅជួរសរសេរផងដែរ។ 
ការធ្វើបច្ចុប្បន្នភាពលក្ខណៈសម្បត្តិពីខាងក្រៅមើលទៅដូចគ្នានឹងការធ្វើការជាមួយវត្ថុ POCO៖

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

អ្នកអាចលុបវត្ថុតាមវិធីខាងក្រោម៖

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

នេះក៏បន្ថែមវត្ថុទៅជួរលុប។

តើការសន្សំដំណើរការយ៉ាងដូចម្តេច?

ObjectRepository នៅពេលដែលវត្ថុដែលបានត្រួតពិនិត្យផ្លាស់ប្តូរ (ទាំងការបន្ថែម ឬការលុប ឬផ្លាស់ប្តូរលក្ខណសម្បត្តិ) បង្កើតព្រឹត្តិការណ៍មួយ។ ម៉ូដែលផ្លាស់ប្តូរបានជាវ ការផ្ទុក. ការអនុវត្ត ការផ្ទុក នៅពេលដែលព្រឹត្តិការណ៍កើតឡើង ម៉ូដែលផ្លាស់ប្តូរ ការផ្លាស់ប្តូរត្រូវបានដាក់ជា 3 ជួរ - សម្រាប់បន្ថែម ធ្វើបច្ចុប្បន្នភាព និងសម្រាប់ការលុប។

ការអនុវត្តផងដែរ។ ការផ្ទុក នៅពេលចាប់ផ្តើម ពួកគេបង្កើតកម្មវិធីកំណត់ម៉ោងដែលបណ្តាលឱ្យការផ្លាស់ប្តូរត្រូវបានរក្សាទុករៀងរាល់ 5 វិនាទី។ 

លើសពីនេះទៀត មាន API ដើម្បីបង្ខំឱ្យរក្សាទុកការហៅទូរសព្ទ៖ ObjectRepository.Save().

មុនពេលការរក្សាទុកនីមួយៗ ប្រតិបត្តិការដែលគ្មានន័យត្រូវបានដកចេញពីជួរដំបូង (ឧទាហរណ៍ ព្រឹត្តិការណ៍ស្ទួន - នៅពេលដែលវត្ថុមួយត្រូវបានផ្លាស់ប្តូរពីរដង ឬបានបន្ថែម/យកចេញវត្ថុភ្លាមៗ) ហើយមានតែការរក្សាទុកខ្លួនឯងប៉ុណ្ណោះ។ 

ក្នុងគ្រប់ករណីទាំងអស់ វត្ថុបច្ចុប្បន្នទាំងមូលត្រូវបានរក្សាទុក ដូច្នេះវាអាចទៅរួចដែលថាវត្ថុត្រូវបានរក្សាទុកក្នុងលំដាប់ផ្សេងជាងពួកគេត្រូវបានផ្លាស់ប្តូរ រួមទាំងកំណែថ្មីនៃវត្ថុជាងពេលដែលពួកគេត្រូវបានបន្ថែមទៅជួរ។

តើ​មាន​អ្វី​ផ្សេងទៀត​នៅ​ទីនោះ?

• បណ្ណាល័យទាំងអស់គឺផ្អែកលើ .NET Standard 2.0 ។ អាចប្រើក្នុងគម្រោង .NET ទំនើបណាមួយ។
• API មានសុវត្ថិភាព។ ការប្រមូលផ្ទៃក្នុងត្រូវបានអនុវត្តដោយផ្អែកលើ វចនានុក្រមស្របគ្នា។អ្នកដោះស្រាយព្រឹត្តិការណ៍មានសោ ឬមិនត្រូវការវា។ 
  រឿងតែមួយគត់ដែលគួរចងចាំគឺការហៅទូរស័ព្ទ ObjectRepository.Save();
• លិបិក្រមបំពាន (ទាមទារភាពប្លែកពីគេ)៖

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

តើអ្នកណាប្រើវា?

ដោយផ្ទាល់ ខ្ញុំបានចាប់ផ្តើមប្រើវិធីសាស្រ្តនេះនៅក្នុងគម្រោងចំណង់ចំណូលចិត្តទាំងអស់ ព្រោះវាមានភាពងាយស្រួល និងមិនតម្រូវឱ្យមានការចំណាយច្រើនសម្រាប់ការសរសេរស្រទាប់ចូលប្រើទិន្នន័យ ឬដាក់ពង្រាយហេដ្ឋារចនាសម្ព័ន្ធធ្ងន់។ ដោយផ្ទាល់ ការរក្សាទុកទិន្នន័យក្នុង litedb ឬឯកសារជាធម្មតាគ្រប់គ្រាន់សម្រាប់ខ្ញុំ។ 

ប៉ុន្តែកាលពីមុន នៅពេលដែល EscapeTeams ចាប់ផ្តើមដំណើរការឥឡូវនេះ (ខ្ញុំ​គិត​ថា​នៅ​ទី​នេះ​ជា​លុយ ប៉ុន្តែ​អត់​មាន​បទពិសោធន៍​ម្ដង​ទៀត។) - ប្រើដើម្បីរក្សាទុកទិន្នន័យនៅក្នុង Azure Table Storage ។

ផែនការសម្រាប់អនាគត

ខ្ញុំចង់ជួសជុលគុណវិបត្តិចម្បងមួយនៃវិធីសាស្រ្តនេះ - ការធ្វើមាត្រដ្ឋានផ្ដេក។ ដើម្បីធ្វើដូច្នេះ អ្នកត្រូវការប្រតិបត្តិការចែកចាយ (sic!) ឬធ្វើការសម្រេចចិត្តដោយឆន្ទៈដ៏មុតមាំថាទិន្នន័យដូចគ្នាពីករណីផ្សេងៗគ្នាមិនគួរផ្លាស់ប្តូរ ឬអនុញ្ញាតឱ្យពួកគេផ្លាស់ប្តូរតាមគោលការណ៍ "អ្នកណាចុងក្រោយគឺត្រូវ"។

តាមទស្សនៈបច្ចេកទេស ខ្ញុំឃើញគ្រោងការណ៍ខាងក្រោមតាមដែលអាចធ្វើទៅបាន៖

• រក្សាទុក EventLog និង Snapshot ជំនួសឱ្យគំរូវត្ថុ
• ស្វែងរកវត្ថុផ្សេងទៀត (បន្ថែមចំណុចបញ្ចប់នៃវត្ថុទាំងអស់ទៅការកំណត់? udp discovery? master/slave?)
• ចម្លងរវាងធាតុ EventLog តាមរយៈក្បួនដោះស្រាយការឯកភាពណាមួយ ដូចជា RAFT ជាដើម។

វាក៏មានបញ្ហាមួយទៀតដែលធ្វើឱ្យខ្ញុំព្រួយបារម្ភផងដែរ - ការលុបល្បាក់ ឬការរកឃើញករណីនៃការលុបវត្ថុដែលមានតំណភ្ជាប់ពីវត្ថុផ្សេងទៀត។ 

ប្រភព

ប្រសិនបើអ្នកបានអានគ្រប់ផ្លូវទៅកាន់ទីនេះ នោះអ្វីៗដែលនៅសល់គឺត្រូវអានកូដ វាអាចត្រូវបានរកឃើញនៅលើ GitHub៖
https://github.com/DiverOfDark/ObjectRepository

ប្រភព: www.habr.com