Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Tenho uma dll de terceiro feita em C#, quero criar uma lib static C# para poder usar em…

  1. 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();

  2. 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.DllExport ao seu projeto C# via NuGet.
    Install-Package UnmanagedExports
    

    2. 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 GCHandle para 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.LPWStr para strings wide (Unicode).

    • Convenção de Chamada: Use a convenção de chamada correta (geralmente StdCall no 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.