ऑब्जेक्ट को अपने वास्तविक प्रकार में कैसे डाला जाए?

Question

तो मेरे पास है:

void MyMethod(Object obj) { ... } 

कैसे मैं क्या इसकी वास्तविक प्रकार है करने के लिए obj डाली कर सकते हैं? आप वास्तविक प्रकार, जानते हैं तो बस

void MyMethod(Object obj) { 
    ActualType actualyType = (ActualType)obj; 
} 

Answer 1

:

SomeType typed = (SomeType)obj; 
typed.MyFunction(); 

आप वास्तविक प्रकार पता नहीं है, तो:

Answer 2

वास्तविक प्रकार के लिए कास्टिंग के लिए आसान है वास्तव में नहीं, नहीं।

// reflection 
obj.GetType().GetMethod("MyFunction").Invoke(obj, null); 

// interface 
IFoo foo = (IFoo)obj; // where SomeType : IFoo and IFoo declares MyFunction 
foo.MyFunction(); 

// dynamic 
dynamic d = obj; 
d.MyFunction(); 

Answer 3

मुझे नहीं लगता कि:

• प्रतिबिंब
• को लागू करने के एक प्रसिद्ध इंटरफ़ेस
• गतिशील

उदाहरण के लिए: आप के बजाय एक का उपयोग करने के लिए होगा आप (प्रतिबिंब के बिना नहीं) कर सकते हैं, आपको अपने फ़ंक्शन में एक प्रकार भी प्रदान करना चाहिए:

void MyMethod(Object obj, Type t) 
{ 
    var convertedObject = Convert.ChangeType(obj, t); 
    ... 
} 

युपीडी:

यह आप के लिए काम कर सकते हैं:

void MyMethod(Object obj) 
{ 
    if (obj is A) 
    { 
     A a = obj as A; 
     ... 
    } 
    else if (obj is B) 
    { 
     B b = obj as B; 
     ... 
    } 
} 

Answer 4

Implement an interface to call your function in your method 
interface IMyInterface 
{ 
void MyinterfaceMethod(); 
} 

IMyInterface MyObj = obj as IMyInterface; 
if (MyObj != null) 
{ 
MyMethod(IMyInterface MyObj); 
} 

Answer 5

अपने MyFunction() विधि केवल एक वर्ग (और उसके वंश) में परिभाषित किया गया है, तो कोशिश

void MyMethod(Object obj) 
{ 
    var o = obj as MyClass; 
    if (o != null) 
     o.MyFunction(); 
} 

यदि आप समारोह आप कॉल करना चाहते परिभाषित करने असंबंधित कक्षाओं में एक बड़ी संख्या है, तो आप एक इंटरफेस को परिभाषित करने और अपनी कक्षाओं कि इंटरफेस को परिभाषित करना चाहिए है:

interface IMyInterface 
{ 
    void MyFunction(); 
} 

void MyMethod(Object obj) 
{ 
    var o = obj as IMyInterface; 
    if (o != null) 
     o.MyFunction(); 
} 

Answer 6

अपनी असली प्रकार के कास्ट यह अगर तुम अब उदाहरण के लिए प्रकार यह एबीसी नाम की कक्षा से उन्मुख है। आप इस तरीके से अपने फ़ंक्शन को कॉल कर सकते हैं:

(abc)(obj)).MyFunction(); 

अगर आप समारोह में यह एक अलग तरीके से किया जा सकता है पता नहीं है। हमेशा आसान नहीं है। लेकिन आप इसे किसी हस्ताक्षर से किसी भी तरह से पा सकते हैं। यदि यह आपका मामला है, तो आपको हमें बताना चाहिए।

Answer 7

मेरे मामले में ऑटोमैपर अच्छी तरह से काम करता है।

AutoMapper किसी भी स्पष्ट विन्यास के बिना गतिशील वस्तुओं से/मैप कर सकते हैं:

public class Foo { 
    public int Bar { get; set; } 
    public int Baz { get; set; } 
} 
dynamic foo = new MyDynamicObject(); 
foo.Bar = 5; 
foo.Baz = 6; 

Mapper.Initialize(cfg => {}); 

var result = Mapper.Map<Foo>(foo); 
result.Bar.ShouldEqual(5); 
result.Baz.ShouldEqual(6); 

dynamic foo2 = Mapper.Map<MyDynamicObject>(result); 
foo2.Bar.ShouldEqual(5); 
foo2.Baz.ShouldEqual(6); 

इसी तरह आप शब्दकोशों से सीधे मैप कर सकते हैं वस्तुओं के लिए, AutoMapper संपत्ति नामों के साथ कुंजी लाइन अप होगा।

अधिक जानकारी https://github.com/AutoMapper/AutoMapper/wiki/Dynamic-and-ExpandoObject-Mapping