COMO: Gravar um empacotador personalizado de interoperação de COM usando o Visual translation from VPE for Csharp .NET

• Um servidor COM que implementa o IUnmanagedServer interface.
• Um IUnmanagedServer que tenha um único método chamado UnmanagedServerMethod . Este método requer um único parâmetro do tipo IUnmanaged como entrada.
• Um cliente .NET que possui uma instância de digite IManaged.
• Um cliente .NET que passa a instância IManaged para o UnmanagedServerMethod de servidor COM.

interface IUnmanaged : IUnknown
{
	HRESULT UnmanagedMethod([out, retval] LONG *RetVal);
};

public interface IManaged
{
	long ManagedMethod();
}

• Um servidor .NET que implementa um único método chamado ManagedServerMethod . Este método requer um único parâmetro do tipo IManaged como entrada.
• Um cliente COM que tenha uma instância de digite IUnmanaged.
• Um cliente COM que passa a instância IUnmanaged para o ManagedServerMethod do .NET server.

Voltar para o início

Empacotamento personalizado em um cliente .NET a um servidor COM

Passos para criar um servidor COM de ATL

1. Abra o Microsoft Visual Studio .NET .
2. No menu arquivo , aponte para novo e, em seguida, clique em Project .
3. Na caixa de diálogo New Project , clique em Projetos do Visual c++ em Project Types e clique em Projeto ATL em modelos .
4. Na caixa de texto nome , digite ComServer .
5. Clique em OK .
6. Na caixa de diálogo do Assistente , clique na guia Configurações do aplicativo .
7. Clique para desmarcar a caixa de seleção atribuída e em seguida, clique em Concluir .
8. No Solution Explorer , clique com o botão direito no nó ComServer (projeto) , aponte para Adicionar e, em seguida, clique em Add Class .
9. Na caixa de diálogo Add Class , clique em ATL Simple Object em modelos e em seguida, clique em Abrir .
10. Na caixa de diálogo ATL Simple Object Wizard , digite UnmanagedServer na caixa de texto nome curto e, em seguida, clique em Concluir .
11. No Solution Explorer , expanda Arquivos de origem .
12. Clique duas vezes em ComServer.idl para abrir o arquivo .idl em um editor. Adicionar a seguinte definição de interface para o arquivo .idl.

    [
    	object,
    	uuid(XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX),
    	helpstring("IUnmanaged Interface"),
    	pointer_default(unique)
    ]
    interface IUnmanaged : IUnknown
    {
    	HRESULT UnmanagedMethod([out, retval] LONG *RetVal);
    };

    substituir o conteúdo do atributo uuid com o GUID é gerado a partir da ferramenta guidgen . Na biblioteca, adicione a interface IUnmanaged conforme mostrado no código anterior. Isso expõe a interface por meio da biblioteca de tipos é gerada. Adicionar o código a seguir à instrução biblioteca no arquivo .idl:

    library ComServerLib
    {
    	importlib("stdole2.tlb");
    	//Add the following line to the idl file.
    	interface IUnmanaged;
    	...
    };
    

13. No modo de exibição Class , expanda ComServer .
14. Clique com o botão direito do mouse IUnmanagedServer , aponte para Add e, em seguida, clique em Adicionar método .
15. Na caixa de texto Method Name , digite UnmanagedServerMethod .
16. Clique para selecionar os atributos de parâmetro de caixa de seleção.
17. Na caixa de combinação tipo de parâmetro , digite IUnmanaged 1 .
18. Na caixa de texto parâmetro , digite não gerenciado e, em seguida, clique em Adicionar .
19. Clique em Concluir .
20. No Solution Explorer , clique duas vezes em UnmanagedServer.cpp .
21. Substitua o código padrão que é gerado para o método CUnmanagedServer::UnmanagedServerMethod com o código que segue: dados

    LONG data;
    HRESULT hr;
    hr = unmanaged->UnmanagedMethod(&data);
    if(FAILED(hr))
    	return hr;
    printf("The output of the IUnmanaged::UnmanagedMethod is : %d", data);
    return S_OK;

22. No menu Build , clique em Build Solution para criar o aplicativo de servidor COM ATL.

Passos para criar um cliente .NET

