Windows Application Programming Interface

aus Wikipedia, der freien Enzyklopädie
(Weitergeleitet von Win32s)

Das Windows Application Programming Interface (kurz: WinAPI; englisch für: „Windows-Anwendungs-Programmierschnittstelle“) ist eine Programmierschnittstelle und Laufzeitumgebung zur Erstellung von Anwendungsprogrammen für Windows-Betriebssysteme.

Einzelheiten

Die Funktionen der WinAPI sind ausschließlich in den Programmiersprachen C und Assembler geschrieben und können von Windows-Programmierern im selbst erstellten Quelltext verwendet werden. Sie befinden sich in dynamischen Bibliotheken, den sogenannten DLL-Dateien, beispielsweise kernel32.dll, user32.dll und gdi32.dll und sind Bestandteil des Betriebssystems. Die WinAPI abstrahiert die nativen Funktionen des Betriebssystems, die durch die ntdll.dll exportiert und im Windows-Kernel (ntoskrnl.exe) implementiert sind. Dies ermöglicht es Microsoft, die Implementierung der WinAPI zu modifizieren, ohne deren Funktionsweise zu ändern.

Die WinAPI wird immer verwendet, wenn native Windows-Anwendungen geschrieben werden, obwohl der Programmierer sie eventuell direkt im Quelltext gar nicht aufgerufen hat. Die Aufrufe der API werden durch eine Laufzeitbibliothek gekapselt, die ihrerseits Funktionen der Windows-API aufrufen. Windows NT/2000 hat eine native API, die sowohl für im Kernel-Mode als auch für im User-Mode laufende Programme eine Programmierschnittstelle bereitstellt. Diese Schnittstellen sind Bestandteil des Betriebssystemkerns, der letzten Endes alle hardwarenahen Operationen mit und an der Hardware durchführt.

Die objektorientierten Bibliotheken, wie die MFC-Bibliothek und das .NET Framework, sind eine Alternative zur direkten Nutzung der Windows API. Hierbei werden die nativen Methoden der Windows API gekapselt und ermöglichen auf diese Art und Weise eine bequemere objektorientierte Handhabung der zur Verfügung stehenden Funktionen. Viele von Programmen ausgeführte Aktionen, seien es I/O-Operationen, Windows-Dialoge oder Speicherverwaltung, wären ohne die Windows API nur sehr eingeschränkt durchführbar. Systemnaher Zugriff auf das Windows-Betriebssystem, der hauptsächlich von Gerätetreibern benötigt wird, wird mithilfe des Windows Driver Model (WDM) unter allen Windows-NT-Versionen realisiert.

Versionen

Beinahe mit jeder neuen Version von Windows wurde die Windows API erweitert und abgeändert. Der Name der API wurde dennoch zwischen den Versionen beibehalten und nur leicht verändert, um gravierende Unterschiede zwischen den Windows-Architekturen und den Plattformen zu verdeutlichen. So wurde der ursprüngliche Begriff WinAPI, der in den 16-Bit-Versionen von Windows vorherrschte, um die Zahl 32 zu Win32 API erweitert, um dem bedeutsamen Sprung zur 32-Bit-Architektur deutlich zu machen. Dennoch wird heute der allgemeine Begriff Windows API verwendet, der sowohl die alte API als auch die neue miteinschließt.

Win16

Win16 war die erste API für die 16-Bit-Versionen von Windows. Gängiger Begriff war schlicht Windows API, wurde aber später umbenannt in Win16, um sie von der neueren Windows API der 32-Bit-Architektur unterscheiden zu können. Die Funktionen der Win16 API liegen hauptsächlich im Kern des Betriebssystems: kernel.exe (oder krnl286.exe oder krnl386.exe), user.exe und gdi.exe. Trotz der Dateiendung exe sind diese Dateien tatsächlich sogenannte Programmbibliotheken.

Win32

Win32 ist die 32-Bit-API für moderne Versionen von Windows. Die API besteht aus Funktionen, die, wie bei Win16, in Programmbibliotheken implementiert sind. Die Kern-DLLs von Win32 sind kernel32.dll, user32.dll und gdi32.dll. Win32 wurde mit Windows NT eingeführt. Die Version von Win32, die mit Windows 95 ausgeliefert wurde, lief ursprünglich unter dem Namen Win32c, wobei das „c“ für Kompatibilität (englisch compatibility) stand, aber dieser Ausdruck wurde später von Microsoft zugunsten von Win32 wieder verworfen. In Windows NT und seinen Nachfolgern (eingeschlossen alle modernen Windows-Versionen) werden Win32-Aufrufe durch zwei Module ausgeführt, csrss.exe (englisch Client/Server Runtime Subsystem) im User-Modus und win32k.sys im Kernel-Modus. Dies dient dem Schutz des Betriebssystems und verhindert, dass laufende Anwendungen des Benutzers kritische Daten des Betriebssystems modifizieren oder darauf zugreifen können. Die Modi werden direkt vom Prozessor zur Verfügung gestellt.

Obwohl auch Windows CE eine Win32-ähnliche API enthält, gibt es tiefgreifende Unterschiede,[1] die Portierungen von Quellcode in der Realität meist aufwändig gestalten.

