Freigeben über

Registration-Free Aktivierung von .NET-Based-Komponenten: Eine exemplarische Vorgehensweise

 

Steve White
Premier Support für Entwickler, Microsoft UK

Leslie Muller
Global IT Research & Development, Credit Suisse First Boston

Juli 2005

Zusammenfassung: Das Microsoft Platform SDK bietet eine hervorragende Aufgabe, die Themen isolierten Anwendungen und parallelen Assemblyszu dokumentieren. Aber nicht jeder gleicht dieses Thema mit der registrierungsfreien Aktivierung von COM-Komponenten. Registrierungsfreie COM ist ein Plattformfeature von großem Interesse für Unternehmen mit gesperrten Servern und Anwendungen, die auf gemeinsam genutzten Infrastrukturen isoliert sind. In diesem Artikel wird ein funktionierendes Beispiel für die registrierungsfreie Aktivierung einer .NET Framework-basierten Komponente durch systemeigene Clients über COM-Interoperabilität erläutert. (11 gedruckte Seiten)

Gilt für:
   Microsoft Windows Server 2003
   Microsoft Windows XP Service Pack 2
   Microsoft .NET Framework, Version 1.1
   Microsoft Visual Studio .NET 2003
   Microsoft Visual Basic 6.0

Laden Sie das Beispiel herunter, das zu diesem Artikel gehört, MSDNRegFreeNet.msi.

Einleitung
Registration-Free COM-Terminologie
Ausführen des Beispiels
Erstellen einer .NET-Assembly als COM-Server
Erstellen des Clients
Registration-Free Aktivierung
Fehlerbehebung
Schlussfolgerung
Weitere Lektüre

Einleitung

Registrierungsfreie COM ist ein Mechanismus, der auf den Plattformen Microsoft Windows XP (SP2 für .NET Framework-basierte Komponenten) und Microsoft Windows Server 2003 verfügbar ist. Wie der Name schon sagt, ermöglicht der Mechanismus eine einfache (z. B. XCOPY)-Bereitstellung von COM-Komponenten auf einem Computer, ohne dass sie registriert werden müssen.

Auf den Zielplattformen besteht eine der Phasen der Initialisierung eines Prozesses und seiner abhängigen Module darin, alle zugeordneten Manifestdateien in eine Speicherstruktur zu laden, die als Aktivierungskontextbezeichnet wird. Wenn keine entsprechenden Registrierungseinträge vorhanden sind, handelt es sich um einen Aktivierungskontext, der die Bindungs- und Aktivierungsinformationen bereitstellt, die die COM-Laufzeit benötigt. Im COM-Server oder im Client ist kein spezieller Code erforderlich, es sei denn, Sie entscheiden, die Verwendung von Dateien zu deaktivieren, indem Sie Aktivierungskontexte selbst mithilfe der Aktivierungskontext-APIerstellen.

In dieser exemplarischen Vorgehensweise wird eine einfache .NET-Assembly erstellt und von systemeigenen COM-Clients verwendet, die in Visual C++ und Visual Basic 6.0 geschrieben wurden. Sie können den Quellcode und die Beispiele herunterladen und sofort in Aktion sehen, oder Sie können die exemplarische Vorgehensweise befolgen und sie schrittweise erstellen.

Registration-Free COM-Terminologie

Jeder, der mit der .NET-Technologie vertraut ist, wird sich an den Begriff Assembly gewöhnt, bedeutet, dass eine Gruppe von mindestens einem bereitgestellten Modul, benannt und als Einheit, mit einem Modul, das ein Manifest enthält,, das den Satz definiert. Bei der registrierungfreien COM werden die Begriffe Assembly und Manifest- für Ideen ausgeliehen, die im Konzept ähnlich sind, aber nicht mit ihren .NET-Gegenstücken identisch sind.

