डायनेमिक कॉल: यह क्या है और क्यों है?

मुझे लगता है कि स्थैतिक प्रोग्रामिंग भाषाओं में काम करने वाले प्रत्येक डेवलपर के लिए, कभी-कभी डायनेमिक कॉल का सहारा लेने की आवश्यकता होती है - एक ऐसी पद्धति को कॉल करने की जिसके बारे में अभी तक कुछ भी नहीं पता है। या किसी वस्तु से कुछ संपत्ति प्राप्त करें, जो केवल रन-टाइम पर ज्ञात होगी।



यह कभी-कभी तथाकथित टंकण के आधार पर एल्गोरिदम में उपयोग किया जाता है:

यदि कोई बतख जैसा दिखता है, तो बतख की तरह तैरता है और बतख की तरह झपटता है, तो यह संभवतः एक बतख है।

इस लेख में, मैं Microsoft .NET 4.0 में उपलब्ध मुख्य तरीकों पर विचार करना चाहूंगा, उनके प्रदर्शन और वाक्यविन्यास की तुलना करूंगा।

मुख्य विकल्प उपलब्ध हैं

सबसे पहले, मैं उन विकल्पों की सूची दूंगा जिनका मैं इस लेख में विश्लेषण करूंगा। यदि कोई भी विकल्प निर्बाध लगता है, तो इसे छोड़ दें। और अगर विचार करने लायक कोई अन्य विकल्प हैं, तो कृपया लिखें, मैं उन्हें पाठ में जोड़ दूंगा।



मैं आपको तुरंत चेतावनी देता हूं कि जिन विधियों पर चर्चा की गई है, वे पूरी तरह से परस्पर विनिमय करने योग्य नहीं हैं: प्रत्येक की अपनी ख़ासियत और गुंजाइश है। मैं उपयोग की जटिलता और गतिशील तरीकों के उपयोग / आह्वान की गति की तुलना करना चाहता था। इससे किसी विशिष्ट कार्य के आधार पर किसी विशेष विधि को चुनना संभव होगा।



तो:



- परावर्तन (परावर्तन, आरटीटीआई, आत्मनिरीक्षण)

- अर्थ का शब्दकोश

- प्रतिनिधियों का शब्दकोश

- एक स्थिर कंटेनर के साथ गतिशील वस्तु

- विस्तारक के साथ गतिशील वस्तु

- कॉल पिक के साथ गतिशील वस्तु

- भावों का संकलन (भाव)

परीक्षण पद्धति

इसलिए, लक्ष्य के रूप में खेतों / विधियों तक पहुंच की गति की तुलना करना है, मैंने इस तरह के एक सामान्य संरचना में परीक्षणों को डिज़ाइन किया है:

- एक परीक्षण कंटेनर ऑब्जेक्ट (ऑब्जेक्टटेस्टर) है, जिसमें परीक्षण की गई वस्तु शामिल है

- परीक्षण ऑब्जेक्ट में दो गुण होने चाहिए - एक पूर्णांक (A) और एक स्ट्रिंग (B)

- टेस्ट ऑब्जेक्ट टेस्ट ऑब्जेक्ट को A और B कॉल को दर्शाता है

- परीक्षण वातावरण 2000 कंटेनर ऑब्जेक्ट्स की एक सरणी बनाता है, उन्हें डेटा के साथ भरता है

- परीक्षण वातावरण एरे में प्रत्येक वस्तु पर 2000 बार परीक्षण ऑपरेशन करता है

- परीक्षण ऑपरेशन को गुणों ए और बी के मूल्य का कम से कम दो गुना प्राप्त करना चाहिए (समाधान में कैश की उपस्थिति की जांच करने में सक्षम करने के लिए दो बार)

- प्रत्येक परीक्षण विधि के लिए, परीक्षण 5 बार चलता है



कोड रिलीज़ कॉन्फ़िगरेशन के तहत संकलित करता है।

विंडोज 7 x64, .NET 4.0.30319, इंटेल कोर 2 क्वाड Q9400 (2666 मेगाहर्ट्ज), 4 जीबी D22 पर टेस्ट चलते हैं

स्थैतिक (गैर-गतिशील) कार्यान्वयन

तुलना के लिए, एक ऑब्जेक्टटेस्टर को एक संदर्भ बिंदु के रूप में जोड़ा गया है, जिसमें दो ऑटो-गुणों के साथ एक साधारण वर्ग होता है और प्रतिनिधि इस वर्ग को कॉल करते हैं।



