.NET प्रोग्राम में अप्रबंधित C ++ कोड का फिर से उपयोग करना

लगभग एक साल पहले मैंने एक लेख लिखा था कि कैसे आप COM पुस्तकालयों, सी ++ / सीएलआई, आदि को पंजीकृत किए बिना किसी भी .NET प्रोग्राम से शुद्ध C ++ में लिखी कक्षाओं के तरीकों को कॉल कर सकते हैं।

आज मैं एक और मूल और बहुत सुविधाजनक दृष्टिकोण के बारे में बात करूँगा, और, इसके अलावा, यह विषय उन सभी हेब्रटिकी के लिए दिलचस्पी का होगा जो अद्भुत उपकरण प्रतिबिंब के बारे में अधिक जानना चाहते हैं। प्रवेश (मेरी राय में यह विषय हब पर अच्छी तरह से कवर नहीं किया गया है)।


एक उदाहरण के रूप में, चलो C ++ कक्षाओं के एक जोड़े और एक परीक्षण फॉर्म के साथ एक ही पुराना आवेदन लेते हैं।

तो चलिए शुरू करते हैं। सबसे पहले, आइए पुराने उदाहरण को लें और COM से संबंधित सभी कचरे को एक या दूसरे तरीके से हटा दें। इसके अलावा, हम HRESULTs, GUID, और अन्य बुरी आत्माओं को हटाएंगे, जिनके साथ और बिना, चारों ओर लौट रहे हैं। कोड तुरंत लगभग आधा हो गया :) जितना हो सके, इसके बजाय, एक डिस्पोज़ विधि जोड़ें, जो ऑब्जेक्ट को मुक्त कर देगा।

तो, हमारा सबसे सरल C ++ वर्ग अब इस तरह दिखता है:

class CHello
{
public :
LIBCALL Dispose()
{
delete this ;
}

LIBCALL SetName(LPWSTR AName)
{
mName = AName;
}

LIBCALL Say(HWND AParent)
{
wstring message = L "Hello, my friend " + mName;
MessageBox(AParent, message.c_str(), L "From C++" , MB_ICONINFORMATION);
}

private :
wstring mName;
};


यहाँ LIBCALL == वर्चुअल शून्य __stdcall

चलो C # भाग पर चलते हैं। पहली चीज़ जो हमें करने की ज़रूरत है, वह एक इंटरफ़ेस घोषित करना है जो निर्यात की गई C ++ वर्ग का वर्णन करता है (यह घोषित करने के क्रम को बनाए रखने के लिए महत्वपूर्ण है):

[InvokerObject(EObjectType.Hello)]
public interface IHello : IDisposable
{
void SetName([MarshalAs(UnmanagedType.LPWStr)] string AName);
void Say( IntPtr AParent);
}


आप देख सकते हैं कि इंटरफ़ेस को आईडीसॉरोपी से विरासत में मिला है, इसलिए ऑब्जेक्ट की पहली विधि, वास्तव में, डिस्पोज़ विधि होगी। InvokerObject विशेषता के बारे में मैं आपको और बताऊंगा।

अब, एक C # प्रोग्राम में हमारी C ++ ऑब्जेक्ट का उपयोग करने के लिए, बस लिखें :

IHello hello = Invoker.Create<IHello>();
hello.SetName(txtName.Text);
hello.Say(Handle);


कोड से परे

अब, हम सबसे दिलचस्प पर आगे बढ़ सकते हैं - यह सब अंदर से कैसे काम करता है। हमारे कार्यक्रम का नायक आज CIL opcode Calli है । यह ऑपकोड आपको दिए गए तर्कों के साथ एक मनमाने मशीन पते पर एक फ़ंक्शन को कॉल करने की अनुमति देता है। यह उस पर है कि हमारे चिलमन का पूरा काम बनाया जाएगा।

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

इनवॉकर वर्ग एल्गोरिथ्म इस प्रकार है:

1. एक डायनामिक असेंबली बनाएँ ( AppDomain.CurrentDomain.DefineDynamicAssembly )
2. इस असेंबली में हम निर्दिष्ट इंटरफ़ेस से विरासत में मिला एक वर्ग बनाते हैं
3. हम उस क्लास में एक कंस्ट्रक्टर बनाते हैं, जो अनमैन्ड क्लास को एक इंटप्राटर पॉइंटर स्वीकार करता है और, इंटरफेस में विधियों की संख्या के अनुसार, वर्चुअल मेथड टेबल से फंक्शन एड्रेस की आवश्यक संख्या पढ़ता है।
4. हम इंटरफ़ेस में सभी विधियों के आसपास जाते हैं
5. प्रत्येक विधि के लिए, हम अपने स्वयं के फ़ंक्शन का निर्माण करते हैं जो कि वांछित तर्क देता है और कैली का उपयोग करके C ++ वर्ग की अंतिम विधि को कॉल करता है

सार को समझने के लिए हैराचिट्री को आसान बनाने के लिए, मैं इस वर्ग (चरण 2 और 3) बनाने के कार्य के लिए टिप्पणी कोड देता हूं:

// (+1 .. Dispose)
int k = InterfaceType.GetMethods().Count() + 1;

// unmanaged
typeBuilder = InvokerDynamicAssembly.Instance.Builder.DefineType(TypeName, TypeAttributes.Class | TypeAttributes.Public);
//
typeBuilder.AddInterfaceImplementation(InterfaceType);

//
ptrThis = typeBuilder.DefineField( "ptr" , typeof ( IntPtr ), FieldAttributes.Private);
methods = typeBuilder.DefineField( "methods" , typeof ( IntPtr []), FieldAttributes.Private);
vtbl = typeBuilder.DefineField( "vtbl" , typeof ( IntPtr ), FieldAttributes.Private);

// , VTBL unmanaged
ConstructorBuilder constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[] { typeof (System. IntPtr ) });
constructorBuilder.DefineParameter(1, ParameterAttributes.In, "Pointer" );
ILGenerator ctorGen = constructorBuilder.GetILGenerator();

//
ctorGen.Emit(OpCodes.Ldarg_0);
ctorGen.Emit(OpCodes.Call, ObjectCtorInfo);

// ptrThis
ctorGen.Emit(OpCodes.Ldarg_0);
ctorGen.Emit(OpCodes.Ldarg_1);
ctorGen.Emit(OpCodes.Stfld, ptrThis);

//
ctorGen.Emit(OpCodes.Ldarg_0);
ctorGen.Emit(OpCodes.Ldarg_1);
ctorGen.Emit(OpCodes.Call, ReadIntPtr); // Marshal.ReadIntPtr
ctorGen.Emit(OpCodes.Stfld, vtbl);

ctorGen.Emit(OpCodes.Ldarg_0);
ctorGen.Emit(OpCodes.Ldc_I4_S, k);
ctorGen.Emit(OpCodes.Newarr, typeof ( IntPtr ));
ctorGen.Emit(OpCodes.Stfld, methods);

//
for ( int i = 0; i < k; i++)
{
ctorGen.Emit(OpCodes.Ldarg_0);
ctorGen.Emit(OpCodes.Ldfld, methods);
ctorGen.Emit(OpCodes.Ldc_I4_S, i);

ctorGen.Emit(OpCodes.Ldarg_0);
ctorGen.Emit(OpCodes.Ldfld, vtbl);
ctorGen.Emit(OpCodes.Ldc_I4, i * IntPtr .Size);
ctorGen.Emit(OpCodes.Add);
ctorGen.Emit(OpCodes.Call, ReadIntPtr);

ctorGen.Emit(OpCodes.Stelem, typeof ( IntPtr ));
}

//
ctorGen.Emit(OpCodes.Ret);

//
AddMethods();

createdType = typeBuilder.CreateType();


अब बात करते हैं InvokerObjectAttribute की। इनवॉकर श्रेणी की सबसे महत्वपूर्ण विशेषता:

