क्या स्टार्टअप क्लास में सब कुछ जोड़ने के साथ ASP.NET Core 3.1 में निर्भरता दर्ज करने का एक मजबूत तरीका है?

9

मेरे पास ASP.NET Core 3.1 परियोजना है। आमतौर पर, मैं कक्षा ConfigureServices()में विधि का उपयोग करके किसी भी निर्भरता को पंजीकृत करता हूं Startup.cs।

लेकिन, मुझे लगता है कि मुझे बहुत सारी निर्भरताएँ दर्ज करनी पड़ रही हैं और बहुत ConfigureServices()बड़ा लग रहा है! मुझे पता है कि मैं शायद एक स्थिर विधि का एक विस्तार विधि बना सकता हूं और इसे कॉन्फिगरस्वाइस () वर्ग से कॉल कर सकता हूं, लेकिन अगर कोई बेहतर तरीका है तो सोच रहा हूं।

यदि आईओसी कंटेनर में निर्भरता दर्ज करने का कोई तरीका है, तो उन्हें इस तरह से एक बार में परिभाषित करने के बिना

services.AddScoped<Interface, Class>();
.... 200 lines later
services.AddScoped<ISettings, Settings>()

10

कस्टम निर्भरता विधियों में संबंधित निर्भरता को समूहबद्ध करना ऐसा करने का एक बहुत ही सामान्य तरीका है। ASP.NET Core पहले से ही कई आंतरिक सेवाओं के लिए ऐसा करता है, और आप आसानी से उसके ऊपर विस्तार कर सकते हैं और उन्हें अपने आवेदन के लिए आवश्यक तरीके से सेट कर सकते हैं। उदाहरण के लिए प्रमाणीकरण और प्राधिकरण स्थापित करने के लिए:

public IServiceCollection AddSecurity(this IServiceCollection services)
{
    services.AddAuthentication()
        .AddCookie();

    service.AddAuthorization(options =>
    {
        options.DefaultPolicy = …;
    });

    return services;
}

आप अपनी एप्लिकेशन-विशिष्ट सेवाओं के लिए भी ऐसा कर सकते हैं और उन्हें तार्किक रूप से अलग-अलग एक्सटेंशन विधियों में समूहित कर सकते हैं।

यदि आपके पास बहुत सारे सेवा पंजीकरण हैं जो बहुत समान हैं, तो आप स्क्रूटन का उपयोग करके एक कन्वेंशन-आधारित पंजीकरण भी नियोजित कर सकते हैं । उदाहरण के लिए, यह एक निश्चित नाम स्थान के भीतर सभी सेवाओं को उनके संबंधित इंटरफ़ेस के लिए क्षणिक रूप में पंजीकृत करता है:

services.Scan(scan => scan
    .FromAssemblyOf<Startup>()
        .AddClasses(c => c.InNamespaces("MyApp.Services"))
            .AsImplementedInterfaces()
            .WithTransientLifetime()
);

स्क्रूटोर बहुत जटिल नियमों को सेवाओं के लिए स्कैन करने की अनुमति देता है, इसलिए यदि आपकी सेवाएं कुछ पैटर्न का पालन करती हैं , तो आप संभवतः इसके लिए एक नियम के साथ आने में सक्षम होंगे।

— प्रहार
स्रोत

3

एक कस्टम विशेषता बनाएं (जिसे AutoBindAttribute कहा जाता है)

public class AutoBindAttribute : Attribute
{
}

इसे bellow की तरह उपयोग करें (उन सभी कार्यान्वयनों को सजाने के लिए जिन्हें आप स्वचालित रूप से [AutroBind] के साथ बाँधना चाहते हैं)

public interface IMyClass {}

[AutoBind]
public class MyClass : IMyClass {}

अब IServiceCollection के लिए एक extention विधि बनाएँ

public class ServiceCollectionExtentions
{
    public static void AutoBind(this IServiceCollection source, params Assembly[] assemblies)
    {
       source.Scan(scan => scan.FromAssemblies(assemblies)
        .AddClasses(classes => classes.WithAttribute<AutoBindAttribute>())
        .AsImplementedInterfaces()
        .WithTransientLifetime();
    }
}

अब इसे Startup.cs में कॉल करें

public class Startup
{

    public void ConfigureServices(IServiceCollection services)
    {
        services.AutoBind(typeof(Startup).Assembly);
    }

}

नोट: आप ServiceCollectionExtentionsसभी स्कोप जैसे सिंगलटन आदि का समर्थन करने के लिए कक्षा में सुधार कर सकते हैं । यह उदाहरण केवल क्षणिक जीवनकाल के लिए दिखाता है।

का आनंद लें!!!

— दिलन जयतिलके
स्रोत

0

इसके अलावा जो उल्लेख किया गया था।

व्यक्तिगत रूप से मुझे प्रत्येक विधानसभा के लिए एक अलग वर्ग पंजीकरण निर्भरताएं रखना पसंद है। यह सही परत पर कक्षाओं का उपयोग करने पर अधिक नियंत्रण जोड़ता है और उन्हें बनाने की अनुमति देता है internalजो आईएमओ अच्छा है।

scanतंत्र का उपयोग करना है या नहीं यह आप पर निर्भर है। कुछ फ्रेमवर्क डिफ़ॉल्ट रूप से इसे देते हैं। कक्षाओं / विधियों के एक सेट में समान निर्भरता को समूहित करना, बदले में, किसी भी परिवर्तन के लिए एक सुसंगत स्थान पर तर्क को हल करने में मदद करना चाहिए। आप दोनों दृष्टिकोणों को जोड़ सकते हैं।

— Shymep
स्रोत