यह विधि सबसे तेज़ होगी, क्योंकि यह पूरी तरह से गैर-गतिशील है। इसलिए, हम इस संबंध में अन्य तरीकों की तुलना करेंगे।



कोड काफी सरल है (वैसे, स्थिर वर्ग को याद रखें, हम इसे भी उपयोग करेंगे):

private class StaticObject

{

public int A { get ; set ; }

public string B { get ; set ; }

}



private class StaticObjectTester : ObjectTester

{

private readonly StaticObject _o = new StaticObject();



public override int A

{

get { return _o.A; }

set { _o.A = value ; }

}



public override string B

{

get { return _o.B; }

set { _o.B = value ; }

}

}



* This source code was highlighted with Source Code Highlighter .





private class StaticObject

{

public int A { get ; set ; }

public string B { get ; set ; }

}



private class StaticObjectTester : ObjectTester

{

private readonly StaticObject _o = new StaticObject();



public override int A

{

get { return _o.A; }

set { _o.A = value ; }

}



public override string B

{

get { return _o.B; }

set { _o.B = value ; }

}

}



* This source code was highlighted with Source Code Highlighter .





परिणाम: 00: 00: 06.6274538 (+ 0.00%)



पेशेवरों:

- जितनी जल्दी हो सके

विपक्ष

- गतिशील रूप से नहीं

परावर्तन (परावर्तन, आरटीटीआई, आत्मनिरीक्षण)

मुझे लगता है कि यह पहला तरीका है जो आपके दिमाग में आता है जब आपको डायनेमिक कॉल की आवश्यकता होती है।



जितना संभव हो उतना तेज करने के लिए, मैंने स्थैतिक कैशिंग संपत्तिइन्फो का उपयोग किया। आमतौर पर वास्तविक परियोजनाओं में प्रतिबिंब के लिए आवश्यक जानकारी को किसी तरह कैश करने का अवसर होता है।



चूंकि हम परावर्तन की गति में रुचि रखते हैं, इसलिए हम डेटा को संग्रहीत करने के लिए दो गुणों के साथ एक तैयार वर्ग का उपयोग करेंगे।



टेस्ट ऑब्जेक्ट कोड:

private class ReflectionObjectTester : ObjectTester

{

private static readonly PropertyInfo PropertyA = typeof (StaticObject).GetProperty( "A" );

private static readonly PropertyInfo PropertyB = typeof (StaticObject).GetProperty( "B" );

private static readonly object [] Empty = new object [0];

private readonly Object _o = new StaticObject();



public override int A

{

get { return ( int ) PropertyA.GetValue(_o, Empty); }

set { PropertyA.SetValue(_o, value , Empty); }

}



public override string B

{

get { return ( string ) PropertyB.GetValue(_o, Empty); }

set { PropertyB.SetValue(_o, value , Empty); }

}

}



* This source code was highlighted with Source Code Highlighter .







private class ReflectionObjectTester : ObjectTester

{

private static readonly PropertyInfo PropertyA = typeof (StaticObject).GetProperty( "A" );

private static readonly PropertyInfo PropertyB = typeof (StaticObject).GetProperty( "B" );

private static readonly object [] Empty = new object [0];

private readonly Object _o = new StaticObject();



public override int A

{

get { return ( int ) PropertyA.GetValue(_o, Empty); }

set { PropertyA.SetValue(_o, value , Empty); }

}



public override string B

{

get { return ( string ) PropertyB.GetValue(_o, Empty); }

set { PropertyB.SetValue(_o, value , Empty); }

}

}



* This source code was highlighted with Source Code Highlighter .







private class ReflectionObjectTester : ObjectTester

{

private static readonly PropertyInfo PropertyA = typeof (StaticObject).GetProperty( "A" );

private static readonly PropertyInfo PropertyB = typeof (StaticObject).GetProperty( "B" );

private static readonly object [] Empty = new object [0];

private readonly Object _o = new StaticObject();



public override int A

{

get { return ( int ) PropertyA.GetValue(_o, Empty); }

set { PropertyA.SetValue(_o, value , Empty); }

}



public override string B

{

get { return ( string ) PropertyB.GetValue(_o, Empty); }

set { PropertyB.SetValue(_o, value , Empty); }

}

}



* This source code was highlighted with Source Code Highlighter .













परिणाम : 00: 01: 32.3217880 (+ 1293.02%)