1. No menu arquivo , aponte para novo e, em seguida, clique em Project .
2. Na caixa de diálogo New Project , clique em projetos do Visual translation from VPE for Csharp em Project Types e clique em Aplicativo de console em modelos .
3. Clique para selecionar a opção de Adicionar a solução e, em seguida, clique em OK .
4. No Solution Explorer , expanda ConsoleApplication1 , clique com o botão direito do mouse em References e em seguida, clique em Add Reference .
5. Na caixa de diálogo Add Reference , clique na guia COM .
6. Clique em Biblioteca de tipos de 1.0 ComServer em Nome do componente e clique em Selecionar .
7. Clique em OK .
8. Substitua o código padrão de Class1.cs com o código que segue:

   using System;
   using System.Runtime.InteropServices;
   
   public interface IManaged
   {
   	long ManagedMethod();
   }
   
   public class ManagedImplementation : IManaged
   {
   	public long ManagedMethod()
   	{
   		return 200;
   	}
   }
   
   class Class1
   {
   	static void Main(string[] args)	
   	{
   		comserverLib.IUnmanagedServer server = new comserverLib.UnmanagedServerClass();
   		IManaged managed = new ManagedImplementation();
   		server.UnmanagedServerMethod(managed);
   	}
   }
   

Passos para criar um wrapper

1. Adicione o código que segue a Class1.cs:

   [
   	ComImport,
   	Guid("XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX"),
   	InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)
   ]
   public interface UCOMIUnmanaged
   {
   	long UnmanagedMethod();
   }
   
   public class ManagedIUnmanaged : UCOMIUnmanaged
   {
   	IManaged managedObj;
   
   	public ManagedIUnmanaged(IManaged managedObj)
   	{
   		if(managedObj != null)
   			this.managedObj = managedObj;
   		else
   			throw new ArgumentNullException("The instance of IManaged is null.");
   	}
   
   	public long UnmanagedMethod()
   	{
   		return  managedObj.ManagedMethod();
   	}
   }
   

   substituir o conteúdo do atributo GUID com o conteúdo do atributo uuid . O atributo uuid é gerado para a interface IUnmanaged no arquivo ComServer.idl.

Passos para criar um empacotador personalizado

1. Add the code that follows to Class1.cs:

   public class SampleMarshaler : ICustomMarshaler
   {
   	static SampleMarshaler marshaler;
   
   	public object MarshalNativeToManaged(IntPtr pNativeData)
   	{
   		return null;
   	}
   	
   	public IntPtr MarshalManagedToNative(object managedObj)
   	{
   		if(managedObj == null)
   			return IntPtr.Zero;
   		if(!(managedObj is IManaged))
   			throw new MarshalDirectiveException("This custom marshaler must be used on a IManaged derived type.");
   
   	ManagedIUnmanaged customObject = new ManagedIUnmanaged((IManaged)managedObj);
   	return Marshal.GetComInterfaceForObject(customObject, typeof(UCOMIUnmanaged));
   	}
   
   	public void CleanUpNativeData(IntPtr pNativeData)
   	{
   		Marshal.Release(pNativeData);
   	}
   
   	public void CleanUpManagedData(object managedObj)
   	{
   
   	}
   
   	public int GetNativeDataSize()
   	{
   		return -1;
   	}
   
   	public static ICustomMarshaler GetInstance(string cookie)
   	{
   		if(marshaler == null)
   			return marshaler = new SampleMarshaler();
   		return marshaler;
   	}
   }

2. Associe o empacotador personalizado com o empacotamento da instância da interface IManaged a uma instância da interface IUnmanaged. Adicione o código que segue a Class1.cs para associar o empacotador personalizado:

   [
   	ComImport,
   	Guid("XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX"),
   	InterfaceTypeAttribute(ComInterfaceType.InterfaceIsDual)
   ]
   public interface UCOMIUnmanagedServer
   {
   	void UnmanagedServerMethod(
   		[MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(SampleMarshaler)), In]
   		object unmanaged);
   }

   é O GUID que você especificar com o atributo GUID o mesmo que o atributo de uuid que é especificado para a interface IUnmanagedServer em .IDL para o servidor COM.
3. Modifique o método Main de Class1 em Class1.cs da seguinte forma:

   static void Main(string[] args)
   {
   	UCOMIUnmanagedServer server = (UCOMIUnmanagedServer)new ComServerLib.UnmanagedServerClass();
   	IManaged managed = new ManagedImplementation();
   	server.UnmanagedServerMethod(managed);
   }

   quando o cliente não gerenciado chama o servidor não gerenciado, o cliente não gerenciado passa uma instância de um objeto gerenciado para o servidor não gerenciado. O objeto gerenciado é personalizado empacotada para um objeto que expõe a interface não gerenciada como esperada pelo servidor COM.
