0Pricing
C# Academy · Aula

Fundamentos de interoperabilidade (P/Invoke) de relance

Chame funções nativas com P/Invoke: fundamentos de DllImport, marshal de cadeias de caracteres, SetLastError e demonstrações simples do Win32 (Sleep, GetTickCount64).

Fundamentos de interoperabilidade (P/Invoke) de relance é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 2 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 3 aulas no total.

Conceito e objetivos

P/Invoke permite que o C# chame funções de DLLs nativas.

  • Use DllImport para associar um método
  • Escolha CharSet e SetLastError quando necessário
  • Mantenha as assinaturas simples e precisas

P/Invoke: Sleep

Associe a função nativa declarando um método gerenciado com DllImport.

using System;
using System.Runtime.InteropServices;

// Simple P/Invoke call to native Sleep (Windows kernel32)
// Note: This demo may only run on Windows, but it compiles everywhere.
public class Program
{
  [DllImport("kernel32.dll")]
  private static extern void Sleep(uint dwMilliseconds);

  public static void Main(string[] args)
  {
    Console.WriteLine("Sleeping for 200 ms...");
    // Call native function
    Sleep(200);
    Console.WriteLine("Awake!");
  }
}

Valores de retorno nativos

Combine a assinatura nativa: aqui retornamos um valor sem sinal de 64 bits.

using System;
using System.Runtime.InteropServices;

// Get system uptime (ms) from native function.
public class Program
{
  [DllImport("kernel32.dll")]
  private static extern ulong GetTickCount64();

  public static void Main(string[] args)
  {
    ulong ms = GetTickCount64();
    Console.WriteLine("Uptime (ms): " + ms);
  }
}

Cadeias de caracteres e CharSet

Use CharSet.Unicode para APIs de cadeias de caracteres largas (as versões “W”). Capture erros de execução em plataformas sem suporte.

using System;
using System.Runtime.InteropServices;

// Demo: marshaling strings to Unicode with CharSet.Unicode.
// On non-Windows environments this may fail at runtime.
public class Program
{
  [DllImport("user32.dll", CharSet = CharSet.Unicode)]
  private static extern int MessageBox(IntPtr hWnd, string text, string caption, uint type);

  public static void Main(string[] args)
  {
    Console.WriteLine("Calling MessageBox (may require Windows GUI)...");
    // 0x00000040 = MB_ICONINFORMATION
    try
    {
      int result = MessageBox(IntPtr.Zero, "Hello from P/Invoke", "Interop", 0x00000040);
      Console.WriteLine("MessageBox returned: " + result);
    }
    catch (Exception ex)
    {
      Console.WriteLine("MessageBox failed at runtime: " + ex.GetType().Name);
    }
  }
}

SetLastError e tipos

Tratamento de erros:

  • Para APIs que definem GetLastError, adicione SetLastError=true em DllImport
  • Após uma chamada malsucedida, leia Marshal.GetLastWin32Error()
  • Prefira tipos exatos: uint em vez de int, ponteiros como IntPtr

Boas práticas de interoperabilidade

  • Comece com APIs simples (sem estruturas complexas)
  • Use IntPtr para identificadores; libere-os com a função nativa correta
  • Evite chamadas de interface gráfica em ambientes sem interface
  • Documente as limitações da plataforma (somente Windows etc.)

Finalidade de DllImport

Verificação rápida: o que o atributo DllImport faz em P/Invoke?

Recapitulação

Recapitulação: declare chamadas nativas com DllImport, combine os tipos com cuidado, escolha CharSet para cadeias de caracteres e trate os erros por meio de SetLastError e GetLastError quando aplicável.

Perguntas Frequentes

A aula “Fundamentos de interoperabilidade (P/Invoke) de relance” é grátis?

Sim — o texto completo de “Fundamentos de interoperabilidade (P/Invoke) de relance” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 3 aulas no total.

O que vou aprender em “Fundamentos de interoperabilidade (P/Invoke) de relance”?

Chame funções nativas com P/Invoke: fundamentos de DllImport, marshal de cadeias de caracteres, SetLastError e demonstrações simples do Win32 (Sleep, GetTickCount64). Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 3.

Quanto tempo leva a aula “Fundamentos de interoperabilidade (P/Invoke) de relance”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Scripting em C# (dotnet script), trechos e REPL
  2. Fundamentos de interoperabilidade (P/Invoke) de relance
  3. Ergonomia da CLI
← Voltar para C# Academy