Event Listeners, Processors, ଏବଂ DbContext — Pitfalls Best Practices

କଳ୍ପନା କରନ୍ତୁ ଯେ ଆପଣଙ୍କ ଆପ୍‌ରେ ଦୁଇଟି ସାଥୀ ଅଛନ୍ତି: ଗୋଟିଏ EventListener ଏବଂ ଗୋଟିଏ EventProcessor। ଇଭେଣ୍ଟ୍ ପାଇଁ ଅପେକ୍ଷା କରି, EventListener ସବୁବେଳେ ବସିଥାଏ, ଯେତେବେଳେ କି ଏକ ଇଭେଣ୍ଟ୍ ଆସିବା ପରେ EventProcessor ପ୍ରକୃତ କାମ କରେ। ଦକ୍ଷ ଆପ୍ଲିକେସନ୍‌ଗୁଡ଼ିକ ନିର୍ମାଣ କରିବା ପାଇଁ ସେମାନଙ୍କର ଲାଇଫ୍‌ଟାଇମ୍‌କୁ କିପରି ମ୍ୟାନେଜ୍ କରିବେ ତାହା ବୁଝିବା ଅତ୍ୟନ୍ତ ଗୁରୁତ୍ୱପୂର୍ଣ୍ଣ। ଏହି ବିଷୟ ବର୍ତ୍ତମାନ ବିଶେଷ ଗୁରୁତ୍ୱପୂର୍ଣ୍ଣ ଅଟେ, କାରଣ ଅନେକ ଡେଭେଲପର୍ .NET 10 ସହିତ କାମ କରୁଛନ୍ତି ଏବଂ ସେମାନଙ୍କର ଆପ୍ଲିକେସନ୍‌ଗୁଡ଼ିକ ସୁଗମ ଭାବରେ ଚାଲିବା ନିଶ୍ଚିତ କରିବାକୁ ଆବଶ୍ୟକ କରୁଛନ୍ତି।

Lifetimes ବୁଝିବା

.NET ରେ, ସର୍ଭିସ୍‌ଗୁଡ଼ିକର ବିଭିନ୍ନ ଲାଇଫ୍‌ଟାଇମ୍ ରହିପାରେ:

• Singleton: ସମ୍ପୂର୍ଣ୍ଣ ଆପ୍ଲିକେସନ୍ ପାଇଁ ଗୋଟିଏ ଇନଷ୍ଟାନ୍ସ।
• Scoped: ପ୍ରତି ଅନୁରୋଧରେ ଗୋଟିଏ ନୂଆ ଇନଷ୍ଟାନ୍ସ।
• Transient: ପ୍ରତିଥର ଏହାକୁ ଅନୁରୋଧ କରାଯିବା ବେଳେ ଗୋଟିଏ ନୂଆ ଇନଷ୍ଟାନ୍ସ।

ଆପଣ ଏହି ଲାଇଫ୍‌ଟାଇମ୍‌ଗୁଡ଼ିକୁ ମିଶାଇବା ସମୟରେ ଚ୍ୟାଲେଞ୍ଜ୍ ଉତ୍ପନ୍ନ ହୁଏ, ବିଶେଷ କରି ଯେତେବେଳେ ଏକ ବ୍ୟବହାର କରନ୍ତି DbContext.

ସାଧାରଣ ପିଟ୍‌ଫଲ୍: Scoped DbContext ସହିତ Singleton Processor

ଏକ ସାଧାରଣ ଭୁଲ୍ ହୁଏ ଯେତେବେଳେ ଏକ singleton EventProcessor ଏକ scoped ଉପରେ ନିର୍ଭର କରେ DbContext। ଏହି ସେଟଅପ୍‌ରେ:

• ଏହା EventProcessor ଆପ୍ଲିକେସନ୍‌ର ଲାଇଫ୍‌ଟାଇମ୍ ପାଇଁ ଥରେ ତିଆରି କରାଯାଏ।
• ଏହା DbContext ଅନୁରୋଧ ଅନୁଯାୟୀ ତିଆରି କରାଯାଏ।

ଏହା ଅନେକ ସମସ୍ୟାର କାରଣ ହୋଇପାରେ:

• Stale Data: singleton DbContext ପୁରୁଣା ଡାଟା ଧରି ରଖିପାରେ, ଯାହା ଅସଙ୍ଗତିର କାରଣ ହୋଇଥାଏ।
• Concurrency Issues: ଏକାଧିକ ଅନୁରୋଧ ସମାନ ଆକ୍ସେସ୍ କରୁଛି DbContext ରେସ୍ କଣ୍ଡିସନ୍ ଏବଂ ଡାଟା କରପସନ୍ ହୋଇପାରେ।
• Memory Leaks: ଦୀର୍ଘଜୀବୀ DbContext ଇନଷ୍ଟାନ୍ସଗୁଡ଼ିକ ଟ୍ରାକ୍ କରାଯାଇଥିବା ଏଣ୍ଟିଟିଗୁଡ଼ିକୁ ସଂଗ୍ରହ କରିପାରେ, ଅତ୍ୟଧିକ ମେମୋରୀ ବ୍ୟବହାର କରେ।

Best Practices

ଏହି ପିଟ୍‌ଫଲ୍‌ଗୁଡ଼ିକୁ ଏଡାଇବା ପାଇଁ, ନିମ୍ନଲିଖିତ ଆପ୍ରୋଚ୍‌ଗୁଡ଼ିକୁ ବିଚାର କରନ୍ତୁ:

Best Practice #1: Singleton Processor ରେ IServiceScopeFactory ବ୍ୟବହାର କରନ୍ତୁ

ଇଞ୍ଜେକ୍ଟ୍ କରନ୍ତୁ IServiceScopeFactory singleton ରେ EventProcessor। ଏହା ଆପଣଙ୍କୁ ଗୋଟିଏ ନୂଆ ସ୍କୋପ୍ ତିଆରି କରିବାକୁ ଏବଂ ଗୋଟିଏ ନୂଆ ରିଜଲ୍ଭ କରିବାକୁ ଅନୁମତି ଦିଏ DbContext ପ୍ରତି ଇଭେଣ୍ଟ୍ ପାଇଁ:

public class EventProcessor : IEventProcessor
{
    private readonly IServiceScopeFactory _scopeFactory;

    public EventProcessor(IServiceScopeFactory scopeFactory)
    {
        _scopeFactory = scopeFactory;
    }

    public async Task ProcessAsync(Event evt)
    {
        using var scope = _scopeFactory.CreateScope();
        var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();

        db.Events.Add(evt);
        await db.SaveChangesAsync();
    }
}

ଏହା ସୁନିଶ୍ଚିତ କରେ ଯେ ପ୍ରତ୍ୟେକ ଇଭେଣ୍ଟ୍ ଏକ ନୂଆ ସହିତ ପ୍ରୋସେସ୍ ହୋଇଛି DbContext, ଷ୍ଟେଲ୍ ଡାଟା ଏବଂ କନକରେନ୍ସି ସମସ୍ୟାକୁ ରୋକିଥାଏ।

Best Practice #2: Processor Scoped କରନ୍ତୁ

ବିକଳ୍ପ ଭାବରେ, ଆପଣ ରେଜିଷ୍ଟର୍ କରିପାରିବେ EventProcessor scoped ଭାବରେ। ଏହାକୁ ସହିତ ଅନୁରୋଧ ଅନୁଯାୟୀ ତିଆରି କରିବାକୁ ଅନୁମତି ଦିଏ DbContext:

services.AddScoped<IEventProcessor, EventProcessor>();
services.AddSingleton<IEventListener, EventListener>();

ଏହି କନଫିଗରେସନ୍‌ରେ, singleton EventListener ଏକ scoped ରିଜଲ୍ଭ କରେ EventProcessor ପ୍ରତି ଇଭେଣ୍ଟ୍ ପାଇଁ, ଏହା ନିଶ୍ଚିତ କରେ ଯେ ଉଭୟ processor ଏବଂ DbContext ଅନୁରୋଧ ପାଇଁ scoped ଅଟେ।

Key Takeaways