Registrierungsfreie COM verwendet Assembly-, um eine Gruppe von mindestens einem PE-Modul (d. h. entweder systemeigenen oder verwalteten) zu bedeuten, die als Einheit bereitgestellt, benannt und versioniert ist. Registrierungsfreie COM verwendet Manifest-, um auf Textdateien mit der MANIFEST-Erweiterung mit XML zu verweisen, die entweder die Identität eines Assembly- (Assemblymanifest) zusammen mit den Bindungs- und Aktivierungsdetails seiner Klassen definiert oder die Identität einer Anwendung (Anwendungsmanifest) zusammen mit mindestens einem Assemblyidentitätsverweise definiert. Eine Assemblymanifestdatei wird für die Assembly benannt, und eine Anwendungsmanifestdatei wird für die Anwendung benannt.

Der Begriff parallelen (SxS)-Assemblys bezieht sich auf die Konfiguration verschiedener Versionen derselben COM-Komponente über Manifestdateien, damit sie gleichzeitig von verschiedenen Threads geladen werden können, ohne registriert werden zu müssen. SxS ermöglicht und ist lose gleichbedeutend mit registrierungsfreien COM-.

Ausführen des Beispiels

Nachdem Sie den Beispielcode heruntergeladen und extrahiert haben, finden Sie einen Ordner namens \deployed. Hier ist die Visual C++-Version der Clientanwendung (client.exe), das Manifest (client.exe.manifest) und die C#-Version des COM-Servers (SideBySide.dll). Fahren Sie fort, und führen Sie client.exeaus. Das erwartete Ergebnis ist, dass client.exe eine Instanz von SideBySideClass- (implementiert in SideBySide.dll) aktiviert und das Ergebnis des Aufrufs der Version-Methode anzeigt, die wie "1.0.0-C#" aussehen soll.

Erstellen einer .NET-Assembly als COM-Server

Schritt 1

Erstellen Sie in Visual Studio .NET 2003 eine neue C#- oder Visual Basic .NET Class Library Project und rufen Sie es SideBySide-auf. Entfernen Sie die AssemblyInfo. [cs/vb] Datei aus dem Projekt und implementieren Sie eine Klasse wie folgt:

C#-Code

using System;
using System.Reflection;
using System.Runtime.InteropServices;

[assembly: AssemblyVersion("1.0.0.0")]
[assembly: Guid("[LIBID_SideBySide]")]

namespace SideBySide
{
   [Guid("[IID_ISideBySideClass]")]
   public interface ISideBySideClass
   {
      string Version();
   }

   [Guid("[CLSID_SideBySideClass]")]
   public class SideBySideClass : ISideBySideClass
   {
      public string Version()
      {
         return "1.0.0-C#";
      }
   }
}

Visual Basic .NET-Code

Imports System
Imports System.Reflection
Imports System.Runtime.InteropServices

<Assembly: AssemblyVersion("1.0.0.0")> 
<Assembly: Guid("[LIBID_SideBySide]")>

<Guid("[IID_ISideBySideClass]")> _
Public Interface ISideBySideClass
    Function Version() As String
End Interface

<Guid("[CLSID_SideBySideClass]")> _
Public Class SideBySideClass
    Implements ISideBySideClass
    Function Version() As String Implements ISideBySideClass.Version
        Version = "1.0.0-VB.NET"
    End Function
End Class

Ich habe die GUID-Werte geschrieben, die speziell für Ihr Projekt in Form von Platzhaltern sind. Sie müssen das guidgen Tool verwenden, um eindeutige GUIDs zu generieren, die die jeweiligen Werte sind, die ich beabsichtige, wenn ich anschließend die Platzhalter verwende.

Schritt 2

Damit eine Typbibliothek zur Erstellungszeit generiert und registriert wird, legen Sie die Für COM-Interoperabilität registrieren Einstellung des Projekts auf "true" fest.

Schritt 3

Erstellen Sie einen Releasebuild, und kopieren Sie SideBySide.dll in \deployed.

Erstellen des Clients

Der nächste Schritt besteht darin, den Client zu erstellen und für diese exemplarische Vorgehensweise haben Sie die Möglichkeit, entweder ein Visual C++- oder einen Visual Basic 6.0--Client zu erstellen.

Schritt 4 (Option A: Visual C++)

