Making a C++/MFC application to extract AssemblyInfo from other applications?

I am trying to make a C++/MFC application (so called "Update Application") that can extract AssemblyVersion information from other applications written in C#/.NET 3.5.

So I can update my C# program according to the version information I can get.

I am pretty sure this is possible, but I don't know which way would be the best way.

I would like to know some techniques or keywords that I can search on the web.开发者_如何学编程

A direct explanation would be appreciated, too.

Here's roughly how we do something similar in a native C++ app.

Compile with /clr. You can do this project-wide or just on selected C++ files, but as far as I remember there were complications doing it selectively and so we just did it project-wide. Also #include <vcclr.h> wherever appropriate.

You'll need to learn about app domains. The main thing here is that once you've loaded an assembly into a domain, you can't unload the assembly except by unloading the entire domain. Since you want to load an assembly, query its version, and then let it go, you'll probably want to create a temporary domain and load into this.

In our system we have a managed C++ class called ModelLoader to load object models, query their version info, and discard them - just like what you want to do. This class is the pivotal element in our managed/unmanaged marshaling.

The code in the ModelLoader has to execute in the temporary domain, because we want it to load the target assemblies there and then unload the domain However, the main app is already running in the main domain and so it needs to be able to marshal method calls across to the ModelLoader in the temp domain. So ModelLoader inherits System::MarshalByRefObject, which allows the .NET runtime to do all the marshaling magic.

So the basic steps are something like this:

1. Load the assembly that contains the code for ModelLoader. In our system this is built into our main unmanaged .EXE and so we just use Reflection::Assembly::GetExecutingAssembly() to get a handle to it. If your equivalent of ModelLoader is in a separate assembly then you'll have to load it somehow. But since you probably won't need to unload this assembly you can load it into the main domain.

2. Create a temporary domain.

3. Create an instance of your ModelLoader class (obviously it will have a different name in your system) within the temporary domain.

4. Marshal a handle to that new instance back to your main domain.

5. Use the marshaled handle from within your main domain to execute code in the temp domain.

6. Unload the temporary domain.

So, in code:

AppDomain ^domain = AppDomain::CreateDomain(L"temp domain");
Assembly ^assembly = Assembly::GetExecutingAssembly();
ObjectHandle ^handle = domain->CreateInstanceFrom(
                         assembly->Location,L"ModeLoader");
Object ^o = handle->Unwrap();
ModelLoader ^loader = dynamic_cast<ModelLoader^>(o);
loader->GetAssemblyVersion(...);
AppDomain::Unload(domain);

To save you some head-scratching, the namespaces involved are:

System::AppDomain
System::Reflection::Assembly
System::Runtime::Remoting::ObjectHandle
System::Object

Within your ModelLoader, you'll want to load the target assembly and query its version info. Compared to all the other stuff, this is straightforward:

void ModelLoader::GetAssemblyVersion(const wchar_t *filename, AssemblyName ^name)
{
    Assembly ^assembly = Assembly::Load(gcnew String(filename));
    name = assembly->GetName();
}

(I made this function up just now, so it might not be quite right.)

Another thing to watch out for is assembly resolution. This is how the assembly loader resolves assembly names to DLL files. This is quite a large field in its own right, so I won't talk any more about it right now. (And in any case I'm no expert.) To get started, just make sure that all the assemblies you want to load are in your main app directory and I think you'll be more or less OK. Then when you have the basic loading working, you can worry about more sophisticated resolution.