/// <summary>
///
/// </summary>
/// <returns> </returns>
public static T Create<T>()
where T : class , IDisposable
{
object [] attr = typeof (T).GetCustomAttributes( true );
foreach ( var it in attr)
{
if (it is InvokerObjectAttribute)
{
var objectType = (it as InvokerObjectAttribute).ObjectType;

Invoker inv = new Invoker();
inv.InterfaceType = typeof (T);
inv.Pointer = Lib.CreateObject(objectType);
inv.InitializeType();
return inv.CreateInstance() as T;
}
}
return null ;
}

यहां हम InvokerObjectAttribute का उपयोग यह जानने के लिए करते हैं कि हमें किस ऑब्जेक्ट को बनाने की आवश्यकता है, और P \ Invoke Lib कॉल का उपयोग करके। CreateObject हम C ++ लाइब्रेरी को वांछित प्रकार की एक नई अप्रबंधित वस्तु बनाने और हमें पॉइंटर वापस करने के लिए कहते हैं।

क्या विशेष रूप से दिलचस्प है, हम केवल इंटरफ़ेस के लिए पहली पहुंच में एक गतिशील विधानसभा के अंदर एक नए प्रकार की घोषणा कर सकते हैं, और बाद में एक मौजूदा का उपयोग करते हैं, इसे एक नया पॉइंटर पास करते हैं। यह इस तरह से कुछ काम करता है:

private void InitializeType()
{
if (InvokerDynamicAssembly.Instance.HasType(TypeName))
createdType = InvokerDynamicAssembly.Instance.GetType(TypeName);
else
CreateType();
}


जाहिर है, इनवोकर का मुख्य कार्य उन तरीकों का निर्माण करना है जो अप्रबंधित कार्यों की कॉल को लपेटते हैं। इस विधि के लिए रैपर ऐसा दिखता है:

.method public hidebysig virtual
instance void Say (
native int ''
) cil managed
{
// Method begins at RVA 0x2164
// Code size 29 (0x1d)
.maxstack 4

IL_0000: ldarg.0
IL_0001: ldfld native int InvokerDynamicAssembly.net2c.IHello::ptr
IL_0006: ldarg.1
IL_0007: ldarg.0
IL_0008: ldfld native int [] InvokerDynamicAssembly.net2c.IHello::methods
IL_000d: ldc.i4.s 2
IL_000f: nop
IL_0010: nop
IL_0011: nop
IL_0012: ldelem.any [mscorlib]System. IntPtr
IL_0017: calli System.Void(System. IntPtr ,System. IntPtr )
IL_001c: ret
}

जैसा कि आप देख सकते हैं, यह सिर्फ इनपुट के लिए दिए गए तर्कों को लेता है और उनके साथ अप्रबंधित वस्तु की आभासी विधि को कॉल करता है।

दृष्टिकोण के लाभ

1. COM इंटरॉप से ​​लगभग 1.6 गुना तेजी से काम करता है। मैंने सी ++ / सीएलआई के साथ तुलना नहीं की, जो लोग चाहते हैं वे परीक्षण और सदस्यता समाप्त कर सकते हैं।

2. MTA \ STA से अनलिंक करना। COM इंटरोप को थ्रेड एपार्टमेंट स्टेट के लिए सख्त पालन की आवश्यकता होती है, हालांकि, प्रोग्रामर की मदद करने के बजाय बहुत बार (मेरी स्मृति में लगभग हमेशा), यह सी # में ऑब्जेक्ट्स के साथ काम करने में कई अनावश्यक कठिनाइयों का निर्माण करता है। यह विधि पूरी तरह से इस दोष से रहित है, क्योंकि वह किसी भी धारा को बांधने के लिए नहीं करता है।

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

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

PS यदि आप C # में प्रोग्राम करते हैं, लेकिन अभी भी केवल IL से परिचित हैं, तो मैं इस विषय पर एक अच्छा संक्षिप्त परिचय पढ़ने की सलाह देता हूं: www.wasm.ru/series.php?sid=22

पीपीएस हां, मैं लगभग भूल गया, जैसा कि मैंने वादा किया था, मैं इस सभी अपमान का पूरा स्रोत संलग्न कर रहा हूं : public.66bit.ru/files/2011.10.07/7458c3ca96a60a912020fe049117974fx4/Net2C.rar