blocks|key|1824315|text|我尝试这样做已经有一段时间了，但我相信调用程序集的进程的位数决定了它是JITed+as+x86还是x64。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1824316|因此，如果您编写一个小型控制台应用程序并将其构建为x86，另一个构建为x64，则运行其中一个或另一个将导致加载到进程中的其他程序集以32位或64位运行。当然，这假设您是在64位机器上运行的。|1824317|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

It has been a while since I tried this, but I believe that the bitness of the process that calls the assembly determines whether it will be JITed as x86 or x64.

So if you write a small console application and build it as x86, and another as x64, running one or the other will cause other assemblies loaded into the process to run as 32 or 64 bit. This, of course, assumes you are running on a 64 bit machine.

blocks|key|2038337|text|您可以了解应用程序的运行方式，并使用CorFlags应用程序对其进行静态更改。要了解应用程序将如何运行，请使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2038338|corflags+<PathToExe>|code-block|syntax|javascript|2038339|要更改应用程序的运行方式，请使用：|2038340|corflags+/32bit%2B++<PathToExe>|2038341|这将使EXE文件作为32位进程运行。有关程序集应如何运行的信息存储在PE标头中。请参阅堆栈溢出问题。|2038342|如果要在运行时注入代码，则必须在C%2B%2B/COM中编写.NET探查器。有关更多详细信息，请参阅和。|2038343|您将需要实现JitCompilationStarted回调并在那里完成您的工作。如果你朝这个方向走，你将不得不以x86和x64的形式构建注入DLL文件。设置以下环境变量后，CLR将加载本机DLL文件：|2038344|Cor_Enable_Profiling=0x1
COR_PROFILER={CLSID-of-your-native-DLL-file}|2038345|如果设置正确，那么64位版本将“看到”64位进程，而32位版本将“看到”32位进程。|2038346|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/ms164699%2528VS.80%2529.aspx|1|http://en.wikipedia.org/wiki/C_%2528programming_language%2529|2|http://en.wikipedia.org/wiki/.NET_Framework|3|http://en.wikipedia.org/wiki/Common_Language_Runtime^0|I|8|0|0|0|0|0|0|G|3|1|Q|4|2|0|2E|3|3|0|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@$A|1B|B|1C|1|1D]]|C|$]]|$1|D|3|E|5|F|7|1E|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1F|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|1G|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|1H|8|@]|9|@]|C|$]]|$1|O|3|P|5|6|7|1I|8|@]|9|@$A|1J|B|1K|1|1L]|$A|1M|B|1N|1|1O]]|C|$]]|$1|Q|3|R|5|6|7|1P|8|@]|9|@$A|1Q|B|1R|1|1S]]|C|$]]|$1|S|3|T|5|F|7|1T|8|@]|9|@]|C|$G|H]]|$1|U|3|V|5|6|7|1U|8|@]|9|@]|C|$]]|$1|W|3|-4|5|6|7|1V|8|@]|9|@]|C|$]]]|X|$Y|$5|Z|10|11|C|$12|13]]|14|$5|Z|10|11|C|$12|15]]|16|$5|Z|10|11|C|$12|17]]|18|$5|Z|10|11|C|$12|19]]]]

You can find out how an application will run and change it statically using the <a href="http://msdn.microsoft.com/en-us/library/ms164699%28VS.80%29.aspx" rel="nofollow noreferrer">CorFlags</a> application. To find out how the application will run, use:

<pre><code>corflags &lt;PathToExe&gt;
</code></pre>

To change how the application will run, use:

<pre><code>corflags /32bit+ &lt;PathToExe&gt;
</code></pre>

This will make the EXE file run as a 32-bit process. The information about how the assembly should run is stored in the PE header. See Stack Overflow question <a href="https://stackoverflow.com/questions/480696">How to find if a native DLL file is compiled as x64 or x86?</a>.

