重新发布 - 从纯模式转换为混合模式Dll [英] Repost - Converting from pure mode to mixed mode Dll
问题描述
我第一次发布时没有收到任何关于此的答案，所以我会再次尝试
。我无法破译MSDN主题可能会发现其他人无法解决这个问题，而且有人可以解密并解释它。
我对此有一些疑问有关创建混合模式DLL的说明，请参阅MSDN主题从纯转换C ++项目的托管扩展中的
中间语言到混合模式在Managed Extensions for C ++
Reference中。
1）转换为混合模式的第一条指令是链接
/ NOENTRY。尽管已经在链接器中使用此选项设置了纯模式DLL，但是之前关于混合
模式的解释说必须修改你的DLL有一个明确的入口点。
第一条指令是否正确？
2）我不理解进一步修改需要考虑的三个方面
主题为修改为手动使用DLL的组件
初始化。我正在创建一个DLL作为类库（.NET）项目。我没有使用__declspec（dllexport）在任何DLL导出中添加
，而且我希望我的Dll的最终用户将它用于.NET组件我已创建
。我也不知道托管入口点是什么意思
与非托管代码中的正常DllMain入口点相对，但我还没有手动添加
一个DllMain，如果这意味着什么，除了通过将__DllMainCRTStartup @ 12添加到强制模式转换为混合模式，以及强制符号引用属性。这三种情况中的任何一种都适用于我，或者我可以忽略本节中的说明吗？最后的
可能适用，你的DLL'的消费者可以使用托管代码，而你的
DLL包含DLL导出或托管入口点，所以我想要知道
如果我必须实现该解决方案中提到的代码，然后有一个
控制台或Window程序手动调用我的初始化并终止静态
成员函数在其主要和WinMain
例程的开头和结尾。
见下文：
" Edward Diener" < ED ****** @ tropicsoft.com>在消息中写道
新闻：eP ************** @ TK2MSFTNGP12.phx.gbl ...我没有得到任何答案这是我第一次发布，所以我会再次尝试
。我无法破译MSDN主题，可能会发现其他人无法解决问题并且有人可以解密并解释它。
我对创建混合模式DLL的说明有疑问< MSDN主题将C ++项目的托管扩展从
纯中间语言转换为混合模式中的br />在Managed Extensions for C ++
Reference中。
1）转换为混合模式的第一条指令是与
/ NOENTRY链接。尽管事实上已经在链接器中使用此选项设置了纯模式DLL，并且先前关于
混合模式的解释说你必须修改你的DLL以具有明确的入口点 ;。
这第一条指令是否正确？
[ALBERT：]是的，这是正确的。您必须与/ NOENTRY链接以避免
加载程序锁定。 bug。
（ http://msdn.microsoft.com/library/de...-us/dv_vstecha
rt / html / vcconMixedDLLLoadingProblem.asp）
这里提到的明确的入口点是你指示在文章中进一步创建的
。 （见下文）。
2）我不理解在修改为手册使用DLL的组件主题下进一步进行
更改需要考虑的三个方面初始化。我正在创建一个DLL作为类库（.NET）项目。
我没有使用__declspec（dllexport）添加任何DLL导出自己，而
我希望我的Dll的最终用户将它用于我创建的.NET组件。我也不知道托管入口点
的意思是什么，而不是非托管代码中的正常DllMain入口点，但是我有
没有手动添加DllMain，如果这是什么意味着，除了遵循
之外，通过将__DllMainCRTStartup @ 12添加到Force Symbol References属性来转换为混合模式的指令。这三种情况中的任何一种都适用于我，或者我可以忽略本节中的说明吗？
[ALBERT：]＃3适用于你。在这种情况下管理入口点只是
静态或
托管类型的实例方法。
最后的可能性可能适用， 你的DLL'的消费者可以使用托管代码，你的
DLL包含DLL导出或托管入口点'，所以我想
知道我是否必须实现该解决方案中提到的代码，然后让
a控制台或Window程序在他们的main和WinMain
例程的开头和结尾手动调用我的初始化并终止静态
成员函数。
[ALBERT：]我在这里有点困惑，因为你说你只有
管理客户
和管理客户没有WinMain你可以修改。尽管如此，
的答案是肯定的。
你的客户肯定要在
启动和ManagedWrapper.mterminate上调用ManagedWrapper.minitialize（） ）
关机。这是上面提到的明确的切入点。
Albert Szilvasy写道：见下文：
Edward Diener ; < ED ****** @ tropicsoft.com>在消息中写道
新闻：eP ************** @ TK2MSFTNGP12.phx.gbl ...我第一次没有得到这方面的答案我发布了，所以我会再试一次。我无法破译MSDN主题可能会发现其他人具有相同的无能力以及可以解密和解释它的人。
我对创建一个问题的说明有些疑问。 MSDN主题中的混合模式DLL将C ++的托管扩展转换为从纯中间语言到混合模式的项目在
托管扩展C ++参考中。
1）转换为混合模式的第一条指令是与
/ NOENTRY链接。尽管事实上已经在链接器中使用此选项设置了纯模式DLL，并且之前关于混合模式的解释说您必须修改您的DLL以使其具有
明确的入口点。这第一条指令是否正确？ [阿尔伯特：]是的，这是正确的。您必须与/ NOENTRY链接以避免加载程序锁定。 bug。
（ http://msdn.microsoft.com/library/de...-us/dv_vstecha rt / html / vcconMixedDLLLoadingProblem.asp）
明确的入口点是指这是你被指示在文章中进一步创建的那个。 （见下文）。
好的，我理解，这很有道理。令我感到困惑的是，当我没有必要这样做时，要求我更改
a，因为纯模式.NET类库的标准设置
已经有/ noentry标志设置。
2）我不理解在修改使用DLL的组件主题下进行进一步更改的三个方面需要考虑/>用于手动初始化。我正在创建一个DLL作为类库
（.NET）项目。我没有在任何DLL中添加使用
__declspec（dllexport）导出自己，我希望我的Dll的最终用户将它用于我创建的.NET组件。我也没有任何关于托管入口点的含义，而不是非托管代码中的正常
DllMain入口点，但我没有手动添加
一个DllMain，如果这意味着，除了通过将
__DllMainCRTStartup @ 12添加到Force Symbol References属性后转换为混合模式的
指令。这三种情况中的任何一种都适用于我，或者我可以忽略本节中的
说明吗？ [ALBERT：]＃3适用于你。在这种情况下管理入口点只是静态或管理类型的实例方法。
谢谢，这澄清了是什么意思管理入口点。一个通常
认为DllMain用于DLL，而WinMain或主要用于GUI和控制台应用程序，作为
入口点。现在我理解管理入口点这个术语。是任何.NET类型方法的
。
最后的可能性可能适用，你的DLL的消费者可以使用托管代码，
和你的DLL包含DLL导出或托管入口点，
所以我想知道我是否必须实现该
解决方案中提到的代码，然后有一个控制台或Window程序手动调用我的
初始化并终止静态成员函数，并在其主要和WinMain例程结束时结束。 [ALBERT：]我在这里有点困惑，因为你说你只有受管理的客户
而且管理的客户没有你可以修改的WinMain。
托管客户端可能是.NET WinForms应用程序，不是吗？我是创建.NET组件的
，所以我假设我的客户端是其他.NET DLL
或.NET应用程序。
尽管如此，答案是肯定的。
你的客户肯定要在启动时调用ManagedWrapper.minitialize（）
并且ManagedWrapper.mterminate（）
shutdown。这是上面提到的explict入口点。
如果我的一个.NET组件程序集使用了我的另一个.NET组件
程序集，我应该在我自己的程序中专门调用
中的后者'
ManagedWrapper.minitialize和ManagedWrapper.mterminate函数吗？是什么阻止这些例程被称为更多
而不是一对，或者无关紧要？
最后我注意到我的.NET组件DLL已经有了没有DllMain，不像具有WinMain的.NET
Windows窗体应用程序。是否有理由使用混合模式DLL来获得这个
，或者它只是完全没有必要在
..NET程序集中？如果一个纯模式程序集需要通过调用ManagedWrapper.minitialize和ManagedWrapper.mterminate来初始化我的程序集，那么
在哪里这样做呢？我会从DllMain PROCESS_ATTACH和
PROCESS_DETACH中猜到但是因为我没有看到任何DllMain我对如何跟踪装配dll中的启动和关闭感到困惑。
没有装配启动/关闭这样的东西。至少，这个合同
并不像传统的dll（即DllMain）那样标准化。我认为他们相信他们正在考虑标准化相似的东西，但它现在还没有
。
你的dll的客户端在他们开始使用
你的dll中的任何其他功能之后必须调用minitialize并在他们完成使用后使用
你的dll.
Albert
" Edward Diener" < ED ****** @ tropicsoft.com>在消息中写道
新闻：％2 **************** @ TK2MSFTNGP11.phx.gbl ...Albert Szilvasy写道：见下文：
Edward Diener < ED ****** @ tropicsoft.com>在消息中写道
新闻：eP ************** @ TK2MSFTNGP12.phx.gbl ...我第一次没有得到这方面的答案我发布了，所以我会再试一次。我无法破译MSDN主题可能会发现其他人具有相同的无能力以及可以解密和解释它的人。
我对创建一个问题的说明有些疑问。 MSDN主题中的混合模式DLL将C ++的托管扩展转换为从纯中间语言到混合模式的项目在
托管扩展C ++参考中。
1）转换为混合模式的第一条指令是与
/ NOENTRY链接。尽管事实上已经在链接器中使用此选项设置了纯模式DLL，并且之前关于混合模式的解释说您必须修改您的DLL以使其具有
明确的入口点。这第一条指令是否正确？ [阿尔伯特：]是的，这是正确的。您必须与/ NOENTRY链接以避免加载程序锁定。 bug。
（ http://msdn.microsoft.com/library/de...-us/dv_vstechart / html / vcconMixedDLLLoadingProblem.asp）
这里提到的显式入口点是指示您在文章中进一步创建的入口点。 （见下文）。
好的，我理解，这很有道理。令我困惑的是要求我
在没有必要时进行更改，因为纯模式.NET类库的标准设置已经具有/ noentry标志设置。
2）我不理解在主题下进行进一步更改的三个方面需要考虑;修改使用DLL的组件
手动初始化。我正在创建一个DLL作为类库
（.NET）项目。我没有在任何DLL中添加使用
__declspec（dllexport）导出自己，我希望我的Dll的最终用户将它用于我创建的.NET组件。我也没有任何关于托管入口点的含义，而不是非托管代码中的正常
DllMain入口点，但我没有手动添加
一个DllMain，如果这意味着，除了通过将
__DllMainCRTStartup @ 12添加到Force Symbol References属性后转换为混合模式的
指令。这三种情况中的任何一种都适用于我，或者我可以忽略本节中的
说明吗？ [ALBERT：]＃3适用于你。在这种情况下管理入口点只是静态或管理类型的实例方法。
谢谢，这澄清了托管入口点的含义。 。一个
通常认为DllMain是DLL，WinMain或主要用于GUI和控制台应用程序，
作为入口点。现在我理解管理入口点这个术语。是
任何.NET类型的方法。
最后的
可能适用，你的DLL的消费者可以使用托管代码，
和你的DLL包含DLL导出或托管入口点，
所以我想知道我是否必须实现该
解决方案中提到的代码，然后有一个控制台或Window程序手动调用我的
初始化并终止静态成员函数，并在其主要和WinMain例程结束时结束。 [ALBERT：]我在这里有点困惑，因为你说你只有受管理的客户
而且管理的客户没有你可以修改的WinMain。
托管客户端可能是.NET WinForms应用程序，不是吗？我正在创建.NET组件，所以我假设我的客户端是其他.NET
DLL或.NET应用程序。
尽管如此，答案是肯定的。
您的客户将在启动时显然必须调用ManagedWrapper.minitialize（）
并且ManagedWrapper.mterminate（）
关闭。这是上面提到的explict入口点。
如果我的一个.NET组件程序集使用我的另一个.NET组件
程序集，我应该专门调用后者的
在我自己的内容中，ManagedWrapper.minitialize和ManagedWrapper.mterminate函数是什么？是什么阻止这些例程比成对更多地被调用，或者无关紧要？
最后我注意到我的.NET组件DLL没有DllMain，不像.NET <具有WinMain的Windows窗体应用程序。是否有理由使用混合模式DLL，或者在.NET程序集中完全没有必要？如果纯模式程序集需要通过调用ManagedWrapper.minitialize和ManagedWrapper.mterminate来初始化我的程序集
，那么
是这样做的吗？我会从DllMain PROCESS_ATTACH和
PROCESS_DETACH中猜到，但由于我没有看到任何DllMain，我对如何跟踪装配dll中的启动和关闭感到困惑。
I received no answers about this the first time I posted, so I will try
again. My inability to decipher an MSDN topic may find others who have the
same inability and someone who can decipher and explain it.
I have some questions about the instructions for creating a mixed mode DLL
in the MSDN topic "Converting Managed Extensions for C++ Projects from Pure
Intermediate Language to Mixed Mode" in the "Managed Extensions for C++
Reference".
1) The first instruction in converting to mixed mode is to link with
/NOENTRY. This occurs despite the fact that a pure mode DLL is already set
up with this option in the linker, and the previous explanation about mixed
mode says "you must modify your DLL to have an explicit entry point". Is
this first instruction correct ?
2) I don''t understand the three areas to consider for making further changes
under the topic "Modifying Components That Consume the DLL for Manual
Initializiation". I am creating a DLL as a "Class Library (.NET)" project. I
have not added in any DLL exports myself using __declspec(dllexport), and I
expect the end-user of my Dll will use it for the .NET components I have
created. I also don''t have any idea what is meant by managed entry points as
opposed to the normal DllMain entry point in unmanaged code, but I have not
manually added a DllMain, if that is what is meant, other than following the
instructions to convert to mixed mode by adding __DllMainCRTStartup@12 to
the Force Symbol References property. Do any of the three situations apply
to me, or can I just ignore the instructions in this section ? The last
possibility may apply,"Your DLL''s consumers can use managed code, and your
DLL contains either DLL exports or managed entry points", so I want to know
if I have to implement the code mentioned in that solution, and then have a
console or Window program manually call my initialize and terminate static
member functions at the beginning and end of their main and WinMain
routines.
See below:
"Edward Diener" <ed******@tropicsoft.com> wrote in message
news:eP**************@TK2MSFTNGP12.phx.gbl...I received no answers about this the first time I posted, so I will try
again. My inability to decipher an MSDN topic may find others who have the
same inability and someone who can decipher and explain it.
I have some questions about the instructions for creating a mixed mode DLL
in the MSDN topic "Converting Managed Extensions for C++ Projects from Pure Intermediate Language to Mixed Mode" in the "Managed Extensions for C++
Reference".
1) The first instruction in converting to mixed mode is to link with
/NOENTRY. This occurs despite the fact that a pure mode DLL is already set
up with this option in the linker, and the previous explanation about mixed mode says "you must modify your DLL to have an explicit entry point". Is
this first instruction correct ? [ALBERT:] Yes, this is correct. You must link with /NOENTRY to avoid the
"loader lock" bug.
(http://msdn.microsoft.com/library/de...-us/dv_vstecha
rt/html/vcconMixedDLLLoadingProblem.asp)
The explicit entry point referred to here is the one that you are
instructed to create further down in the article. (see below).
2) I don''t understand the three areas to consider for making further changes under the topic "Modifying Components That Consume the DLL for Manual
Initializiation". I am creating a DLL as a "Class Library (.NET)" project. I have not added in any DLL exports myself using __declspec(dllexport), and I expect the end-user of my Dll will use it for the .NET components I have
created. I also don''t have any idea what is meant by managed entry points as opposed to the normal DllMain entry point in unmanaged code, but I have not manually added a DllMain, if that is what is meant, other than following the instructions to convert to mixed mode by adding __DllMainCRTStartup@12 to
the Force Symbol References property. Do any of the three situations apply
to me, or can I just ignore the instructions in this section ? [ALBERT:] #3 applies to you. Managed entry point in this context is simply
static or
instance method of managed type.
The last
possibility may apply,"Your DLL''s consumers can use managed code, and your
DLL contains either DLL exports or managed entry points", so I want to know if I have to implement the code mentioned in that solution, and then have a console or Window program manually call my initialize and terminate static
member functions at the beginning and end of their main and WinMain
routines.
[ALBERT:] I''m a bit confused here because you said that you only have
managed clients
and managed clients don''t have WinMain that you could modify. Nevertheless,
the answer is yes.
Your clients will explictly have to call ManagedWrapper.minitialize() on
startup and ManagedWrapper.mterminate()
shutdown. This is the explict entry point that is referred to above.
Albert Szilvasy wrote:See below:
"Edward Diener" <ed******@tropicsoft.com> wrote in message
news:eP**************@TK2MSFTNGP12.phx.gbl...I received no answers about this the first time I posted, so I will
try again. My inability to decipher an MSDN topic may find others
who have the same inability and someone who can decipher and explain
it.
I have some questions about the instructions for creating a mixed
mode DLL in the MSDN topic "Converting Managed Extensions for C++
Projects from Pure Intermediate Language to Mixed Mode" in the
"Managed Extensions for C++ Reference".
1) The first instruction in converting to mixed mode is to link with
/NOENTRY. This occurs despite the fact that a pure mode DLL is
already set up with this option in the linker, and the previous
explanation about mixed mode says "you must modify your DLL to have
an explicit entry point". Is this first instruction correct ? [ALBERT:] Yes, this is correct. You must link with /NOENTRY to avoid
the "loader lock" bug.
(http://msdn.microsoft.com/library/de...-us/dv_vstecha rt/html/vcconMixedDLLLoadingProblem.asp)
The explicit entry point referred to here is the one that you are
instructed to create further down in the article. (see below).
OK, I understand and it makes sense. What confused me was asking me to make
a change when there was no necessity to do so, because the standard setup
for a pure mode .NET class library already has the /noentry flag set.
2) I don''t understand the three areas to consider for making further
changes under the topic "Modifying Components That Consume the DLL
for Manual Initializiation". I am creating a DLL as a "Class Library
(.NET)" project. I have not added in any DLL exports myself using
__declspec(dllexport), and I expect the end-user of my Dll will use
it for the .NET components I have created. I also don''t have any
idea what is meant by managed entry points as opposed to the normal
DllMain entry point in unmanaged code, but I have not manually added
a DllMain, if that is what is meant, other than following the
instructions to convert to mixed mode by adding
__DllMainCRTStartup@12 to the Force Symbol References property. Do
any of the three situations apply to me, or can I just ignore the
instructions in this section ? [ALBERT:] #3 applies to you. Managed entry point in this context is
simply static or
instance method of managed type.
Thanks, that clarifies what is meant by "managed entry points". One usually
thinks of DllMain for DLLs, and WinMain or main for GUI and console apps, as
entry points. Now I understand that the term for "managed entry point" is
any .NET types methods.
The last
possibility may apply,"Your DLL''s consumers can use managed code,
and your DLL contains either DLL exports or managed entry points",
so I want to know if I have to implement the code mentioned in that
solution, and then have a console or Window program manually call my
initialize and terminate static member functions at the beginning
and end of their main and WinMain routines. [ALBERT:] I''m a bit confused here because you said that you only have
managed clients
and managed clients don''t have WinMain that you could modify.
A managed client could be a .NET WinForms application, could it not ? I am
creating .NET components, so I assume my clients are either other .NET DLLs
or .NET applications.
Nevertheless, the answer is yes.
Your clients will explictly have to call ManagedWrapper.minitialize()
on startup and ManagedWrapper.mterminate()
shutdown. This is the explict entry point that is referred to above.
If one of my .NET component assemblies uses another of my .NET component
assemblies, should I specifically call the latter''s
ManagedWrapper.minitialize and ManagedWrapper.mterminate functions from
within my own ones ? What prevents these routines from being called more
than once as a pair, or does it not matter ?
Finally I noticed that my .NET component DLL has no DllMain, unlike a .NET
Windows Form application which does have a WinMain. Is there a reason to
have this with a mixed-mode DLL, or is it just completely unnecessary in
..NET assemblies ? If a pure mode assembly needs to initialize my assembly by
calling ManagedWrapper.minitialize and ManagedWrapper.mterminate, where does
it do this ? I would have guessed from a DllMain PROCESS_ATTACH and
PROCESS_DETACH but as I don''t see any DllMain I am confused about how one
tracks startup and shutdown in an assembly dll.
There''s no such thing as assembly startup/shutdown. At least, this contract
is not standardized as it was with traditional dlls (i.e. DllMain). I
believe they looking at standardizing something similar but it doesn''t
currently exist.
The client of your dll will have to call minitialize before they start using
any other functions in your dll and mterminate after they finished using
your dll.
Albert
"Edward Diener" <ed******@tropicsoft.com> wrote in message
news:%2****************@TK2MSFTNGP11.phx.gbl...Albert Szilvasy wrote:See below:
"Edward Diener" <ed******@tropicsoft.com> wrote in message
news:eP**************@TK2MSFTNGP12.phx.gbl...I received no answers about this the first time I posted, so I will
try again. My inability to decipher an MSDN topic may find others
who have the same inability and someone who can decipher and explain
it.
I have some questions about the instructions for creating a mixed
mode DLL in the MSDN topic "Converting Managed Extensions for C++
Projects from Pure Intermediate Language to Mixed Mode" in the
"Managed Extensions for C++ Reference".
1) The first instruction in converting to mixed mode is to link with
/NOENTRY. This occurs despite the fact that a pure mode DLL is
already set up with this option in the linker, and the previous
explanation about mixed mode says "you must modify your DLL to have
an explicit entry point". Is this first instruction correct ? [ALBERT:] Yes, this is correct. You must link with /NOENTRY to avoid
the "loader lock" bug.
(http://msdn.microsoft.com/library/de...-us/dv_vstechart/html/vcconMixedDLLLoadingProblem.asp)
The explicit entry point referred to here is the one that you are
instructed to create further down in the article. (see below).
OK, I understand and it makes sense. What confused me was asking me to
make a change when there was no necessity to do so, because the standard setup
for a pure mode .NET class library already has the /noentry flag set.2) I don''t understand the three areas to consider for making further
changes under the topic "Modifying Components That Consume the DLL
for Manual Initializiation". I am creating a DLL as a "Class Library
(.NET)" project. I have not added in any DLL exports myself using
__declspec(dllexport), and I expect the end-user of my Dll will use
it for the .NET components I have created. I also don''t have any
idea what is meant by managed entry points as opposed to the normal
DllMain entry point in unmanaged code, but I have not manually added
a DllMain, if that is what is meant, other than following the
instructions to convert to mixed mode by adding
__DllMainCRTStartup@12 to the Force Symbol References property. Do
any of the three situations apply to me, or can I just ignore the
instructions in this section ? [ALBERT:] #3 applies to you. Managed entry point in this context is
simply static or
instance method of managed type.
Thanks, that clarifies what is meant by "managed entry points". One
usually thinks of DllMain for DLLs, and WinMain or main for GUI and console apps, as entry points. Now I understand that the term for "managed entry point" is
any .NET types methods.The last
possibility may apply,"Your DLL''s consumers can use managed code,
and your DLL contains either DLL exports or managed entry points",
so I want to know if I have to implement the code mentioned in that
solution, and then have a console or Window program manually call my
initialize and terminate static member functions at the beginning
and end of their main and WinMain routines. [ALBERT:] I''m a bit confused here because you said that you only have
managed clients
and managed clients don''t have WinMain that you could modify.
A managed client could be a .NET WinForms application, could it not ? I am
creating .NET components, so I assume my clients are either other .NET
DLLs or .NET applications.Nevertheless, the answer is yes.
Your clients will explictly have to call ManagedWrapper.minitialize()
on startup and ManagedWrapper.mterminate()
shutdown. This is the explict entry point that is referred to above.
If one of my .NET component assemblies uses another of my .NET component
assemblies, should I specifically call the latter''s
ManagedWrapper.minitialize and ManagedWrapper.mterminate functions from
within my own ones ? What prevents these routines from being called more
than once as a pair, or does it not matter ?
Finally I noticed that my .NET component DLL has no DllMain, unlike a .NET
Windows Form application which does have a WinMain. Is there a reason to
have this with a mixed-mode DLL, or is it just completely unnecessary in
.NET assemblies ? If a pure mode assembly needs to initialize my assembly
by calling ManagedWrapper.minitialize and ManagedWrapper.mterminate, where does it do this ? I would have guessed from a DllMain PROCESS_ATTACH and
PROCESS_DETACH but as I don''t see any DllMain I am confused about how one
tracks startup and shutdown in an assembly dll.
这篇关于重新发布 - 从纯模式转换为混合模式Dll的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