Erstellen Sie ein neues Visual C++-Win32-Konsolenprojekt namens Client- in einem gleichgeordneten Ordner relativ zum Ordner SideBySide Projekts. Aktivieren Sie im Win32-Anwendungs-Assistentenauf der Registerkarte Anwendungseinstellungen das Kontrollkästchen Unterstützung für ATL- hinzufügen.

Bearbeiten Sie stdafx.h, und fügen Sie die folgende Zeile am Anfang der Datei unmittelbar nach dem #pragma oncehinzu:

#define _WIN32_DCOM

Fügen Sie auch in stdafx.h unten in der Datei die folgende Zeile hinzu:

import "[path]\SideBySide.tlb" no_namespace

Hier sollte [Pfad] der relative Pfad zu der Typbibliothek sein, die generiert wurde, wenn Sie die SideBySide--Assembly erstellt haben. Dieser Pfad variiert in der Regel je nachdem, ob Sie in Schritt 1 ein C#- oder ein Visual Basic.NET-Projekt ausgewählt haben.

Ersetzen Sie den Inhalt von client.cpp durch diesen Code:

#include "stdafx.h"
#include <iostream>
using namespace std;

void ErrorDescription(HRESULT hr)
{
    TCHAR* szErrMsg;
    if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|
      FORMAT_MESSAGE_FROM_SYSTEM, 
      NULL, hr, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), 
      (LPTSTR)&szErrMsg, 0, NULL) != 0)
   {
        cout << szErrMsg << endl;
        LocalFree(szErrMsg);
    }
   else
        cout << "Could not find a description for error 0x" 
           << hex << hr << dec << endl;
}

int _tmain(int argc, _TCHAR* argv[])
{
   CoInitializeEx(0, COINIT_MULTITHREADED);

   {
      ISideBySideClassPtr ptr;
      HRESULT hr = 
              ptr.CreateInstance(__uuidof(SideBySideClass));
      if (SUCCEEDED(hr))
      {
         cout << ptr->Version() << endl;
      }
      ErrorDescription(hr);

      char c;
      cin >> c;
   }

   CoUninitialize();

   return 0;
}

Erstellen Sie einen Releasebuild, und kopieren Sie \release\client.exe in \deployed.

Schritt 4 (Option B: Visual Basic 6.0)

Erstellen Sie ein neues Visual Basic 6.0 Standard EXE Projekt. Wählen Sie im Projekt-Explorer den Knoten Project1 aus, und ändern Sie im eigenschaftenfenster den Namen in Client-. Datei auswählen | Speichern Sie Project als, und speichern Sie die Formulardatei und die Projektdatei in einem gleichgeordneten Ordner relativ zum Ordner SideBySide Projekts. Wählen Sie Projekt | Verweise, aktivieren Sie das Kontrollkästchen neben SideBySide-, und wählen Sie OKaus.

Doppelklicken Sie im Formular-Designer auf das Hauptformular, und fügen Sie den folgenden Code in Sub-Form_Load()ein:

    Dim obj As New SideBySideClass
    Dim isxs As SideBySide.ISideBySideClass
    Set isxs = obj
    MsgBox isxs.Version()

Datei auswählen | Machen Sie client.exe..., navigieren Sie zum Ordner \deployed, und wählen Sie dann OKaus.

Schritt 5

Derzeit sollte der Ordner "\deployed" nur client.exe und SideBySide.dllenthalten; und letzteres wird von seinem Buildprozess registriert worden sein. Um zu überprüfen, ob Ihr Server und Der Client unter diesen normalen Umständen zusammenarbeiten, führen Sie \deployed\client.exe aus, und notieren Sie die erwartete Ausgabe "1.0.0-C#" oder "1.0.0-VB.NET".

Schritt 6

In dieser exemplarischen Vorgehensweise geht es um registrierungsfreien COM, daher müssen wir die Registrierung der SideBySide--Assembly aufheben. Navigieren Sie an einer Visual Studio 2003-Eingabeaufforderung zum Ordner \deployed, und führen Sie den Befehl aus: regasm /u SideBySide.dll.

