Interop Marshalling

1. #pragma once
2. #ifndef For_Pch
3. #define For_Pch
4. 
   
5. #include "Windows.h"
6. #include "PathCch.h"
7. #include "strsafe.h"
8. #include "objbase.h"
9. #include "Combaseapi.h"
10. #include "oleauto.h"
11. #include "propvarutil.h"
12. #include "wtypes.h"
13. #include "stdio.h"
14. #include "ctime"
15. #include "exception"
16. #include "typeinfo"
17. #include "shlwapi.h"
18. #include "Psapi.h"
19. #include "stdexcept"
20. #include "stdarg.h"
21. #include "comdef.h"
22. #include <algorithm>
23. #include <vector>
24. #include <type_traits>
25. #include <concepts>
26. #include <atlbase.h>
27. #include <atlcom.h>
28. #include <memory>
29. 
    
30. #endif // !For_Pch

1. #pragma once
2. #include "For_Pch.h"
3. #ifdef _DEBUG
4. #  define My_Configuration Debug
5. #else
6. #  define My_Configuration Release
7. #endif
8. 
   
9. #define Stringizing_To_raw_string_w(arg) LR#arg
10. #define Stringizing_To_raw_string(arg)    R#arg
11. #define Add_Deliniter_w(str) Stringizing_To_raw_string_w( ***( ## str ## )*** )
12. #define Add_Deliniter(str)   Stringizing_To_raw_string(   ***( ## str ## )*** )
13. #define Expand_Macro_Parameter_definition3_w(A,B,C) Add_Deliniter_w( A ## B ## C )
14. #define Expand_Macro_Parameter_definition3(A,B,C) Add_Deliniter(     A ## B ## C )
15. #define Expand_Macro_Parameter_definition1_w(A)     Add_Deliniter_w(A)
16. #define Expand_Macro_Parameter_definition1(A)       Add_Deliniter(  A)
17. 
    
18. #define Server_Name_w(rr,Config_be_Expanded,ss) Expand_Macro_Parameter_definition3_w(rr,Config_be_Expanded,ss)
19. #define Server_Name(  rr,Config_be_Expanded,ss) Expand_Macro_Parameter_definition3(  rr,Config_be_Expanded,ss)
20. #define DLL_Name_w(rr,Config_be_Expanded,ss) Expand_Macro_Parameter_definition3_w(rr,Config_be_Expanded,ss)
21. #define DLL_Name(  rr,Config_be_Expanded,ss) Expand_Macro_Parameter_definition3(  rr,Config_be_Expanded,ss)
22. #define Raw_string_w(str)  Expand_Macro_Parameter_definition1_w(str)
23. #define Raw_string(str)    Expand_Macro_Parameter_definition1(str)
24. #define Lib_Name_inside(rr,Config_be_Expanded,ss) Expand_Macro_Parameter_definition3(rr,Config_be_Expanded,ss)
25. #define Lib_Name_outside(rr,Config_be_Expanded,ss) Expand_Macro_Parameter_definition3(rr,Config_be_Expanded,ss)
26. 
    
27. #pragma comment(lib,Lib_Name_outside(..\..\StaticLib_Marshalling\x64\,My_Configuration,\StaticLib_Marshalling))
28. #pragma comment(lib,"PathCch")
29. 
    
30. __interface ICreationInstance :IDispatch
31. {
32.     HRESULT Get_Interface3(
33.         _In_ PVOID AssemblyInfo_ptr,
34.         _COM_Outptr_ PVOID* ppvid);
35.     HRESULT GetDescription(
36.         _In_ BSTR description);
37.     HRESULT GetDescription2(
38.         _Out_ BSTR* description);
39.     HRESULT Get_Interface4(
40.         PVOID AssemblyInfo_ptr,
41.         VARIANT* ppVoid_object);
42. };
43. 
    
44. typedef void (*MyWriteLine)(const WCHAR* format, va_list);
45. 
    
46. struct TestParameter {
47.     MyWriteLine MyWriteLine;
48.     PVOID ptr_to_Interface;
49.     const WCHAR* PathRoot;
50. };
51. 
    
52. class ExportedData {
53.     MyWriteLine MyWriteLine;
54.     const WCHAR* start;
55.     va_list My_va_list;
56.     static inline ExportedData* ED_ptr = nullptr;
57. public:
58.     static ExportedData* const MySelf() { return ED_ptr; }
59.     void WriteLine(const WCHAR* format, ...) {
60.         va_start(My_va_list, format);
61.         MyWriteLine(format, My_va_list);
62.         va_end(My_va_list);
63.     }
64.     ExportedData(TestParameter* pTestParameter, const WCHAR* start) {
65.         MyWriteLine = pTestParameter->MyWriteLine;
66.         this->start = start;
67.         ED_ptr = this;
68.         WriteLine(L"====== Begin %s =======", start);
69.     }
70.     ~ExportedData() {
71.         WriteLine(L"====== End %s   =======", start);
72.         ED_ptr = nullptr;
73.     }
74. };
75. 
    
76. 
    
77. #define PAUSE system("pause");
78. #define HR_(Express,errorCode) \
79. try { My_Message((Express),(errorCode), __FILEW__, __LINE__, __FUNCTIONW__);} \
80. catch (const std::exception & ) { return errorCode ; }
81. #define RETURN(retVal) return My_RETURN(retVal, __FILEW__ , __LINE__ , __FUNCTIONW__);
82. 
    
83. 
    
84. template <class T> concept  Is_BSTR_v = std::is_convertible_v<T, BSTR>;
85. 
    
86. template <class T> concept  Is_LPCOLESTR_v = std::is_convertible_v<LPCOLESTR, T>;
87. 
    
88. template <typename T>
89. struct ServerInfo_Struct {
90.     T AssemblyPath;
91.     T TypeFullName;
92.     T CreationMethod;
93.     T CLSID;
94.     T IID;
95.     ServerInfo_Struct(T t1, T t2, T t3, T t4, T t5) :
96.         AssemblyPath(t1),
97.         TypeFullName(t2),
98.         CreationMethod(t3),
99.         CLSID(t4),
100.         IID(t5) {
101.     }
102.     ServerInfo_Struct& operator=(const ServerInfo_Struct&) = delete;
103.     ServerInfo_Struct(const ServerInfo_Struct&) = delete;
104. 
     
105.     ~ServerInfo_Struct() requires Is_BSTR_v<T> {
106.         if (0 == strcmp(typeid(T).name(), typeid(BSTR).name())) {
107.             printf("std::is_convertible_v< %s , %s >\n",
108.                 typeid(T).name(), typeid(BSTR).name());
109.         }
110.         else printf("===> Error:%s\n", typeid(T).name());
111. 
     
112.         ::SysFreeString((wchar_t*)AssemblyPath);
113.         ::SysFreeString((wchar_t*)TypeFullName);
114.         ::SysFreeString((wchar_t*)CreationMethod);
115.         ::SysFreeString((wchar_t*)CLSID);
116.         ::SysFreeString((wchar_t*)IID);
117.     }
118. 
     
119.     ~ServerInfo_Struct()requires Is_LPCOLESTR_v<T> {
120.         puts(typeid(T).name());
121.         if (0 == strcmp(typeid(LPCOLESTR).name(), typeid(T).name())) {
122.             printf("std::is_convertible_v< %s , %s >\n",
123.                 typeid(LPCOLESTR).name(), typeid(T).name());
124.         }
125.         else printf("===> Error:%s\n", typeid(T).name());
126.     }
127. };
128. const WCHAR* AddCurlyBracket(const WCHAR* uuid);
129. const WCHAR* ToFullPath(const WCHAR* pRoot, const WCHAR* relativePath);
130. void My_Message(HRESULT hr2, int errorCode, LPCWSTR file_, int Line_, const wchar_t* fn);
131. int My_RETURN(int retVal, LPCWSTR file_, int Line_, const wchar_t* fn);
132. 
     
133. int Get_ServerInterface4(TestParameter* ptr,
134.     ServerInfo_Struct<LPCOLESTR>& MyServerString, PVOID* pRetVal);
135. int Get_ServerInterface(TestParameter* ptr,
136.     ServerInfo_Struct<LPCOLESTR>& MyServerString, PVOID* pRetVal);
137. int SetErrorInfo_Chen(const WCHAR* Description, const WCHAR* source);
138. 
     

1. // StaticLib_Marshalling.cpp : Defines the functions for the static library.
2. //
3. 
   
4. #include "pch.h"
5. #include "framework.h"
6. #include "TestParameter.h"
7. 
   
8. const WCHAR* AddCurlyBracket(const WCHAR* uuid) {
9.     const size_t MAX_index = 5, Max_length = 40;
10.     static WCHAR TempUUID[MAX_index][Max_length + 3];
11.     static size_t index = 0;
12.     if (++index >= MAX_index)index = 0;
13.     WCHAR* const UUID_ = TempUUID[index];
14.     size_t size_uuid = wcsnlen_s(uuid, Max_length);
15.     wcsncpy_s(UUID_ + 1, Max_length, uuid, size_uuid);
16.     UUID_[0] = L'{';                   // '\u007b';
17.     UUID_[size_uuid + 1] = L'}';      //'\u007d';
18.     UUID_[size_uuid + 2] = L'\u0000';  // '\0';
19.     //wprintf(L"%s\n", UUID_);PAUSE
20.     return TempUUID[index];
21. }
22. const WCHAR* ToFullPath(const WCHAR* pRoot, const WCHAR* relativePath) {
23.     const size_t MAX_index = 5, Max_length = 4000;
24.     static WCHAR tempFullPath[MAX_index][Max_length];
25.     static size_t index = 0;
26.     if (++index >= MAX_index)index = 0;
27.     wcscpy_s<Max_length>(tempFullPath[index], pRoot);
28.     PathCchAppend(tempFullPath[index], Max_length, relativePath);
29.     return tempFullPath[index];
30. }
31. //==================================================
32. int Get_ServerInterface(TestParameter* ptr,
33.     ServerInfo_Struct<LPCOLESTR>& MyServerString, PVOID* pRetVal) {
34.     ServerInfo_Struct<BSTR> My_Server{
35.         SysAllocString(ToFullPath(ptr->PathRoot,MyServerString.AssemblyPath)),
36.         SysAllocString(MyServerString.TypeFullName),
37.         SysAllocString(MyServerString.CreationMethod),
38.         SysAllocString(MyServerString.CLSID),
39.         SysAllocString(MyServerString.IID)
40.     };
41.     ICreationInstance* Ptr_Creation_Instance;
42.     IUnknown* pIUnknown;
43.     IID myiid2;
44.     Ptr_Creation_Instance = (ICreationInstance*)ptr->ptr_to_Interface;
45.     HR_(Ptr_Creation_Instance->Get_Interface3(&My_Server, (PVOID*)&pIUnknown), 31)
46.         HR_(IIDFromString(AddCurlyBracket(My_Server.IID), &myiid2), 32)
47.         HR_(pIUnknown->QueryInterface(myiid2, pRetVal), 33)
48.         pIUnknown->Release();
49.     return 0;
50. }
51. 
    
52. int Get_ServerInterface4(TestParameter* ptr,
53.     ServerInfo_Struct<LPCOLESTR>& MyServerString, PVOID* pRetVal) {
54.     IUnknown* pIUnknown;
55.     IDispatch* pIDispatch;
56.     VARIANT Variant;
57.     IID myiid;
58.     ICreationInstance* pICreationInstance;
59.     ServerInfo_Struct<BSTR> My_Server{
60.         SysAllocString(ToFullPath(ptr->PathRoot,MyServerString.AssemblyPath)),
61.         SysAllocString(MyServerString.TypeFullName),
62.         SysAllocString(MyServerString.CreationMethod),
63.         SysAllocString(MyServerString.CLSID),
64.         SysAllocString(MyServerString.IID)
65.     };
66.     pICreationInstance = (ICreationInstance*)ptr->ptr_to_Interface;
67.     VariantInit(&Variant);
68.     HR_(pICreationInstance->Get_Interface4(&My_Server, &Variant), 31)
69.         HR_(IIDFromString(AddCurlyBracket(My_Server.IID), &myiid), 32)
70.         if (V_VT(&Variant) == VT_UNKNOWN) {
71.             pIUnknown = V_UNKNOWN(&Variant);
72.             HR_(pIUnknown->QueryInterface(myiid, pRetVal), 33)
73.                 HR_(pIUnknown->QueryInterface(IID_IDispatch, (void**)&pIDispatch), 34)
74.                 printf("V_VT(&Variant) == VT_UNKNOWN\n");
75.         }
76.         else if (V_VT(&Variant) == VT_DISPATCH) {
77.             pIDispatch = V_DISPATCH(&Variant);
78.             HR_(pIDispatch->QueryInterface(myiid, pRetVal), 35)
79.                 HR_(pIDispatch->QueryInterface(IID_IUnknown, (void**)&pIUnknown), 36)
80.                 printf("V_VT(&Variant) == VT_DISPATCH\n");
81.         }
82.         else {
83.             printf("V_VT(&_variant)= %d\n", V_VT(&Variant));
84.             RETURN(39);
85.         }
86.     printf("(pIUnknown  = %p)\n(pIDispatch = %p)\n(*pRetVal   = %p)\n",
87.         pIUnknown, pIDispatch, *pRetVal);
88.     printf("(%d)pIUnknown->Release()\n", pIUnknown->Release());
89.     printf("(%d)pIDispatch->Release()\n", pIDispatch->Release());
90.     PAUSE
91.         return 0;
92. }
93. void My_Message(HRESULT hr2, int errorCode, LPCWSTR file_, int Line_, const wchar_t* fn) {
94.     if (FAILED(hr2)) {
95.         IErrorInfo* pIErrorInfo = NULL;
96.         HRESULT hr = GetErrorInfo(0, &pIErrorInfo);
97.         _com_error hr_err(hr2);
98.         SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_BLUE | FOREGROUND_RED);
99.         printf(" %S\n Line=%i fn=%S\n", file_, Line_, fn);
100.         printf("hr=%x (%S)\n", unsigned(hr2), hr_err.ErrorMessage());
101.         if (SUCCEEDED(hr) && pIErrorInfo) {
102.             BSTR Description, source;
103.             pIErrorInfo->GetDescription(&Description);
104.             pIErrorInfo->GetSource(&source);
105.             printf("Description=%S\n", Description);
106.             printf("Source=%S\n", source);
107.             SysFreeString(Description); SysFreeString(source);
108.             pIErrorInfo->Release();
109.         }
110.         SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
111.             FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED);
112. 
     
113.         throw std::exception("Exception from procedure(My_Message)");
114.     }
115. }
116. int My_RETURN(int retVal, LPCWSTR file_, int Line_, const wchar_t* fn) {
117.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_BLUE);
118.     printf(" %S\n Line=%i fn=%S\n", file_, Line_, fn);
119.     printf("return value = %i\n", retVal);
120.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
121.         FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED);
122.     return retVal;
123. };
124. int SetErrorInfo_Chen(const WCHAR* Description,
125.     const WCHAR* source) {
126. 
     
127.     ICreateErrorInfo* pICreateErrorInfo;
128.     IErrorInfo* pIErrorInfo;
129.     HRESULT hr;
130.     hr = CreateErrorInfo(&pICreateErrorInfo);
131.     if (SUCCEEDED(hr)) {
132.         hr = pICreateErrorInfo->QueryInterface(IID_IErrorInfo, (void**)&pIErrorInfo);
133.         if (SUCCEEDED(hr)) {
134.             const  size_t size_MAX = 4000;
135.             size_t size;
136.             WCHAR* Tmp_Str = new WCHAR[size_MAX + 1];
137.             hr = StringCchLengthW(Description, size_MAX, &size);
138.             if (FAILED(hr) || size >= size_MAX)return -12;
139.             StringCchCopyW(Tmp_Str, size_MAX, Description);
140. 
     
141.             pICreateErrorInfo->SetDescription(Tmp_Str);
142. 
     
143.             hr = StringCchLengthW(source, size_MAX, &size);
144.             if (FAILED(hr) || size >= size_MAX)return -13;
145.             StringCchCopyW(Tmp_Str, size_MAX, source);
146.             pICreateErrorInfo->SetSource(Tmp_Str);
147.             delete[]Tmp_Str;
148.             SetErrorInfo(0, pIErrorInfo);
149.             pIErrorInfo->Release();
150.         }
151.         else return -1;
152.         pICreateErrorInfo->Release();
153.     }
154.     else return -2;
155.     return 0;
156. }
157. 
     

1. #include <iostream>
2. namespace Chen { int My_Console_Main(const wchar_t* comment); }
3. 
   
4. int main()
5. {
6.     std::cout << "Hello World!\n";
7.     return Chen::My_Console_Main(L"Startup project with =====> CPP");
8. }

1. #if defined(_M_X64) && defined(_WIN64) && defined(_CONSOLE) && \
2.     _MSVC_LANG >= 201703L 
3. 
   
4. #include "TestParameter.h"
5. #pragma comment(lib,Lib_Name_inside(..\x64\,My_Configuration,\Create_dotNET_Platform))
6. //#pragma comment(linker,Raw_string(/ENTRY:mainCRTStartup))
7. /*
8. #pragma comment(linker,"/LIBPATH:C:\Users\Networker")
9.  $(SolutionDir)= C:\Users\Networker\Desktop\CPP_Main_Test_Marshalling_Project\
10.  $(ProjectDir)=  C:\Users\Networker\Desktop\CPP_Main_Test_Marshalling_Project\CPP_Main_Test_Marshalling_Project\
11.  $(TargetDir)=   C:\Users\Networker\Desktop\CPP_Main_Test_Marshalling_Project\x64\Debug\
12.  $(USERPROFIL)=  C:\Users\Networker
13.  $(HOMEPATH)=      \Users\Networker
14.  %(AdditionalLibraryDirectories)
15. */
16. 
    
17. 
    
18. #define AfxLoadLibrary  LoadLibraryW
19. #define AfxFreeLibrary  FreeLibrary   
20. 
    
21. #define CreationInstance_clsid  OLESTR("91DD12FD-4DBD-4B83-AC40-439E3B6393A1")
22. #define CreationInstance_iid    OLESTR("85927839-0BB2-423B-97D6-89A2D4002519")
23. #define LeadingLibrary_clsid    OLESTR("2B6E5DB5-CF45-40B8-8091-55027E408231")
24. #define LeadingLibrary_IID      OLESTR("16142434-D1CF-4DC8-BD7B-7E5091058490")
25. 
    