वास्तव में, प्रतिबिंब के उपयोग ने निष्पादन समय को लगभग 13 गुना बढ़ा दिया है! इस पद्धति का उपयोग करने से पहले सोचने का एक अच्छा तरीका।



पेशेवरों:

- पूरी तरह से समय चलाने

विपक्ष:

- बहुत लंबा

- अधिकारों की आवश्यकता के कारण समस्याएं उत्पन्न हो सकती हैं "परावर्तन विचलन"

मूल्यों का शब्दकोश

विधि का अर्थ केवल एक शब्दकोश में मूल्यों को संग्रहीत करना है (शब्दकोश <TKey, TValue>)। कुंजी के रूप में, हम फ़ील्ड का नाम लेते हैं, मान के रूप में - फ़ील्ड का मान। आपको एक मान प्रकार के रूप में ऑब्जेक्ट का उपयोग करना होगा।



कोड:

private class DictionaryObjectTester : ObjectTester

{

private const string AName = "A" ;

private const string BName = "B" ;

private readonly Dictionary< string , Object> _o = new Dictionary< string , object >();



public override int A

{

get { return ( int ) _o[AName]; }

set { _o[AName] = value ; }

}



public override string B

{

get { return ( string ) _o[BName]; }

set { _o[BName] = value ; }

}

}



* This source code was highlighted with Source Code Highlighter .





private class DictionaryObjectTester : ObjectTester

{

private const string AName = "A" ;

private const string BName = "B" ;

private readonly Dictionary< string , Object> _o = new Dictionary< string , object >();



public override int A

{

get { return ( int ) _o[AName]; }

set { _o[AName] = value ; }

}



public override string B

{

get { return ( string ) _o[BName]; }

set { _o[BName] = value ; }

}

}



* This source code was highlighted with Source Code Highlighter .





परिणाम: 00: 00: 10.8516518 (+ 63.64%)



पेशेवरों:

- बहुत गतिशील: आप जोड़ और हटा सकते हैं

विपक्ष:

- मूल्यों की कमजोर टाइपिंग (वस्तु)

- केवल मूल्य, विधियां नहीं

प्रतिनिधि शब्दकोश

व्यवहार में, थोड़ा अधिक जटिल संस्करण अक्सर उपयोग किया जाता है - हम मूल्यों को संग्रहीत नहीं करते हैं, लेकिन इन मूल्यों को प्राप्त करने के तरीके। या सिर्फ कार्यों / कार्यों के कुछ गतिशील सेट।



कार्यान्वयन:

private class DictionaryDelegateTester : ObjectTester

{

private const string AName = "A" ;

private const string BName = "B" ;



private readonly Dictionary< string , Func<Object>> _getters;

private readonly Dictionary< string , Action<Object>> _setters;



private readonly StaticObject _o = new StaticObject();



public DictionaryDelegateTester()

{

_getters = new Dictionary< string , Func<Object>>

{

{AName, () => _o.A},

{BName, () => _o.B}

};

_setters = new Dictionary< string , Action< object >>

{

{AName, v => _o.A = ( int ) v},

{BName, v => _o.B = v.ToString()},

};

}



public override int A

{

get { return ( int ) _getters[AName](); }

set { _setters[AName]( value ); }

}



public override string B

{

get { return ( string ) _getters[BName](); }

set { _setters[BName]( value ); }

}

}



* This source code was highlighted with Source Code Highlighter .





private class DictionaryDelegateTester : ObjectTester

{

private const string AName = "A" ;

private const string BName = "B" ;



private readonly Dictionary< string , Func<Object>> _getters;

private readonly Dictionary< string , Action<Object>> _setters;



private readonly StaticObject _o = new StaticObject();



public DictionaryDelegateTester()

{

_getters = new Dictionary< string , Func<Object>>

{

{AName, () => _o.A},

{BName, () => _o.B}

};

_setters = new Dictionary< string , Action< object >>

{

{AName, v => _o.A = ( int ) v},

{BName, v => _o.B = v.ToString()},

};

}



public override int A

{

get { return ( int ) _getters[AName](); }

set { _setters[AName]( value ); }

}



public override string B

{

get { return ( string ) _getters[BName](); }

set { _setters[BName]( value ); }

}

}



* This source code was highlighted with Source Code Highlighter .





परिणाम: 00: 00: 12.3299023 (+ 85.93%)



पेशेवरों:

- बहुत गतिशील: आप जोड़ और हटा सकते हैं

विपक्ष:

- जटिल वाक्यविन्यास

एक स्थिर कंटेनर के साथ गतिशील वस्तु

