Dependencyinjection: निर्भरता के निर्माण को परिभाषित करते समय प्रासंगिक जानकारी

खुले जेनेरिक प्रकारों की सजावट का समर्थन करने के लिए मैंने पहले एक समान, लेकिन थोड़ी अलग सुविधा मांगी है; फ़ैक्टरी प्रतिनिधि में अनुरोधित सेवा प्रकार तक पहुँच प्राप्त करें।

उदाहरण:

services.AddScoped(typeof(IService<>), typeof(Service<>));

// the call below is basically a way to do decoration with MS.Ext.DI...
services.AddScoped(typeof(IService<>), (provider, context) =>
{
    var typeArgument = context.RequestedType.GetGenericArguments().First();

    var decoratorType = typeof(DecoratedService<>).MakeGenericType(typeArgument);

    var decoratedInstance = /* get the decorated instance from the service provider */

    return ActivatorUtilities.CreateInstance(provider, decoratorType, decoratedInstance);
});

जहां context.RequestedType सेवा प्रदाता को दिया गया वास्तविक सेवा प्रकार है, अर्थात provider.GetService<IService<string>>() -> typeof(IService<string>) ।

मुझे लगता है कि यहां मुख्य मुद्दा यह है कि यह MS.Ext.DI एडेप्टर के लिए और अधिक "आवश्यकताएं" लाएगा। अचानक, उन सभी को यह जानकारी प्रदान करने में सक्षम होना होगा।

शायद इसे आगे की चर्चा के लिए एक आधार के रूप में इस्तेमाल किया जा सकता है।

LightInject प्रदान करता है RegisterConstructorDependency/RegisterPropertyनिर्भरता विधियां जो इंजेक्शन की जा रही निर्भरता से संबंधित "संदर्भ" प्रदान करती हैं।

निम्न उदाहरण एक लकड़हारा बनाने का उदाहरण दिखाता है जो उस प्रकार से जुड़ा होता है जो लकड़हारे से अनुरोध करता है
http://www.lightinject.net/webapirequestloging/

हुह। मैं इस छोटी सी बातचीत के कारण यहां ठोकर खाई, जो एक स्टैक ओवरफ्लो प्रश्न से उत्पन्न हुई थी जिसे मैंने कुछ समय पहले उसी सामान्य चिंता के साथ यहां पोस्ट किया था। मैं जानना चाहता हूं कि @खेलंग ने पहले कहां इस सुविधा के लिए कहा था। क्या यह एक और मुद्दा है?

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

मान लें कि मेरे पास IRepository<TModel> अवधारणा है, जिसमें दो वर्ग हैं जिन्हें मैं इसमें स्टोर कर सकता हूं, FreeSpirit और Curmudgeon । मैं उन्हें यहां परिभाषित करूंगा:

public interface IRepository<TModel> where TModel: Model {
    public TModel GetById(Guid id);
    public TModel Create(TModel toCreate);
}

public class FreeSpirit : Model {
    public Guid Id { get; }
    public String Name { get; }

    public FreeSpirit(Guid id, String name) {
        this.Id = id;
        this.Name = name;
    }
}

public class Curmudgeon : Model {
    public Guid Id { get; }
    public DateTime EventTimestamp { get; }

    public Curmudgeon(Guid id, DateTime eventTimestamp) {
        this.Id = id;
        this.EventTimestamp = eventTimestamp;
    }
}

StandardRepository<TModel> के आधार दृढ़ता कार्यान्वयन को मानते हुए, हम इस कोड को ASP.NET के निर्भरता इंजेक्शन टूलिंग के साथ पंजीकृत कर सकते हैं जैसे:

services.AddScoped(typeof(IRepository<>), typeof(StandardRepository<>));

अब, मान लें कि हर बार जब कोई Curmudgeon अपडेट करता है तो हम उसके बारे में जानना चाहते हैं, उस डेल्टा को कुछ ऑडिट लॉग में रिकॉर्ड करना। इसलिए हम एक [Audited] विशेषता बनाते हैं, इसे Curmudgeon पर लागू करते हैं, और एक AuditingRepositoryWrapper<TModel> कार्यान्वयन बनाते हैं, जैसे:

[Audited]
public class Curmudgeon : Model {
    public Guid Id { get; }
    public DateTime EventTimestamp { get; }

    public Curmudgeon(Guid id, DateTime eventTimestamp) {
        this.Id = id;
        this.EventTimestamp = eventTimestamp;
    }
}

public class AuditingRepositoryWrapper<TModel> : IRepository<TModel> {

    private IRepository<TModel> inner { get; }
    private IAuditingService auditService { get; }

    public AuditingRepositoryWrapper(IRepository<TModel> inner, IAuditingService auditService) {
        this.inner = inner;
        this.auditService = auditService;
    }

    public TModel GetById(Guid id) {
        return this.inner.GetById(id);
    }

    public TModel Create(TModel toCreate) {
        var result = this.inner.Create(toCreate);

        this.auditService.AuditChanges(toCreate, result);

        return result;
    }

}

अब पंजीकरण मुश्किल है। मुझे अपने StandardRepository<TModel> कार्यान्वयन को AuditingRepositoryWrapper<TModel> के साथ लपेटने की आवश्यकता है यदि केवल [Audited] विशेषता है। context चर के @khellang के उदाहरण को बजाते हुए, मैं निम्नलिखित कार्य कर सकता था:

सामान्य, वांछित परिणाम:

services.AddScoped(typeof(StandardRepository<>));
services.AddScoped(typeof(IAuditingService), typeof(AuditingService));

services.AddScoped(typeof(IService<>), (provider, context) => {
    var typeArgument = context.RequestedType.GetGenericArguments().First();

    var isAudited =
        typeArgument
            .GetTypeInfo()
            .CustomAttributes
            .Any(attr => attr.AttributeType == typeof(AuditedAttribute));

    // Would need to solve the lack of closing type for the repository variable at this point.
    // (I think the best way to solve this is with a factory at this point that takes in the 'context'.)
    // See: https://github.com/invio/Invio.Extensions.DependencyInjection

    IRepository<?> repository = provider.GetRequiredService(typeof(StandardRepository<?>), typeArgument);
    if (isAudited) {
        repository = new AuditingRepositoryWrapper<?>(
            provider.GetRequiredService(repository, typeof(IAuditingService));
        );
    }

    return repository;
});

मेरी टीम आज कुछ ऐसा करके इस पर काबू पा लेती है जो निम्न के जैसा है:

services.AddScoped(typeof(StandardRepository<>));
services.AddScoped(typeof(IAuditingService), typeof(AuditingService));

services.AddRepository<FreeSpirit>();
services.AddRepository<Curmudgeon>();
[ ... ]

public static IServiceCollection AddRepository<TModel>(this IServiceCollection services) {
    var isAudited =
        typeof(TModel)
            .GetTypeInfo()
            .CustomAttributes
            .Any(attr => attr.AttributeType == typeof(AuditedAttribute));

    if (isAudited) {
        services.AddScoped(
            typeof(IRepository<TModel>),
            (provider) => {
                new AuditingRepositoryWrapper<TModel>(
                    provider.GetRequiredService<IAuditingService>(),
                    provider.GetRequiredService<StandardRepository<TModel>()
                );
            }
        );
    } else {
        services.AddScoped(typeof(IRepository<TModel>), typeof(StandardRepository<TModel>));
    }

    return services;
});

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

मुझे यह जानना अच्छा लगेगा कि इस सुविधा पर माइक्रोसॉफ्ट का क्या रुख है। अगर वे कभी भी इसका समर्थन नहीं करना चाहते हैं, तो ठीक है, मैं सिर्फ अन्य डीआई ढांचे का उपयोग करूंगा। मैंने पहले ही अपनी लाइब्रेरी से इसके खिलाफ अपना सिर पीट लिया है।

इसका उल्लेख https://github.com/aspnet/DependencyInjection/issues/474 में भी किया गया है। मुझे याद नहीं है कि यह कोई मुद्दा था, चैट में या व्यक्तिगत रूप से, लेकिन इस पर निश्चित रूप से चर्चा की गई है।

धन्यवाद, @खेलंग। इसके लायक क्या है, स्ट्रक्चर मैप माइक्रोसॉफ्ट के डीआई के साथ रचना के आसपास की समस्याओं को हल करता है । अगली बार जब हमें अपने DI लॉजिक में निवेश करना होगा तो हमने आंतरिक रूप से उसी तरह जाने का फैसला किया है।

@खेलंग याद है कि आप एक समय में डेकोरेटर सपोर्ट के साथ खेलते थे?

वैसे भी, सोचा कि मैं आपको दिखाना चाहता हूं कि इसे लाइटइंजेक्ट में कैसे हल किया जा सकता है

    using System;
    using System.Diagnostics;
    using System.Reflection;
    using LightInject;

    class Program
    {
        static void Main(string[] args)
        {            
            var container = new ServiceContainer();
            container.Register(typeof(IService<>), typeof(Service<>));
            container.Decorate(typeof(IService<>), typeof(ServiceDecorator<>),
                sr => sr.ImplementingType.GetGenericArguments()[0].GetTypeInfo().IsDefined(typeof(AuditedAttribute)));

            var fooService = container.GetInstance<IService<Foo>>();
            Debug.Assert(fooService is Service<Foo>);
            var barService = container.GetInstance<IService<Bar>>();
            Debug.Assert(barService is ServiceDecorator<Bar>);
        }
    }

    public interface IService<T>
    {
    }

    public class Service<T> : IService<T>
    {

    }

    public class ServiceDecorator<T> : IService<T>
    {
        public ServiceDecorator(IService<T> service)
        {
        }
    }


    public class AuditedAttribute : Attribute
    {
    }


    public class Foo
    {
    }

    [Audited]
    public class Bar
    {
    }

@seesharper हाँ, यह वास्तव में एक NuGet पैकेज के रूप में प्रकाशित हुआ है और स्रोत यहाँ है: https://github.com/khellang/Scrutor

केवल एक ही मुद्दा बचा है कि वह ओपन जेनरिक को सजाने में सक्षम हो। समस्या यह है कि, LightInject के विपरीत, MS.Ext.DI फ़ैक्टरी आपको ImplementingType तक पहुँच प्रदान नहीं करती है, इसलिए वास्तविक सामान्य तर्कों को जानने का कोई तरीका नहीं है जो पूछा जा रहा है...

@खेलंग ने इसे https://github.com/aspnet/DependencyInjection/issues/450 . पाया

हम इस मुद्दे को बंद कर रहे हैं क्योंकि इस मुद्दे के लिए आगे कोई कार्रवाई की योजना नहीं है। यदि आपके पास अभी भी कोई समस्या या प्रश्न हैं, तो कृपया अपने पास मौजूद किसी भी अतिरिक्त विवरण के साथ एक नया मुद्दा लॉग करें।