26. namespace Chen {
27.     int My_Console_Main(const wchar_t* comment);
28. 
    
29.     LPCWSTR LeadingLibraryRelativePath = Server_Name_w(LeadingLibraryForLoadingDLL\LeadingLibraryForLoadingDLL\bin\x64\,
30.         My_Configuration, \net9.0\LeadingLibraryForLoadingDLL.dll);
31. 
    
32.     LPCWSTR MyDll_CSharp = DLL_Name_w(CPP_DLL_Test_CSharp_Server\x64\,
33.         My_Configuration, \CPP_DLL_Test_CSharp_Server.dll);
34. 
    
35.     LPCWSTR MyDllname2_dotNET = DLL_Name_w(CPP_Dll_Test_Marshalling_dotNET\x64\,
36.         My_Configuration, \CPP_Dll_Test_Marshalling_dotNET.dll);
37. 
    
38.     LPCWSTR MyDllname3_dotNET = DLL_Name_w(CPP_DLL_Test_Multi_Interface\x64\,
39.         My_Configuration, \CPP_DLL_Test_Multi_Interface.dll);
40. 
    
41. #ifdef _DEBUG
42.     LPCWSTR MyDllname =
43.         Raw_string_w(MFC_DLL_Test_Marshalling\x64\Debug\MFCDLLTestMarshalling.dll);
44. 
    
45.     LPCWSTR MyDllname2 =
46.         Raw_string_w(CPP_Dll_Test_Marshalling\x64\Debug\CPP_Dll_Test_Marshalling.dll);
47. 
    
48. #else
49.     LPCWSTR MyDllname =
50.         L"MFC_DLL_Test_Marshalling\\x64\\Release\\MFCDLLTestMarshalling.dll";
51. 
    
52.     LPCWSTR MyDllname2 =
53.         L"CPP_Dll_Test_Marshalling\\x64\\Release\\CPP_Dll_Test_Marshalling.dll";
54. 
    
55. #endif // DEBUG
56. 
    
57.     typedef struct {
58.         LPCWSTR DLL_Path;
59.         LPCSTR ProcName;
60.         BOOL   MFC_DLL;
61.         HMODULE hModule;
62.     } ClientInfo_Struct;
63. 
    
64.     ClientInfo_Struct ClientInfo_dotNET[]{
65.        {
66.            MyDll_CSharp,
67.            "CPP_DLL_Test_CSharp_Server",
68.            false
69.        },{
70.            MyDllname3_dotNET,
71.            "CPP_DLL_Test_MultiInterface",
72.            false
73.        },{
74.            MyDllname2_dotNET,
75.            "CPP_DLL_Test_UnregisteredServer1",
76.            false
77.        },{
78.            MyDllname2_dotNET,
79.            "CPP_DLL_Test_UnregisteredServer2",
80.            false
81.        },{
82.            MyDllname2_dotNET,
83.            "CPP_DLL_Test_IXXXX",
84.            false
85.        }
86.     };
87. 
    
88.     ClientInfo_Struct ClientInfo[]{
89.        {
90.            MyDllname,
91.            "MFC_DLL_Test_UnregisteredServer1",
92.            true
93.        },{
94.            MyDllname,
95.            "MFC_DLL_Test_UnregisteredServer2",
96.            true
97.        },{
98.            MyDllname,
99.            "MFC_DLL_Test_IXXXX",
100.            true
101.        },{
102.            MyDllname2,
103.            "CPP_DLL_Test_UnregisteredServer1",
104.            false
105.        },{
106.            MyDllname2,
107.            "CPP_DLL_Test_UnregisteredServer2",
108.            false
109.        },{
110.            MyDllname2,
111.            "CPP_DLL_Test_IXXXX",
112.            false
113.        }
114.     };
115.     int Get_CreationInstance_To_Create_FollowingServer(
116.         LPCOLESTR LeadingLibrary_AbsolutePath,
117.         LPCOLESTR CLSID_String,
118.         LPCOLESTR IID_String);
119.     void Get_CreationInstance_To_Create_UnregisteredServer(
120.         LPCOLESTR CLSID_String,
121.         LPCOLESTR IID_String);
122.     int My_Test_Function_dotNET();
123.     int My_Test_Function();
124.     void MyEnumModules();
125.     void ReleaseResource_dotNET();
126.     void ReleaseResource();
127.     void ErrorMessage(const CHAR* ERR_MSG);
128.     namespace Debug_namespace {
129.         inline namespace FileForDebug_namespace {
130.             const size_t BufferSize_File = 5UI64 << 20;
131.             class FileForDebug {
132.                 bool OnDebug;
133.                 bool IsSave;
134.                 bool TooLarge;
135.                 WCHAR  previousCHAR[BufferSize_File];
136.                 WCHAR* pStart_Previous;
137.                 size_t ReadSize, WriteSize;
138. 
     
139.             public:
140.                 FileForDebug();
141.                 void compareData(const wchar_t* pStart, int size);
142.                 void Save();
143.             };
144.             FileForDebug* MyFileForDebug;
145.         }
146. 
     
147.         inline namespace ExportedData_namespace {
148. 
     
149.             const size_t BufferSize_Line = 1500UI64;
150.             WCHAR MyLine[BufferSize_Line + 3];
151.             size_t size;
152.             va_list My_va_list;
153.             void OutputFunction(const WCHAR* str, int size) {
154.                 wprintf(L"%s", str);
155.                 MyFileForDebug->compareData(str, size);
156.             }
157.             void Ellipsis() {
158.                 size = BufferSize_Line - 1;
159.                 *(MyLine + size++) = L'.';
160.                 *(MyLine + size++) = L'.';
161.                 *(MyLine + size++) = L'.';
162.                 *(MyLine + size) = L'\0';
163.                 OutputFunction(MyLine, (int)size);
164.                 // printf("size= %I64u   BufferSize_Line=%I64u\n", 
165.                 //  size, BufferSize_Line);system("pause");
166.             }
167.             void AppendNewline() {
168.                 *(MyLine + size++) = L'\r';
169.                 *(MyLine + size++) = L'\n';
170.                 *(MyLine + size) = L'\0';
171.                 OutputFunction(MyLine, (int)size);
172.             }
173.             void My_Write_Line(const WCHAR* format, va_list va_list) {
174.                 size = _vsnwprintf_s(MyLine, BufferSize_Line, _TRUNCATE, format, va_list);
175.                 if (size >= BufferSize_Line) Ellipsis();
176.                 else AppendNewline();
177.             }
178.             void  MyWriteLine(const WCHAR* format, ...) {
179.                 va_start(My_va_list, format);
180.                 My_Write_Line(format, My_va_list);
181.                 va_end(My_va_list);
182.             }
183.             void My_Write(const WCHAR* format, va_list va_list) {
184.                 size = _vsnwprintf_s(MyLine, BufferSize_Line, _TRUNCATE, format, va_list);
185.                 if (size >= BufferSize_Line) Ellipsis();
186.                 else  OutputFunction(MyLine, (int)size);
187.             }
188.             void  MyWrite(const WCHAR* format, ...) {
189.                 va_start(My_va_list, format);
190.                 My_Write(format, My_va_list);
191.                 va_end(My_va_list);
192.             }
193.         }
194. 
     
195. 
     
196.     }
197.     using Debug_namespace::MyWriteLine;
198.     using Debug_namespace::MyFileForDebug;
199.     using Debug_namespace::FileForDebug;
200. 
     
201.     class MyException : public std::exception {
202.         const char* ExceptionString;
203.     public:
204.         int errorNo;
205.         MyException(const char* Exception_MSG, int errorNo) :
206.             ExceptionString(Exception_MSG), errorNo(errorNo) {
207.         }
208.         virtual const char* what()const;
209.     };
210.     const char* MyException::what()const { return ExceptionString; }
211. #define NTFS_MAX_PATH ( 32llu <<10)
212.     WCHAR Current_Directory[NTFS_MAX_PATH];
213.     WCHAR ProcessImageFileName[NTFS_MAX_PATH];
214.     WCHAR ModuleFileName[NTFS_MAX_PATH];
215.     WCHAR APP_Dir[NTFS_MAX_PATH];
216.     WCHAR MyPathRoot[NTFS_MAX_PATH];
217.     size_t MyPathRoot_Len;
218.     HANDLE hThread;
219.     DWORD ProcessID;
220.     HANDLE hProcess;
221.     IUnknown* pIUnknown_dotNET;
222.     ICreationInstance* pICreationInstance_dotNET;
223.     IUnknown* pIUnknown;
224.     ICreationInstance* pICreationInstance;
225.     const bool b_FreeLibrary = false;   //true;
226. 
     
227.     void MyEnumModules() {
228.         struct Modules
229.         {
230.             std::wstring Name;
231.             HMODULE hModule;
232.         };
233.         const size_t hModuleSize = 1000;
234.         static HMODULE hModule_Chen[hModuleSize];
235.         static WCHAR ModuleName[NTFS_MAX_PATH];
236.         if (!hProcess) return;
237. 
     
238.         DWORD cbNeeded = 0;
239.         std::vector<struct Modules> MyModules;
240.         std::vector<struct Modules> Modules_system;
241.         auto GetAllModules = [&] {
242.             MyModules.clear(); Modules_system.clear();
243.             if (!K32EnumProcessModules(hProcess, hModule_Chen,
244.                 DWORD(hModuleSize * sizeof(HMODULE)), &cbNeeded)) {
245.                 ErrorMessage("error: K32EnumProcessModules "); return;
246.             }
247.             int32_t CountOfModules = cbNeeded / sizeof(HMODULE);
248.             for (int i = 0; i < CountOfModules; i++) {
249.                 HMODULE hModule = hModule_Chen[i];
250.                 GetModuleFileNameExW(hProcess, hModule, ModuleName, NTFS_MAX_PATH);
251.                 if (_wcsnicmp(ModuleName, MyPathRoot, MyPathRoot_Len) == 0)
252.                     MyModules.push_back(Modules(ModuleName, hModule));
253.                 else Modules_system.push_back(Modules(ModuleName, hModule));
254.             }
255.             std::sort(MyModules.begin(), MyModules.end(), [](Modules A, Modules B)
256.                 {return A.hModule < B.hModule; });
257.             std::sort(Modules_system.begin(), Modules_system.end(), [](Modules A, Modules B)
258.                 {return _wcsicmp(A.Name.c_str(), B.Name.c_str()) < 0; });
259.             };
260.         auto FreeLib = [&] {
261.             for (int aa = 0; aa < ARRAYSIZE(ClientInfo_dotNET); aa++) {
262.                 BOOL FreeLib_OK = (ClientInfo_dotNET[aa].MFC_DLL ?
263.                     AfxFreeLibrary : FreeLibrary)(ClientInfo_dotNET[aa].hModule);
264.                 LPCWSTR DLL_Name = ClientInfo_dotNET[aa].DLL_Path;
265.                 if (FreeLib_OK)
266.                     MyWriteLine(L"  FreeLibrary OK %s\n", DLL_Name);
267.                 else
268.                     MyWriteLine(L" error: FreeLibrary %s\n", DLL_Name);
269.             }
270.             for (int aa = 0; aa < ARRAYSIZE(ClientInfo); aa++) {
271.                 BOOL FreeLib_OK = (ClientInfo[aa].MFC_DLL ?
272.                     AfxFreeLibrary : FreeLibrary)(ClientInfo[aa].hModule);
273.                 LPCWSTR DLL_Name = ClientInfo[aa].DLL_Path;
274.                 if (FreeLib_OK)
275.                     MyWriteLine(L"  FreeLibrary OK %s\n", DLL_Name);
276.                 else
277.                     MyWriteLine(L" error: FreeLibrary %s\n", DLL_Name);
278.             }
279.             };
280.         auto DisplayModules = [&] {
281.             auto SimplePtr = [](HMODULE xptr) { return UINT64(xptr) >> 16; };
282.             int count = 0;
283.             for (int j = 0; j < Modules_system.size(); j++) {
284.                 Modules& t = Modules_system.at(j);
285.                 printf("%2i %12llX %S\n", ++count, SimplePtr(t.hModule), t.Name.c_str());
286.             }
287.             for (int j = 0; j < MyModules.size(); j++) {
288.                 Modules& t = MyModules.at(j);
289.                 printf("%2i %12I64X %S\n", ++count, SimplePtr(t.hModule), t.Name.c_str() + MyPathRoot_Len);
290.             }
291.             printf("========= Count(%I32i) ==========\n", count);
292.             };
293.         GetAllModules();
294.         FreeLib();
295.         DisplayModules();
296.         GetAllModules();
297.         DisplayModules();
298.     }
299.     int AppInitialize() {
300. #define MyFMT "\t%S\n"
301.         GetCurrentDirectoryW(NTFS_MAX_PATH, Current_Directory);
302.         printf("CurrentDir =" MyFMT, Current_Directory);
303.         hThread = GetCurrentThread();
304.         ProcessID = GetProcessIdOfThread(hThread);
305.         hProcess = OpenProcess(
306.             PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, false, ProcessID);
307.         DWORD size = NTFS_MAX_PATH;
308.         if (!QueryFullProcessImageNameW(hProcess, 0, ProcessImageFileName, &size))
309.             throw MyException("QueryFullProcessImageNameW", -1004);
310.         printf("APPFullName=" MyFMT, ProcessImageFileName);
311.         if (GetModuleFileNameW(NULL, ModuleFileName, NTFS_MAX_PATH) >= NTFS_MAX_PATH)
312.             throw MyException("GetModuleFileNameW", -1001);
313.         printf("ModuleFileName=" MyFMT, ModuleFileName);
314.         wcscpy_s(APP_Dir, NTFS_MAX_PATH, ProcessImageFileName);
315.         PathCchRemoveFileSpec(APP_Dir, NTFS_MAX_PATH);
316.         printf("APP_Dir=    " MyFMT, APP_Dir);
317.         HR_(PathCchCombine(MyPathRoot, NTFS_MAX_PATH, APP_Dir, L"..\\..\\..\\"), 1002)
318.             PathCchAddBackslash(MyPathRoot, NTFS_MAX_PATH);
319.         printf("MyPathRoot=" MyFMT, MyPathRoot);
320.         HR_(StringCchLengthW(MyPathRoot, NTFS_MAX_PATH, &MyPathRoot_Len), 1003)
321. 
     
322.             // ---> For debug 
323.             printf("RelativePath=\t%100S\n", LeadingLibraryRelativePath);
324.         const WCHAR* pFullPath = ToFullPath(MyPathRoot, LeadingLibraryRelativePath);
325.         if (PathFileExistsW(pFullPath))
326.             printf("    FullPath= \t%100S\n", pFullPath);
327.         else  printf("file not exist\t%100S\n", LeadingLibraryRelativePath);
328.         // ---> For debug 
329.         PAUSE
330.             return 0;
331.     }
332.     int My_Console_Main(const wchar_t* comment) {
333.         int rv;
334.         printf("%S\n", comment);
335.         printf("CommandLine=%S\n", GetCommandLineW());
336.         if (AppInitialize())return -1;
337.         try {
338.             MyFileForDebug = new FileForDebug();
339.             //HR_(CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE), 1)
340.             //HR_(OleInitialize(NULL), 2)
341. 
     
342.             if (rv = Get_CreationInstance_To_Create_FollowingServer(
343.                 ToFullPath(MyPathRoot, LeadingLibraryRelativePath),
344.                 LeadingLibrary_clsid, LeadingLibrary_IID))return rv;
345.             if (rv = My_Test_Function_dotNET())return rv;
346. 
     
347.             printf("http://cheninnjer.blogspot.com\n");
348.             system("pause");
349.             Get_CreationInstance_To_Create_UnregisteredServer(
350.                 CreationInstance_clsid, CreationInstance_iid);
351.             if (rv = My_Test_Function())return rv;
352. 
     
353.             system("pause");
354.             MyEnumModules();
355.             system("pause");
356.             ReleaseResource_dotNET();
357.             ReleaseResource();
358.             system("pause");
359.             //OleUninitialize();
360.             //CoUninitialize();
361.             MyFileForDebug->Save();
362.         }
363.         catch (const MyException& ex) {
364.             printf("errorNo=%d\n", ex.errorNo);
365.             ErrorMessage(ex.what());
366.             return ex.errorNo;
367.         }
368.         catch (const std::exception& ex) {
369.             ErrorMessage(ex.what());
370.             return -1000;
371.         }
372.         return 0;
373.     }
374. 
     
375.     int Get_CreationInstance_To_Create_FollowingServer(
376.         LPCOLESTR LeadingLibrary_AbsolutePath,
377.         LPCOLESTR CLSID_String, LPCOLESTR IID_String) {
378.         HRESULT CreateLeadingLibrary(
379.             const wchar_t* LeadingLibrary_FullPath,
380.             const wchar_t* param_LeadingLibrary_clsid, void** ppvoid);
381.         HR_(CreateLeadingLibrary(LeadingLibrary_AbsolutePath,
382.             CLSID_String, (void**)&pIUnknown_dotNET), 12)
383.             IID MyIID;
384.         HR_(IIDFromString(AddCurlyBracket(IID_String), &MyIID), 13)
385.             HR_(pIUnknown_dotNET->QueryInterface(MyIID, (void**)&pICreationInstance_dotNET), 14)
386. 
     
387.             if (pIUnknown_dotNET + 1 != pICreationInstance_dotNET)
388.                 ErrorMessage("pIUnknown_dotNET + 1 != pICreationInstance_dotNET");
389.         BSTR Description = NULL;
390.         HR_(pICreationInstance_dotNET->GetDescription2(&Description), 17)
391.             MyWriteLine(L"%s", Description);
392.         ::SysFreeString(Description);
393.         return 0;
394.     }
395. 
     
396.     void Get_CreationInstance_To_Create_UnregisteredServer(
397.         LPCOLESTR CLSID_String, LPCOLESTR IID_String) {
398.         HRESULT hr;
399.         CLSID MyClsid;
400.         hr = CLSIDFromString(AddCurlyBracket(CLSID_String), &MyClsid);
401.         if (FAILED(hr))throw MyException("CLSIDFromString", -11);
402.         hr = CoCreateInstance(MyClsid, NULL, CLSCTX_INPROC_SERVER,
403.             IID_IUnknown, (LPVOID*)&pIUnknown);
404.         if (FAILED(hr))throw MyException("CoCreateInstance", -12);
405.         IID MyIID;
406.         hr = IIDFromString(AddCurlyBracket(IID_String), &MyIID);
407.         if (FAILED(hr))throw MyException("IIDFromString", -13);
408.         hr = pIUnknown->QueryInterface(MyIID, (void**)&pICreationInstance);
409.         if (FAILED(hr))throw MyException("QueryInterface", -14);
410. 
     
411.         if (pIUnknown + 1 != pICreationInstance) {
412.             ErrorMessage("pIUnknown + 1 ");
413.         }
414.         BSTR Description = ::SysAllocStringByteLen("", 5000);
415.         if (!Description)throw MyException("SysAllocStringLen", -15);
416.         hr = pICreationInstance->GetDescription(Description);
417.         if (FAILED(hr)) {
418.             ::SysFreeString(Description);
419.             throw MyException("GetDescription", -16);
420.         }
421.         // printf("%d", (*(INT32*)Description));
422.         MyWriteLine(L"%s", Description + 2);
423.         ::SysFreeString(Description);
424.         hr = pICreationInstance->GetDescription2(&Description);
425.         if (FAILED(hr)) throw MyException("GetDescription2", -17);
426.         MyWriteLine(L"%s", Description);
427.         ::SysFreeString(Description);
428.     }
429. 
     
430.     int My_Test_Function_dotNET() {
431.         int length = ARRAYSIZE(ClientInfo_dotNET);
432.         for (int aa = 0; aa < length; aa++) {
433.             HMODULE& hModule = ClientInfo_dotNET[aa].hModule;
434.             const WCHAR* DLL_Absolute_Path = ToFullPath(MyPathRoot, ClientInfo_dotNET[aa].DLL_Path);
435.             hModule = ClientInfo_dotNET[aa].MFC_DLL ?
436.                 AfxLoadLibrary(DLL_Absolute_Path) : LoadLibraryW(DLL_Absolute_Path);
437.             if (!hModule) {
438.                 printf("Error: %S\n", DLL_Absolute_Path);
439.                 RETURN(21)
440.             }
441.             using Test_UnregisteredServer = int (*)(TestParameter*);
442.             Test_UnregisteredServer FunctionPointer =
443.                 (Test_UnregisteredServer)GetProcAddress(hModule, ClientInfo_dotNET[aa].ProcName);
444.             if (!FunctionPointer) {
445.                 if (b_FreeLibrary) {
446.                     ClientInfo_dotNET[aa].MFC_DLL ?
447.                         AfxFreeLibrary(hModule) : FreeLibrary(hModule);
448.                     hModule = NULL;
449.                 }
450.                 RETURN(22)
451.             }
452.             TestParameter MyParameter = {
453.                  Debug_namespace::My_Write_Line,
454.                  pICreationInstance_dotNET ,
455.                  MyPathRoot
456.             };
457.             int rv = FunctionPointer(&MyParameter);
458.             if (b_FreeLibrary) {
459.                 ClientInfo_dotNET[aa].MFC_DLL ?
460.                     AfxFreeLibrary(hModule) : FreeLibrary(hModule);
461.                 hModule = NULL;
462.             }
463.             if (rv)RETURN(rv)
464.         }
465.         return 0;
466.     }
467. 
     
468.     int My_Test_Function() {
469.         int length = ARRAYSIZE(ClientInfo);
470.         for (int aa = 0; aa < length; aa++) {
471.             HMODULE& hModule = ClientInfo[aa].hModule;
472.             const WCHAR* DLL_Absolute_Path = ToFullPath(MyPathRoot, ClientInfo[aa].DLL_Path);
473.             hModule = ClientInfo[aa].MFC_DLL ?
474.                 AfxLoadLibrary(DLL_Absolute_Path) : LoadLibraryW(DLL_Absolute_Path);
475.             if (!hModule) {
476.                 printf("Error: %S\n", DLL_Absolute_Path);
477.                 RETURN(21)
478.             }
479.             using Test_UnregisteredServer = int (*)(TestParameter*);
480.             Test_UnregisteredServer FunctionPointer =
481.                 (Test_UnregisteredServer)GetProcAddress(hModule, ClientInfo[aa].ProcName);
482.             if (!FunctionPointer) {
483.                 if (b_FreeLibrary) {
484.                     ClientInfo[aa].MFC_DLL ?
485.                         AfxFreeLibrary(hModule) : FreeLibrary(hModule);
486.                     hModule = NULL;
487.                 }
488.                 RETURN(22)
489.             }
490.             TestParameter MyParameter = {
491.                  Debug_namespace::My_Write_Line,
492.                  pICreationInstance ,
493.                  MyPathRoot
494.             };
495.             int rv = FunctionPointer(&MyParameter);
496.             if (b_FreeLibrary) {
497.                 ClientInfo[aa].MFC_DLL ?
498.                     AfxFreeLibrary(hModule) : FreeLibrary(hModule);
499.                 hModule = NULL;
500.             }
501.             if (rv)RETURN(rv);
502.         }
503.         return 0;
504.     }
505.     void ReleaseResource_dotNET() {
506.         if (!pIUnknown_dotNET || !pICreationInstance_dotNET)return;
507.         HRESULT hr;
508. 
     
509.         IDispatch* pIDispatch_dotNET;
510.         hr = pIUnknown_dotNET->QueryInterface(IID_IDispatch, (void**)&pIDispatch_dotNET);
511.         if (FAILED(hr))
512.             ErrorMessage("QueryInterface (IID_IDispatch) ");
513.         else
514.             printf("   %p(%d)pIDispatch_dotNET\n", pIDispatch_dotNET, pIDispatch_dotNET->Release());
515.         printf("   %p(%d)pIUnknown_dotNET\n", pIUnknown_dotNET, pIUnknown_dotNET->Release());
516.         printf("   %p(%d)pICreationInstance_dotNET\n", pICreationInstance_dotNET,
517.             pICreationInstance_dotNET->Release());
518.     }
519. 
     
520.     void ReleaseResource() {
521.         if (!pIUnknown || !pICreationInstance)return;
522.         HRESULT hr;
523.         IDispatch* pIDispatch;
524.         hr = pIUnknown->QueryInterface(IID_IDispatch, (void**)&pIDispatch);
525.         if (FAILED(hr))
526.             ErrorMessage("QueryInterface (IID_IDispatch) ");
527.         else
528.             printf("   %p(%d)pIDispatch\n", pIDispatch, pIDispatch->Release());
529.         printf("   %p(%d)pIUnknown\n", pIUnknown, pIUnknown->Release());
530.         printf("   %p(%d)pICreationInstance\n", pICreationInstance,
531.             pICreationInstance->Release());
532.     }
533.     void ErrorMessage(const CHAR* ERR_MSG) {
534.         MessageBeep(MB_ICONERROR);
535.         HANDLE herr = GetStdHandle(STD_ERROR_HANDLE);
536.         CONSOLE_SCREEN_BUFFER_INFO Screen_Buf;
537.         GetConsoleScreenBufferInfo(herr, &Screen_Buf);
538.         SetConsoleTextAttribute(herr, FOREGROUND_RED);
539.         fprintf(stderr, "%s\n", ERR_MSG);
540. 
     
541.         SetConsoleTextAttribute(herr, FOREGROUND_GREEN);
542.         int NoOpenStream = _flushall();//printf("No=%d\n", NoOpenStream);
543.         PAUSE
544.             SetConsoleTextAttribute(herr, Screen_Buf.wAttributes);
545.     }
546. 
     
547. #define MyDebugFilename "MyFileForDebug.txt"
548. #define _WMyDebugFilename OLESTR("MyFileForDebug.txt")
549.     Debug_namespace::FileForDebug::FileForDebug() :
550.         IsSave(false),
551.         OnDebug(false),
552.         TooLarge(false),
553.         previousCHAR{}, WriteSize(0), ReadSize(0),
554.         pStart_Previous(previousCHAR)
555.     {
556.         FILE* _Stream = NULL;
557.         errno_t errNo = _wfopen_s(&_Stream, ToFullPath(APP_Dir, _WMyDebugFilename), L"r,ccs=UNICODE");
558.         if (!_Stream || errNo) {
559.             ErrorMessage("Unable to open " MyDebugFilename);
560.             return;
561.         }
562.         ReadSize = fread_s(previousCHAR, sizeof(previousCHAR),
563.             sizeof(previousCHAR[0]), BufferSize_File, _Stream);
564.         fclose(_Stream);
565.         OnDebug = true;
566.         printf("BufferSize_File=%lluMB ReadFileSize=%llu\n", (BufferSize_File >> 20), ReadSize);
567.         system("pause");
568.     }
569.     void Debug_namespace::FileForDebug::Save() {
570.         if (IsSave || OnDebug) return;
571.         FILE* _Stream = NULL;
572.         errno_t errNo = _wfopen_s(&_Stream, ToFullPath(APP_Dir, _WMyDebugFilename), L"w,ccs=UNICODE");
573.         if (_Stream && !errNo) {
574.             WriteSize = fwrite(previousCHAR, sizeof(previousCHAR[0]),
575.                 pStart_Previous - previousCHAR, _Stream);
576.             fclose(_Stream);
577.             IsSave = true;
578.             printf("BufferSize_File=%I64u  ReadFileSize= %I64u\n", BufferSize_File, ReadSize);
579.             printf("BufferSize_File=%I64u  WriteFileSize=%I64u\n", BufferSize_File, WriteSize);
580.             PAUSE
581.         }
582.     }
583.     void  Debug_namespace::FileForDebug::compareData(const wchar_t* pStart, int size) {
584.         if (TooLarge)return;
585.         if (pStart_Previous + size > previousCHAR + BufferSize_File) {
586.             TooLarge = true;
587.             ErrorMessage("Output data Too Large in compareData");
588.             return;
589.         }
590.         if (OnDebug) {
591.             int ret = memcmp(pStart, pStart_Previous, sizeof(wchar_t) * size);
592.             if (ret) {
593.                 OnDebug = false;
594.                 ErrorMessage("The output is not consistent with previous one");
595.             }
596.             else { pStart_Previous += size; return; }
597.         }
598.         if (memcpy_s(pStart_Previous, size * sizeof(wchar_t),
599.             pStart, size * sizeof(wchar_t))) {
600.             ErrorMessage("memcpy_s");
601.         }
602.         pStart_Previous += size;
603.     }
604. 
     
605. };
606. #endif 
607. 
     