खैर, यहाँ हम उस नए प्रकार के 'गतिशील' पर जाते हैं। उसके लिए, मैं तुरंत तीन तरीकों को लागू करूंगा। पहला यह है कि जब हम गतिशील के लिए एक ही स्थिर प्रकार को "समर्थित ऑब्जेक्ट" के रूप में संग्रहीत करते हैं:



private class DynamicObjectTester : ObjectTester

{

private readonly dynamic _o = new StaticObject();



public override int A

{

get { return _o.A; }

set { _o.A = value ; }

}



public override string B

{

get { return _o.B; }

set { _o.B = value ; }

}

}



* This source code was highlighted with Source Code Highlighter .





private class DynamicObjectTester : ObjectTester

{

private readonly dynamic _o = new StaticObject();



public override int A

{

get { return _o.A; }

set { _o.A = value ; }

}



public override string B

{

get { return _o.B; }

set { _o.B = value ; }

}

}



* This source code was highlighted with Source Code Highlighter .





परिणाम: 00: 00: 10.7193446 (+ 61.65%)



पेशेवरों:

- DLR (एफ #) में प्रेषित किया जा सकता है

- सरल वाक्यविन्यास

विपक्ष:

- और अभी तक डेढ़ गुना लंबा है

एक्सपेंडेओ के साथ डायनामिक ऑब्जेक्ट

दरअसल, गतिशील का उपयोग करने के लिए इसे और अधिक सुविधाजनक बनाने के लिए, हमने एक्सपेंडेओबजेक्ट प्रकार को जोड़ा। इसमें बहुत सी अच्छी छोटी चीजें हैं - यह दोनों IDEDIA और IEnumerable है।



का उपयोग करें:

private class ExpandoDynamicObjectTester : ObjectTester

{

private readonly dynamic _o = new ExpandoObject();



public override int A

{

get { return _o.A; }

set { _o.A = value ; }

}



public override string B

{

get { return _o.B; }

set { _o.B = value ; }

}

}



* This source code was highlighted with Source Code Highlighter .





private class ExpandoDynamicObjectTester : ObjectTester

{

private readonly dynamic _o = new ExpandoObject();



public override int A

{

get { return _o.A; }

set { _o.A = value ; }

}



public override string B

{

get { return _o.B; }

set { _o.B = value ; }

}

}



* This source code was highlighted with Source Code Highlighter .





परिणाम: 00: 00: 09.7034082 (+ 46.33%)



पेशेवरों:

- DLR (एफ #) में प्रेषित किया जा सकता है

- सरल वाक्यविन्यास और अतिरिक्त सुविधाएँ (गणना)

विपक्ष:

- गति में वृद्धि को छोड़कर व्यावहारिक रूप से अनुपस्थित

पिक पिक डायनेमिक ऑब्जेक्ट

डायनेमिक की एक और अच्छी विशेषता यह है कि कॉल करने के तरीकों और गुणों को रोकने की क्षमता है। हम उपयोग करेंगे:

private class PureDynamicObjectTester : ObjectTester

{

private readonly dynamic _o = new DynamicContainer();



public override int A

{

get { return _o.A; }

set { _o.A = value ; }

}



public override string B

{

get { return _o.B; }

set { _o.B = value ; }

}



#region Nested type: DynamicContainer



private class DynamicContainer : DynamicObject

{

private int _a;

private string _b;



public override bool TryGetMember(GetMemberBinder binder, out object result)

{

if (binder.Name == "A" )

{

result = _a;

return true ;

}

if (binder.Name == "B" )

{

result = _b;

return true ;

}

return base .TryGetMember(binder, out result);

}



public override bool TrySetMember(SetMemberBinder binder, object value )

{

if (binder.Name == "A" )

{

_a = ( int ) value ;

return true ;

}

if (binder.Name == "B" )

{

_b = ( string ) value ;

return true ;

}

return base .TrySetMember(binder, value );

}

}



#endregion

}



* This source code was highlighted with Source Code Highlighter .





private class PureDynamicObjectTester : ObjectTester

{

private readonly dynamic _o = new DynamicContainer();



public override int A

{

get { return _o.A; }

set { _o.A = value ; }

}



public override string B

{

get { return _o.B; }

set { _o.B = value ; }

}



#region Nested type: DynamicContainer



private class DynamicContainer : DynamicObject

{

private int _a;

private string _b;



public override bool TryGetMember(GetMemberBinder binder, out object result)

{

if (binder.Name == "A" )

{

result = _a;

return true ;

}

if (binder.Name == "B" )

{

result = _b;

return true ;

}

return base .TryGetMember(binder, out result);

}



public override bool TrySetMember(SetMemberBinder binder, object value )

{

if (binder.Name == "A" )

{

_a = ( int ) value ;

return true ;

}

if (binder.Name == "B" )

{

_b = ( string ) value ;

return true ;

}

return base .TrySetMember(binder, value );

}

}



#endregion

}



* This source code was highlighted with Source Code Highlighter .





थोड़ी देर बाहर निकले।



परिणाम: 00: 00: 11.1040041 (+ 67.45%)



पेशेवरों:

- DLR (एफ #) में प्रेषित किया जा सकता है

- गुण भी मौजूद नहीं हो सकते हैं

विपक्ष:

- काफी अधिक कोड की आवश्यकता है

संकलित अभिव्यक्तियाँ

यह विधि डायनेमिक का उपयोग नहीं करती है (हालाँकि इसे डायनेमिकऑब्जेक्ट में लपेटना काफी आसान है), और रिफ्लेक्शन का उपयोग करते हुए विधि के सबसे करीब है। वास्तव में, वह प्रतिबिंब का उपयोग करता है, लेकिन केवल एक अभिव्यक्ति पेड़ बनाने और उसे संकलित करने के लिए।



वास्तव में, आईएल-कोड का "उत्सर्जन"। नतीजतन, हमें बस गति में भारी वृद्धि मिलती है।



मैंने इसे लागू किया: मैंने वास्तविक गेटटर और सेटर प्राप्त करने के लिए प्रॉपर्टीइन्फो पर दो विस्तार विधियाँ कीं, लेकिन मेथेमाइन्फो के रूप में सामान्य प्रतिबिंब के लिए नहीं, बल्कि फंक (गटर) और एक्शन (सेटर) के रूप में। वास्तव में, मेरा गेटटर कुछ ऐसा दिखता है जैसे " o => ((T)o).{name}



" और सेटर " (o, v) => ((T)o).{name} = v



" जैसा दिखता है।



इन सहायक तरीकों को पढ़ने के लिए सरल छोड़ने के लिए, मैंने प्रत्येक अभिव्यक्ति नोड को अलग-अलग चर में रखा:

public static Func< object , T> GetValueGetter<T>( this PropertyInfo propertyInfo)

{

var instance = Expression.Parameter( typeof (Object), "i" );

var castedInstance = Expression.ConvertChecked(instance, propertyInfo.DeclaringType);

var property = Expression.Property(castedInstance, propertyInfo);

var convert = Expression. Convert (property, typeof (T));

var expression = Expression.Lambda(convert, instance);

return (Func< object , T>)expression.Compile();

}



public static Action< object ,T> GetValueSetter<T>( this PropertyInfo propertyInfo)

{

var instance = Expression.Parameter( typeof (Object), "i" );

var castedInstance = Expression.ConvertChecked(instance, propertyInfo.DeclaringType);

var argument = Expression.Parameter( typeof (T), "a" );

var setterCall = Expression.Call(

castedInstance,

propertyInfo.GetSetMethod(),

Expression. Convert (argument, propertyInfo.PropertyType));

return (Action< object ,T>)Expression.Lambda(setterCall, instance, argument)

.Compile();

}



* This source code was highlighted with Source Code Highlighter .





public static Func< object , T> GetValueGetter<T>( this PropertyInfo propertyInfo)

{

var instance = Expression.Parameter( typeof (Object), "i" );

var castedInstance = Expression.ConvertChecked(instance, propertyInfo.DeclaringType);

var property = Expression.Property(castedInstance, propertyInfo);

var convert = Expression. Convert (property, typeof (T));

var expression = Expression.Lambda(convert, instance);

return (Func< object , T>)expression.Compile();

}



public static Action< object ,T> GetValueSetter<T>( this PropertyInfo propertyInfo)

{

var instance = Expression.Parameter( typeof (Object), "i" );

var castedInstance = Expression.ConvertChecked(instance, propertyInfo.DeclaringType);

var argument = Expression.Parameter( typeof (T), "a" );

var setterCall = Expression.Call(

castedInstance,

propertyInfo.GetSetMethod(),

Expression. Convert (argument, propertyInfo.PropertyType));

return (Action< object ,T>)Expression.Lambda(setterCall, instance, argument)

.Compile();

}



* This source code was highlighted with Source Code Highlighter .





नतीजतन, परीक्षण वर्ग:

private class ExpressionObjectTester : ObjectTester

{

private static readonly Func< object , int > AGetter =

typeof (StaticObject).GetProperty( "A" ).GetValueGetter< int >();



private static readonly Func< object , string > BGetter =

typeof (StaticObject).GetProperty( "B" ).GetValueGetter< string >();



private static readonly Action< object , int > ASetter =

typeof (StaticObject).GetProperty( "A" ).GetValueSetter< int >();



private static readonly Action< object , string > BSetter =

typeof (StaticObject).GetProperty( "B" ).GetValueSetter< string >();



private readonly StaticObject _o = new StaticObject();



public override int A

{

get { return AGetter(_o); }

set { ASetter(_o, value ); }

}



public override string B

{

get { return BGetter(_o); }

set { BSetter(_o, value ); }

}

}



* This source code was highlighted with Source Code Highlighter .





private class ExpressionObjectTester : ObjectTester

{

private static readonly Func< object , int > AGetter =

typeof (StaticObject).GetProperty( "A" ).GetValueGetter< int >();



private static readonly Func< object , string > BGetter =

typeof (StaticObject).GetProperty( "B" ).GetValueGetter< string >();



private static readonly Action< object , int > ASetter =

typeof (StaticObject).GetProperty( "A" ).GetValueSetter< int >();



private static readonly Action< object , string > BSetter =

typeof (StaticObject).GetProperty( "B" ).GetValueSetter< string >();



private readonly StaticObject _o = new StaticObject();



public override int A

{

get { return AGetter(_o); }

set { ASetter(_o, value ); }

}



public override string B

{

get { return BGetter(_o); }

set { BSetter(_o, value ); }

}

}



* This source code was highlighted with Source Code Highlighter .





परिणाम : 00: 00: 08.5675928 (+ 29.20%)



पेशेवरों:

- अद्भुत गति

विपक्ष

- थोड़ा जटिल कार्यान्वयन

धुरी तालिका और निष्कर्ष

विधि का नाम	समय	समय जोड़
प्रतिबिंब	00: 01: 33.6077139	1311.59%
मूल्यों का शब्दकोश	00: 00: 10.8516518	63.64%
प्रतिनिधि शब्दकोश	00: 00: 12.3299023	85.93%
एक स्थिर कंटेनर के साथ गतिशील वस्तु	00: 00: 10.7193446	61.65%
एक्सपैंडो के साथ डायनामिक ऑब्जेक्ट	00: 00: 09.7034082	46.33%
पिक पिक डायनेमिक ऑब्जेक्ट	00: 00: 11.1040041	67.45%
संकलित अभिव्यक्तियाँ	00: 00: 08.5675928	29.20%

निष्कर्ष बहुत सरल हैं:

- अगर आपको गति की आवश्यकता है - एक्सप्रेशन का उपयोग करें। यदि आप थोड़ा खोदते हैं तो वे इतने डरावने नहीं हैं, लेकिन पारंपरिक प्रतिबिंब की तुलना में वे केवल आश्चर्यजनक परिणाम देते हैं (हालांकि अगर गतिशील के साथ भी, यह औसत पर लगभग दो गुना तेज है)

- यदि आपको गतिशील वस्तुओं (उदाहरण के लिए, DLR - F #, IronRuby के साथ संयोजन में) का उपयोग करने की आवश्यकता है, तो एक्सपेंडीओबजेक्ट का उपयोग करना बेहतर है। यह उत्कृष्ट परिणाम देता है।

- .NET में डायनामिक s का कार्यान्वयन डिक्शनरी के साथ तुलना करने पर भी काफी प्रभावी है



लेकिन सबसे महत्वपूर्ण बात: डायनामिक कॉल्स का प्रयोग वहीं करें जहाँ उनकी वास्तव में जरूरत हो !



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



मत भूलो - गतिशील प्रकार व्यावहारिक रूप से रिफैक्टिंग की संभावना, संकलन चरण में त्रुटियों को पकड़ने की संभावना और प्रभावी अनुकूलन की संभावना को नकारते हैं।



मुझे उम्मीद है कि यह लेख उन लोगों की मदद करेगा जो भाषा की गतिशील क्षमताओं का लाभ उठाने के लिए सोचते हैं - या तो सही तरीका चुनें या इसका उपयोग न करने का निर्णय लें।



क्लोनिंग या देखने के लिए कोड Google कोड पर उपलब्ध है ।