4. No menu Build , clique em Build Solution .
5. No Solution Explorer , clique no nó de projeto ConsoleApplication1 com o botão direito do mouse e clique em Set as StartUp Project .
6. No menu Debug , clique em Iniciar .

Voltar para o início

Empacotamento personalizado em um cliente COM a um servidor .NET

Passos para criar um cliente COM

1. No menu arquivo , aponte para novo e, em seguida, clique em Project .
2. Clique em Projetos do Visual c++ em Tipos de projeto e clique em Projeto ATL em modelos .
3. Na caixa de texto nome , digite ComComponent e, em seguida, clique em OK .
4. Na caixa de diálogo ATL Project Wizard , clique na guia Configurações do aplicativo .
5. Clique para desmarcar a caixa de seleção atribuída e em seguida, clique em Concluir .
6. No Solution Explorer , clique com o botão direito ComComponent (projeto) , aponte para Adicionar e, em seguida, clique em Add Class .
7. Na caixa de diálogo Add Class , clique em ATL Simple Object em modelos e em seguida, clique em Abrir .
8. Na caixa de diálogo ATL Simple Object Wizard , digite Unmanaged o nome curto texto caixa e clique em Concluir .
9. No Class View , expanda ComComponent , clique com o botão direito do mouse IUnmanaged , aponte para Add e, em seguida, clique em Adicionar método .
10. Na caixa de diálogo Assistente para Adicionar método , digite UnmanagedMethod na caixa de texto Nome do método .
11. Selecione LONG 1 da lista em tipo de parâmetro .
12. Clique para selecionar retval em atributos de parâmetro e, em seguida, digite lRetVal na caixa de texto nome do parâmetro .
13. Clique em Adicionar e clique em Concluir .
14. No Solution Explorer , clique duas vezes em Unmanaged.cpp para abrir o arquivo.
15. Substitua o código padrão para CUnmanaged::UnmanagedMethod com o código que segue:

    *lRetVal = 300;
    return S_OK;
    

16. No menu Build , clique em Build Solution para criar o componente COM.

Etapas para criar um servidor .NET

1. No menu arquivo , aponte para novo e, em seguida, clique em Project .
2. Clique em projetos do Visual translation from VPE for Csharp em Tipos de projeto e clique em Class Library em modelos .
3. Clique para selecionar a opção de Adicionar a solução e, em seguida, clique em OK .
4. No arquivo Class1.cs gerado por padrão, substitua o código padrão com o código que segue:

   using System;
   using System.Runtime.InteropServices;
   
   [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
   public interface IManaged
   {
   	long ManagedMethod();
   }
   
   [ClassInterface(ClassInterfaceType.AutoDual)]
   public class ManagedServer
   {
   	public void ManagedServerMethod(IManaged managed)
   	{
   		Console.WriteLine("The output of IManaged.ManagedMethod is : {0}", managed.ManagedMethod());
   	}
   }
   

Passos para criar um wrapper

1. No Solution Explorer , expanda ClassLibrary1 .
2. Na ClassLibrary1 , clique com o botão direito do mouse em References e clique em Add Reference .
3. Na caixa de diálogo Add Reference , clique na guia COM .
4. Clique em biblioteca de tipos ComComponent 1.0 em nome do componente .
5. Clique em Selecionar e clique em OK .
6. No arquivo Class1.cs, adicione código a seguir:

   [ComVisible(false)]
   public class ComUnmanaged : IManaged
   {
   	ComComponentLib.IUnmanaged unmanaged;
   
   	public ComUnmanaged(ComComponentLib.IUnmanaged unmanaged)
   	{
   		if(unmanaged != null)
   			this.unmanaged = unmanaged;
   		else
   			throw new ArgumentNullException("NULL");
   	}
   
   	public long ManagedMethod()
   	{
   		return unmanaged.UnmanagedMethod();
   	}
   }
   	

Passos para criar um empacotador personalizado

1. Adicione o código que segue a Class1.cs:

   [ComVisible(false)]
   public class SampleMarshaler : ICustomMarshaler
   {
   	static SampleMarshaler marshaler;
   
   	public object MarshalNativeToManaged(IntPtr pNativeData)
   	{
   		if(pNativeData == IntPtr.Zero)
   			return null;
   
   		object rcw = Marshal.GetObjectForIUnknown(pNativeData);
   		if(!(rcw is ComComponentLib.IUnmanaged))
   			throw new ArgumentException("The object must implement IUnmanaged");
   
   		return new ComUnmanaged((ComComponentLib.IUnmanaged) rcw);
   	}
   
   	public IntPtr MarshalManagedToNative(object managedObj)
   	{
   		return IntPtr.Zero;
   	}
   
   	public void CleanUpNativeData(IntPtr pNativeData)
   	{
   		Marshal.Release(pNativeData);
   	}
   
   	public void CleanUpManagedData(object managedObj)
   	{
   
   	}
   
   	public int GetNativeDataSize()
   	{
   		return -1;
   	}
   
   	public static ICustomMarshaler GetInstance(string cookie)
   	{
   		if(marshaler == null)
   			return marshaler = new SampleMarshaler();
   		return marshaler;
   	}
   }

2. Adicione MarshalAsAttribute para o parâmetro que é personalizado empacotado. Modificar o código para ManagedServerMethod da seguinte maneira:

   public void ManagedServerMethod(
   	[MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(SampleMarshaler)), In]
   	IManaged managed)
   {
   	Console.WriteLine("The output of IManaged.ManagedMethod is : {0}", managed.ManagedMethod());
   }