If you want to inject code at run time, you have to write a <a href="http://en.wikipedia.org/wiki/.NET_Framework" rel="nofollow noreferrer">.NET</a> profiler in <a href="http://en.wikipedia.org/wiki/C_%28programming_language%29" rel="nofollow noreferrer">C++</a>/COM.
See <a href="http://www.blong.com/Conferences/DCon2003/Internals/Profiling.htm#Docs" rel="nofollow noreferrer">.NET Internals: The Profiling API</a> and <a href="http://msdn.microsoft.com/en-us/library/ms404386.aspx" rel="nofollow noreferrer">Profiling (Unmanaged API Reference)</a> for more details. 

You'll need to implement the JitCompilationStarted callback and do your work there. If you go in this direction, you'll have to build the injecting DLL file both as x86 and x64. The native DLL files will be loaded by the <a href="http://en.wikipedia.org/wiki/Common_Language_Runtime" rel="nofollow noreferrer">CLR</a> once the following environment variables will be set:

<pre><code>Cor_Enable_Profiling=0x1
COR_PROFILER={CLSID-of-your-native-DLL-file}
</code></pre>

If you have it set correctly then the 64-bit version will 'see' the 64 bit processes and the 32-bit version will 'see' the 32-bit processes.

blocks|key|2038460|text|我通过创建两个(实际上是三个)二进制文件做了类似的事情。我让一个人检测我试图注入的进程是32位还是64位。然后，此过程将启动您的注入二进制文件的32位或64位版本(而不是像您提到的那样重新启动自身)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2038461|这听起来很混乱，但您可以在构建时通过生成输出二进制文件的副本并使用CorFlags实用程序强制该副本作为32位运行的构建后事件轻松实现这一点。这样，您就不必将CorFlags实用程序与应用程序一起部署，因为出于某种原因，这可能是不合法的。|offset|length|2038462|我认为这与您最初的想法非常相似，除了两行构建事件之外，实际上不需要更多的工作。|2038463|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/ms164699%2528v=vs.80%2529.aspx^0|0|X|8|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

I've done something similar by creating two (really three) binaries. I had one detect whether the process I was trying to inject into was 32 or 64-bit. This process will then launch either the 32-bit or 64-bit version of your injection binary (as opposed to relaunching itself like you mentioned). 

It sounds messy, but you can easily achieve this at build time with a post-build event that makes a copy of your output binary and uses the <a href="http://msdn.microsoft.com/en-us/library/ms164699%28v=vs.80%29.aspx" rel="noreferrer">CorFlags</a> utility to force the copy to run as 32-bit. This way you don't have to deploy the CorFlags utility with your application, which probably isn't legal for some reason anyway.

I think this is quite similar to your initial idea and really doesn't require more work except for a two-line build event.

In .NET, the 'Platform Target: Any CPU' compiler option allows a .NET assembly to run as 64&nbsp;bit on a x64 machine, and 32&nbsp;bit on an x86 machine. It is also possible to force an assembly to run as x86 on an x64 machine using the 'Platform Target: x86' compiler option.

Is it possible to run an assembly with the 'Any CPU' flag, but determine whether it should be run in the x86 or x64 CLR? Normally this decision is made by the CLR/OS Loader (as is my understanding) based on the bitness of the underlying system.

I am trying to write a C# .NET application that can interact with (read: inject code into) other running processes. x64 processes can only inject into other x64 processes, and the same with x86. Ideally, I would like to take advantage of JIT compilation and the Any CPU option to allow a single application to be used to inject into either x64 or x86 processes (on an x64 machine).

The idea is that the application would be compiled as Any CPU. On an x64 machine, it would run as x64. If the target process is x86, it should relaunch itself, forcing the CLR to run it as x86. Is this possible?

Force x86 CLR on an 'Any CPU' .NET assembly

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

在.NET中，“平台目标:任何CPU”编译器选项允许.NET程序集在x64机器上以64位运行，在x86机器上以32位运行。还可以使用'Platform Target: x86‘编译器选项强制程序集在x64计算机上以x86身份运行。是否可以运行带有“Any CPU”标志的程序集，但确定它应该在x86还是x64 CLR中运...

问在'Any CPU‘.NET程序集上强制x86 CLR
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在'Any CPU‘.NET程序集上强制x86 CLREN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在'Any CPU‘.NET程序集上强制x86 CLR
EN