Tenho uma dll de terceiro feita em C#, quero criar uma lib static C# para poder usar em…
- User
Tenho uma dll de terceiro feita em C#, quero criar uma lib static C# para poder usar em meu código rust e c++ como chamo funções dessa dll c# custom no meu código lib
classe da lib
namespace GRFlib { public class Class1 {
}}
funções da dll
GrfHolder grf = new GrfHolder(@"C:\data.grf");
grf.Commands.AddFile(@"data\texture\grid.tga", @"C:\test\custom_grid.tga"); grf.Commands.RemoveFile(@"data\texture\loading00.jpg");
if (grf.Commands.CanUndo) grf.Commands.Undo();
if (grf.Commands.CanRedo) grf.Commands.Redo();
grf.QuickSave(); // Reload is only necessary if you plan on using the GRF again after saving it. grf.Reload();
- Assistant
Para chamar funções de uma DLL C# personalizada em seu código Rust ou C++, você precisará expor essas funções de uma maneira que código não gerenciado (unmanaged code) possa invocá-las. Isso pode ser feito criando exportações não gerenciadas (unmanaged exports) a partir de seu código C#. Aqui está um guia passo a passo para alcançar isso:
1. Use o pacote
UnmanagedExports(RGiesecke.DllExport)Este pacote permite que você exponha funções de uma DLL C# como funções exportadas que podem ser chamadas a partir de código nativo.
- Adicione o pacote
RGiesecke.DllExportao seu projeto C# via NuGet.
Install-Package UnmanagedExports2. Modifique seu código C# para exportar funções
Decore os métodos que você deseja exportar com o atributo
[DllExport]. Certifique-se de que esses métodos sejam estáticos e use tipos que possam ser facilmente interpretados em código não gerenciado.using RGiesecke.DllExport; using System; using System.Runtime.InteropServices; namespace GRFlib { public class Class1 { [DllExport("CreateGrfHolder", CallingConvention = CallingConvention.StdCall)] public static IntPtr CreateGrfHolder([MarshalAs(UnmanagedType.LPWStr)] string grfFilePath) { GrfHolder grf = new GrfHolder(grfFilePath); // Aloca um GCHandle para manter referência ao objeto return GCHandle.ToIntPtr(GCHandle.Alloc(grf)); } [DllExport("AddFile", CallingConvention = CallingConvention.StdCall)] public static void AddFile(IntPtr grfHandle, [MarshalAs(UnmanagedType.LPWStr)] string destination, [MarshalAs(UnmanagedType.LPWStr)] string source) { // Recupera o objeto GrfHolder a partir do handle GCHandle handle = GCHandle.FromIntPtr(grfHandle); GrfHolder grf = (GrfHolder)handle.Target; grf.Commands.AddFile(destination, source); } [DllExport("ReleaseGrfHolder", CallingConvention = CallingConvention.StdCall)] public static void ReleaseGrfHolder(IntPtr grfHandle) { GCHandle handle = GCHandle.FromIntPtr(grfHandle); handle.Free(); } // Exporte outras funções conforme necessário... } }3. Use a DLL exportada em seu código C++
No código C++, você pode declarar as funções exportadas e usá-las como faria com qualquer função de DLL.
// Declare as funções exportadas extern "C" { typedef void* (__stdcall *CreateGrfHolderFunc)(const wchar_t* grfFilePath); typedef void (__stdcall *AddFileFunc)(void* grfHandle, const wchar_t* destination, const wchar_t* source); typedef void (__stdcall *ReleaseGrfHolderFunc)(void* grfHandle); } // Carregue a DLL e obtenha os ponteiros para as funções HMODULE hModule = LoadLibrary(L"GRFlib.dll"); CreateGrfHolderFunc CreateGrfHolder = (CreateGrfHolderFunc)GetProcAddress(hModule, "CreateGrfHolder"); AddFileFunc AddFile = (AddFileFunc)GetProcAddress(hModule, "AddFile"); ReleaseGrfHolderFunc ReleaseGrfHolder = (ReleaseGrfHolderFunc)GetProcAddress(hModule, "ReleaseGrfHolder"); // Use as funções void* grfHolder = CreateGrfHolder(L"C:\\data.grf"); AddFile(grfHolder, L"data\\texture\\grid.tga", L"C:\\test\\custom_grid.tga"); // ... // Libere recursos quando terminar ReleaseGrfHolder(grfHolder); FreeLibrary(hModule);4. Uso em Rust
Em Rust, você pode usar FFI (Foreign Function Interface) para interagir com as funções exportadas.
extern "stdcall" { fn CreateGrfHolder(grf_file_path: *const u16) -> *mut std::ffi::c_void; fn AddFile(grf_handle: *mut std::ffi::c_void, destination: *const u16, source: *const u16); fn ReleaseGrfHolder(grf_handle: *mut std::ffi::c_void); } // Helper para converter &str em ponteiro wide string fn to_wide_chars(s: &str) -> Vec<u16> { use std::os::windows::ffi::OsStrExt; std::ffi::OsStr::new(s).encode_wide().chain(std::iter::once(0)).collect() } fn main() { unsafe { let grf_file = to_wide_chars("C:\\data.grf"); let grf_holder = CreateGrfHolder(grf_file.as_ptr()); let destination = to_wide_chars("data\\texture\\grid.tga"); let source = to_wide_chars("C:\\test\\custom_grid.tga"); AddFile(grf_holder, destination.as_ptr(), source.as_ptr()); // ... ReleaseGrfHolder(grf_holder); } }Considerações Importantes:
-
Gerenciamento de Memória: Ao passar objetos entre código gerenciado e não gerenciado, é crucial gerenciar a memória adequadamente para evitar vazamentos. Utilizamos
GCHandlepara manter referências aos objetos C# no heap gerenciado. -
Tipos Compatíveis: Certifique-se de usar tipos primitivos e strings que possam ser corretamente marshallizados entre os ambientes gerenciado e não gerenciado. Usamos
UnmanagedType.LPWStrpara strings wide (Unicode). -
Convenção de Chamada: Use a convenção de chamada correta (geralmente
StdCallno Windows) ao exportar funções e ao declará-las no código não gerenciado. -
Plataforma Alvo: Este exemplo é específico para Windows devido ao uso de chamadas e tipos específicos do Windows. Ajustes podem ser necessários para outras plataformas.
Alternativas:
-
COM Interop: Você pode expor suas classes C# como objetos COM e usá-los a partir de C++ ou outras linguagens que suportem COM. No entanto, isso pode ser mais complexo e envolver registro de componentes.
-
C++/CLI: Crie uma DLL usando C++/CLI que atua como um wrapper entre seu código C# gerenciado e o código C++ não gerenciado. Esta abordagem permite usar classes e métodos C# diretamente em C++/CLI e expor uma API não gerenciada.
-
gRPC ou IPC: Use comunicação entre processos como gRPC ou outras formas de IPC (Inter-Process Communication) para interagir com um serviço escrito em C#.
Ao seguir os passos acima, você poderá chamar funções de sua DLL C# personalizada a partir de código Rust ou C++, permitindo a integração necessária para seu projeto.
- Adicione o pacote