1. #pragma once
2. 
   
3. using namespace System;
4. 
   
5. namespace CreatedotNETPlatform {
6. public ref class Class1
7. {
8. // TODO: Add your methods for this class here.
9. void MyInspection(void);
10. String^ LeadingLibPath;
11. Reflection::Assembly^ Assembly_Leading_Library;
12. Type^ clsid_type;
13. public:
14. long Create_dotNET_Platform(
15. const wchar_t* LeadingLib,
16. const wchar_t* clsid,
17. void** pIUnknown);
18. };
19. }

1. #include "pch.h"
2. 
   
3. #include "TestParameter.h"
4. #include "Create_dotNET_Platform.h"
5. 
   
6. __declspec(dllexport) HRESULT CreateLeadingLibrary(
7. const wchar_t* LeadingLibPath,
8. const wchar_t* clsid_Str,
9. void** pIUnknown)
10. {
11. 
    
12. long errorCode = (
13. gcnew CreatedotNETPlatform::Class1()
14. )->Create_dotNET_Platform(LeadingLibPath, clsid_Str, pIUnknown);
15. if (errorCode)return (HRESULT)(errorCode + (7 << 29));
16. return S_OK;
17. }
18. 
    
19. using namespace System::Reflection;
20. using namespace System::Runtime::InteropServices;
21. namespace CreatedotNETPlatform {
22. long Class1::Create_dotNET_Platform(
23. const wchar_t* Leading_Library_Path,
24. const wchar_t* clsid_str,
25. void** pIunknown)
26. {
27. size_t String_Len;
28. try {
29. //throw gcnew System::FormatException("MyTest");
30. if (FAILED(StringCchLengthW(Leading_Library_Path, 4000, &String_Len))) return 1;
31. LeadingLibPath = gcnew String(Leading_Library_Path, 0, (int)String_Len);
32. Assembly_Leading_Library = Reflection::Assembly::LoadFrom(LeadingLibPath);
33. if (FAILED(StringCchLengthW(clsid_str, 200, &String_Len))) return 2;
34. Guid clsid = Guid::Parse(gcnew String(clsid_str, 0, (int)String_Len));
35. Collections::Generic::IEnumerable<Type^>^ IEnumateType =
36. Assembly_Leading_Library->ExportedTypes;
37. for each (clsid_type in IEnumateType)
38. if (clsid_type->GUID == clsid) {
39. MyInspection();
40. Object^ obj = Activator::CreateInstance(clsid_type);
41. if (obj) {
42. *pIunknown = Marshal::GetIUnknownForObject(obj).ToPointer();
43. return 0;
44. }
45. else return 0X9;
46. }
47. return 0xb;
48. }
49. catch (System::IO::FileNotFoundException^ const f) {
50. System::String^ des = L" FileNotFound ->" + f->FileName;
51. System::IntPtr ptr = Marshal::StringToHGlobalUni(des);
52. SetErrorInfo_Chen((const WCHAR*)ptr.ToInt64(), __FUNCTIONW__);
53. Marshal::FreeHGlobal(ptr);
54. return 0x100;
55. }
56. catch (System::Exception^ const ex) {
57. System::String^ des = L" Exception Message ->" + ex->Message;
58. System::IntPtr ptr = Marshal::StringToHGlobalUni(des);
59. SetErrorInfo_Chen((const WCHAR*)ptr.ToInt64(), __FUNCTIONW__);
60. Marshal::FreeHGlobal(ptr);
61. return 0x333;
62. }
63. }
64. void Class1::MyInspection(void) {
65. MethodInfo^ Get_Interface3;
66. array<ParameterInfo^>^ MyParams;
67. //throw gcnew Exception("My Exception");
68. Console::WriteLine("*************************");
69. Console::WriteLine("__cplusplus_cli = " + __cplusplus_cli);
70. Console::WriteLine(__func__);
71. Console::WriteLine(" __FUNCSIG__ =      "  __FUNCSIG__);
72. Console::WriteLine(
73. "FrameworkDescription is " +
74. Runtime::InteropServices::RuntimeInformation::FrameworkDescription
75. );
76. Console::WriteLine("Leading Library path = " + LeadingLibPath);
77. if (!clsid_type)goto out;
78. Console::WriteLine("CLSID    = " + clsid_type->GUID);
79. Console::WriteLine("FullName = " + clsid_type->FullName);
80. Get_Interface3 = clsid_type->GetMethod("Get_Interface3");
81. if (!Get_Interface3) goto out;
82. Console::WriteLine("Get_Interface3");
83. MyParams = Get_Interface3->GetParameters();
84. for each (ParameterInfo ^ MyParam in MyParams) {
85. Console::WriteLine("Position:" + MyParam->Position.ToString() +
86. "  TypeName(" + MyParam->ParameterType->Name + ")");
87. }
88. out:
89. Console::WriteLine("*************************");
90. Console::ReadKey();
91. }
92. }
93. 
    

1. #If TARGET = "library" And PLATFORM = "x64" Then
2. Option Strict On
3. Imports System.Reflection
4. Imports System.Runtime.InteropServices
5. Imports System.Text
6. 
   
7. <ComClass(LeadingLibrary.ClassId, LeadingLibrary.IID_LeadingLibrary)>
8. Public Class LeadingLibrary
9. 
   
10.     Public Const ClassId As String = "2B6E5DB5-CF45-40B8-8091-55027E408231"
11.     Public Const IID_LeadingLibrary As String = "16142434-D1CF-4DC8-BD7B-7E5091058490"
12. 
    
13.     Sub Get_Interface3(<[In]> AssemblyInfo_ptr As IntPtr,
14.                        <Out> ByRef ppVoid As IntPtr)
15.         'Throw New MyException(&HE0000004, "Don't use Get_Interface3")
16.         Try
17.             MyAssemblyInfo =
18.               Marshal.PtrToStructure(Of AssemblyInfo_Struct)(AssemblyInfo_ptr)
19.             AssemblyPath =
20.               Marshal.PtrToStringBSTR(MyAssemblyInfo.AssemblyPath)
21.             UnregisteredServerAssembly = Assembly.LoadFrom(AssemblyPath)
22.             InvokeCreationMethod()
23.             ppVoid = Marshal.ReadIntPtr(ppvoid_temp)
24.         Catch ex As IO.FileNotFoundException
25.             Throw New MyException(ex.HResult, AssemblyPath & " Cannot be found")
26.         Catch ex As Exception
27.             Throw New MyException(ex.HResult, "Unknown Exception -->" & ex.Message)
28.         End Try
29.         If ppVoid = IntPtr.Zero Then
30.             Throw New MyException(&HE0000222, "ppVoid = ZERO")
31.         End If
32.     End Sub
33.     Sub GetDescription(Description As IntPtr)
34.         Dim Source As New StringBuilder(
35.          "This is a  leadingLibrary")
36.         Source.AppendLine()
37.         Source.AppendLine("HRESULT value reference : winerror.h")
38.         Source.AppendLine(
39.            "My location is " &
40.                System.Reflection.Assembly.GetExecutingAssembly.Location)
41.         Source.AppendLine(
42.            "FrameworkDescription is " &
43.         System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription
44.         )
45. 
    
46.         Dim MainType As Type = GetType(LeadingLibrary)
47.         Dim ThisModule As Reflection.Module = MainType.Module
48.         Dim peKind As PortableExecutableKinds
49.         Dim machine As ImageFileMachine
50.         ThisModule.GetPEKind(peKind, machine)
51.         Source.AppendFormat("machine={0:G} peKind={1:G}", machine, peKind)
52.         Source.Append(ChrW(0))
53.         Dim BufferSize As Int32 = Marshal.ReadInt32(Description - 4)
54.         If BufferSize < (4 + Source.Length * 2) Then
55.             Marshal.WriteInt32(Description, 0)
56.         End If
57.         Marshal.Copy(Source.ToString().ToCharArray(), 0,
58.                      Description + 4, Source.Length)
59.         Marshal.WriteInt32(Description, (Source.Length - 1) * 2)
60.     End Sub
61.     Sub GetDescription2(<Out> ByRef Description As String)
62.         Dim MainType As Type = GetType(LeadingLibrary)
63.         Dim ThisModule As Reflection.Module = MainType.Module
64.         Dim peKind As PortableExecutableKinds
65.         Dim machine As ImageFileMachine
66.         ThisModule.GetPEKind(peKind, machine)
67.         Dim Source As New StringBuilder()
68.         Source.AppendLine("This is a LeadingLibrary")
69.         Source.AppendLine("HRESULT value reference : winerror.h")
70.         Source.AppendLine("My location is " &
71.      System.Reflection.Assembly.GetExecutingAssembly.Location)
72.         Source.AppendLine("FrameworkDescription is " &
73.      System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription)
74.         Source.Append($"machine={machine} peKind={peKind}")
75.         Description = Source.ToString()
76.     End Sub
77. 
    
78.     Sub Get_Interface4(<[In]> AssemblyInfo_ptr As IntPtr,
79.                        <Out> ByRef ppVoid_object As Object)
80.         Try
81.             MyAssemblyInfo =
82.               Marshal.PtrToStructure(Of AssemblyInfo_Struct)(AssemblyInfo_ptr)
83.             AssemblyPath =
84.               Marshal.PtrToStringBSTR(MyAssemblyInfo.AssemblyPath)
85.             UnregisteredServerAssembly = Assembly.LoadFrom(AssemblyPath)
86.             InvokeCreationMethod4()
87.             ppVoid_object = ppvoid_temp_object
88.         Catch ex As IO.FileNotFoundException
89.             Throw New MyException(ex.HResult, AssemblyPath & " Cannot be found")
90.         Catch ex As Exception
91.             Throw New MyException(ex.HResult, "Unknown Exception -->" & ex.Message)
92.         End Try
93.         If ppVoid_object Is Nothing Then
94.             Throw New MyException(&HE0000222, "ppVoid_object Is Nothing")
95.         End If
96.     End Sub
97. 
    
