Schreiben von CLS-kompatiblem Code

Die CLS-Kompatibilität (Common Language Specification) bezieht sich i. d. R. auf den Anspruch, dass CLS-Regeln und ‑Einschränkungen befolgt werden. Abhängig davon, ob von CLS-kompatiblem Code oder von CLS-kompatiblen Entwicklungstools wie einem Compiler die Rede ist, hat das Konzept der Kompatibilität jedoch eine jeweils spezifische Bedeutung. Mithilfe von CLS-kompatiblen Tools können Sie CLS-kompatiblen Code schreiben.

CLS-kompatibler Code

Für CLS-kompatiblen Code müssen Funktionen an den folgenden Orten CLS-kompatibel verfügbar sein:

• In Definitionen öffentlicher Klassen.

• In Definitionen öffentlicher Member von öffentlichen Klassen sowie in Membern, auf die abgeleitete Klassen zugreifen können (family-Zugriff).

• In Parametern und Rückgabetypen öffentlicher Methoden von öffentlichen Klassen sowie in Methoden, auf die abgeleitete Klassen zugreifen können.

Die Features in Definitionen privater Klassen, in Definitionen privater Methoden in öffentlichen Klassen und in lokalen Variablen müssen den CLS-Regeln nicht entsprechen. Sie können außerdem im Implementierungscode für die Klasse beliebige Sprachfeatures verwenden; die Komponente bleibt trotzdem CLS-kompatibel.

Mit dem CLSCompliantAttribute können Sie Assemblys, Module, Typen und Member als CLS-kompatibel oder nicht CLS-kompatibel markieren. Alle Assemblys, für die CLS-Kompatibilität vorgesehen ist, müssen als solche markiert sein. Eine Assembly, die nicht als CLS-kompatibel markiert ist, wird als nicht CLS-kompatibel betrachtet. Wenn einem Typ kein CLS-Attribut zugewiesen ist, wird angenommen, dass dieser Typ über dieselbe CLS-Kompatibilität verfügt wie die Assembly, in der der Typ definiert ist. Ebenso verhält es sich, wenn einem Member kein CLS-Attribut zugewiesen ist: Es wird angenommen, dass der Member über dieselbe CLS-Kompatibilität verfügt wie der Typ, der ihn definiert. Ein Programmelement kann nicht als CLS-kompatibel markiert werden, wenn für das einschließende Element keine CLS-Kompatibilität angegeben ist. Das Beispiel am Ende dieses Themas veranschaulicht die Verwendung von CLSCompliantAttribute.

Assemblys, Module und Typen können auch dann CLS-kompatibel sein, wenn einige Teile der Assembly, des Moduls bzw. des Typs nicht CLS-kompatibel sind. Hierfür müssen die beiden folgenden Bedingungen erfüllt sein:

• Wenn das Element als CLS-kompatibel markiert ist, müssen die nicht CLS-kompatiblen Teile markiert sein, indem das Argument des CLSCompliantAttribute auf false festgelegt wird.

• Für jeden nicht CLS-kompatiblen Member muss ein vergleichbarer CLS-kompatibler Alternativmember bereitgestellt werden.

Wenn Sie eine CLS-kompatible Klassenbibliothek entwerfen, wird für die Bibliothek die Interoperabilität mit einer Vielzahl von Programmiersprachen garantiert. Die Kundenbasis für eine solche Bibliothek ist daher höchstwahrscheinlich größer als für eine nicht CLS-kompatible Version der Bibliothek.

.NET Framework stellt eine CLS-kompatible Klassenbibliothek bereit. Weitere Informationen finden Sie unter .NET Framework-Klassenbibliothek.

CLS-kompatible Tools

Sprachen für die Common Language Runtime unterstützen CLS-Features und befolgen die CLS-Regeln für Compiler. Diese Sprachcompiler vereinfachen das Herstellen von CLS-Kompatibilität, indem sie CLS-Datentypen und ‑Features für die Verwendung bei der Komponentenerstellung bereitstellen. Die Stufen der CLS-Kompatibilität bei Compilern und anderen Tools lassen sich wie folgt beschreiben:

• CLS-kompatible Consumertools.

  Consumertools sind Sprachen, die Entwicklern den Zugriff auf alle in CLS-kompatiblen Bibliotheken verfügbaren Features ermöglichen. Entwickler, die die Sprachen verwenden, können CLS-kompatible Bibliotheken zwar nicht durch das Erstellen neuer Typen erweitern, aber sie können alle Typen verwenden, die in einer CLS-kompatiblen Bibliothek definiert sind. Diese Kompatibilitätsstufe kann nützlich sein, wenn Sie auf eine .NET Framework-Klassenbibliothek zugreifen möchten, aber keine neuen Objekte für andere erstellen müssen. Dies ist z. B. der Fall, wenn Sie Web Forms auf einer ASP.NET-Seite verwenden oder eine Windows Forms-Benutzeroberfläche erstellen.

• CLS-kompatible Extendertools.

  Extendertools sind Sprachen, mit denen Entwickler die in CLS-kompatiblen Bibliotheken definierten Typen sowohl verwenden als auch erweitern können. Entwickler können vorhandene Typen verwenden und neue Typen definieren. Extendertools müssen dieselben Regeln wie Consumertools sowie einige zusätzliche Regeln einhalten, die in der Spezifikation für die Common Language Infrastructure, Partition I - Architecture, beschrieben sind, die auf der Microsoft Developer Network (MSDN)-Website verfügbar ist.

Beim Entwerfen eigener CLS-kompatibler Komponenten ist es hilfreich, ein CLS-kompatibles Tool zu verwenden. Das Schreiben CLS-kompatibler Komponenten ohne diese Unterstützung ist schwieriger, da Sie in diesem Fall möglicherweise nicht auf alle gewünschten CLS-Features zugreifen können.

In einigen CLS-kompatiblen Sprachcompilern, z. B. im C#- oder Visual Basic-Compiler, können Sie angeben, dass Code CLS-kompatibel sein soll. Diese Compiler überprüfen die CLS-Kompatibilität und informieren Sie, wenn im Code nicht von der CLS unterstützte Funktionen verwendet werden. Wenn Sie mit dem C#- und Visual Basic-Compiler ein Programmelement als CLS-kompatibel markieren und der Code nicht CLS-kompatibel ist, generiert der Compiler einen Kompilierzeitfehler. Beispielsweise verursacht der folgende Code eine Compilerwarnung:

<Assembly: CLSCompliant(True)>

<CLSCompliant(True)> Public Class MyCompliantClass
   Public Sub ChangeValue(value As UInt32)
   End Sub

   Public Shared Sub Main()
      Dim i As Integer = 2
      Console.WriteLine(i)
   End Sub   
End Class

using System;

// Assembly marked as compliant.
[assembly: CLSCompliant(true)]

// Class marked as compliant.
[CLSCompliant(true)]
public class MyCompliantClass {
   // ChangeValue exposes UInt32, which is not in CLS.
   // A compile-time warning results.
   public void ChangeValue(UInt32 value){ }

   public static void Main( ) {
   int i = 2;
   Console.WriteLine(i);
   }
}

Dieser Code generiert folgende C#-Warnung:

warning CS3001: Argument type 'uint' is not CLS-compliant

oder folgende Visual Basic-Warnung:

warning BC40028: Type of parameter 'value' is not CLS-compliant.

Um die Warnung zu entfernen, können Sie wie im folgenden Beispiel angeben, dass ChangeValue nicht kompatibel ist.

' Assembly marked as compliant.
<Assembly: CLSCompliant(True)>

' Class marked as compliant.
<CLSCompliant(True)> Public Class MyCompliantClass
   ' Method marked as not compliant.
   <CLSCompliant(False)> Public Sub ChangeValue(value As UInt32)
   End Sub

   Public Shared Sub Main()
      Dim i As Integer = 2
      Console.WriteLine(i)
   End Sub   
End Class

using System;

// Assembly marked as compliant.
[assembly: CLSCompliantAttribute(true)]

// Class marked as compliant.
[CLSCompliantAttribute(true)]
public class MyCompliantClass {
   // Method marked as not compliant.
   [CLSCompliantAttribute(false)]
   public void ChangeValue(UInt32 value){ }

   public static void Main( ) {
   int i = 2;
   Console.WriteLine(i);
   }
}

In diesem Code werden keine Compilerwarnungen erzeugt. Die Ausgabe lautet 2.

Weitere Informationen über das Angeben der CLS-Kompatibilität für Code finden Sie in der Dokumentation des verwendeten Sprachcompilers.

Siehe auch

Weitere Ressourcen

Sprachübergreifende Interoperabilität