ऑब्जेक्ट को गतिशील रूप से कोड

Question

में इंटरफ़ेस को कार्यान्वित करें, मैं यह परीक्षण पास करना चाहता हूं - किसी को भी यह पता चल जाएगा कि यह कैसे करें?

public class Something 
{ 
    public string Name {get; set} 
} 

public interface IWithId 
{ 
    public Guid Id {get; set} 
} 

public class IdExtender 
{ 
    public static Object Extend(object toExtend) 
    { 
     ...? 
    } 
} 

public class Tests 
{ 
    [Test] 
    public void Should_extend_any_object() 
    { 
     var thing = new Something { Name = "Hello World!"}; 
     var extended = IdExtender.Extend(thing); 
     Assert.IsTrue(extended is IWithId); 
     Assert.IsTrue(extended.Id is Guid); 
     Assert.IsTrue(extened.Name == "Hello World!"); 
    } 
} 

मैं कुछ इस तरह लगता है कि महल गतिशील प्रॉक्सी, linfu, आदि ... लेकिन कैसे के साथ किया जा सकता है?

Answer 1

कैसल डी पी (जाहिर है)

खैर का उपयोग करना - आप के बाद से आप एक मौजूदा प्रकार एक नए इंटरफ़ेस हासिल रूप में अपने कार्यक्रम निष्पादित हो रहा है नहीं हो सकता है वापस जाने के लिए एक नई वस्तु बनाने करना होगा।

ऐसा करने के लिए आपको प्रॉक्सी बनाने की आवश्यकता होगी और फिर प्रॉक्सी पर अपनी पूर्व-मौजूदा ऑब्जेक्ट की स्थिति दोहराएं। डीपी ओओटीबी नहीं करता है। V2.5 में आप लक्ष्य के साथ नई कक्षा प्रॉक्सी का उपयोग कर सकते हैं, लेकिन यह केवल तभी काम करेगा जब प्रकार के सभी गुण वर्चुअल थे।

वैसे भी। आप नए प्रकार को IWithId इंटरफ़ेस प्राप्त कर सकते हैं या तो संपत्ति को कार्यान्वित करने वाली मौजूदा ऑब्जेक्ट के साथ प्रॉक्सी में मिलाकर। फिर इंटरफ़ेस के सदस्यों को कॉल ऑब्जेक्ट पर अग्रेषित की जाएगी।

वैकल्पिक रूप से आप इसे लागू करने के लिए अतिरिक्त इंटरफ़ेस प्रदान कर सकते हैं और एक इंटरसेप्टर को कार्यान्वयनकर्ता की भूमिका में भर सकते हैं।

Answer 2

mocking framework like Moq या RhinoMocks का उपयोग क्यों न करें। वे आपको सीधे प्रॉक्सी बनाने के बिना इंटरफेस को गतिशील रूप से कार्यान्वित करने की अनुमति देते हैं।

Moq के साथ आप लिख सकते हैं:

var mock = new Mock<IWithId>(); // mock the interface 
mock.Setup(foo => foo.Name).Returns("Hello World"); // setup a property 

कि के अलावा, आप कुछ जटिल काम करने के लिए आप क्या चाहते हैं पाने के लिए होगा। जहां तक ​​मुझे पता है, आप रनटाइम पर मौजूदा क्लास में विधि या गुण जोड़ नहीं सकते हैं। आप एक नई वस्तु का एक उदाहरण वापस कर सकते हैं जो गतिशील रूप से पारित प्रकार से प्राप्त होता है। कैसल निश्चित रूप से इसकी अनुमति देता है, लेकिन आवश्यक कोड विशेष रूप से सुरुचिपूर्ण या सरल नहीं है।

Answer 3