98.     '============================================================
99.     Public Sub New()
100.         MyBase.New()
101.         ppvoid_temp = Marshal.AllocCoTaskMem(12)
102.     End Sub
103.     Protected Sub Finallize()
104.         Marshal.FreeCoTaskMem(ppvoid_temp)
105.     End Sub
106.     Private Class MyException
107.         Inherits Exception
108.         Sub New(errorcode As Int32, Message As String)
109.             MyBase.New(Message)
110.             HResult = errorcode
111.         End Sub
112.     End Class
113.     Dim MyAssemblyInfo As AssemblyInfo_Struct
114.     Private Structure AssemblyInfo_Struct
115.         Public AssemblyPath As IntPtr
116.         Public TypeFullname As IntPtr
117.         Public CreationMethod As IntPtr
118.         Public CLSID As IntPtr
119.         Public IID As IntPtr
120.     End Structure
121.     Dim AssemblyPath As String
122.     Dim TypeFullname As String
123.     Dim CreationMethod As String
124.     Dim CLSID_string As String
125.     Dim IID_string As String
126.     ReadOnly ppvoid_temp As IntPtr
127.     Dim ppvoid_temp_object As Object
128.     Dim UnregisteredServerAssembly As Assembly
129.     Dim IEnumateType As IEnumerable(Of Type)
130.     Private Sub InvokeCreationMethod()
131.         Dim Type_CLSID As Guid
132.         CLSID_string =
133.          Marshal.PtrToStringBSTR(MyAssemblyInfo.CLSID)
134.         If Not Guid.TryParse(CLSID_string, Type_CLSID) Then
135.             Throw New Exception($"Error:CLSID({CLSID_string})")
136.         End If
137.         IEnumateType = UnregisteredServerAssembly.ExportedTypes
138.         For Each MyTypeInfo As TypeInfo In IEnumateType
139.             If Type_CLSID <> MyTypeInfo.GUID Then Continue For
140.             TypeFullname = Marshal.PtrToStringBSTR(MyAssemblyInfo.TypeFullname)
141.             If TypeFullname <> MyTypeInfo.FullName Then
142.                 Dim FG As ConsoleColor = Console.ForegroundColor
143.                 Console.ForegroundColor = ConsoleColor.Green
144.                 Console.WriteLine("In     :" & TypeFullname)
145.                 Console.WriteLine("MyType :" & MyTypeInfo.FullName)
146.                 Console.ForegroundColor = FG
147.             End If
148.             Dim UnregisteredServerType As Type = MyTypeInfo.AsType
149.             CreationMethod =
150.                 Marshal.PtrToStringBSTR(MyAssemblyInfo.CreationMethod)
151.             Dim CreateObject_Chen As MethodInfo =
152.                   UnregisteredServerType.GetMethod(CreationMethod)
153.             If CreateObject_Chen Is Nothing Then
154.                 Throw New Exception($"Error:CreateMethod({CreationMethod})")
155.             End If
156.             IID_string = Marshal.PtrToStringBSTR(MyAssemblyInfo.IID)
157.             Dim Interface_IID As Guid
158.             If Not Guid.TryParse(IID_string, Interface_IID) Then
159.                 Throw New Exception($"Error:Interface_IID({IID_string})")
160.             End If
161.             Dim args() As Object = {Interface_IID, ppvoid_temp, New IntPtr(12345)}
162.             CreateObject_Chen.Invoke(Nothing, args)
163.             Exit Sub
164.         Next
165.         Throw New Exception("Error:CLSID not found")
166.     End Sub
167.     Private Sub InvokeCreationMethod4()
168.         ' Console.WriteLine("InvokeCreationMethod4()")
169.         Dim Type_CLSID As Guid
170.         CLSID_string = Marshal.PtrToStringBSTR(MyAssemblyInfo.CLSID)
171.         If Not Guid.TryParse(CLSID_string, Type_CLSID) Then
172.             Throw New Exception($"Error:CLSID({CLSID_string})")
173.         End If
174.         IEnumateType = UnregisteredServerAssembly.ExportedTypes
175.         For Each MyTypeInfo As TypeInfo In IEnumateType
176.             If Type_CLSID <> MyTypeInfo.GUID Then Continue For
177.             TypeFullname = Marshal.PtrToStringBSTR(MyAssemblyInfo.TypeFullname)
178.             If TypeFullname <> MyTypeInfo.FullName Then
179.                 Dim FG As ConsoleColor = Console.ForegroundColor
180.                 Console.ForegroundColor = ConsoleColor.Green
181.                 Console.WriteLine("In     :" & TypeFullname)
182.                 Console.WriteLine("MyType :" & MyTypeInfo.FullName)
183.                 Console.ForegroundColor = FG
184.             End If
185.             Dim UnregisteredServerType As Type = MyTypeInfo.AsType
186.             CreationMethod = Marshal.PtrToStringBSTR(MyAssemblyInfo.CreationMethod)
187.             Dim CreateObject4_Chen As MethodInfo =
188.                   UnregisteredServerType.GetMethod(CreationMethod)
189.             If CreateObject4_Chen Is Nothing Then
190.                 Throw New Exception($"Err:CreateObject4_Chen Is Nothing({CreationMethod})")
191.             End If
192.             IID_string = Marshal.PtrToStringBSTR(MyAssemblyInfo.IID)
193.             Dim Interface_IID As Guid
194.             If Not Guid.TryParse(IID_string, Interface_IID) Then
195.                 Throw New Exception($"Error:Interface_IID({IID_string})")
196.             End If
197.             Dim args() As Object = {Interface_IID, New IntPtr(12345)}
198.             ppvoid_temp_object = CreateObject4_Chen.Invoke(Nothing, args)
199.             Exit Sub
200.         Next MyTypeInfo
201.         Throw New Exception("Error:CLSID not found")
202.     End Sub
203. 
     
204. End Class
205. #End If

1. #include "pch.h"
2. 
   
3. #if defined(_M_X64) && defined(_WIN64) && defined(_WINDOWS) && \
4.      _MSVC_LANG >= 202002L &&  defined(_USRDLL)
5. #include "TestParameter.h"    
6. 
   
7. LPCOLESTR MyServerName = Server_Name_w(
8.     CSharp_Server_For_Testing\CSharp_Server_For_Testing\bin\x64\,
9.     My_Configuration, \net9.0\CSharp_Server_For_Testing.dll);
10. 
    
11. __interface IMyTest : IDispatch {
12.     HRESULT Hello(INT32 id, BSTR str);
13. };
14. 
    
15. __interface IMyTest2 : IDispatch {
16.     HRESULT Hello2(BSTR* str);
17.     HRESULT Test_in_out_ref(
18.         INT32* ref_int32,
19.         INT32 int32_2,
20.         INT32* out_int32,
21.         void* ptr);
22.     HRESULT Test_ref_readonly(INT32* ref_int32, void* ptr);
23. };
24. 
    
25. __interface IMyTest3 : IDispatch {
26.     HRESULT Hello3(BSTR* str);
27. };
28. 
    
29. HRESULT pfnDeferredFillIn(EXCEPINFO* pEx) {
30.     for (int aa = 1; aa < 20; aa++) printf("Description\n");
31.     PAUSE
32.         //printf("Description=%S\n", pEx->bstrDescription);
33.         return S_OK;
34. }
35. int Invoke_Hello_method(ExportedData& ED, IMyTest* pIMyTest) {
36.     CComBSTR str = SysAllocString(L"=========== Hello method ==========");
37. 
    
38.     HRESULT hr;
39.     auto  Invoke_Hello = [&](int ID) {
40.         hr = pIMyTest->Hello(ID, str);
41.         ED.WriteLine(L"hr = 0X%X", hr);
42.         CComPtr<IErrorInfo> MypError;
43.         hr = GetErrorInfo(0, &MypError);
44.         if (SUCCEEDED(hr)) {
45.             CComBSTR Description, source;
46.             MypError->GetDescription(&Description);
47.             MypError->GetSource(&source);
48.             ED.WriteLine(L"Description=%s", Description);
49.             ED.WriteLine(L"Source=%s", source);
50.         }
51.         };
52.     Invoke_Hello(1);
53.     Invoke_Hello(222);
54.     DISPID dispid_Hello;
55.     LPCOLESTR names = L"Hello";
56.     HR_(pIMyTest->GetIDsOfNames(IID_NULL, const_cast<LPOLESTR*>(&names), 1,
57.         LOCALE_USER_DEFAULT, &dispid_Hello), -1234)
58.         ED.WriteLine(L"========== DISPID=%d ===========\n", dispid_Hello);
59. 
    
60. 
    
61.     for (int ID = 111; ID <= 222; ID += 111) {
62.         VARIANTARG varg[2], pRetValue;
63.         UINT puArgErr = 0;
64.         DISPPARAMS DispParams{
65.           .rgvarg = varg,
66.           .rgdispidNamedArgs = new DISPID[]{ },
67.           .cArgs = 2,
68.           .cNamedArgs = 0,
69.         };
70.         VariantInit(varg);
71.         V_VT(varg) = VT_BSTR; V_BSTR(varg) = str; //in reverse order
72.         VariantInit(varg + 1);
73.         V_VT(varg + 1) = VT_I4; V_I4(varg + 1) = ID;
74.         VariantInit(&pRetValue);
75.         V_VT(&pRetValue) = VT_I4;
76.         EXCEPINFO ex = {
77.             .pfnDeferredFillIn = pfnDeferredFillIn,
78.             .scode = (LONG)0XE0012345
79.         };
80.         hr = pIMyTest->Invoke(dispid_Hello,
81.             IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD,
82.             &DispParams, &pRetValue, &ex, &puArgErr);
83.         printf("puArgErr=%d MyHRESULT=0x%x\n", puArgErr, hr);
84.         if (V_VT(&pRetValue) != VT_EMPTY)
85.             printf(" type=%d RetValue=0x%x\n", V_VT(&pRetValue), V_I4(&pRetValue));
86. 
    
87.         if (hr == DISP_E_EXCEPTION) {
88.             printf("ex.wCode=%d ex.scode=0X%X \n", ex.wCode, ex.scode);
89.             printf("ex.bstrSource: %S  \n", ex.bstrSource);
90.             hr = ex.scode;
91.         }
92.         ED.WriteLine(L"hr = 0X%X", hr);
93.     }
94.     return 0;
95. }
96. class MyEventTestClass :public IDispatch
97. {
98.     LONG refCount;
99. public:
100.     MyEventTestClass() : refCount(0) {}
101.     HRESULT QueryInterface(REFIID iid, void** ppvoid) {
102.         printf("QueryInterface\n");
103.         LPOLESTR  iid_str;
104.         HR_(StringFromIID(iid, &iid_str), -1212)
105.             printf("IID=%S\n", iid_str);
106.         CoTaskMemFree(iid_str);
107.         PAUSE
108.             if (iid == IID_IUnknown) {
109.                 printf(" IID_IUnknown\n");
110.                 *ppvoid = dynamic_cast<IUnknown*>(this);
111.                 refCount++;
112.                 return S_OK;
113.             }
114.         if (iid == IID_INoMarshal) {
115.             printf(" IID_INoMarshal\n");
116.             return E_NOINTERFACE;
117.         }
118.         if (iid == IID_IAgileObject) {
119.             printf(" IID_IAgileObject\n");
120.             return E_NOINTERFACE;
121.         }
122.         if (iid == IID_IMarshal) {
123.             printf(" IID_IMarshal\n");
124.             return E_NOINTERFACE;
125.         }
126.         printf("  QueryInterface error\n");
127.         return S_FALSE;
128.     }
129.     ULONG  AddRef() {
130.         refCount++;
131.         printf("AddRef(%d) \n", refCount);
132.         PAUSE
133.             return refCount;
134.     }
135.     ULONG Release() {
136.         refCount--;
137.         printf("Release(%d) \n", refCount);
138.         PAUSE
139.             return refCount;
140.     }
141.     HRESULT GetTypeInfoCount(UINT* pctInfo) {
142.         printf("GetTypeInfoCount\n");
143.         PAUSE
144. 
     
145.             if (!pctInfo)return E_POINTER;
146.         ITypeInfo* pITypeInfo;
147.         //TYPEINfoHelp
148.         *pctInfo = 0;
149.         return S_FALSE;
150.     }
151.     HRESULT GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo) {
152.         printf("GetTypeInfo\n");
153.         PAUSE
154.             return 0;
155.     }
156.     HRESULT GetIDsOfNames(REFIID iid, LPOLESTR* str,
157.         UINT cNames, LCID lcid, DISPID* rgDispID) {
158.         printf("GetIDsOfNames\n");
159.         PAUSE
160.             return S_OK;
161.     }
162.     HRESULT Invoke(DISPID dispidMember, REFIID iid, LCID lcid, WORD flag,
163.         DISPPARAMS* dispParam,
164.         VARIANT* pVariant, EXCEPINFO* pExcepInfo, UINT* puArg) {
165.         printf("Invoke\n");
166.         PAUSE
167.             return 0;
168.     }
169. };
170. __interface  IClass1Events : IDispatch {};
171. static int Test_Event(IMyTest* pIMyTest) {
172.     HRESULT hr;
173.     LPCOLESTR IDD_Event = (LPCOLESTR)OLESTR("3AAEFAB5-6DC7-49FD-A658-44A8DEF91F02");
174.     IClass1Events* pIClass1Events = NULL;
175.     IID myiid2;
176.     HR_(IIDFromString(AddCurlyBracket(IDD_Event), &myiid2), -32)
177.         HR_(pIMyTest->QueryInterface(myiid2, (void**)&pIClass1Events), -33)
178.         printf("------------ Event -------------\n");
179.     DISPID DispID_add_MyTestFun;
180.     LPCOLESTR names = L"add_Event_MyTestFun";
181.     HR_(pIClass1Events->GetIDsOfNames(IID_NULL, (LPOLESTR*)&names, 1,
182.         LOCALE_USER_DEFAULT, &DispID_add_MyTestFun), -333)
183.         printf("DispID_add_MyTestFun = 0X%X\n", DispID_add_MyTestFun);
184.     VARIANTARG varg[2], pRetValue;
185.     DISPPARAMS DispParams{};
186.     DispParams.cArgs = 1;
187.     DispParams.rgvarg = varg;
188.     VariantInit(varg);
189.     std::unique_ptr<MyEventTestClass> pkkk(new MyEventTestClass);
190.     V_VT(varg) = VT_UNKNOWN;
191.     V_UNKNOWN(varg) = static_cast<IUnknown*>(pkkk.get());
192.     V_UNKNOWN(varg) = NULL;
193.     VariantInit(&pRetValue);
194.     UINT puArgErr = 0;
195.     EXCEPINFO ex{};
196.     hr = pIClass1Events->Invoke(DispID_add_MyTestFun,
197.         IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD,
198.         &DispParams, &pRetValue, &ex, &puArgErr);
199.     if (FAILED(hr))
200.         if (DISP_E_TYPEMISMATCH == hr)  printf("Type mismatch\n");
201.         else if (E_INVALIDARG == hr)         printf("One or more arguments are invalid\n");
202.         else if (DISP_E_BADPARAMCOUNT == hr) printf("Invalid number of parameter\n");
203.         else {
204.             printf("pRetValue=0X%X\n", V_I4(&pRetValue));
205.             printf("hr=0X%X puArgErr=%d\n", hr, puArgErr);
206.         }
207.     printf("------------ Event -------------(%d)\n", pIClass1Events->Release());
208.     return 0;
209. }
210. struct My_Struct {
211.     INT32 A;
212.     INT32 B;
213.     INT32 C;
214. };
215. extern "C" __declspec(dllexport)
216. int CPP_DLL_Test_CSharp_Server(TestParameter* ptr) {
217.     ExportedData ED(ptr, L"DLL_Test_CSharp_Server");
218.     int rv;
219.     IMyTest* pIMyTest;
220.     ServerInfo_Struct<LPCOLESTR> My_Server_string = {
221.               MyServerName,
222.               (LPCOLESTR)OLESTR("CSharp_Server_For_Testing.Class1"),
223.               (LPCOLESTR)OLESTR("CreateObject4_Chen"),
224.               (LPCOLESTR)OLESTR("6E0C1B45-7569-47DA-AE26-4BE21F323923"),
225.               (LPCOLESTR)OLESTR("FECA0AEE-FF0F-4897-8CB9-27B44BB97765")
226.     };
227.     rv = Get_ServerInterface4(ptr, My_Server_string, (PVOID*)&pIMyTest);
228.     if (rv)return rv;
229.     if (Invoke_Hello_method(ED, pIMyTest))return -1000;
230.     if (Test_Event(pIMyTest))return -10001;
231.     printf("(%d)pIMyTest->Release  %p\n", pIMyTest->Release(), pIMyTest);
232.     PAUSE
233. 
     
234.         IMyTest2* pIMyTest2 = NULL;
235.     My_Server_string.IID = (LPCOLESTR)OLESTR("C8439959-322C-4FE3-AC66-24B062A77152");
236.     rv = Get_ServerInterface4(ptr, My_Server_string, (PVOID*)&pIMyTest2);
237.     if (rv)return rv;
238.     CComBSTR str2 = NULL;
239.     HR_(pIMyTest2->Hello2(&str2), -3456)
240.         ED.WriteLine(L"str2(%s)", str2);
241.     INT32 ref_int32, out_int32;
242.     My_Struct s{ 11,2,3 };
243.     pIMyTest2->Test_in_out_ref(&ref_int32, 34, &out_int32, (void*)&s);
244.     ED.WriteLine(L"ref_int32 = %d  out_int32=%d", ref_int32, out_int32);
245.     pIMyTest2->Test_ref_readonly(&ref_int32, (void*)&s);
246.     ED.WriteLine(L"ref_readonly_int32 = %d %d", ref_int32, s.A);
247.     printf("(%d)pIMyTest2->Release  %p\n", pIMyTest2->Release(), pIMyTest2);
248.     PAUSE
249. 
     
250.         IMyTest3* pIMyTest3 = NULL;
251.     My_Server_string.IID = (LPCOLESTR)OLESTR("731D1161-8436-4827-AB75-F334A112B2F1");
252.     rv = Get_ServerInterface4(ptr, My_Server_string, (PVOID*)&pIMyTest3);
253.     if (rv)return rv;
254.     printf("(pIMyTest3  = %p)\n", pIMyTest3);
255.     str2.Empty();
256.     HR_(pIMyTest3->Hello3(&str2), -34563)
257.         ED.WriteLine(L"str2(%s)", str2);
258.     ED.WriteLine(L"(%d)pIMyTest3->Release  ", pIMyTest3->Release());
259.     PAUSE
260.         return 0;
261. }
262. #endif

1. using System.Runtime.InteropServices;
2. namespace CSharp_Server_For_Testing
3. {
4.     [Guid(Class1.IMyTest_IID)]
5.     [ComVisible(true)]
6.     public interface IMyTest
7.     {
8.         [DispId(8)] void Hello(Int32 id, String str);
9.     }
10. 
    
11.     [Guid(clsid)]
12.     [ClassInterface(ClassInterfaceType.None)]
13.     public partial class Class1 : IMyTest
14.     {
15.         public const String clsid = "6E0C1B45-7569-47DA-AE26-4BE21F323923";
16.         public const String IMyTest_IID = "FECA0AEE-FF0F-4897-8CB9-27B44BB97765";
17.         void IMyTest.Hello(Int32 id, String str)
18.         {
19.             Console.WriteLine(str + $" id = {id}");
20.             EventHandler_MyTestFun?.Invoke(this, EventArgs.Empty);
21.             Console.WriteLine("************** Hello world *****************");
22.             if (id == 111) return;
23.             else if (id == 222) System.Reflection.Assembly.LoadFrom("");
24.             else throw new Exception() { HResult = (0XE << 28) | 0X12345 };
25.         }
26.         public static object? CreateObject4_Chen(ref Guid IID, IntPtr Not_Used)
27.         {
28.             if (IID == Guid.Parse(Class1.IMyTest_IID))
29.             {
30.                 return new Class1();
31.             }
32. 
    
33.             Object? MyReturnObj = null;
34.             Console.WriteLine($"{IID}  ------Enter MyMethod_Next_Interface2");
35.             MyMethod_Next_Interface2(in IID, ref MyReturnObj);
36.             Console.WriteLine($"{IID}  ------Exit  MyMethod_Next_Interface2");
37.             Console.ReadKey();
38. 
    
39.             if (MyReturnObj != null) return MyReturnObj;
40.             return null;
41.         }
42.         static partial void MyMethod_Next_Interface2(in Guid IID, ref object? MyReturnObj);
43.     }
44. }

1. using System.Runtime.InteropServices;
2. 
   