• Singletons ରେ Scoped Services ଇଞ୍ଜେକ୍ଟ୍ କରିବା ଠାରୁ ଦୂରେଇ ରୁହନ୍ତୁ: ଡାଇରେକ୍ଟ ଇଞ୍ଜେକ୍ସନ୍ ଡାଟା ଅସଙ୍ଗତି ଏବଂ କନକରେନ୍ସି ସମସ୍ୟାର କାରଣ ହୋଇପାରେ।
• Singletons ରେ Scoped Dependencies ପାଇଁ IServiceScopeFactory ବ୍ୟବହାର କରନ୍ତୁ: ଏହି ଆପ୍ରୋଚ୍ ପ୍ରତ୍ୟେକ ଅପରେସନ୍ ପାଇଁ ଗୋଟିଏ ନୂଆ ସ୍କୋପ୍ ତିଆରି କରେ, ସ୍କୋପଡ୍ ସର୍ଭିସ୍‌ଗୁଡ଼ିକର ନୂଆ ଇନଷ୍ଟାନ୍ସ ସୁନିଶ୍ଚିତ କରେ।
• Processors କୁ ଉପଯୁକ୍ତ ଭାବରେ ରେଜିଷ୍ଟର୍ କରନ୍ତୁ: ଆପଣଙ୍କର ରେଜିଷ୍ଟର୍ କରିବେ କି ନାହିଁ ସ୍ଥିର କରନ୍ତୁ EventProcessor ଏହାର ଷ୍ଟେଟ୍‌ଫୁଲ୍‌ନେସ୍ ଏବଂ ନିର୍ଭରଶୀଳତା ଉପରେ ଆଧାର କରି ସ୍କୋପ୍ କିମ୍ବା ସିଙ୍ଗଲଟନ୍ ଭାବରେ।

ଏହି ବେଷ୍ଟ୍ ପ୍ରାକ୍ଟିସ୍‌ଗୁଡ଼ିକୁ ଅନୁସରଣ କରି, ଆପଣ ରୋବଷ୍ଟ୍ ଏବଂ ଦକ୍ଷ .NET ଆପ୍ଲିକେସନ୍‌ଗୁଡ଼ିକ ତିଆରି କରିପାରିବେ ଯାହା ଇଭେଣ୍ଟ୍ ଏବଂ ଡାଟାବେସ୍ ଅପରେସନ୍‌ଗୁଡ଼ିକୁ ନିରନ୍ତର ଭାବରେ ପରିଚାଳନା କରେ।

Conclusion

.NET ରେ ଲାଇଫ୍‌ଟାଇମ୍ ମ୍ୟାନେଜ୍ କରିବା ନିର୍ଭରଯୋଗ୍ୟ ଆପ୍ଲିକେସନ୍‌ଗୁଡ଼ିକ ତିଆରି କରିବା ପାଇଁ ଅତ୍ୟାବଶ୍ୟକ। ପିଟ୍‌ଫଲ୍‌ସ୍ ଏବଂ ବେଷ୍ଟ୍ ପ୍ରାକ୍ଟିସ୍‌ଗୁଡ଼ିକୁ ବୁଝିବା ଦ୍ୱାରା, ଆପଣ ସାଧାରଣ ଭୁଲ୍‌ଗୁଡ଼ିକୁ ଏଡାଇ ପାରିବେ ଏବଂ ଆପଣଙ୍କ ଆପ୍ ସୁଗମ ଭାବରେ ଚାଲିବା ନିଶ୍ଚିତ କରିପାରିବେ।

Merits

• ଆପ୍ଲିକେସନ୍ ଷ୍ଟାବିଲିଟିରେ ଉନ୍ନତି।
• ଡାଟା ଅସଙ୍ଗତିର ସମ୍ଭାବନା ହ୍ରାସ।
• ସମ୍ବଳଗୁଡ଼ିକୁ ପ୍ରଭାବଶାଳୀ ଭାବରେ ପରିଚାଳନା କରି କାର୍ଯ୍ୟଦକ୍ଷତା ବୃଦ୍ଧି।

Demerits

• ସର୍ଭିସ୍ ରେଜିଷ୍ଟ୍ରେସନ୍‌ରେ ଜଟିଳତା ବୃଦ୍ଧି।
• ନୂଆ ଡେଭେଲପର୍‌ମାନଙ୍କ ପାଇଁ ସମ୍ଭାବ୍ୟ ଲର୍ଣ୍ଣିଂ କର୍ଭ।

Caution

ଏହି ଆର୍ଟିକିଲ୍ ଶିକ୍ଷଣୀୟ ଅଟେ। ଆପଣଙ୍କ କୋଡ୍‌ରେ ପ୍ରକୃତ ଭାଲ୍ୟୁ ସହିତ କୌଣସି ପ୍ଲେସହୋଲ୍ଡର ଭାଲ୍ୟୁକୁ ବଦଳାଇବାକୁ ମନେରଖନ୍ତୁ। ସେମାନଙ୍କ ଉପରେ ନିର୍ଭର କରିବା ପୂର୍ବରୁ ସର୍ବଦା ମୂଳ ଉତ୍ସ ବିରୁଦ୍ଧରେ ଦାବିଗୁଡ଼ିକୁ ଯାଞ୍ଚ କରନ୍ତୁ।