Schritt 7

Um zu sehen, welche Auswirkung der vorherige Schritt hatte, führen Sie \deployed\client.exe erneut aus, und Sie sehen die Meldung "Klasse nicht registriert" oder "Laufzeitfehler '429': ActiveX-Komponente kann kein Objekt erstellen". In diesem Stadium haben wir die COM-Laufzeit frustriert, die benötigten Informationen in der Registrierung zu finden, aber wir müssen die Informationen noch auf alternative Weise verfügbar machen. Wir werden dies in den folgenden Schritten beheben.

Registration-Free Aktivierung

Schritt 8

Erstellen Sie im Ordner \deployed eine Anwendungsmanifestdatei (eine Textdatei) für die client.exe Anwendung, und rufen Sie sie client.exe.manifestauf. Fügen Sie Folgendes in die Datei ein:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" 
   manifestVersion="1.0">
<assemblyIdentity
            type = "win32"
            name = "client"
            version = "1.0.0.0" />
<dependency>
            <dependentAssembly>
                        <assemblyIdentity
                                    type="win32"
                                    name="SideBySide"
                                    version="1.0.0.0" />
            </dependentAssembly>
</dependency>
</assembly>

Schritt 9

Erstellen Sie im Ordner SideBySide Projekts eine private Assemblymanifestdatei (eine Textdatei), und rufen Sie sie SideBySide.manifestauf. Fügen Sie Folgendes in die Datei ein:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" 
  manifestVersion="1.0">
<assemblyIdentity
            type="win32"
            name=" SideBySide"
            version="1.0.0.0" />
<clrClass
            clsid="{[CLSID_SideBySideClass]}"
            progid="SideBySide.SideBySide"
            threadingModel="Both"
            name="SideBySide.SideBySideClass" >
</clrClass>
</assembly>

Der nächste Vorgang besteht darin, die oben genannte Assemblymanifestdatei in die SideBySide- Assembly als Win32-Ressource einzubetten. Zum Zeitpunkt des Schreibens ist dies für Windows XP obligatorisch, aber nicht für Windows Server 2003. Unter Windows Server 2003 können Sie die Assemblymanifestdatei einfach zusammen mit der Assembly bereitstellen. Ich fordere Sie jedoch dringend auf, nicht von diesem Verhalten abhängig zu sein, da es sich in einem bevorstehenden Windows Server 2003 Service Pack gut ändern kann. Um sicherzustellen, dass Sie beide Plattformen in Zukunft weiterhin unterstützen, führen Sie die nächsten Schritte aus, und betten Sie die Assemblymanifestdatei in Ihre .NET-Assembly als Win32-Ressource ein. Dies ist nur für die registrierungsfreie Aktivierung von erforderlich. NET-basierte-Komponenten und ist keine Voraussetzung für die registrierungfreie Aktivierung von systemeigenen COM--Komponenten.

Schritt 10

Erstellen Sie im Ordner SideBySide Projekt eine Skriptdatei für die Ressourcendefinition (eine Textdatei), und rufen Sie sie SideBySide.rcauf. Fügen Sie Folgendes in die Datei ein:

#include <windows.h>
#define MANIFEST_RESOURCE_ID 1
MANIFEST_RESOURCE_ID RT_MANIFEST SideBySide.manifest

Die windows.h--Datei und deren Abhängigkeiten sind verfügbar, wenn Sie entweder den Platform SDK (Core SDK-Abschnitt) oder Visual C++ installieren. Der Teil windows.h-, der hier erforderlich ist, ist die Definition:

#define RT_MANIFEST 24

Folglich wird der Inhalt von SideBySide.rc zu:

1 24 SideBySide.manifest

Es ist jedoch klarer und allgemeiner, die Makrodefinitionen wie folgt zu verwenden.

Schritt 11

Erstellen Sie im Ordner SideBySide Projekt eine Buildbefehlsdatei (eine Textdatei), und rufen Sie sie build.cmdauf. Fügen Sie Folgendes in die Datei ein:

So erstellen Sie C#:

rc SideBySide.rc
csc /t:library /out:..\deployed\SideBySide.dll 
/win32res:SideBySide.res Class1.cs

So erstellen Sie Visual Basic .NET:

rc SideBySide.rc
vbc /t:library /out:..\deployed\SideBySide.dll 
/win32resource:SideBySide.res /rootnamespace:SideBySide Class1.vb

Diese Befehle führen zuerst aus, um das Microsoft Windows-Ressourcencompilertool aus dem Platform SDK (rc.exe) aufzurufen, um das Ressourcendefinitionsskript aus Schritt 10 in eine kompilierte Ressourcendatei mit dem Namen SideBySide.reszu kompilieren. Als Nächstes ruft er den C#- oder Visual Basic .NET-Compiler auf, um die Quellcodedatei in eine Assembly zu erstellen und die kompilierte Ressourcendatei als Win32-Ressource einzubetten. Die kompilierte Assembly wird in den Ordner \deployed geschrieben, aber sie wird nicht für COM-Interoperabilität registriert.

Schritt 12

Navigieren Sie an einer Visual Studio 2003-Eingabeaufforderung zum Ordner SideBySide Projekts, und führen Sie den Befehl aus: build.

Schritt 13

Um dies zu überprüfen , führen Sie \deployed\client.exe aus, und notieren Sie sich die erwartete Ausgabe "1.0.0-C#" oder "1.0.0-VB.NET".

Fehlerbehebung

Wie wir gesehen haben, erfordert die registrierungsfreie Aktivierung von .NET Framework-basierten Komponenten keinen speziellen Code auf dem Server oder im Client. Alles, was erforderlich ist, ist ein übereinstimmende Paar von Manifestdateien, von denen eine in die .NET-Assembly als Win32-Ressource vom Typ RT_MANIFEST eingebettet ist.

Ich schlage ihnen vor, ihre eigene registrierungsfreie Entwicklung so zu entwickeln, wie diese exemplarische Vorgehensweise funktioniert. Insbesondere: Rufen Sie zuerst einen bekannten Zustand auf, indem Sie sehen, dass Ihr Client mit einem registrierten Server arbeitet; heben Sie dann die Registrierung des Servers auf, und bestätigen Sie, dass Ihre Fehlermeldung das ist, was Sie erwartet haben; und schließlich die Situation zu beheben, indem Manifestdateien erstellt und bereitgestellt werden. Auf diese Weise werden Ihre Problembehandlungsmaßnahmen bei der Registrierung kostenlosen Aktivierung auf die Struktur Ihrer Manifestdateien und die korrekte Einbettung des Assemblymanifests beschränkt.

Bei der Problembehandlung bei registrierungsfreien COM-Problemen ist die Ereignisanzeige unter Windows Server 2003 Ihr Freund. Wenn Windows XP oder Windows Server 2003 einen Konfigurationsfehler erkennt, wird in der Regel ein Fehlermeldungsfeld mit dem Titel der Anwendung angezeigt, die Sie gestartet haben, und die Meldung "Diese Anwendung konnte nicht gestartet werden, da die Anwendungskonfiguration falsch ist. Durch erneutes Installieren der Anwendung kann dieses Problem behoben werden." Ich empfehle, dass Sie jedes Mal, wenn Sie diese Meldung sehen, das Problem unter Windows Server 2003 reproduzieren, das Systemereignisprotokoll konsultieren und nach Ereignissen aus der SideBySide- Quelle suchen. Der Grund, warum ich nicht vorschlage, dass Sie das Ereignisprotokoll von XP in diesen Fällen betrachten, besteht darin, dass sie invariablen eine Meldung wie "Generieren des Aktivierungskontexts für [Pfad]\[Anwendungsdateiname] enthält. Manifest. Referenzfehlermeldung: Der Vorgang wurde erfolgreich abgeschlossen", wodurch das Problem nicht erkannt wird.