किसी संपत्ति या इंटरफ़ेस को गतिशील रूप से संलग्न करने के सवाल को अलग करना, ऐसा लगता है कि आप जो कुछ करने का प्रयास कर रहे हैं वह अतिरिक्त डेटा के साथ मौजूदा कक्षाओं को बढ़ा रहा है। इस समस्या का एक बहुत ही सामान्य समाधान Dictionary<Something, SomethingExtra> का उपयोग करना है और इसे मैपिंग को बनाए रखने वाले कुछ सेवा वर्ग में संग्रहीत करना है। अब, जब आपको SomethingExtra तक पहुंच की आवश्यकता है, तो आप संबंधित जानकारी के लिए सेवा कक्षा से पूछें।

लाभ:

1. कार्यान्वयन को समझते हैं और एक समाधान प्रतिबिंब और गतिशील प्रॉक्सी पीढ़ी का उपयोग करने से बनाए रखने के लिए आसान है।

2. यदि आपको विस्तारित प्रकार से प्राप्त करने की आवश्यकता है, तो वर्ग को सील नहीं किया जा सकता है। एसोसिएटिंग जानकारी बाहरी रूप से मुहरबंद कक्षाओं के साथ ठीक काम करती है।

3. आप बढ़ी हुई वस्तु के निर्माण के लिए ज़िम्मेदार होने के बिना जानकारी को जोड़ सकते हैं। आप कहीं भी बनाए गए उदाहरण ले सकते हैं और नई जानकारी को जोड़ सकते हैं।

नुकसान:

1. आप सेवा उदाहरण है कि मानचित्रण का कहना है इंजेक्षन की जरूरत है। यदि आप सिंगलटन स्थिर एक्सेसर के माध्यम से एक, मैनुअल इंजेक्शन (आमतौर पर एक कन्स्ट्रक्टर के माध्यम से पारित) का उपयोग कर रहे हैं, या यदि कोई अन्य विकल्प नहीं है, तो आप इसे आईओसी फ्रेमवर्क के माध्यम से कर सकते हैं।

2. यदि आपके पास बहुत बड़ी संख्या है और उन्हें तेजी से बनाया/हटाया जा रहा है, तो शब्दकोश ओवरहेड ध्यान देने योग्य हो सकता है। मुझे संदेह है कि उपरोक्त कार्यान्वयन की तुलना में ओवरहेड ध्यान देने योग्य होने से पहले आपको बहुत भारी भार की आवश्यकता होगी।

Answer 4

अभी के लिए मैं इस तरह linfu साथ जा रहा हूँ:

public class IdExtender 
{ 
    public static Object Extend(object toExtend) 
    { 
     var dyn = new DynamicObject(toExtend); 
     dyn.MixWith(new WithId { 
           Id = Guid.New() 
           }); 
     var extended = dyn.CreateDuck<IWithId>(returnValue.GetType().GetInterfaces()); 
     return extended; 
    } 
} 

Answer 5

मैं वास्तव में एक similar question पिछले सप्ताह जवाब दे दिया है। मैंने एक छोटी सी लाइब्रेरी भी लिखी है जो यह एक काम करता है। यह मेरे blog से उपलब्ध है, जिसे मैं लापरवाही से जोड़ रहा हूं।

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

public static TIntf CreateMixinWithTarget<TIntf>(TIntf target, params object[] instances) where TIntf : class{ 

    ProxyGenerator generator = new ProxyGenerator(); 
    ProxyGenerationOptions options = new ProxyGenerationOptions(); 

    instances.ToList().ForEach(obj => options.AddMixinInstance(obj)); 

    return generator.CreateInterfaceProxyWithTarget <TIntf>(target, options); 
} 

[Test] 
public void Should_extend_any_object() 
{ 
    var thing = new Something { Name = "Hello World!"}; 
    var extended = CreateMixinWithTarget<ISomething>(thing, new WithId(), new GuidImpl()); 
    Assert.IsTrue(extended is IWithId); 
    Assert.IsTrue(extended.Id is Guid); 
    Assert.IsTrue(extened.Name == "Hello World!"); 
}