Win32s

Win32s ist die 32-Bit-API für die Windows-3.1x-Familie und als solche die 32-Bit-Erweiterung[2] für die ansonsten 16-bittigen Betriebssysteme. Das „s“ steht für Teilmenge (englisch

subset

). Dabei wurden die Funktionsbibliotheken aus Windows NT nicht komplett übernommen, sondern lediglich eine Auswahl daraus, so ist beispielsweise MS Office 97 unter Windows NT 3.51 lauffähig, nicht jedoch unter Windows 3.1x. In Kombination mit Grafikschnittstellen wie OpenGL oder Video for Windows sollte damit jedoch bis zum Erscheinen von Windows 95 ein ausreichender Standard für Heimanwender gesetzt werden. Sie wurde mehrmals angepasst und in höheren Versionsnummern ergänzt. Die letzte Version war Version 1.30c.[3] Für die Nutzung der Win32s-API ist in Windows 3.x der Enhanced Mode erforderlich.

Win64

Win32 für 64-Bit-Windows, auch bekannt unter dem Namen Win64, ist die Version der API, die für 64-Bit-Versionen von Windows – namentlich Windows XP „x64 Edition“, Windows Server 2003 „x64 Edition“ (für AMD64-Prozessoren) und Windows Server 2003 für Itanium-Serien – entworfen wurde. Bei den 64-Bit-Versionen handelt es sich nur um zwei weitere unterstützte Plattformen innerhalb der Windows-NT-Architektur, so dass sowohl die 32-Bit- als auch die 64-Bit-Version einer Anwendung aus demselben Quellcode kompiliert werden können. Alle Zeiger auf den Speicher sind standardmäßig 64 Bit groß, weshalb der Quellcode gegebenenfalls auf Kompatibilität überprüft werden muss. Obwohl keine neuen Funktionen zur API hinzugefügt wurden, gibt es Unterschiede zwischen Win32 und Win64. Deshalb wird auf 64-Bit-Systemen – für 32-Bit-Anwendungen – durch eine Abstraktionsebene namens WOW64 eine zu Win32 kompatible API bereitgestellt.

.NET Framework

Die .NET-Framework-API (früher WinFX genannt) ist eine neue, objektorientierte API, die die native Windows-API erweitert. Die API wurde unter anderem entworfen, um zukünftigen Anwendungen einen einfachen, verwalteten Zugriff auf die zahlreichen neuen Features in Windows Vista zu geben. .NET-Anwendungen laufen als sogenannter Managed Code (verwalteter Code) unter einer Laufzeitumgebung namens Common Language Runtime (CLR), einer virtuellen Maschine, die im Sinne der Abstraktion keine direkten Maschinenbefehle ausführt, sondern stattdessen das aus Bytecode bestehende Programm in Maschinencode umwandelt, bevor dieses dann vom Prozessor ausgeführt werden kann. Der GUI-API-Satz für WinFX, der unter dem Codenamen Avalon läuft, wird Windows Presentation Foundation genannt und löst die alte GDI- und GDI+-APIs ab. Sie setzt direkt auf DirectX auf und benötigt Grafikkarten mit Hardwarebeschleunigung, um alle Effekte angemessen darstellen zu können.

Weitere APIs

Überdies haben frühere Versionen von Windows auch die APIs anderer Betriebssysteme mitgebracht. Windows NT 3.1 sowie Windows NT 4.0 waren noch mit einer leicht abgespeckten Version der OS/2- und einer POSIX-API ausgestattet. Dadurch war es in eingeschränkter Form möglich, auch Programme auszuführen, welche eigentlich für OS/2 oder Unix-Systeme kompiliert waren. Möglich wurde dies durch eine tiefer liegende zweite API-Schicht – die weitestgehend undokumentierte

native

API. Auf die Funktionen dieser API stößt man z. B., wenn man Betriebssystem-DLLs mit einem Debugger durchläuft. Die Windows-API-Funktionen von Win32 usw. rufen zum Teil wiederum Funktionen der Native API auf, ebenso wie das OS/2- und POSIX-Subsystem. Inzwischen hat Microsoft die anderen APIs entfernt, der prinzipielle Mechanismus ist aber auch in Windows Vista noch unverändert. Mit der .NET-API wurde sogar eine dritte, nun aber wesentlich modernere objektorientierte Schicht über die Win32-API und die Native API gesetzt.

Implementierungen außerhalb von Windows

Wine und das Win32/64-API in verschiedenen Betriebssystemen.

Neben der in aktuellen Windows-Versionen enthaltenen Win32/64-API von Microsoft gibt es auch Varianten für andere Betriebssysteme. Diese Nachbildungen dienen dazu, Windows-Anwendungsprogramme ohne Windows-Betriebssystem zu nutzen. Aus rechtlichen Gründen sind meist nicht alle Funktion der original-API vorhanden, was die Kompatibilität mit Anwendungsprogrammen einschränken kann. Da die wenigsten Anwendungsprogramme alle Funktionen der Win32/64-API benötigen, sind viele aber trotzdem voll nutzbar.