3. namespace CSharp_Server_For_Testing
4. {
5.     public struct MyStruct
6.     {
7.         public Int32 A;
8.         public Int32 B;
9.         public Int32 C;
10.     };
11.     [Guid(Class1.IMyTest2_IID)]
12.     [ComVisible(true)]
13.     public interface IMyTest2
14.     {
15.         [DispId(0x33)] void Hello2(ref String str);
16.         [DispId(0x34)]
17.         void
18.          Test_in_out_ref(ref Int32 ref_int32,
19.                              Int32 int32_2,
20.                          out Int32 out_int32,
21.                           in MyStruct s);
22.         [DispId(0x35)]
23.         void Test_readonly_ref(ref readonly Int32 ref_int32,
24.                                 ref readonly MyStruct s);
25. 
    
26.     }
27.     public partial class Class1 : IMyTest2
28.     {
29.         public const String IMyTest2_IID = "C8439959-322C-4FE3-AC66-24B062A77152";
30.         void IMyTest2.Hello2(ref String str)
31.         {
32.             Console.WriteLine("************** Hello world -2 *****************");
33.             str = $"=== void IMyTest2.Hello2(ref String str) === <<-- ";
34.         }
35.         void IMyTest2.Test_in_out_ref(ref Int32 ref_int32, Int32 int32_2,
36.                  out Int32 out_int32, in MyStruct s)
37.         {
38.             ref_int32 = 10000 + int32_2;
39.             out_int32 = 1110000;
40.             out_int32 += s.A;
41.             Console.WriteLine($"out_int32 = {out_int32}");
42.         }
43.         void IMyTest2.Test_readonly_ref(ref readonly Int32 ref_readonly_int32,
44.                                         ref readonly MyStruct s)
45.         {
46.             Console.WriteLine($"ref_readonly_int32 = {ref_readonly_int32}");
47.             Console.WriteLine($"ref_readonly s.A= {s.A}");
48.         }
49. 
    
50.         static partial void MyMethod_Next_Interface2(in Guid IID, ref object? MyReturnObj)
51.         {
52.             if (IID == Guid.Parse(Class1.IMyTest2_IID))
53.             {
54.                 Console.WriteLine($"{IID}  MyMethod_Next_Interface2");
55.                 Console.ReadKey();
56.                 MyReturnObj = new Class1();
57.             }
58.             else
59.             {
60.                 Console.WriteLine($"{IID}  ------Enter MyMethod_Next_Interface3");
61.                 MyMethod_Next_Interface3(in IID, ref MyReturnObj);
62.                 Console.WriteLine($"{IID}  ------Exit  MyMethod_Next_Interface3");
63.             }
64.         }
65.         static partial void MyMethod_Next_Interface3(in Guid IID, ref object? MyReturnObj);
66.     }
67. }

1. using System.Runtime.InteropServices;
2. 
   
3. namespace CSharp_Server_For_Testing
4. {
5.     [Guid(Class1.IMyTest3_IID)]
6.     [ComVisible(true)]
7.     public interface IMyTest3
8.     {
9.         [DispId(333)] void Hello3(ref String str);
10.     }
11.     public partial class Class1 : IMyTest3
12.     {
13.         public const String IMyTest3_IID = "731D1161-8436-4827-AB75-F334A112B2F1";
14.         void IMyTest3.Hello3(ref String str)
15.         {
16.             Console.WriteLine("=======************** Hello world -3 *****************");
17.             GC.Collect();
18.             GC.WaitForPendingFinalizers();
19.             str = $"=== void IMyTest3.Hello3(ref String str) ===";
20.         }
21.         void Destructor()
22.         {
23.             Console.WriteLine();
24.             Console.WriteLine("~Class1()  Destructor()  -------------");
25.             Console.Beep();
26.             Console.WriteLine("------------- ~Class1()  Destructor() ");
27.         }
28.         ~Class1()
29.         {
30.             Destructor();
31.         }
32.         static Class1 MyClass1_obj = new Class1();
33.         static partial void MyMethod_Next_Interface3(in Guid IID, ref object? MyReturnObj)
34.         {
35.             if (IID == Guid.Parse(Class1.IMyTest3_IID))
36.             {
37.                 Console.WriteLine($"{IID}  MyMethod_Next_Interface3");
38.                 MyReturnObj = MyClass1_obj;
39.                 Console.WriteLine(" MyReturnObj = new Class1();");
40.                 Console.ReadKey();
41.             }
42.             else
43.             {
44.                 Console.WriteLine($"{IID}  ------Enter MyMethod_Next_Interface4");
45.                 MyMethod_Next_Interface4(in IID, ref MyReturnObj);
46.                 Console.WriteLine($"{IID}  ------Exit  MyMethod_Next_Interface4");
47.             }
48.         }
49.         static partial void MyMethod_Next_Interface4(in Guid IID, ref object? MyReturnObj);
50.     }
51. }

1. using System.Runtime.InteropServices;
2. 
   
