Grundlagen der Interoperabilität (P/Invoke) im Überblick
Rufen Sie native Funktionen mit P/Invoke auf: Grundlagen von DllImport, Marshaling von Zeichenketten, SetLastError und einfache Win32-Demos (Sleep, GetTickCount64).
Grundlagen der Interoperabilität (P/Invoke) im Überblick ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 3 Lektionen.
Konzept und Ziele
P/Invoke ermöglicht es C#, Funktionen aus nativen DLLs aufzurufen.
- Verwenden Sie DllImport, um eine Methode zu binden
- Wählen Sie bei Bedarf CharSet und SetLastError
- Halten Sie Signaturen einfach und korrekt
P/Invoke: Sleep
Binden Sie die native Funktion, indem Sie eine verwaltete Methode mit DllImport deklarieren.
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!");
}
}
Native Rückgabewerte
Passen Sie die native Signatur an: Hier geben wir einen vorzeichenlosen 64-Bit-Wert zurück.
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);
}
}
Zeichenketten und CharSet
Verwenden Sie CharSet.Unicode für APIs mit breiten Zeichenketten (die „W“-Varianten). Fangen Sie Laufzeitfehler auf nicht unterstützten Plattformen ab.
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 und Typen
Fehlerbehandlung:
- Fügen Sie bei APIs, die GetLastError setzen, SetLastError=true in DllImport hinzu
- Lesen Sie nach einem fehlgeschlagenen Aufruf Marshal.GetLastWin32Error() aus
- Bevorzugen Sie exakte Typen: uint statt int, Zeiger als IntPtr
Gute Interop-Praxis
- Beginnen Sie mit einfachen APIs (ohne komplexe Strukturen)
- Verwenden Sie IntPtr für Handles und geben Sie diese mit der richtigen nativen Funktion frei
- Vermeiden Sie GUI-Aufrufe in Umgebungen ohne grafische Oberfläche
- Dokumentieren Sie Plattformgrenzen (nur Windows usw.)
Zweck von DllImport
Zusammenfassung
Zusammenfassung: Deklarieren Sie native Aufrufe mit DllImport, stimmen Sie die Typen sorgfältig ab, wählen Sie für Zeichenketten CharSet und behandeln Sie Fehler gegebenenfalls mit SetLastError und GetLastError.
Häufig gestellte Fragen
Ist die Lektion „Grundlagen der Interoperabilität (P/Invoke) im Überblick“ kostenlos?
Ja — der vollständige Text von „Grundlagen der Interoperabilität (P/Invoke) im Überblick“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 3 Lektionen.
Was lerne ich in „Grundlagen der Interoperabilität (P/Invoke) im Überblick“?
Rufen Sie native Funktionen mit P/Invoke auf: Grundlagen von DllImport, Marshaling von Zeichenketten, SetLastError und einfache Win32-Demos (Sleep, GetTickCount64). Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um C# Academy zu starten?
Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 3.
Wie lange dauert die Lektion „Grundlagen der Interoperabilität (P/Invoke) im Überblick“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?
Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- C#-Scripting (dotnet script), Snippets und REPL
- Grundlagen der Interoperabilität (P/Invoke) im Überblick
- CLI-Bedienkomfort