मैं सी # का उपयोग कर गतिशील विधि और इसके व्यावहारिक उदाहरण सीखना चाहता हूं।
गतिशील विधि और प्रतिबिंब के बीच कोई संबंध है?
कृपया मेरी मदद करें।गतिशील विधि का व्यावहारिक उदाहरण?
उत्तर
आप डायनामिक मोड क्लास के माध्यम से एक विधि बना सकते हैं।
DynamicMethod squareIt = new DynamicMethod(
"SquareIt",
typeof(long),
methodArgs,
typeof(Example).Module);
ILGenerator il = squareIt.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Conv_I8);
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Mul);
il.Emit(OpCodes.Ret);
Fully commented example on MSDN
मैं नोट करना चाहिए कि इस पद्धति का उपयोग विकास बहुत धीमी गति से और बहुत उपयोगी नहीं है।
@VMAtm में गतिशील विधि की एक अवधारणा भी है .. मैंने डायनामिक मोड के कुछ लेख पढ़े थे, कहीं मैंने पाया कि वे तेज़ी से प्रतिबिंब हैं। गतिशील विधि भी वे कस्टम क्रमबद्धता और deserialization कोड लिखने की आवश्यकता को खत्म करते हैं। – Pankaj
मेरा मतलब है विकास की गति - यह कोड को बनाए रखने के लिए बहुत तेज़ और बहुत कठिन नहीं है। – VMAtm
ILGenerator - System.Reflection.Emit कुछ हद तक यह प्रतिबिंब और गतिशील विधियों के बीच एक संबंध है – VMAtm
हम गति प्रतिबिंब के लिए गतिशील तरीकों का उपयोग कर रहे हैं। यहां हमारे प्रतिबिंब अनुकूलक का कोड है। यह केवल 10% प्रत्यक्ष कॉल और 2000 गुना तेजी से कि प्रतिबिंब कॉल
public class ReflectionEmitPropertyAccessor
{
private readonly bool canRead;
private readonly bool canWrite;
private IPropertyAccessor emittedPropertyAccessor;
private readonly string propertyName;
private readonly Type propertyType;
private readonly Type targetType;
private Dictionary<Type,OpCode> typeOpCodes;
public ReflectionEmitPropertyAccessor(Type targetType, string property)
{
this.targetType = targetType;
propertyName = property;
var propertyInfo = targetType.GetProperty(property);
if (propertyInfo == null)
{
throw new ReflectionOptimizerException(string.Format("Property \"{0}\" is not found in type "+ "{1}.", property, targetType));
}
canRead = propertyInfo.CanRead;
canWrite = propertyInfo.CanWrite;
propertyType = propertyInfo.PropertyType;
}
public bool CanRead
{
get { return canRead; }
}
public bool CanWrite
{
get { return canWrite; }
}
public Type TargetType
{
get { return targetType; }
}
public Type PropertyType
{
get { return propertyType; }
}
#region IPropertyAccessor Members
public object Get(object target)
{
if (canRead)
{
if (emittedPropertyAccessor == null)
{
Init();
}
if (emittedPropertyAccessor != null) return emittedPropertyAccessor.Get(target);
}
else
{
throw new ReflectionOptimizerException(string.Format("У свойства \"{0}\" нет метода get.", propertyName));
}
throw new ReflectionOptimizerException("Fail initialize of " + GetType().FullName);
}
public void Set(object target, object value)
{
if (canWrite)
{
if (emittedPropertyAccessor == null)
{
Init();
}
if (emittedPropertyAccessor != null) emittedPropertyAccessor.Set(target, value);
}
else
{
throw new ReflectionOptimizerException(string.Format("Property \"{0}\" does not have method set.", propertyName));
}
throw new ReflectionOptimizerException("Fail initialize of " + GetType().FullName);
}
#endregion
private void Init()
{
InitTypeOpCodes();
var assembly = EmitAssembly();
emittedPropertyAccessor = assembly.CreateInstance("Property") as IPropertyAccessor;
if (emittedPropertyAccessor == null)
{
throw new ReflectionOptimizerException("Shit happense in PropertyAccessor.");
}
}
private void InitTypeOpCodes()
{
typeOpCodes = new Dictionary<Type, OpCode>
{
{typeof (sbyte), OpCodes.Ldind_I1},
{typeof (byte), OpCodes.Ldind_U1},
{typeof (char), OpCodes.Ldind_U2},
{typeof (short), OpCodes.Ldind_I2},
{typeof (ushort), OpCodes.Ldind_U2},
{typeof (int), OpCodes.Ldind_I4},
{typeof (uint), OpCodes.Ldind_U4},
{typeof (long), OpCodes.Ldind_I8},
{typeof (ulong), OpCodes.Ldind_I8},
{typeof (bool), OpCodes.Ldind_I1},
{typeof (double), OpCodes.Ldind_R8},
{typeof (float), OpCodes.Ldind_R4}
};
}
private Assembly EmitAssembly()
{
var assemblyName = new AssemblyName {Name = "PropertyAccessorAssembly"};
var newAssembly = Thread.GetDomain().DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
var newModule = newAssembly.DefineDynamicModule("Module");
var dynamicType = newModule.DefineType("Property", TypeAttributes.Public);
dynamicType.AddInterfaceImplementation(typeof(IPropertyAccessor));
dynamicType.DefineDefaultConstructor(MethodAttributes.Public);
var getParamTypes = new[] { typeof(object) };
var getReturnType = typeof(object);
var getMethod = dynamicType.DefineMethod("Get",
MethodAttributes.Public | MethodAttributes.Virtual,
getReturnType,
getParamTypes);
var getIL = getMethod.GetILGenerator();
var targetGetMethod = targetType.GetMethod("get_" + propertyName);
if (targetGetMethod != null)
{
getIL.DeclareLocal(typeof(object));
getIL.Emit(OpCodes.Ldarg_1); //Load the first argument
getIL.Emit(OpCodes.Castclass, targetType); //Cast to the source type
getIL.EmitCall(OpCodes.Call, targetGetMethod, null); //Get the property value
if (targetGetMethod.ReturnType.IsValueType)
{
getIL.Emit(OpCodes.Box, targetGetMethod.ReturnType); //Box
}
getIL.Emit(OpCodes.Stloc_0); //Store it
getIL.Emit(OpCodes.Ldloc_0);
}
else
{
getIL.ThrowException(typeof(MissingMethodException));
}
getIL.Emit(OpCodes.Ret);
var setParamTypes = new[] { typeof(object), typeof(object) };
const Type setReturnType = null;
var setMethod = dynamicType.DefineMethod("Set",
MethodAttributes.Public | MethodAttributes.Virtual,
setReturnType,
setParamTypes);
var setIL = setMethod.GetILGenerator();
var targetSetMethod = targetType.GetMethod("set_" + propertyName);
if (targetSetMethod != null)
{
Type paramType = targetSetMethod.GetParameters()[0].ParameterType;
setIL.DeclareLocal(paramType);
setIL.Emit(OpCodes.Ldarg_1); //Load the first argument //(target object)
setIL.Emit(OpCodes.Castclass, targetType); //Cast to the source type
setIL.Emit(OpCodes.Ldarg_2); //Load the second argument
//(value object)
if (paramType.IsValueType)
{
setIL.Emit(OpCodes.Unbox, paramType); //Unbox it
if (typeOpCodes.ContainsKey(paramType)) //and load
{
var load = typeOpCodes[paramType];
setIL.Emit(load);
}
else
{
setIL.Emit(OpCodes.Ldobj, paramType);
}
}
else
{
setIL.Emit(OpCodes.Castclass, paramType); //Cast class
}
setIL.EmitCall(OpCodes.Callvirt,targetSetMethod, null); //Set the property value
}
else
{
setIL.ThrowException(typeof(MissingMethodException));
}
setIL.Emit(OpCodes.Ret);
// Load the type
dynamicType.CreateType();
return newAssembly;
}
}
कार्यान्वयन विभिन्न स्रोतों से एकत्रित किया गया है और मुख्य इस CodeProject लेख है की तुलना में धीमी है।
धन्यवाद @@ सर्गेई मिरोडा ... अधिक जानकारी क्या गतिशील विधि और प्रतिबिंब – Pankaj
के बीच कोई संबंध है हां यह है। प्रतिबिंब। प्रवेश .net प्रतिबिंब का एक हिस्सा है। –
भी गतिशील विधि __only__ तरीका है यदि आप रनटाइम निर्माण कोड पर जाना चाहते हैं जिसे कचरा एकत्र किया जा सकता है। –
- 1. पॉलिमॉर्फिज्म का व्यावहारिक उदाहरण
- 2. लंबे कमजोर संदर्भ का कोई व्यावहारिक उदाहरण?
- 3. सी # 4.0 में "गतिशील" चर का व्यावहारिक उपयोग क्या है?
- 4. ईबीसी का उपयोग कर वास्तुकला का व्यावहारिक उदाहरण?
- 5. बूस्ट :: एमपीएल के व्यावहारिक उपयोग के उदाहरण?
- 6. LockSupport और AbstractQueuedSynchronizer का कोई व्यावहारिक उदाहरण उपयोग करते हैं?
- 7. रूबी गतिशील रूप से उदाहरण विधि को कैसे परिभाषित करें?
- 8. क्या स्ट्रिंग की टूस्ट्रिंग() विधि का कोई व्यावहारिक उद्देश्य है?
- 9. गतिशील_कास्ट का व्यावहारिक उपयोग?
- 10. इंटरफ़ेस ईवेंट का व्यावहारिक उपयोग
- 11. एक विश्वसनीय सेवा को अधिकृत करने के व्यावहारिक उदाहरण?
- 12. `stackalloc` कीवर्ड का व्यावहारिक उपयोग
- 13. उदाहरण विधि के साथ Func का उपयोग
- 14. कक्षा का एक उदाहरण लौटने जावा विधि
- 15. एक उदाहरण विधि
- 16. कॉल उदाहरण विधि
- 17. दायरे में उदाहरण विधि
- 18. फैक्टरी विधि सिंगलटन उदाहरण
- 19. एक उदाहरण विधि
- 20. मेथडेंटल क्लास के व्यावहारिक उपयोग?
- 21. फैक्टरी विधि पैटर्न के व्यावहारिक उपयोग क्या हैं?
- 22. घटना बुलबुले और कैप्चरिंग के सामान्य, व्यावहारिक उपयोग के उदाहरण?
- 23. अक्षम उदाहरण विधि चेतावनी
- 24. क्या कोई व्यावहारिक उदाहरण है कि उन्होंने .NET में विधि पैरामीटर पर विशेषताओं का उपयोग कैसे किया है?
- 25. अभिव्यक्ति पेड़ों का व्यावहारिक उपयोग
- 26. वस्तु # विधि और गतिशील प्रतिसाददाताओं
- 27. रेल: मॉडल उदाहरण विधि या सहायक विधि?
- 28. प्रदर्शन विस्तार विधि बनाम उदाहरण विधि
- 29. व्यावहारिक विश्वसनीयता
- 30. शामिल होना समझना() विधि उदाहरण
मुझे _dynamic method_ शब्द नहीं समझा जाता है। डेल्फी में गतिशील विधियां हैं, जिसके लिए सी # में कोई समानता नहीं है, और वहां एक प्रोग्रामिंग तकनीक है जिसे _dynamic प्रोग्रामिंग_ कहा जाता है। या आपका मतलब _virtual method_ है? मुझे लगता है, "रिफ्लेक्शन" से, आपका मतलब प्रतिबिंब है। –
कोई भी व्यक्ति सी # – Pankaj