Bevor wir mit der Struktur von Manifestdateien fortfahren, sprechen wir über Win32-Ressourcen. Wie bereits erwähnt, definiert windows.h das RT_MANIFEST-Symbol als Wert 24. Dabei handelt es sich um den Wert, den das Betriebssystem als eingebettete Manifestdatei erkennt. Wenn Sie vergessen, windows.h in Ihr Ressourcendefinitionsskript (RC-Datei) einzuschließen, ist Ihr Build weiterhin erfolgreich, und die Manifestdatei wird weiterhin als Ressource eingebettet, aber nicht vom richtigen Typ. Um sicherzustellen, dass Sie das Manifest ordnungsgemäß eingebettet haben, öffnen Sie Ihre SideBySide.dll in Visual Studio (Datei | Öffnen | Datei...). Es wird eine Strukturansicht mit den Ressourcen innerhalb des Moduls angezeigt. Unter dem Stammknoten sollte ein Knoten mit dem Namen RT_MANIFEST sein, darunter ein anderer Knoten mit der Ressourcennummer Der Manifestressource (1 in der exemplarischen Vorgehensweise). Doppelklicken Sie auf diesen letzten Knoten, um die Daten in einer binären Ansicht anzuzeigen, und geben Sie ihm eine schnelle Berücksichtigung, dass er Ihrer XML-Manifestdatei ähnelt. Obwohl es binär ist, sind die Zeichen aus dem ASCII-Bereich offensichtlich. Wenn die Binärdaten fehlen oder falsch aussehen, überprüfen Sie, ob ihr Ressourcendefinitionsskript (RC-Datei) auf Ihre Manifestdatei verweist. Wenn sich der Text des RT_MANIFEST Knotens in Anführungszeichen befindet, haben Sie wahrscheinlich vergessen, windows.h in Ihr Ressourcendefinitionsskript (RC-Datei) einzuschließen.

Jeder der erwähnten Fehler wird im Windows Server 2003-Systemereignisprotokoll mit der Meldung "Abhängige Assembly [Name] konnte nicht gefunden werden, und letzter Fehler war die referenzierte Assembly nicht auf Ihrem System installiert.".

Die Schemas der verschiedenen Manifestdateien werden im Platform SDK unter der Überschrift Manifestdateien Referenzdokumentiert, und das Schemaüberprüfungstool Manifestchk.vbs ist verfügbar, daher werde ich hier nur einige Punkte aufrufen, die für die exemplarische Vorgehensweise relevant sind. Zunächst untersuchen wir die Assemblymanifestdatei. Ein Beispiel: Schauen Sie auf Schritt 9 zurück.

Sie werden daran erinnern, dass eine Assembly im sinne der registrierungsfreien COM- eine abstrakte Idee ist, mit der Sie eine oder mehrere physische Dateien mithilfe des Inhalts des Assemblymanifests Datei zuordnen.

Das assemblyIdentity--Element definiert die Identität der Assembly. Für. NET-basierte Komponenten, deren Name Attribut muss mit dem Namen der .NET-Assembly und damit dem Dateinamen übereinstimmen. Andernfalls wird die folgende Meldung im Windows Server 2003-Systemereignisprotokoll angezeigt: "Abhängige Assembly [Wert von Name Attribut] konnte nicht gefunden werden, und der letzte Fehler war die assembly, auf die verwiesen wird, ist nicht auf Ihrem System installiert." Die Version Attributs muss jedoch nicht mit der AssemblyVersionder .NET-Assemblyversion übereinstimmen, noch mit der AssemblyFileVersion, obwohl es ratsam ist, eine art Konsistenz anzuwenden.