3. No menu Build , clique em Build Solution .
4. No menu arquivo , aponte para novo e, em seguida, clique em Project .
5. Na caixa de diálogo New Project , clique em Projetos do Visual c++ em Project Types e clique em Projeto Win32 em modelos .
6. Na caixa de texto nome , digite ComClient .
7. Clique para selecionar a opção de Adicionar a solução e, em seguida, clique em OK .
8. Na caixa de diálogo do Assistente de aplicativos Win32 , clique na guia Configurações do aplicativo .
9. Clique para selecionar o Aplicativo de console opção sob a seção Application digite e clique em Concluir .
10. No Solution Explorer , expanda ComClient e clique duas vezes em stdafx.h arquivo para abrir o arquivo. Adicione o código que segue para o arquivo:

    #import "ComComponent.tlb" no_namespace raw_interfaces_only named_guids
    #import "ClassLibrary1.tlb" no_namespace raw_interfaces_only named_guids

11. No Solution Explorer , expanda ComClient e clique duas vezes no arquivo ComClient.cpp para abrir esse arquivo. Adicione o código que segue ao file:

    #include "stdafx.h"
    int _tmain(int argc, _TCHAR* argv[])
    {
    	HRESULT hr;
    	IUnmanaged *unmanagedObj;
    	_ManagedServer *managedServer;
    
    	CoInitialize(NULL);
    	hr = CoCreateInstance(CLSID_Unmanaged, NULL, CLSCTX_INPROC_SERVER, IID_IUnmanaged, (LPVOID *)&unmanagedObj);
    	if(FAILED(hr))
    		goto Error;
    
    	hr = CoCreateInstance(CLSID_ManagedServer, NULL, CLSCTX_INPROC_SERVER, IID__ManagedServer, (LPVOID *)&managedServer);
    	if(FAILED(hr))
    		goto Error;
    
    	hr = managedServer->ManagedServerMethod(unmanagedObj);
    	if(FAILED(hr))
    		goto Error;
    
    	return 0;
    
    Error:
    	CoUninitialize();
    	return hr;
    }

12. Para gerar o ClassLibrary1.tlb, digite o comando seguinte no prompt de comando:
    regasm /tlb ClassLibrary1.dll
    Verifique se o arquivo ClassLibrary1.dll está no diretório de compilação para o projeto ClassLibrary1. O ClassLibrary1.dll gera o ClassLibrary1.tlb e também registra a biblioteca de classes.
13. Copiar o arquivo ClassLibrary1.tlb e o ComComponent.tlb arquivo para o diretório de projeto para o aplicativo ComClient.
14. No menu Build , clique em Build Solution .
15. Copie o arquivo ClassLibrary1.dll e o arquivo Interop.comclientLib.dll do diretório de compilação do ClassLibrary1 projeto para o diretório de compilação para o aplicativo de console ComClient.
16. No Solution Explorer , clique com o botão direito do mouse ComClient e clique em Set as StartUp Project .
17. No menu Debug , clique em Iniciar .

Voltar para o início