Frequently asked questions

• .NET ରେ DbContext କଣ? — ଏକ DbContext ହେଉଛି ଏକ କ୍ଲାସ୍ ଯାହା Entity Framework ରେ ଡାଟାବେସ୍ କନେକ୍ସନ୍ ଏବଂ ଅପରେସନ୍‌ଗୁଡ଼ିକୁ ପରିଚାଳନା କରେ।
• .NET ରେ ବିଭିନ୍ନ ସର୍ଭିସ୍ ଲାଇଫ୍‌ଟାଇମ୍ କଣ? — ସର୍ଭିସ୍‌ଗୁଡ଼ିକ singleton, scoped, କିମ୍ବା transient ହୋଇପାରେ, ପ୍ରତ୍ୟେକ ସର୍ଭିସ୍ ଇନଷ୍ଟାନ୍ସ କେତେ ସମୟ ବଞ୍ଚିଥାଏ ତାହା ବ୍ୟାଖ୍ୟା କରେ।
• ମୁଁ କାହିଁକି singletons ରେ scoped ସର୍ଭିସ୍ ଇଞ୍ଜେକ୍ଟ୍ କରିବା ଠାରୁ ଦୂରେଇ ରହିବା ଉଚିତ୍? — ଏପରି କରିବା ଦ୍ୱାରା ଷ୍ଟେଲ୍ ଡାଟା ଏବଂ କନକରେନ୍ସି ସମସ୍ୟା ହୋଇପାରେ, କାରଣ singleton ସ୍କୋପଡ୍ ସର୍ଭିସ୍‌କୁ ଇଚ୍ଛା ଠାରୁ ଅଧିକ ସମୟ ଧରି ରଖିବ।
• IServiceScopeFactory କଣ? — IServiceScopeFactory ହେଉଛି ଏକ ଇଣ୍ଟରଫେସ୍ ଯାହା ଆପଣଙ୍କୁ ସର୍ଭିସ୍ ରିଜଲ୍ଭ କରିବା ପାଇଁ ଏକ ନୂଆ ସ୍କୋପ୍ ତିଆରି କରିବାକୁ ଅନୁମତି ଦିଏ, ବିଶେଷ କରି singletons ରେ scoped ସର୍ଭିସ୍‌ଗୁଡ଼ିକୁ ମ୍ୟାନେଜ୍ କରିବା ପାଇଁ ଉପଯୋଗୀ।
• ମୁଁ କିପରି DbContext ଲାଇଫ୍‌ଟାଇମ୍‌କୁ ପ୍ରଭାବଶାଳୀ ଭାବରେ ମ୍ୟାନେଜ୍ କରିପାରିବି? — ପ୍ରତ୍ୟେକ ଅପରେସନ୍ ପାଇଁ ଗୋଟିଏ ନୂଆ DbContext ତିଆରି କରିବାକୁ IServiceScopeFactory ବ୍ୟବହାର କରନ୍ତୁ କିମ୍ବା ପ୍ରତି ଅନୁରୋଧରେ ଗୋଟିଏ ନୂଆ DbContext ଅଛି ବୋଲି ନିଶ୍ଚିତ କରିବାକୁ ଆପଣଙ୍କର ପ୍ରୋସେସର୍‌କୁ ସ୍କୋପ୍ କରନ୍ତୁ।
• .NET ଆପ୍ଲିକେସନ୍‌ଗୁଡ଼ିକରେ ମେମୋରୀ ଲିକ୍‌ର ପରିଣାମ କଣ? — ମେମୋରୀ ଲିକ୍ ସମୟ ସହିତ ମେମୋରୀ ବ୍ୟବହାର, ଆପ୍ଲିକେସନ୍ ମନ୍ଥରତା, ଏବଂ କ୍ରାସ୍ ବୃଦ୍ଧି କରିପାରେ।

Tags

#dotnet #eventdriven #microservices #dependencyinjection #DbContext #IServiceScopeFactory #bestpractices #softwaredevelopment