Beispiele von Win32-Implementierungen:

  • Wine: Ein Open-Source-Projekt mit dem Ziel, eine vollständige Win32- und Win64-API für Linux- und Unix-artige Betriebssysteme zu erstellen.
  • CrossOver: Eine kommerzielle Erweiterung von Wine.
  • Cedega (früher WineX): Eine nahezu komplette kommerzielle Win32- und DirectX-Implementation mit dem Ziel, Windows-Spiele unter Linux lauffähig zu machen.
  • Darwine: Eine Wine Portierung für macOS.
  • Odin: Wine32-API für OS/2.
  • Proton: Eine auf Wine basierende Software mit dem Ziel, Windows-Spiele auf anderen Plattformen auszuführen.
  • ReWind
  • ReactOS: Verwendet einen Teil der Wine-Bibliotheken, um sich doppelte Entwicklungsarbeit zu sparen.
  • HX DOS Extender: Macht Win32-Anwendungen unter DOS lauffähig.
  • Wabi: Windows Application Binary Interface ein Win16-API-Projekt von Sun Microsystems aus den frühen 1990er-Jahren.

Das Mono-Projekt bietet eine Entwicklungsumgebung und eine API für .NET-Anwendungen in Linux- und Unix-artigen Betriebssystemen. Mono orientiert sich dabei vor allem am Common-Language-Infrastructure-Standard.

Programmbeispiel

Folgender Quelltext implementiert ein Programm mit Hilfe der WinAPI, welches ein Fenster erzeugt und den Text „Hello World!“ ausgibt. Das Programm ist in der Programmiersprache C verfasst. 

#include <windows.h>

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
                   PSTR szCmdLine, int iCmdShow)
{
   static TCHAR const szAppName[] = TEXT("Klassenname");
   HWND       hWnd;
   MSG        msg;
   WNDCLASSEX wndclassex;

   wndclassex.cbSize        = sizeof (WNDCLASSEX);
   wndclassex.style         = CS_HREDRAW | CS_VREDRAW;
   wndclassex.lpfnWndProc   = &WndProc;
   wndclassex.cbClsExtra    = 0;
   wndclassex.cbWndExtra    = 0;
   wndclassex.hInstance     = hInstance;
   wndclassex.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
   wndclassex.hCursor       = LoadCursor(NULL, IDC_ARROW);
   wndclassex.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
   wndclassex.lpszMenuName  = NULL;
   wndclassex.lpszClassName = szAppName;
   wndclassex.hIconSm       = wndclassex.hIcon;

   if (!RegisterClassEx(&wndclassex))
   {
      MessageBox(NULL, TEXT("RegisterClassEx fehlgeschlagen!"),
                 szAppName, MB_OK | MB_ICONERROR);
      return -1;
   }

   hWnd = CreateWindowEx(WS_EX_OVERLAPPEDWINDOW, // erweiterter Fensterstil
                  szAppName, // Name der Fensterklasse
                  TEXT("Fenstertitel"), // Fenstertitel
                  WS_OVERLAPPEDWINDOW, // Fensterstil
                  CW_USEDEFAULT, // X-Position des Fensters
                  CW_USEDEFAULT, // Y-Position des Fensters
                  CW_USEDEFAULT, // Fensterbreite
                  CW_USEDEFAULT, // Fensterhöhe
                  NULL, // übergeordnetes Fenster
                  NULL, // Menü
                  hInstance, // Programm-Kopiezähler (Programm-ID)
                  NULL); // zusätzliche Parameter

   ShowWindow(hWnd, iCmdShow);
   UpdateWindow(hWnd);

   while(GetMessage(&msg, NULL, 0, 0))
   {
      TranslateMessage(&msg);
      DispatchMessage(&msg);
   }

   UnregisterClass(szAppName, hInstance);

   return (int)msg.wParam;
}

// Die Hauptnachrichtenschleife
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
   HDC hdc;
   PAINTSTRUCT ps;

   switch (message)
   {
   case WM_PAINT:
       hdc = BeginPaint(hWnd, &ps);
       TextOut(hdc, 0, 0, TEXT("Hello World!"), 12);
       EndPaint(hWnd, &ps);
       return 0;

   case WM_CLOSE:
       DestroyWindow(hWnd);
       break;

   case WM_DESTROY:
       PostQuitMessage(0);
       return 0;
   }

   return DefWindowProc(hWnd, message, wParam, lParam);
}

Literatur

  • Mark Russinovich: Windows Internals Part I. Sechste Auflage, Microsoft Press, 2012, ISBN 978-0-7356-4873-9.

Weblinks

Einzelnachweise

  1. ↑ API Considerations. Microsoft, abgerufen am 2. September 2013.
  2. ↑ How to download and install Win32s using Windows 3.1 File Manager (englisch) – MIT, mit „
    Win32s is an extension for the Windows 3.1 and Windows 3.11 operating systems, which allows them to run some 32-bit applications.
    “; letzte Änderung am 18. Februar 1999
  3. ↑ The Win32s compatibility list
Abgerufen von „https://de.wikiup.org/index.php?title=Windows_Application_Programming_Interface&oldid=222632973#Win32s“