C# Dll Funções públicas ausentes

Question

Estou tentando escrever uma DLL usando a estrutura C# .NET 2.0. Tudo compila bem, mas quando tento acessar a DLL do meu aplicativo, ela falha ao tentar obter o endereço do procedimento. Então, eu optei pela DLL em Walker de dependência, e todas as minhas funções públicas estão faltando!

Minha DLL, até agora, é bastante direta:

namespace MyDll_Namespace
{
    public class MyDllClass
    {
        public static int Func1( /* params */ ) { /* ... */ }

        public static int Func2( /* params */ ) { /* ... */ }

        public static int Func3( /* params */ ) { /* ... */ }

        public static int Func4( /* params */ ) { /* ... */ }
    }
}

Não há muito mais, apenas algumas constantes e delegados definidos dentro da classe, bem como fora da classe no espaço para nome. Quaisquer pensamentos ou sugestões seriam muito apreciados. Obrigado.

Answer 1

Decidi escrever minhas DLLs em C ++. No entanto, aqui está um monte de informações úteis que encontrei para usar o código gerenciado do código não gerenciado:

• É possível usar uma DLL criada usando C# em um aplicativo VC ++ não gerenciado?
• Como chamo as DLLs C ++/CLI (.NET) de aplicativos padrão e não gerenciados não gerenciados?
• Usando o código gerenciado em um aplicativo não gerenciado
• Usando componentes gerenciados de código não gerenciado
• Uma visão geral da interoperabilidade de código gerenciada/não gerenciada
• Exportações não gerenciadas
• Chamando objetos gerenciados .NET C# COM do código C ++ não gerenciado
• Estrutura de código all-in-one
• APIs de hospedagem de CLR
• Como: migrar para /clr
• Como chamar uma DLL gerenciada do código Visual C ++ nativo no Visual Studio.net ou no Visual Studio 2005

Answer 2

Dependência Walker é para DLLs Win32 (que é Código nativo), não os conjuntos .NET (que é código gerenciado). Não encontrará métodos em uma classe arbitrária (mesmo que sejam estáticos). Se você precisar ligar para o código gerenciado do código nativo, existem maneiras de fazer isso, Mas não é bonito.

Se você deseja usar sua DLL do código gerenciado, é muito mais fácil. Verificação de saída System.Asshembly e Ativador.

Um exemplo disso:

var assembly = Assembly.LoadFile(@"\path\to\your.dll");
var mydllclass_type = assembly.GetType("MyDllClass");
var instance = Activator.CreateInstance(mydllclass_type);

A instância será um objeto. Para chamar os métodos, você precisa usar a reflexão, porque a interface não é conhecida em tempo de compilação.

Se você estiver criando um sistema de plug -in, a melhor maneira é ter uma interface comum ou base abstrata para todos os plugins e ter referenciado pelo seu programa. Os terceiros que implementam um plug -in também farão referência a este contrato. Nesse caso, a última linha muda um pouco:

var instance = (IMyDllClass)Activator.CreateInstance(mydllclass_type);

Agora você pode usar os métodos como em um objeto construído regularmente.

Answer 3

Parte do problema aqui é que a dependência Walker é uma ferramenta para aplicativos nativos. Ele não entende o código gerenciado e, portanto, não exibirá nenhum dos métodos de Tipos + Gerenciados que você definiu.

Estou confuso com esta linha em sua pergunta

Quando tento acessar a DLL a partir do meu aplicativo, ela falha ao tentar obter o endereço do procedimento

Isso soa um pouco como um erro que eu veria em um aplicativo nativo, não gerenciado. Você está tentando acessar o código C# de um aplicativo nativo? Nesse caso, isso só pode ser feito via magic e não via chamada direta. Você pode explicar com mais detalhes o que está acontecendo aqui?

Answer 4

Experimente o .NET Reflector para ver exatamente o que está dentro da sua DLL construída (para garantir que tudo seja a maneira como deveria). Além disso, verifique se você está no modo de liberação ao criar sua DLL antes de referenciá -lo ... não sei se vai mudar alguma coisa, mas vale a pena tentar =)

Answer 5

Você precisa adicionar uma referência à sua DLL e o tempo de execução permitirá automaticamente que você ligue para sua função. Aqui está um pouco tutorial Ao escrever uma biblioteca de classe .NET.