Das clrClass-Element weist nur zwei obligatorische Attribute auf: Name und clsid. Der Name Attributs muss mit dem kombinierten Namespace und dem Klassennamen der aktivierten CLR-Klasse übereinstimmen. Wenn dies nicht der Fall ist, gibt CoCreateInstance ein HRESULT mit dem Wert COR_E_TYPELOAD (0x80131522) zurück. Dies führt dazu, dass eine System.TypeLoadException ausgelöst wird, wenn der Typladeprogramm den angeforderten CLR-Typ in Ihrer .NET-Assembly nicht finden kann. Achten Sie darauf, ob Ihre .NET-Assembly in Visual Basic .NET geschrieben ist, besteht darin, dass Sie den /rootnamespace-Schalter in der Befehlszeile an den Visual Basic .NET-Compiler (vbc.exe) bereitstellen. Das clsid-attributmuss mit der CLSID übereinstimmen, die der CLR-Klasse zugewiesen ist, die über ihr GuidAttribute aktiviert wird. Andernfalls gibt CoCreateInstance ein HRESULT mit dem Wert REGDB_E_CLASSNOTREG (0x80040154) zurück, für den der Nachrichtentext "Klasse nicht registriert" ist.

Lassen Sie uns nun auf die Anwendungsmanifestdatei aufmerksam machen. Ein Beispiel: Schauen Sie auf Schritt 8 zurück. Das Anwendungsmanifest muss im Format [Anwendungsdateiname].manifestbenannt werden. In der exemplarischen Vorgehensweise wurde es also client.exe.manifest genannt, um klar zu machen, dass es immer gelesen werden sollte, wenn client.exe in einen Prozess geladen wird. Wenn dies nicht ordnungsgemäß erfolgt, gibt CoCreateInstance ein HRESULT mit dem Wert REGDB_E_CLASSNOTREG (0x80040154) zurück, für den der Nachrichtentext "Klasse nicht registriert" ist.

Das wichtigste Element im Anwendungsmanifest ist das abhängige/assemblyIdentity--Element. Dieses Element ist ein Verweis auf das entsprechende element im Assemblymanifest und die beiden müssen genauübereinstimmen. Eine gute Möglichkeit, um sicherzustellen, dass sie dies tun, besteht darin, das Element aus dem Assemblymanifest zu kopieren und hier einzufügen. Wenn es einen Unterschied gibt, wird die folgende Meldung im Windows Server 2003-Systemereignisprotokoll angezeigt: "Die im Manifest gefundene Komponentenidentität stimmt nicht mit der Identität der angeforderten Komponente überein."

Schlussfolgerung

Registrierungsfreie COM ist eine Technologie, die COM-Komponenten von einer Abhängigkeit von der Windows-Registrierung befreit und folglich die Anwendungen befreit, die sie von dedizierten Servern verwenden. Es ermöglicht Anwendungen mit Abhängigkeiten von verschiedenen Versionen derselben COM-Komponente, eine Infrastruktur gemeinsam zu nutzen und diese verschiedenen COM-Komponentenversionen nebeneinander in einem Echo des .NET-Versionsverwaltungs- und Bereitstellungsmechanismus zu laden.

In diesem Artikel werden Sie durch eine Demonstration der registrierungsfreien Aktivierung von .NET Framework-basierten Komponenten durch systemeigene Clientanwendungen geführt, die in Visual C++ und Visual Basic 6.0 geschrieben wurden. Es wurde erläutert, wie der Mechanismus funktioniert und einige mögliche Konfigurationsfehler unterstrichen und wie sie behoben werden können.

Weitere Lektüre

 

Über den Autor

Steve White ist ein Anwendungsentwicklungsberater, der im Premier Support for Developers Team bei Microsoft UK arbeitet. Er unterstützt Kunden bei der Entwicklung mit Visual C#, Windows Forms und ASP.NET. Sein Blog hat weitere Informationen über seine Interessen an Musik, Visualisierungen und Programmierung.

Leslie Muller ist ein Technologe mit dem Research & Development Team der Credit Suisse First Boston. Leslie verfügt über 12 Jahre Erfahrung als Entwickler und technischer Architekt, der in Umgebungen wie Finanzdienstleistungen, Technologie-Startups, Industrieautomatisierung und Verteidigung arbeitet. Wenn er nicht programmieren oder recherchiert, genießt er Skifahren, Eishockey und nach Möglichkeit etwas verrückte Dinge mit motorisierten Fahrzeugen in extremen Umgebungen wie Island oder den Rockies.