3. namespace CSharp_Server_For_Testing
4. {
5.     [Guid(Class1.IMyTest_Event_IID)]
6.     [InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
7.     [ComVisible(true)]
8.     public interface IClass1Events
9.     {
10.         event EventHandler Event_MyTestFun;
11.     }
12. 
    
13.     [ComSourceInterfaces(typeof(IClass1Events))]
14.     [ProgId("MyTest_Chen.ProgId")]
15.     public partial class Class1 : IClass1Events
16.     {
17.         public const String IMyTest_Event_IID = "3AAEFAB5-6DC7-49FD-A658-44A8DEF91F02";
18.         private event EventHandler? EventHandler_MyTestFun;
19.         public event EventHandler? Event_MyTestFun
20.         {
21.             add
22.             {
23.                 Console.WriteLine($" add MyTestFun {value?.GetType().FullName}");
24.                 Console.WriteLine($" value is null = {value is null}");
25.                 Console.ReadKey();
26.                 if (value is not null) EventHandler_MyTestFun += value;
27.             }
28.             remove
29.             {
30.                 Console.WriteLine("remove MyTestFun ");
31.                 Console.ReadKey();
32.                 if (value is not null) EventHandler_MyTestFun -= value;
33.             }
34.         }
35.     }
36. }

1. #include "pch.h"
2. 
   
3. #if defined(_M_X64) && defined(_WIN64) && defined(_WINDOWS) && \
4.      _MSVC_LANG >= 202002L &&  defined(_USRDLL)
5. #include "TestParameter.h"
6. 
   
7. LPCOLESTR MyServerName = (LPCOLESTR)Server_Name_w(MultiInface_VB_NET\MultiInface_VB_NET\bin\x64\,
8.     My_Configuration, \net9.0\MultiInface_VB_NET.dll);
9. 
   
10. struct Microsoft_Example_Struct;
11. typedef INT32(*VB_Fun_Type)(LPSTR* str, LPWSTR* wstr);
12. typedef HRESULT(*CPP_Fun_Type)(PWSTR lpString, int nMaxCount);
13. typedef void  (*std_fun_ptr)(void);
14. __interface _MultiInterface : IDispatch {
15.     HRESULT Array_in(BSTR* result, SAFEARRAY* long_64_bit, SAFEARRAY* pDouble);
16.     HRESULT Array_In_Out(BSTR str, double* Double1, SAFEARRAY** DoubleArrary, SAFEARRAY** Lock);
17.     HRESULT Property_Get_Array(BSTR str, SAFEARRAY** pRetVal);
18.     HRESULT ArraysWithinStructures(Microsoft_Example_Struct P1, Microsoft_Example_Struct* P2);
19. };
20. __interface IMyTest2 : IDispatch {
21.     HRESULT Map_HRESULTs_and_Exceptions_1(long ID);
22.     HRESULT Map_HRESULTs_and_Exceptions_2(long ID);
23. };
24. __interface IMyTest3 : IDispatch {
25.     HRESULT TestFunctionPointer(CPP_Fun_Type CPP_Func, VB_Fun_Type* VB_Func);
26.     HRESULT Test_Delegate(std_fun_ptr CPP_Func);
27. };
28. 
    
29. class SafeArrayPtr {
30.     SAFEARRAY* ptr;
31. public:
32.     SafeArrayPtr(VARTYPE vt, UINT cDim, ULONG cElement1, ULONG cElement2 = 0) {
33.         SAFEARRAYBOUND SafeArrayBound[2] = { {cElement1,0},{cElement2,0} };
34.         ptr = SafeArrayCreate(vt, cDim, SafeArrayBound);
35.         if (!ptr)throw "SafeArrayCreate";
36.     }
37.     ~SafeArrayPtr() {
38.         SafeArrayDestroy(ptr);
39.         ptr = NULL;
40.     }
41.     ULONG CountOfElement(int Dim) { return ptr->rgsabound[Dim].cElements; }
42.     SAFEARRAY* operator->() { return ptr; }
43.     SafeArrayPtr& operator =(SAFEARRAY* ptr) { this->ptr = ptr; return *this; }
44.     SAFEARRAY** operator&() { return &ptr; }
45.     operator SAFEARRAY* () { return ptr; }
46. };
47. void MultiInterface_Array_in(ExportedData& ED, _MultiInterface* p_MultiInterface) {
48.     HRESULT hr;
49.     const int Count_Of_dim1 = 12;
50.     SafeArrayPtr pSafeArray_Double(VT_R8, 1, Count_Of_dim1);
51.     SafeArrayPtr pSafeArray_LongLong(VT_I8, 1, Count_Of_dim1);
52.     double* pdouble = NULL;
53.     long long* ptr_LongLong = NULL;
54.     if (SUCCEEDED(SafeArrayAccessData(pSafeArray_Double, (void**)&pdouble)) &&
55.         SUCCEEDED(SafeArrayAccessData(pSafeArray_LongLong, (void**)&ptr_LongLong)))
56.     {
57.         for (int ii = 0; ii < pSafeArray_Double.CountOfElement(0); ii++) {
58.             pdouble[ii] = ii * 10 + 5;
59.             ptr_LongLong[ii] = 100 * ii + 7;
60.         }
61.         SafeArrayUnaccessData(pSafeArray_Double);
62.         SafeArrayUnaccessData(pSafeArray_LongLong);
63.         BSTR str = NULL;
64.         hr = p_MultiInterface->Array_in(&str, pSafeArray_LongLong, pSafeArray_Double);
65.         if (SUCCEEDED(hr)) ED.WriteLine(L"%s", str);
66.         //if (SUCCEEDED(hr)) printf("%S",str);
67.         else    ED.WriteLine(L"error: p_MultiInterface->Array_in hr=%X", hr);
68.         ::SysFreeString(str);
69.     }
70. }
71. void MultiInterface_Array_In_Out(ExportedData& ED, _MultiInterface* p_MultiInterface) {
72.     HRESULT hr;
73. 
    
74.     SafeArrayPtr  pSafeArray_In_Out_Lock(VT_R8, 1, 500000);
75.     SAFEARRAY* pSafeArray_In_Out_Lock_Original = pSafeArray_In_Out_Lock;
76.     SafeArrayLock(pSafeArray_In_Out_Lock);
77.     double* pDouble_in_Lock, * pDouble_out_Lock;
78.     SafeArrayAccessData(pSafeArray_In_Out_Lock, (void**)&pDouble_in_Lock);
79.     SafeArrayUnaccessData(pSafeArray_In_Out_Lock);
80.     //--------------------------------------------------
81.     SafeArrayPtr  pMy_SafeArray(VT_R8, 1, 500);
82.     double* pDouble_in, * pDouble_out;
83.     double Double1 = 123.456789;
84.     SafeArrayAccessData(pMy_SafeArray, (void**)&pDouble_in);
85.     pDouble_in[1] = 111.111;
86.     SafeArrayUnaccessData(pMy_SafeArray);
87.     BSTR str2 = SysAllocString(L"MultiInterface_Array_In_Out");
88.     hr = p_MultiInterface->Array_In_Out(str2, &Double1, &pMy_SafeArray, &pSafeArray_In_Out_Lock);
89.     ::SysFreeString(str2);
90.     if (SUCCEEDED(hr)) {
91.         wprintf(L"Double1      = %f\n", Double1);
92.         SafeArrayAccessData(pMy_SafeArray, (void**)&pDouble_out);
93.         wprintf(L"pDouble2[1]  = %f\n", pDouble_out[1]);
94.         wprintf(L"pDouble2[33] = %f\n", pDouble_out[33]);
95.         SafeArrayUnaccessData(pMy_SafeArray);
96.         if (pDouble_in != pDouble_out) {
97.             wprintf(L"pDouble_in   (%p)\n", pDouble_in);
98.             wprintf(L"pDouble_out  (%p)\n", pDouble_out);
99.         }
100.         //-------------------------------------------------
101.         SafeArrayAccessData(pSafeArray_In_Out_Lock, (void**)&pDouble_out_Lock);
102.         wprintf(L"pDouble_out_Lock[22]   (%f)\n", pDouble_out_Lock[22]);
103.         SafeArrayUnaccessData(pSafeArray_In_Out_Lock);
104.         if (pDouble_in_Lock != pDouble_out_Lock) {
105.             wprintf(L"pDouble_in_Lock != pDouble_out_Lock\n");
106.         }
107.         if (pSafeArray_In_Out_Lock != pSafeArray_In_Out_Lock_Original) {
108.             wprintf(L"pSafeArray_In_Out_Lock != pSafeArray_In_Out_Lock_Original\n");
109.             SafeArrayDestroy(pSafeArray_In_Out_Lock);
110.             pSafeArray_In_Out_Lock = pSafeArray_In_Out_Lock_Original;
111.         }
112.     }
113.     SafeArrayUnlock(pSafeArray_In_Out_Lock);
114. }
115. void MultiInterface_Property_Get_Array(ExportedData& ED, _MultiInterface* p_MultiInterface) {
116.     HRESULT hr;
117.     SAFEARRAY* pSafeArray = NULL;
118.     BSTR str2 = SysAllocString(L"MultiInterface_Property_Get_Array");
119.     hr = p_MultiInterface->Property_Get_Array(str2, &pSafeArray);
120.     ::SysFreeString(str2);
121.     if (SUCCEEDED(hr)) {
122.         double* pDouble;
123.         SafeArrayLock(pSafeArray);
124.         hr = SafeArrayAccessData(pSafeArray, (void**)&pDouble);
125.         if (SUCCEEDED(hr)) {
126.             LONG LowerBound;
127.             SafeArrayGetLBound(pSafeArray, 1, &LowerBound);
128.             LONG UpperBound;
129.             SafeArrayGetUBound(pSafeArray, 1, &UpperBound);
130.             for (int aa = LowerBound; aa <= UpperBound; aa++) {
131.                 ED.WriteLine(L"Property_Get_Array pDouble(%d) = %f", aa, pDouble[aa]);
132.             }
133.             SafeArrayUnaccessData(pSafeArray);
134.         }
135.         SafeArrayUnlock(pSafeArray);
136.         SafeArrayDestroy(pSafeArray);
137.     }
138. }
139. struct Microsoft_Example_Struct {
140.     short s1[128];
141.     WCHAR* f1;
142.     WCHAR f2[256];
143.     BSTR f3;
144. };
145. void MultiInterface_ArraysWithinStructures(ExportedData& ED, _MultiInterface* p_MultiInterface) {
146.     HRESULT hr;
147.     WCHAR* f_1 = const_cast<WCHAR*>(L"ABCDEF");
148.     BSTR f_3 = ::SysAllocString(L"CPP_f3");
149.     Microsoft_Example_Struct P1{ {},f_1,L"CPP_f2",f_3 }, P2{ {},NULL,{},NULL };
150.     P1.s1[10] = 4444;
151.     P2.s1[10] = 5555;
152.     hr = p_MultiInterface->ArraysWithinStructures(P1, &P2);
153.     ::SysFreeString(f_3);
154.     if (SUCCEEDED(hr)) {
155.         ED.WriteLine(L"P1.s1[10]=%d", P1.s1[10]);
156.         ED.WriteLine(L"P2.s1[10]=%d", P2.s1[10]);
157.         PAUSE
158.     }
159. }
160. 
     
161. void IMyTest2_Map_HRESULTs_and_Exceptions_1(ExportedData& ED, IMyTest2* pIMyTest2) {
162.     for (int id = 0X234; id < 0X238; id++)
163.     {
164.         HRESULT hr;
165.         hr = pIMyTest2->Map_HRESULTs_and_Exceptions_1(id);
166.         if (FAILED(hr)) {
167.             ED.WriteLine(L"hr=%X", hr);
168.             IErrorInfo* pError;
169.             hr = GetErrorInfo(0, &pError);
170.             if (SUCCEEDED(hr)) {
171.                 BSTR Description, source;
172.                 pError->GetDescription(&Description);
173.                 pError->GetSource(&source);
174.                 ED.WriteLine(L"Description=%s", Description);
175.                 ED.WriteLine(L"Source=%s", source);
176.                 SysFreeString(Description); SysFreeString(source);
177.                 pError->Release();
178.             }
179.         }
180.     }
181. }
182. void IMyTest2_Map_HRESULTs_and_Exceptions_2(ExportedData& ED, IMyTest2* pIMyTest2) {
183.     for (int ID = 1; ID <= 5; ID++) {
184.         HRESULT hr;
185.         hr = pIMyTest2->Map_HRESULTs_and_Exceptions_2(ID);
186.         if (FAILED(hr)) ED.WriteLine(L"hr=%X", hr);
187.         hr = [=]()->HRESULT {
188.             HR_(pIMyTest2->Map_HRESULTs_and_Exceptions_2(ID), 334455)
189.                 return S_OK;
190.             }();
191.         ED.WriteLine(L"rerurnValue=%d", hr);
192.     }
193.     PAUSE
194. }
195. HRESULT Fixed_length_string_buffer(PWSTR lpString, int nMaxCount) {
196.     printf("\nCPP_Function\n");
197.     StringCchCopyW(lpString, nMaxCount, L"Fixed_length_string_buffer");
198.     return S_OK;
199. }
200. 
     
201. void IMyTest3_TestFunctionPointer(ExportedData& ED, IMyTest3* pIMyTest3) {
202.     VB_Fun_Type VB_Fun;
203.     HRESULT hr;
204. 
     
205.     hr = pIMyTest3->TestFunctionPointer(Fixed_length_string_buffer, &VB_Fun);
206.     if (FAILED(hr)) ED.WriteLine(L"Error: hr=%X in IMyTest3_TestFunctionPointer", hr);
207.     INT32 retVal;
208.     for (int64_t aa = 0; aa < 3; aa++) {
209.         LPSTR str = NULL;
210.         LPWSTR wstr = NULL;
211.         retVal = VB_Fun(&str, &wstr);
212.         printf("(%s) retVal=%d\n", str, retVal);
213.         printf("(%S)\n", wstr);
214.     }
215. }
216. 
     
217. void IMyTest3_Test_Delegate(ExportedData& ED, IMyTest3* pIMyTest3) {
218.     HRESULT hr;
219. 
     
220.     hr = pIMyTest3->Test_Delegate((std_fun_ptr)Fixed_length_string_buffer);
221.     if (FAILED(hr)) ED.WriteLine(L" ->hr=%X in IMyTest3_Test_Delegate", hr);
222. }
223. #define LOOP1(xx) for(int64_t aaa =0 ; aaa < xx ; aaa++)
224. 
     
225. extern "C"
226. int CPP_DLL_Test_MultiInterface(TestParameter* ptr) {
227.     ExportedData ED(ptr, L"CPP_DLL_Test_MultiInterface");
228.     int rv = 0;
229.     try
230.     {
231.         IMyTest3* pIMyTest3;
232.         _MultiInterface* p_MultiInterface;
233.         IMyTest2* pIMyTest2;
234.         [&]() {
235.             ServerInfo_Struct<LPCOLESTR> My_Server_string = {
236.               MyServerName,
237.               (LPCOLESTR)OLESTR("MultiInface_VB_NET.MultiInterface"),
238.               (LPCOLESTR)OLESTR("CreateObject4_Chen"),
239.               (LPCOLESTR)OLESTR("77381cf4-badb-4ee7-b51f-9090fe145c39"),
240.               (LPCOLESTR)OLESTR("636B8701-78D1-482C-9A2A-E7259C23AEB5")
241.             };
242.             rv = Get_ServerInterface4(ptr, My_Server_string, (PVOID*)&p_MultiInterface);
243.             if (rv)throw std::exception("Get_ServerInterface", rv);
244.             LOOP1(2) MultiInterface_Array_in(ED, p_MultiInterface);
245.             //PAUSE
246.             LOOP1(2) MultiInterface_Array_In_Out(ED, p_MultiInterface);
247.             //PAUSE
248.             MultiInterface_Property_Get_Array(ED, p_MultiInterface);
249.             MultiInterface_ArraysWithinStructures(ED, p_MultiInterface);
250.             }();
251.         [&]() {
252.             ServerInfo_Struct<LPCOLESTR> My_Server_string = {
253.               MyServerName,
254.               (LPCOLESTR)OLESTR("MultiInface_VB_NET.MultiInterface"),
255.               (LPCOLESTR)OLESTR("CreateObject4_Chen"),
256.               (LPCOLESTR)OLESTR("77381cf4-badb-4ee7-b51f-9090fe145c39"),
257.               (LPCOLESTR)OLESTR("31D53FF8-4768-4A77-95E3-DC28DEBB375F")
258.             };
259.             rv = Get_ServerInterface4(ptr, My_Server_string, (PVOID*)&pIMyTest2);
260.             if (rv)throw std::exception("Get_ServerInterface", rv);
261.             IMyTest2_Map_HRESULTs_and_Exceptions_1(ED, pIMyTest2);
262.             IMyTest2_Map_HRESULTs_and_Exceptions_2(ED, pIMyTest2);
263.             }();
264.         [&]() {
265.             ServerInfo_Struct<LPCOLESTR> My_Server_string = {
266.               MyServerName,
267.               (LPCOLESTR)OLESTR("MultiInface_VB_NET.MultiInterface"),
268.               (LPCOLESTR)OLESTR("CreateObject4_Chen"),
269.               (LPCOLESTR)OLESTR("77381cf4-badb-4ee7-b51f-9090fe145c39"),
270.               (LPCOLESTR)OLESTR("9E7F18F8-3B02-4AE0-89A9-DD35240BF509")
271.             };
272.             rv = Get_ServerInterface4(ptr, My_Server_string, (PVOID*)&pIMyTest3);
273.             if (rv)throw std::exception("Get_ServerInterface", rv);
274.             IMyTest3_TestFunctionPointer(ED, pIMyTest3);
275.             IMyTest3_Test_Delegate(ED, pIMyTest3);
276.             //PAUSE
277.             }();
278. 
     
279.         wprintf(L"%p(%d)p_MultiInterface\n", p_MultiInterface, p_MultiInterface->Release());
280.         wprintf(L"%p(%d)pIMyTest2       \n", pIMyTest2, pIMyTest2->Release());
281.         wprintf(L"%p(%d)pIMyTest3       \n", pIMyTest3, pIMyTest3->Release());
282.         PAUSE
283.     }
284.     catch (const std::exception& ex)
285.     {
286.         printf("exception:(%s) in multi-Interface \n", ex.what());
287.     }
288.     return rv;
289. }
290. #endif 

1. LIBRARY
2. EXPORTS
3. CPP_DLL_Test_MultiInterface @1

1. Imports System.Buffers
2. Imports System.Reflection
3. Imports System.Runtime.InteropServices
4. Imports System.Runtime.InteropServices.Marshalling
5. Imports System.Text
6. 
   
7. <ComClass(MultiInterface.MultiInterface_CLSID, MultiInterface.I_MultiInterface_IID, MultiInterface.EventsId)>
8. Public Class MultiInterface : Implements IMyTest2, IMyTest3
9. #Region "COM GUIDs"
10.     ' These  GUIDs provide the COM identity for this class 
11.     ' and its COM interfaces. If you change them, existing 
12.     ' clients will no longer be able to access the class.
13.     Public Const MultiInterface_CLSID As String = "77381cf4-badb-4ee7-b51f-9090fe145c39"
14.     Public Const I_MultiInterface_IID As String = "636b8701-78d1-482c-9a2a-e7259c23aeb5"
15.     Public Const IMyTest2_IID As String = "31D53FF8-4768-4A77-95E3-DC28DEBB375F"
16.     Public Const IMyTest3_IID As String = "9E7F18F8-3B02-4AE0-89A9-DD35240BF509"
17.     Public Const EventsId As String = "c340a1eb-b81b-4553-bc5c-db85fdd3cfc0"
18. #End Region
19. 
    
20.     Public Sub New()
21.         MyBase.New()
22.         MyStringBuilder = New StringBuilder()
23.     End Sub
24.     Dim MyStringBuilder As StringBuilder
25.     Sub Array_in(<Out> ByRef str As String, <[In]> long_64_bit As Long(),
26.            <[In]> pDouble As Double())
27.         MyStringBuilder.Clear()
28.         MyStringBuilder.AppendLine("Array_in *** IN")
29.         MyStringBuilder.AppendLine($"LowerBound= {pDouble.GetLowerBound(0)} UpperBound={pDouble.GetUpperBound(0)}")
30.         For ii As Int32 = pDouble.GetLowerBound(0) To pDouble.GetUpperBound(0)
31.             MyStringBuilder.AppendLine($"{ii:d2}: {pDouble(ii):F2}{vbTab} {long_64_bit(ii)}")
32.         Next
33.         MyStringBuilder.AppendLine("Array_in *** OUT")
34.         str = MyStringBuilder.ToString()
35.     End Sub
36. 
    
37.     Sub Array_In_Out(<[In]> str As String,
38.       <[In], Out> ByRef Double1 As Double,
39.       <[In], Out> ByRef DoubleArray_inOut As Double(),
40.       <[In], Out> ByRef DoubleArray_In_Out_Lock As Double()
41.                      )
42.         Dim Len As Integer = DoubleArray_inOut.GetLength(0)
43.         Console.WriteLine(str)
44.         Console.WriteLine($"Length of DoubleArray = {Len} --- .NET")
45.         Console.WriteLine($"Double1               = {Double1} -- .NET")
46.         Console.WriteLine($"DoubleArray(1)        ={DoubleArray_inOut(1)} --- .NET")
47. 
    
48.         Double1 = 987.654321
49.         DoubleArray_inOut(33) = 33.33
50.         DoubleArray_In_Out_Lock(22) = 22.22
51.     End Sub
52.     Dim _DoubleArray(8) As Double
53.     ReadOnly Property Property_Get_Array(<[In]> str As String) _
54.       As <MarshalAs(UnmanagedType.SafeArray, SafeArraySubType:=VarEnum.VT_R8)> Double()
55.         Get
56.             Console.WriteLine(str)
57.             Dim Len As Integer = _DoubleArray.GetLength(0)
58.             Console.WriteLine($"Property_Get_Array ---  Length = {Len}")
59.             For aa As Integer = _DoubleArray.GetLowerBound(0) To _DoubleArray.GetUpperBound(0)
60.                 _DoubleArray(aa) = aa * 200 + 7
61.             Next
62.             Return _DoubleArray
63.         End Get
64.     End Property
65.     Sub ArraysWithinStructures(<[In]> P1 As Microsoft_Example_Struct,
66.                                <[In], Out> ByRef P2 As Microsoft_Example_Struct)
67.         Console.WriteLine($"P1.f1={P1.f1}         -- .NET")
68.         Console.WriteLine($"P1.f2={P1.f2}         -- .NET")
69.         Console.WriteLine($"P1.f3={P1.f3}         -- .NET")
70.         If P1.f2 <> "CPP_f2" Then
71.             Throw New Exception("P1.f2 <> CPP_f2")
72.         End If
73.         Console.WriteLine($"P1.s1(10)={P1.s1(10)} -- .NET")
74.         Console.WriteLine($"P2.s1(10)={P2.s1(10)} -- .NET")
75.         P1.s1(10) = -987
76.         P2.s1(10) = 1010
77.         Console.ReadKey()
78.     End Sub
79.     '================ IMyTest2 =======================
80.     Private Sub Map_HRESULTs_and_Exceptions_1(ID As Int32) Implements IMyTest2.Map_HRESULTs_and_Exceptions_1
81.         Dim ApplicationException As New ApplicationException("My description in MyTest1")
82.         ApplicationException.HResult = (7 << 29) Or ID
83.         ApplicationException.Source = "MyTest1"
84.         Console.WriteLine($"hr={ApplicationException.HResult:X} -- MyTest1")
85.         Throw ApplicationException
86.     End Sub
87.     Private Sub Map_HRESULTs_and_Exceptions_2(ID As Int32) Implements IMyTest2.Map_HRESULTs_and_Exceptions_2
88.         Select Case ID
89.             Case 1
90.                 Try
91.                     Assembly.LoadFrom("")
92.                 Catch ex As Exception
93.                     Dim What_is_this As New ArgumentException
94.                     Console.WriteLine(
95.                         $"hr={ex.HResult:X} == {What_is_this.HResult:X} {What_is_this}")
96.                 End Try
97.                 Assembly.LoadFrom("")
98.             Case 2
99.                 Dim _INT64 As Int64
100.                 Try
101.                     _INT64 = 2 / (ID - 2)
102.                 Catch ex As Exception
103.                     Dim What_is_this As New OverflowException
104.                     Console.WriteLine(
105.                         $"hr={ex.HResult:X} == {What_is_this.HResult:X} {What_is_this}")
106.                 End Try
107.                 _INT64 = 2 / (ID - 2)
108.             Case 5
109.             Case Else
110.                 Dim MyException As New Exception With {
111.                       .HResult = (7 << 29) Or ID}
112.                 Throw MyException
113.         End Select
114.     End Sub
115.     Protected Delegate Function MyFunction_CPP(<Out> lpString() As Char, nMaxCount As Integer) As Int32
116.     Protected Delegate Function MyFunction_VB(<[In], Out> ByRef str As String,
117.                <[In], Out, MarshalAs(UnmanagedType.LPWStr)> ByRef wstr As String) As Int32
118.     Shared Function VB_Func1(<[In], Out> ByRef str As String,
119.                <[In], Out, MarshalAs(UnmanagedType.LPWStr)> ByRef wstr As String) As Int32
120.         str = "Shared Function VB_Func1(<[In], Out> ByRef str As String,....) As Int32"
121.         wstr = "Shared Function VB_Func1(...,  <[In], Out, MarshalAs(UnmanagedType.LPWStr)> ByRef wstr As String) As Int32"
122.         Return 34567
123.     End Function
124.     '================ IMyTest2 =======================
125. 
     
126.     '================ IMyTest3 =======================
127.     Private Sub TestFunctionPointer(<[In]> CPP_FuncPtr As IntPtr,
128.                                     <[In], Out> ByRef VB_Func As IntPtr
129.          ) Implements IMyTest3.TestFunctionPointer
130.         Dim temp_Delegate As [Delegate] = [Delegate].CreateDelegate(GetType(MyFunction_VB),
131.                   GetType(MultiInterface).GetMethod("VB_Func1"))
132.         VB_Func = Marshal.GetFunctionPointerForDelegate(Of MyFunction_VB)(
133.                   CType(temp_Delegate, MyFunction_VB))
134.         '---------------
135.         Dim CPP_Func As MyFunction_CPP =
136.             Marshal.GetDelegateForFunctionPointer(Of MyFunction_CPP)(CPP_FuncPtr)
137.         Const Length As Int32 = 256
138.         Dim buffer() As Char = ArrayPool(Of Char).Shared.Rent(Length)
139.         Dim hResult As Int32 = CPP_Func.Invoke(buffer, Length)
140.         Dim str As New String(buffer)
141.         Console.WriteLine($"hResult={hResult}  {str}")
142.         ArrayPool(Of Char).Shared.Return(buffer)
143.         'Console.ReadKey()
144.     End Sub
145.     Private Sub Test_Delegate(<[In]> CPP_FuncPtr As IntPtr) Implements IMyTest3.Test_Delegate
146.         Dim hResult As Int32
147.         Const Length As Int32 = 256
148.         Dim buffer() As Char = ArrayPool(Of Char).Shared.Rent(Length)
149.         Dim ParamList As Object() = {buffer, Length}
150.         Dim CPP_Func As MyFunction_CPP
151.         Try
152.             CPP_Func = Marshal.GetDelegateForFunctionPointer(Of MyFunction_CPP)(CPP_FuncPtr)
153.             hResult = CPP_Func.DynamicInvoke(ParamList)
154.         Catch ex As Exception
155.             Console.WriteLine($"Error: {ex.Message} ")
156.             Console.ReadKey()
157.         End Try
158.         Console.WriteLine($"Test_Delegate ---hResult={hResult}  {New String(buffer)}")
159.         ArrayPool(Of Char).Shared.Return(buffer)
160.     End Sub
161.     '================ IMyTest3 =======================
162. 
     
163.     Shared MyMultiInterface_Object As MultiInterface
164. 
     
165.     Shared Function CreateObject4_Chen(ByRef IID As Guid,
166.         Not_Used As IntPtr) As Object
167.         If MyMultiInterface_Object Is Nothing Then
168.             MyMultiInterface_Object = New MultiInterface
169.         End If
170. 
     
171.         Dim MyIID As Guid = Guid.Parse(I_MultiInterface_IID)
172.         Dim MyIID2 As Guid = Guid.Parse(IMyTest2_IID)
173.         Dim MyIID3 As Guid = Guid.Parse(IMyTest3_IID)
174.         If MyIID = IID OrElse MyIID2 = IID OrElse MyIID3 = IID Then
175.             'Console.WriteLine("CreateObject4_Chen ---Object")
176.             Return MyMultiInterface_Object
177.         End If
178.         'Console.WriteLine("CreateObject4_Chen Nothing")
179.         Return Nothing
180.     End Function
181. 
     
182. End Class
183. 
     
184. <Guid(MultiInterface.IMyTest3_IID)>
185. Public Interface IMyTest3
186.     Sub TestFunctionPointer(<[In]> MyFunc As IntPtr, <[In], Out> ByRef VB_Func As IntPtr)
187.     Sub Test_Delegate(<[In]> MyFunc As IntPtr)
188. End Interface
189. 
     
190. <Guid(MultiInterface.IMyTest2_IID)>
191. Public Interface IMyTest2
192.     Sub Map_HRESULTs_and_Exceptions_1(ID As Int32)
193.     Sub Map_HRESULTs_and_Exceptions_2(ID As Int32)
194. End Interface
195. 
     
196. <StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
197. Public Structure Microsoft_Example_Struct
198.     <MarshalAs(UnmanagedType.ByValArray, SizeConst:=128)> Public s1() As Int16
199.     <MarshalAs(UnmanagedType.LPWStr)> Public f1 As String
200.     <MarshalAs(UnmanagedType.ByValTStr, SizeConst:=256)> Public f2 As String
201.     <MarshalAs(UnmanagedType.BStr)> Public f3 As String
202. End Structure
203. Public Structure RetValue4
204.     Public ppvoid As Object
205. End Structure
206. 
     
207. <GeneratedComInterface>
208. <InterfaceType(ComInterfaceType.InterfaceIsIUnknown)>
209. Interface IMyTest_1
210.     Sub MyTest1(ID As Int32)
211.     Sub MyTest2(ID As Int32)
212. End Interface
213. 
     
214. <GeneratedComInterface>
215. <InterfaceType(ComInterfaceType.InterfaceIsIUnknown)>
216. Interface IMyTest_2 : Inherits IMyTest_1
217.     Sub MyTest3(<[In]> MyFunc As IntPtr)
218. End Interface
219. ' If you do not have a type library for an interface
220. ' you can redeclare it using ComImportAttribute.
221. 
     
222. ' This is how the interface would look in an idl file.
223. 
     
224. '[
225. 'object,
226. 'uuid("73EB4AF8-BE9C-4b49-B3A4-24F4FF657B26"),
227. 'dual, helpstring("IMyStorage Interface"),
228. 'pointer_default(unique)
229. ']
230. 'interface IMyStorage : IDispatch
231. '{
232. ' [id(1)]
233. ' HRESULT GetItem([in] BSTR bstrName, [out, retval] IDispatch ** ppItem);
234. ' [id(2)]
235. ' HRESULT GetItems([in] BSTR bstrLocation, [out] SAFEARRAY(VARIANT)* pItems);
236. ' [id(3)]
237. ' HRESULT GetItemDescriptions([in] BSTR bstrLocation, [out] SAFEARRAY(VARIANT) ** ppItems);
238. ' [id(4), propget]
239. ' HRESULT get_IsEmpty([out, retval] BOOL * pfEmpty);
240. '};
241. 
     
242. ' This is the managed declaration.
243. 
     
244. <ComImport(), Guid("73EB4AF8-BE9C-4b49-B3A4-24F4FF657B26")>
245. Public Interface IMyStorage
246.     <DispId(1)>
247.     Function GetItem(<InAttribute(), MarshalAs(UnmanagedType.BStr)> ByVal bstrName As String) _
248.            As <MarshalAs(UnmanagedType.Interface)> Object
249. 
     
250.     <DispId(2)>
251.     Function GetItems(<InAttribute(), MarshalAs(UnmanagedType.BStr)> ByVal bstrLocation As String,
252.            <OutAttribute(), MarshalAs(UnmanagedType.SafeArray, SafeArraySubType:=VarEnum.VT_VARIANT)>
253.                                       ByVal Items() As Object)
254. 
     
255.     <DispId(3)>
256.     Function GetItemDescriptions(<InAttribute()> ByVal bstrLocation As String,
257.            <InAttribute(), OutAttribute(),
258.                       MarshalAs(UnmanagedType.SafeArray)> ByRef varDescriptions() As Object)
259. 
     
260.     <DispId(4)>
261.     ReadOnly Property IsEmpty(<MarshalAs(UnmanagedType.VariantBool)> ByVal bEmpty As Boolean)
262. 
     
263. End Interface
264. 
     
265. 
     

1. LIBRARY
2. EXPORTS
3. CPP_DLL_Test_UnregisteredServer1          @1
4. CPP_DLL_Test_UnregisteredServer2          @2
5. CPP_DLL_Test_IXXXX                              @3

1. #include "pch.h"
2. 
   
3. #if defined(_M_X64) && defined(_WIN64) && defined(_WINDOWS) && \
4.      _MSVC_LANG >= 202002L &&  defined(_USRDLL)
5. #include "TestParameter.h"
6. 
   
7. extern "C" /* exported functions */ {
8.     int CPP_DLL_Test_UnregisteredServer1(TestParameter*);
9.     int CPP_DLL_Test_UnregisteredServer2(TestParameter*);
10.     int CPP_DLL_Test_IXXXX(TestParameter*);
11. }
12. 
    
13. LPCOLESTR MyServerName = Server_Name_w(dotNET_ClassLibrary\dotNET_ClassLibrary\bin\x64\,
14.     My_Configuration, \net9.0\dotNET_ClassLibrary.dll);
15. 
    
16. ServerInfo_Struct<LPCOLESTR> My_Server_string[] = {
17.   {
18.      MyServerName,
19.      (LPCOLESTR)OLESTR("DotNet_ClassLibrary.MyUnregisterServer1"),
20.      (LPCOLESTR)OLESTR("CreateObject4_Chen"),
21.      (LPCOLESTR)OLESTR("04D9F530-CE0C-4232-8F3F-6E0A3244C715"),
22.      (LPCOLESTR)OLESTR("31D53FF8-4768-4A77-95E3-DC28DEBB375F")
23.   },{
24.      MyServerName,
25.      (LPCOLESTR)OLESTR("DotNet_ClassLibrary.MyUnregisterServer2"),
26.      (LPCOLESTR)OLESTR("CreateObject3_Chen"),
27.      (LPCOLESTR)OLESTR("7FDF74B5-2E5D-4B72-B3A3-5BA424645F0D"),
28.      (LPCOLESTR)OLESTR("FDD5D79A-386E-49D0-AF60-81222A990055")
29.   },{
30.      MyServerName,
31.      (LPCOLESTR)OLESTR("DotNet_ClassLibrary.MyUnregisterServer2"),
32.      (LPCOLESTR)OLESTR("CreateObject4_Chen"),
33.      (LPCOLESTR)OLESTR("7FDF74B5-2E5D-4B72-B3A3-5BA424645F0D"),
34.      (LPCOLESTR)OLESTR("FDD5D79A-386E-49D0-AF60-81222A990055")
35.   }
36. };
37. /* Begin CPP_DLL_Test_UnregisteredServer1 */
38. void This_Delegate_will_be_called_While_RaiseEvent(VARIANTARG VAR) {
39.     ExportedData::MySelf()->WriteLine(L"This_Delegate_will_be_called_While_RaiseEvent(VT_BSTR=%d V_VT(&VAR)=%d)",
40.         VT_BSTR, V_VT(&VAR));
41.     ExportedData::MySelf()->WriteLine(L"<@%s@>", V_BSTR(&VAR));
42. }
43. __interface IUnregisteredServer1 :IDispatch
44. {
45.     HRESULT Get_Interface(PVOID*);
46.     HRESULT Get_Interface2(long, VARIANTARG*);
47.     HRESULT Register_Event(void (*)(VARIANT), BSTR, INT32* ID);
48.     HRESULT RemoveEvent(INT32 ID);
49.     HRESULT Raise_Event(LONG64);
50.     HRESULT Get_MyProperty(INT32*);
51.     HRESULT Put_MyProperty(INT32 pRetVal);
52.     HRESULT GetTraceMessage(BSTR*);
53. };
54. int CPP_DLL_Test_UnregisteredServer1(TestParameter* ptr) {
55.     HRESULT hr;
56.     ExportedData ED(ptr, L"Test_UnregisteredServer1 CPP_DLL");
57.     IUnregisteredServer1* pIUnregisteredServer1 = NULL;
58.     int rv = Get_ServerInterface4(ptr, My_Server_string[0], (PVOID*)&pIUnregisteredServer1);
59.     if (rv)return rv;
60. 
    
61.     INT32 _INT32 = 777;
62.     ED.WriteLine(L"(%d)", _INT32);
63.     pIUnregisteredServer1->Get_MyProperty(&_INT32);
64.     ED.WriteLine(L"(%d)", _INT32);
65. 
    
66.     INT32 EventID[3]{};
67.     BSTR MyString_BSTR = SysAllocString(L"Register_Event(&This_Delegate_will_be_called_While_RaiseEvent, MyString_BSTR)");
68.     for (INT64 aa = 21; aa < 25; aa++) {
69.         for (INT32 bb = 0; bb < sizeof(EventID) / sizeof(EventID[0]); bb++) {
70.             pIUnregisteredServer1->Register_Event(&This_Delegate_will_be_called_While_RaiseEvent,
71.                 MyString_BSTR, &EventID[bb]);
72.         }
73.         pIUnregisteredServer1->Raise_Event(aa);
74.         for (INT32 bb = 0; bb < sizeof(EventID) / sizeof(EventID[0]); bb++) {
75.             pIUnregisteredServer1->RemoveEvent(EventID[bb]);
76.         }
77.     }
78.     ::SysFreeString(MyString_BSTR);
79. 
    
80.     int errorCode = 0;
81.     IUnknown* ptr_IUnknown1 = NULL;
82.     IUnknown* ptr_IUnknown2 = NULL;
83.     IUnknown* ptr_IUnknown3 = NULL;
84.     IDispatch* ptr_IDispatch = NULL;
85.     hr = pIUnregisteredServer1->Get_Interface((PVOID*)&ptr_IUnknown1);
86.     if (FAILED(hr)) {
87.         ED.WriteLine(L"error: pIUnregisteredServer1->Get_Interface hr=%X", hr);
88.     }
89.     VARIANT _variant;
90.     VariantInit(&_variant);
91.     hr = pIUnregisteredServer1->Get_Interface2(2, &_variant);
92.     if (FAILED(hr)) {
93.         ED.WriteLine(L"error: pIUnregisteredServer1->Get_Interface2 hr=%X", hr);
94.     }
95. 
    
96.     if (V_VT(&_variant) == VT_UNKNOWN) {
97.         ptr_IUnknown2 = V_UNKNOWN(&_variant);
98.         if (ptr_IUnknown2 != ptr_IUnknown1) errorCode = 1;
99.     }
100.     else if (V_VT(&_variant) == VT_DISPATCH) {
101.         ptr_IDispatch = V_DISPATCH(&_variant);
102.         if (ptr_IUnknown1 + 1 != ptr_IDispatch) errorCode = 2;
103.     }
104.     else errorCode = 3;
105.     if (errorCode) {
106.         pIUnregisteredServer1->QueryInterface(IID_IUnknown, (void**)&ptr_IUnknown3);
107.         printf("         ptr_IUnknown3=%p\n", ptr_IUnknown3);
108.         printf("         ptr_IUnknown2=%p\n", ptr_IUnknown2);
109.         printf("         ptr_IUnknown1=%p\n", ptr_IUnknown1);
110.         printf("         ptr_IDispatch=%p\n", ptr_IDispatch);
111.         printf(" pIUnregisteredServer1=%p\n", pIUnregisteredServer1);
112.         ED.WriteLine(
113.             L"error: V_VT(&_variant)=%d VT_DISPATCH:%d VT_UNKNOWN=%d errorCode=%d",
114.             V_VT(&_variant), VT_DISPATCH, VT_UNKNOWN, errorCode
115.         );
116.     }
117. 
     
118.     BSTR MyMessage = NULL;
119.     pIUnregisteredServer1->GetTraceMessage(&MyMessage);
120.     ED.WriteLine(L"GetTraceMessage");
121.     ED.WriteLine(L"%s", MyMessage);
122.     SysFreeString(MyMessage);
123.     return 0;
124. }
125. /* End  CPP_DLL_Test_UnregisteredServer1 */
126. // 1 ======================================================= 2
127. /* Begin CPP_DLL_Test_UnregisteredServer2 */
128. __interface IUnregisteredServer2_CPP :public IDispatch
129. {
130. public:
131.     HRESULT DefaultMarshallingForObject(VARIANT* v, VARIANT* v2, VARIANT* v3);
132.     HRESULT Map_HResultAndException(BSTR* display);
133.     HRESULT Hello_world3(
134.         DECIMAL decimal2,
135.         GUID guid2,
136.         BSTR* outputResult
137.     );
138. 
     
139.     virtual HRESULT STDMETHODCALLTYPE QueryInterface2(
140.         /* [in] */ REFIID riid,
141.         /* [annotation][iid_is][out] */
142.         _COM_Outptr_  void** ppvObject) = 0;
143. 
     
144.     virtual ULONG STDMETHODCALLTYPE AddRef2(void) = 0;
145. 
     
146.     virtual ULONG STDMETHODCALLTYPE Release2(void) = 0;
147. 
     
148.     virtual HRESULT STDMETHODCALLTYPE GetTypeInfoCount2(
149.         /* [out] */ __RPC__out UINT* pctinfo) = 0;
150. 
     
151.     virtual HRESULT STDMETHODCALLTYPE GetTypeInfo2(
152.         /* [in] */ UINT iTInfo,
153.         /* [in] */ LCID lcid,
154.         /* [out] */ __RPC__deref_out_opt ITypeInfo** ppTInfo) = 0;
155. 
     
156.     virtual HRESULT STDMETHODCALLTYPE GetIDsOfNames2(
157.         /* [in] */ __RPC__in REFIID riid,
158.         /* [size_is][in] */ __RPC__in_ecount_full(cNames) LPOLESTR* rgszNames,
159.         /* [range][in] */ __RPC__in_range(0, 16384) UINT cNames,
160.         /* [in] */ LCID lcid,
161.         /* [size_is][out] */ __RPC__out_ecount_full(cNames) DISPID* rgDispId) = 0;
162. 
     
163.     virtual /* [local] */ HRESULT STDMETHODCALLTYPE Invoke2(
164.         /* [annotation][in] */
165.         _In_  DISPID dispIdMember,
166.         /* [annotation][in] */
167.         _In_  REFIID riid,
168.         /* [annotation][in] */
169.         _In_  LCID lcid,
170.         /* [annotation][in] */
171.         _In_  WORD wFlags,
172.         /* [annotation][out][in] */
173.         _In_  DISPPARAMS* pDispParams,
174.         /* [annotation][out] */
175.         _Out_opt_  VARIANT* pVarResult,
176.         /* [annotation][out] */
177.         _Out_opt_  EXCEPINFO* pExcepInfo,
178.         /* [annotation][out] */
179.         _Out_opt_  UINT* puArgErr) = 0;
180. 
     
181.     virtual HRESULT STDMETHODCALLTYPE GetTraceMessage(BSTR*) = 0;
182. };
183. extern "C" {
184.     /* [unique][uuid][object] */
185.     typedef interface IUnregisteredServer2_C IUnregisteredServer2_C;
186. 
     
187.     typedef struct IUnregisteredServer2_CVtbl
188.     {
189.         BEGIN_INTERFACE
190. 
     
191.             HRESULT(STDMETHODCALLTYPE* QueryInterface)(
192.                 __RPC__in IDispatch* This,
193.                 /* [in] */ __RPC__in REFIID riid,
194.                 /* [annotation][iid_is][out] */
195.                 _COM_Outptr_  void** ppvObject);
196. 
     
197.         ULONG(STDMETHODCALLTYPE* AddRef)(
198.             __RPC__in IUnregisteredServer2_C* This);
199. 
     
200.         ULONG(STDMETHODCALLTYPE* Release)(
201.             __RPC__in IUnregisteredServer2_C* This);
202. 
     
203.         HRESULT(STDMETHODCALLTYPE* GetTypeInfoCount)(
204.             __RPC__in IUnregisteredServer2_C* This,
205.             /* [out] */ __RPC__out UINT* pctinfo);
206. 
     
207.         HRESULT(STDMETHODCALLTYPE* GetTypeInfo)(
208.             __RPC__in IUnregisteredServer2_C* This,
209.             /* [in] */ UINT iTInfo,
210.             /* [in] */ LCID lcid,
211.             /* [out] */ __RPC__deref_out_opt ITypeInfo** ppTInfo);
212. 
     
213.         HRESULT(STDMETHODCALLTYPE* GetIDsOfNames)(
214.             __RPC__in IUnregisteredServer2_C* This,
215.             /* [in] */ __RPC__in REFIID riid,
216.             /* [size_is][in] */ __RPC__in_ecount_full(cNames) LPOLESTR* rgszNames,
217.             /* [range][in] */ __RPC__in_range(0, 16384) UINT cNames,
218.             /* [in] */ LCID lcid,
219.             /* [size_is][out] */ __RPC__out_ecount_full(cNames) DISPID* rgDispId);
220. 
     
221.         /* [local] */ HRESULT(STDMETHODCALLTYPE* Invoke)(
222.             IUnregisteredServer2_C* This,
223.             /* [annotation][in] */
224.             _In_  DISPID dispIdMember,
225.             /* [annotation][in] */
226.             _In_  REFIID riid,
227.             /* [annotation][in] */
228.             _In_  LCID lcid,
229.             /* [annotation][in] */
230.             _In_  WORD wFlags,
231.             /* [annotation][out][in] */
232.             _In_  DISPPARAMS* pDispParams,
233.             /* [annotation][out] */
234.             _Out_opt_  VARIANT* pVarResult,
235.             /* [annotation][out] */
236.             _Out_opt_  EXCEPINFO* pExcepInfo,
237.             /* [annotation][out] */
238.             _Out_opt_  UINT* puArgErr);
239. 
     
240.         /* [local] */ HRESULT(STDMETHODCALLTYPE* DefaultMarshallingForObject)(
241.             __RPC__in IUnregisteredServer2_C* This,
242.             VARIANT* v,
243.             VARIANT* v2,
244.             VARIANT* v3
245.             );
246.         /* [local] */ HRESULT(STDMETHODCALLTYPE* Map_HResultAndException)(
247.             __RPC__in IUnregisteredServer2_C* This, BSTR* Display
248.             );
249.         /* [local] */ HRESULT(STDMETHODCALLTYPE* Hello_world3)(
250.             __RPC__in IUnregisteredServer2_C* This,
251.             DECIMAL decimal2,
252.             GUID guid2,
253.             BSTR* outputResult
254.             );
255. 
     
256.         HRESULT(STDMETHODCALLTYPE* QueryInterface2)(
257.             __RPC__in IDispatch* This,
258.             /* [in] */ __RPC__in REFIID riid,
259.             /* [annotation][iid_is][out] */
260.             _COM_Outptr_  void** ppvObject);
261. 
     
262.         ULONG(STDMETHODCALLTYPE* AddRef2)(
263.             __RPC__in IUnregisteredServer2_C* This);
264. 
     
265.         ULONG(STDMETHODCALLTYPE* Release2)(
266.             __RPC__in IUnregisteredServer2_C* This);
267. 
     
268.         HRESULT(STDMETHODCALLTYPE* GetTypeInfoCount2)(
269.             __RPC__in IUnregisteredServer2_C* This,
270.             /* [out] */ __RPC__out UINT* pctinfo);
271. 
     
272.         HRESULT(STDMETHODCALLTYPE* GetTypeInfo2)(
273.             __RPC__in IUnregisteredServer2_C* This,
274.             /* [in] */ UINT iTInfo,
275.             /* [in] */ LCID lcid,
276.             /* [out] */ __RPC__deref_out_opt ITypeInfo** ppTInfo);
277. 
     
278.         HRESULT(STDMETHODCALLTYPE* GetIDsOfNames2)(
279.             __RPC__in IUnregisteredServer2_C* This,
280.             /* [in] */ __RPC__in REFIID riid,
281.             /* [size_is][in] */ __RPC__in_ecount_full(cNames) LPOLESTR* rgszNames,
282.             /* [range][in] */ __RPC__in_range(0, 16384) UINT cNames,
283.             /* [in] */ LCID lcid,
284.             /* [size_is][out] */ __RPC__out_ecount_full(cNames) DISPID* rgDispId);
285. 
     
286.         /* [local] */ HRESULT(STDMETHODCALLTYPE* Invoke2)(
287.             IUnregisteredServer2_C* This,
288.             /* [annotation][in] */
289.             _In_  DISPID dispIdMember,
290.             /* [annotation][in] */
291.             _In_  REFIID riid,
292.             /* [annotation][in] */
293.             _In_  LCID lcid,
294.             /* [annotation][in] */
295.             _In_  WORD wFlags,
296.             /* [annotation][out][in] */
297.             _In_  DISPPARAMS* pDispParams,
298.             /* [annotation][out] */
299.             _Out_opt_  VARIANT* pVarResult,
300.             /* [annotation][out] */
301.             _Out_opt_  EXCEPINFO* pExcepInfo,
302.             /* [annotation][out] */
303.             _Out_opt_  UINT* puArgErr);
304. 
     
305.         /* [local] */ HRESULT(STDMETHODCALLTYPE* GetTraceMessage)(
306.             __RPC__in IUnregisteredServer2_C* This, BSTR*
307.             );
308.         END_INTERFACE
309.     } IUnregisteredServer2_CVtbl;
310. 
     
311.     interface IUnregisteredServer2_C
312.     {
313.         CONST_VTBL struct IUnregisteredServer2_CVtbl* lpVtbl;
314.     };
315. 
     
316. #define IUnregisteredServer2_C_QueryInterface(This,riid,ppvObject) \
317.     ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
318. 
     
319. #define IUnregisteredServer2_C_AddRef(This) \
320.     ( (This)->lpVtbl -> AddRef(This) ) 
321. 
     
322. #define IUnregisteredServer2_C_Release(This) \
323.     ( (This)->lpVtbl -> Release(This) ) 
324. 
     
325. 
     
326. #define IUnregisteredServer2_C_GetTypeInfoCount(This,pctinfo) \
327.     ( (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) ) 
328. 
     
329. #define IUnregisteredServer2_C_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \
330.     ( (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) ) 
331. 
     
332. #define IUnregisteredServer2_C_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \
333.     ( (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ) 
334. 
     
335. #define IUnregisteredServer2_C_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \
336.     ( (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ) 
337. 
     
338. #define IUnregisteredServer2_C_DefaultMarshallingForObject(This,variant,v2,v3) \
339.     ( (This)->lpVtbl -> DefaultMarshallingForObject(This,variant,v2,v3) ) 
340. 
     
341. }
342. int CPP_DLL_Test_UnregisteredServer2(TestParameter* ptr) {
343.     HRESULT hr;
344.     ExportedData ED(ptr, L"Test_UnregisteredServer2 CPP_DLL");
345.     IUnregisteredServer2_CPP* pIUnregisteredServer2_CPP;
346.     int rv = Get_ServerInterface(ptr, My_Server_string[1], (PVOID*)&pIUnregisteredServer2_CPP);
347.     if (rv)return rv;
348. 
     
349.     VARIANT v, v2, v3;
350.     VariantInit(&v); VariantInit(&v2); VariantInit(&v3);
351.     InitVariantFromInt32(0x12345, &v);
352.     ED.WriteLine(L"V_VT(&v)=%d %X", V_VT(&v), V_I8(&v));
353.     pIUnregisteredServer2_CPP->DefaultMarshallingForObject(&v, &v2, &v3);
354.     if (V_VT(&v) != VT_I8) return -3005;
355.     ED.WriteLine(L"V_VT(&v)=%d %X ", V_VT(&v), V_I8(&v));
356.     ED.WriteLine(L"V_VT(&v2)=%d %f ", V_VT(&v2), V_R8(&v2));
357. 
     
358.     DECIMAL d{ };
359.     GUID g;
360.     d.Lo32 = 6666666; d.scale = 3;
361. 
     
362.     hr = CLSIDFromString(OLESTR("{45A82A95-6446-43F0-83B9-71E7469E14D2}"),
363.         &g);
364.     if (FAILED(hr)) return  -3008;
365.     BSTR outputResult = NULL;
366.     pIUnregisteredServer2_CPP->Hello_world3(d, g,
367.         &outputResult);
368.     ED.WriteLine(L"outputResult %s", outputResult);
369.     ::SysFreeString(outputResult);
370. 
     
371.     IUnregisteredServer2_C* pIUnregisteredServer2_C =
372.         (IUnregisteredServer2_C*)pIUnregisteredServer2_CPP;
373.     if ((void*)pIUnregisteredServer2_CPP != (void*)pIUnregisteredServer2_C) {
374.         ED.WriteLine(L"pIUnregisteredServer2_CPP=%p", pIUnregisteredServer2_CPP);
375.         ED.WriteLine(L"pIUnregisteredServer2_C  =%p", pIUnregisteredServer2_C);
376.     }
377. 
     
378.     VariantInit(&v);
379.     VariantInit(&v2);
380.     VariantInit(&v3);
381.     InitVariantFromInt32(321, &v);
382.     for (int aa = 0; aa < 1; aa++) {
383.         IUnregisteredServer2_C_DefaultMarshallingForObject(
384.             pIUnregisteredServer2_C, &v, &v2, &v3);
385.         ED.WriteLine(L"V_VT(&v)=%d %X", V_VT(&v), V_I8(&v));
386.     }
387. 
     
388.     BSTR Display = NULL;
389.     hr = pIUnregisteredServer2_C->lpVtbl->Map_HResultAndException(
390.         pIUnregisteredServer2_C, &Display);
391.     ED.WriteLine(L"hr=0X%X", hr);
392.     ED.WriteLine(L"Display=%s", Display);
393.     if (Display)  ::SysFreeString(Display);
394.     ED.WriteLine(L"sizeof(lpVtbl)=%d", sizeof(pIUnregisteredServer2_C->lpVtbl));
395. 
     
396. 
     
397.     BSTR MyMessage = NULL;
398.     pIUnregisteredServer2_C->lpVtbl->GetTraceMessage(
399.         pIUnregisteredServer2_C, &MyMessage);
400.     ED.WriteLine(L"GetTraceMessage");
401.     ED.WriteLine(L"%s", MyMessage);
402.     SysFreeString(MyMessage);
403.     return 0;
404. }
405. /* End  CPP_DLL_Test_UnregisteredServer2 */
406. // 2 ================================================= 3
407. /* Begin CPP_DLL_Test_IXXXX */
408. __interface IXXXX :public IUnregisteredServer2_CPP
409. {
410.     HRESULT YYYY(INT64*);
411.     HRESULT YYYY1(BSTR*);
412. };
413. 
     
414. int CPP_DLL_Test_IXXXX(TestParameter* ptr) {
415.     ExportedData ED(ptr, L"Test_IXXXX CPP_DLL");
416.     IXXXX* pIXXXX;
417.     int rv = Get_ServerInterface4(ptr, My_Server_string[2], (PVOID*)&pIXXXX);
418.     if (rv)return rv;
419.     INT64 aaa;
420.     pIXXXX->YYYY(&aaa);
421.     ED.WriteLine(L"aaa = %d", aaa);
422. 
     
423.     BSTR comment = ::SysAllocString(L" ABC ");
424.     pIXXXX->YYYY1(&comment);
425.     ED.WriteLine(L"comment=%s", comment);
426.     ::SysFreeString(comment);
427. 
     
428.     BSTR Trace = NULL;
429.     pIXXXX->GetTraceMessage(&Trace);
430.     ED.WriteLine(L"%s", Trace);
431.     ::SysFreeString(Trace);
432.     return 0;
433. }
434. /* End CPP_DLL_Test_IXXXX */
435. #endif 

1. #If TARGET = "library" And PLATFORM = "x64" Then
2. Option Strict On
3. Imports System.Runtime.InteropServices
4. 
   
5. <ComClass(MyUnregisterServer1.ClassId, MyUnregisterServer1.InterfaceId)>
6. Public Class MyUnregisterServer1
7.     Public Const ClassId As String = "04D9F530-CE0C-4232-8F3F-6E0A3244C715"
8.     Public Const InterfaceId As String = "31D53FF8-4768-4A77-95E3-DC28DEBB375F"
9.     ReadOnly Property Get_Interface() As <MarshalAs(UnmanagedType.IUnknown)> Object
10.         Get
11.             MyTrace("Get_Interface")
12.             Return CreateObject_Chen()
13.         End Get
14.     End Property
15.     Sub Get_Interface2(Interface_ID As Int32,
16.           <Out> ByRef ppVoid As Object)
17.         MyTrace("Get_Interface2")
18.         ppVoid = CreateObject_Chen()
19.     End Sub
20.     Sub Register_Event(
21.      <[In]> FunctionPointer As IntPtr,
22.      <[In], MarshalAs(UnmanagedType.BStr)> BSTR_String As String,
23.      <Out> ByRef ID As Int32)
24. 
    
25.         CppEventClassObj.Register_Event(FunctionPointer, BSTR_String, ID)
26.         MyTrace($"Register_Event {ID}")
27.     End Sub
28.     Sub RemoveEvent(<[In]> ID As Int32)
29.         MyTrace($"RemoveEvent {ID}")
30.         CppEventClassObj.RemoveEvent(ID)
31.     End Sub
32.     Sub Raise_Event(MyTestParameter As Int64)
33.         MyTrace($"Raise_Event {MyTestParameter}")
34.         CppEventClassObj.RaiseEventParameter = MyTestParameter
35.         RaiseEvent Cpp_Event(Me, CppEventClassObj)
36.     End Sub
37.     Dim _MyProperty As Int32 = 222
38.     Property MyProperty As Int32
39.         Get
40.             MyTrace($"Get MyProperty {_MyProperty + 111}")
41.             Return _MyProperty + 111
42.         End Get
43.         Set(value As Int32)
44.             MyTrace($"Set MyProperty value= {value}")
45.             _MyProperty = value
46.         End Set
47.     End Property
48.     ReadOnly Property TraceMessage As String
49.         Get
50.             TraceMessage = Environment.NewLine &
51.              "==== TraceMessage(Chen Inn-Jer) ======" &
52.              Environment.NewLine & _TraceMessage.ToString() &
53.              "==== TraceMessage(Chen Inn-Jer) ======" &
54.              Environment.NewLine
55.             _TraceMessage.Clear() : TraceSteps = 0
56.         End Get
57.     End Property
58.     '1----------------------------------------------------
59. 
    
60.     Private Class CppEventClass : Inherits EventArgs
61.         Public RaiseEventParameter As Int64
62.         Private EventCount As Int32
63.         Private Delegate Sub DelegateForFunctionPointer(
64.                        ByRef obj As System.Object)
65.         Private Structure RegisterEvent_Struct
66.             Dim FunctionPtr As IntPtr
67.             Dim InputString As String
68.             Dim ID As Int32
69.         End Structure
70.         Dim ObjectOwnCppEvent As MyUnregisterServer1
71.         ReadOnly RegisterEventList As List(Of RegisterEvent_Struct)
72.         Sub New(ObjectOwnCppEvent As MyUnregisterServer1)
73.             Me.ObjectOwnCppEvent = ObjectOwnCppEvent
74.             RegisterEventList = New List(Of RegisterEvent_Struct)
75.         End Sub
76.         Sub Register_Event(FunctionPointer As IntPtr,
77.               BSTR_String As String, ByRef ID As Int32)
78.             EventCount += 1
79.             ID = EventCount
80.             RegisterEventList.Add(New RegisterEvent_Struct With {
81.             .FunctionPtr = FunctionPointer,
82.             .InputString = BSTR_String,
83.             .ID = ID
84.             })
85.             If RegisterEventList.Count = 1 Then
86.                 AddHandler ObjectOwnCppEvent.Cpp_Event,
87.                  AddressOf Handler_For_Cpp_Event
88.             End If
89.         End Sub
90.         Sub RemoveEvent(ID As Int32)
91.             For Each myitem As RegisterEvent_Struct In RegisterEventList
92.                 If myitem.ID = ID Then
93.                     If RegisterEventList.Count = 1 Then
94.                         RemoveHandler ObjectOwnCppEvent.Cpp_Event,
95.                             AddressOf Handler_For_Cpp_Event
96.                     End If
97.                     RegisterEventList.Remove(myitem)
98.                     Exit Sub
99.                 End If
100.             Next
101.             Throw New MyException(&HA0010002, "Error:RemoveEvent")
102.         End Sub
103.         Private Sub Handler_For_Cpp_Event(sender As Object, e As EventArgs)
104.             For Each MyItem As RegisterEvent_Struct In RegisterEventList
105.                 Dim DelegateForFunPtr As DelegateForFunctionPointer = CType(
106.                       Marshal.GetDelegateForFunctionPointer(
107.                       MyItem.FunctionPtr, GetType(DelegateForFunctionPointer)),
108.                        DelegateForFunctionPointer)
109.                 If DelegateForFunPtr Is Nothing Then
110.                     'MsgBox("DelegateForFunPtr Is Nothing")
111.                 Else
112.                     DelegateForFunPtr.Invoke(
113.                       $"({RaiseEventParameter})" &
114.                       "Sub Handler_For_Cpp_Event" &
115.                       Environment.NewLine & MyItem.InputString)
116.                 End If
117.             Next
118.         End Sub
119.     End Class
120.     Private ReadOnly CppEventClassObj As CppEventClass
121.     Private Event Cpp_Event As EventHandler
122. 
     
123.     Shared Function CreateObject_Chen() As MyUnregisterServer1
124.         If MyUnregisterServer1_Object Is Nothing Then
125.             MyUnregisterServer1_Object = New MyUnregisterServer1
126.         End If
127.         Return MyUnregisterServer1_Object
128.     End Function
129.     Shared MyUnregisterServer1_Object As MyUnregisterServer1
130.     Shared Sub CreateObject3_Chen(ByRef IID As Guid,
131.        ppvoid_temp As IntPtr, Not_Used As IntPtr)
132.         If MyUnregisterServer1_Object Is Nothing Then
133.             MyUnregisterServer1_Object = New MyUnregisterServer1
134.         End If
135. 
     
136.         MyUnregisterServer1_Object.MyTrace(
137.           $"MyUnregisterServer1 IID={IID}  Not_Used = {Not_Used}")
138.         Dim ppVoid As IntPtr
139.         Dim MyIID As Guid = Guid.Parse(InterfaceId)
140.         If MyIID = IID Then
141.             ppVoid = Marshal.GetIUnknownForObject(MyUnregisterServer1_Object)
142.         Else
143.             ppVoid = IntPtr.Zero
144.         End If
145.         Marshal.WriteIntPtr(ppvoid_temp, ppVoid)
146.     End Sub
147.     Shared Function CreateObject4_Chen(ByRef IID As Guid,
148.         Not_Used As IntPtr) As Object
149.         If MyUnregisterServer1_Object Is Nothing Then
150.             MyUnregisterServer1_Object = New MyUnregisterServer1()
151.         End If
152.         MyUnregisterServer1_Object.MyTrace(
153.           $"MyUnregisterServer1 IID={IID}  Not_Used = {Not_Used}")
154. 
     
155.         Dim MyIID As Guid = Guid.Parse(InterfaceId)
156.         If MyIID = IID Then
157.             'Console.WriteLine("CreateObject4_Chen ---Object")
158.             Return MyUnregisterServer1_Object
159.         End If
160.         'Console.WriteLine("CreateObject4_Chen Nothing")
161.         Return Nothing
162.     End Function
163. 
     
164.     Sub New()
165.         MyBase.New()
166.         CppEventClassObj = New CppEventClass(Me)
167.         _TraceMessage = New Text.StringBuilder
168.         TraceSteps = 0
169.     End Sub
170.     Private Class MyException
171.         Inherits Exception
172.         Sub New(errorcode As Int32, Message As String)
173.             MyBase.New(Message)
174.             HResult = errorcode
175.         End Sub
176.     End Class
177.     Private TraceSteps As Int32
178.     Private ReadOnly _TraceMessage As Text.StringBuilder
179.     Private Sub MyTrace(msg As String)
180.         TraceSteps += 1
181.         _TraceMessage.AppendLine($"{TraceSteps:d2} : {msg}")
182.     End Sub
183. End Class
184. '1 ================================================== 2
185. 
     
186. 
     
187. <ComClass(MyUnregisterServer2.ClassId, MyUnregisterServer2.InterfaceId)>
188. Public Class MyUnregisterServer2
189.     Public Const ClassId As String = "7FDF74B5-2E5D-4B72-B3A3-5BA424645F0D"
190.     Public Const InterfaceId As String = "FDD5D79A-386E-49D0-AF60-81222A990055"
191.     Sub DefaultMarshallingForObject(ByRef obj As Object,
192.                                          ByRef obj2 As Object,
193.                                          ByRef obj3 As Object
194.                                            )
195.         MyTrace($"({obj})DefaultMarshallingForObject-->&H999L")
196.         obj = &H999L
197.         'obj2 = New System.Decimal(666666)
198.         obj2 = 666.6666
199.     End Sub
200.     Sub Map_HResultAndException(
201.        <Out, MarshalAs(UnmanagedType.BStr)>
202.        ByRef Display As String
203.      )
204.         MyTrace("Map_HResultAndException")
205.         'Beep()
206.         Try
207.             Marshal.ThrowExceptionForHR(&H80040154)
208.         Catch ex As Exception
209.             Display = $"msg={ex.Message}"
210.             MyTrace(Display)
211.             Throw New MyException(&HA1110000, ex.Message & " -- Chen")
212.         End Try
213.     End Sub
214.     Sub Hello_world3(
215.         decimal2 As System.Decimal,
216.         guid As System.Guid,
217.      <Out, MarshalAs(UnmanagedType.BStr)> ByRef outputResult As String
218.         )
219.         outputResult =
220.          $" decimal= {decimal2} guid= {guid}"
221.     End Sub
222.     Sub QueryInterface2(
223.      <[In](), MarshalAs(UnmanagedType.LPStruct)> REFIID_riid As Guid,
224.      <Out, MarshalAs(UnmanagedType.IUnknown)> ByRef ppVoid As Object)
225.     End Sub
226.     Sub AddRef2()
227. 
     
228.     End Sub
229.     Sub Release2()
230. 
     
231.     End Sub
232.     Sub GetTypeInfoCount2(
233.        <Out> ByRef out_UINT_pctinfo As UInt32)
234.     End Sub
235.     Sub GetTypeInfo2(
236.         itinfo As UInt32, lcid As UInt32,
237.       <Out, MarshalAs(UnmanagedType.Interface)> ByRef ppTInfo As Object
238.    )
239.     End Sub
240.     Sub GetIDsOfNames2(
241.       <[In](), MarshalAs(UnmanagedType.LPStruct)> REFIID_riid As Guid,
242.       <[In](), MarshalAs(UnmanagedType.LPStr)> LPOLESTR_rgszNames As String,
243.       <[In]()> cNames As UInt32,
244.       <[In]()> LCID_lcid As UInt32,
245.       <Out> ByRef rgDispId As Int32)
246.     End Sub
247.     Sub Invoke2(
248.        <[In]()> _In_DISPID_dispIdMember As Int32,
249.        <[In](), MarshalAs(UnmanagedType.LPStruct)> _In_REFIIDriid As Guid,
250.        <[In]()> _In_LCID_lcid As UInt32,
251.        <[In]()> _In_WORD_wFlags As UInt16,
252.        <[In]()> _In_pDispParams As IntPtr,
253.        <Out> ByRef _Out_opt_VARIANT_pVarResult As Object,
254.        <Out> ByRef _Out_opt_pExcepInfo As IntPtr,
255.        <Out> ByRef _Out_opt_puArgErr As UInt32)
256.     End Sub
257.     ReadOnly Property TraceMessage As String
258.         Get
259.             TraceMessage = Environment.NewLine &
260.              "==== TraceMessage(Chen Inn-Jer) 2 ======" &
261.              Environment.NewLine & _TraceMessage.ToString() &
262.              "==== TraceMessage(Chen Inn-Jer) 2 ======" &
263.              Environment.NewLine
264.             _TraceMessage.Clear() : TraceSteps = 0
265.         End Get
266.     End Property
267.     Sub YYYY(<Out> ByRef intptr_obj As IntPtr)
268.         intptr_obj = New IntPtr(12345678)
269.         MyTrace($"YYYY({intptr_obj})")
270.     End Sub
271.     Sub YYYY1(<[In], Out, MarshalAs(UnmanagedType.BStr)> ByRef Comment As String)
272.         MyTrace($"YYYY1 {Comment}")
273.         Dim MainType As Type = GetType(MyUnregisterServer2)
274.         Dim ThisModule As Reflection.Module = MainType.Module
275.         Dim peKind As Reflection.PortableExecutableKinds
276.         Dim machine As Reflection.ImageFileMachine
277.         ThisModule.GetPEKind(peKind, machine)
278.         Comment = "This is YYYY1 in MyUnregisterServer1" &
279.         Environment.NewLine & "MyLocation is " &
280.          Reflection.Assembly.GetExecutingAssembly.Location &
281.         Environment.NewLine & "FrameworkDescription is " &
282.           Runtime.InteropServices.RuntimeInformation.FrameworkDescription &
283.         Environment.NewLine & $"machine={machine} peKind={peKind}" &
284.         Environment.NewLine
285. 
     
286.     End Sub
287.     '2------------------------------------------------
288.     Shared MyUnregisterServer2_Object As MyUnregisterServer2
289.     Shared Sub CreateObject3_Chen(ByRef IID As Guid,
290.         ppvoid_temp As IntPtr, Not_Used As IntPtr)
291.         If MyUnregisterServer2_Object Is Nothing Then
292.             MyUnregisterServer2_Object = New MyUnregisterServer2()
293.         End If
294.         MyUnregisterServer2_Object.MyTrace(
295.           $"MyUnregisterServer2 IID={IID}  Not_Used = {Not_Used}")
296. 
     
297.         Dim ppvoid As IntPtr
298.         Dim MyIID As Guid = Guid.Parse(InterfaceId)
299.         If MyIID = IID Then
300.             ppvoid = Marshal.GetIUnknownForObject(MyUnregisterServer2_Object)
301.         Else
302.             ppvoid = IntPtr.Zero
303.         End If
304.         Marshal.WriteIntPtr(ppvoid_temp, ppvoid)
305.     End Sub
306.     Shared Function CreateObject4_Chen(ByRef IID As Guid,
307.         Not_Used As IntPtr) As Object
308.         If MyUnregisterServer2_Object Is Nothing Then
309.             MyUnregisterServer2_Object = New MyUnregisterServer2()
310.         End If
311.         MyUnregisterServer2_Object.MyTrace(
312.           $"MyUnregisterServer2 IID={IID}  Not_Used = {Not_Used}")
313. 
     
314.         Dim MyIID As Guid = Guid.Parse(InterfaceId)
315.         If MyIID = IID Then
316.             'Console.WriteLine("CreateObject4_Chen ---Object")
317.             Return MyUnregisterServer2_Object
318.         End If
319.         'Console.WriteLine("CreateObject4_Chen Nothing")
320.         Return Nothing
321.     End Function
322. 
     
323.     Sub New()
324.         MyBase.New()
325.         _TraceMessage = New Text.StringBuilder(5 << 20)
326.         TraceSteps = 0
327.     End Sub
328.     Private Class MyException
329.         Inherits Exception
330.         Sub New(errorcode As Int32, Message As String)
331.             MyBase.New(Message)
332.             HResult = errorcode
333.         End Sub
334.     End Class
335.     Dim TraceSteps As Int32
336.     Dim _TraceMessage As Text.StringBuilder
337.     Private Sub MyTrace(msg As String)
338.         TraceSteps += 1
339.         _TraceMessage.AppendLine($"{TraceSteps:d2} : {msg}")
340.     End Sub
341. 
     
342. End Class
343. #End If