Dieser Artikel wurde manuell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

Sprachübergreifende Interoperabilität

Der Begriff "Sprachenunabhängigkeit" kann mehrere Bedeutungen haben. Eine Bedeutung, die im Artikel Sprachenunabhängigkeit und sprachunabhängige Komponenten erläutert wird, bezeichnet die nahtlose Nutzung von Typen, die in einer Sprache geschrieben wurden, durch eine App, die in einer anderen Sprache geschrieben wurde. Eine zweite Bedeutung, die in diesem Artikels hervorgehoben wird, umfasst die Kombination von Code aus mehreren Sprachen in einer einzelnen .NET Framework-Assembly.

Das folgende Beispiel veranschaulicht die sprachübergreifende Interoperabilität. Es wird die Klassenbibliothek Utilities.dll erstellt, die zwei Klassen einschließt: NumericLib und StringLib. Die NumericLib-Klasse wurde in C# und die StringLib-Klasse in Visual Basic geschrieben. Im Folgenden sehen Sie den Quellcode für "StringUtil.vb", der in der StringLib-Klasse einen einzelnen Member enthält, ToTitleCase.

Imports System.Collections.Generic
Imports System.Runtime.CompilerServices

Public Module StringLib
   Private exclusions As List(Of String) 

   Sub New()
      Dim words() As String = { "a", "an", "and", "of", "the" }
      exclusions = New List(Of String)
      exclusions.AddRange(words)
   End Sub

   <Extension()> _
   Public Function ToTitleCase(title As String) As String 
      Dim words() As String = title.Split() 
      Dim result As String = String.Empty

      For ctr As Integer = 0 To words.Length - 1
         Dim word As String = words(ctr)
         If ctr = 0 OrElse Not exclusions.Contains(word.ToLower()) Then
            result += word.Substring(0, 1).ToUpper() + _
                      word.Substring(1).ToLower()
         Else
            result += word.ToLower()
         End If 
         If ctr <= words.Length - 1 Then
            result += " "              
         End If    
      Next  
      Return result 
   End Function 
End Module

Im Folgenden sehen Sie den Quellcode für "NumberUtil.cs", der eine NumericLib-Klasse mit zwei Membern definiert: IsEven und NearZero.

using System;

public static class NumericLib 
{
   public static bool IsEven(this IConvertible number)
   {
      if (number is Byte ||
          number is SByte ||
          number is Int16 ||
          number is UInt16 || 
          number is Int32 || 
          number is UInt32 ||
          number is Int64)
         return ((long) number) % 2 == 0;
      else if (number is UInt64)
         return ((ulong) number) %2 == 0;
      else 
         throw new NotSupportedException("IsEven called for a non-integer value.");
   }

   public static bool NearZero(double number)
   {
      return number < .00001; 
   }
}

Um die beiden Klassen in einer einzelnen Assembly zu verpacken, müssen Sie sie in Module kompilieren. Verwenden Sie zum Kompilieren der Visual Basic-Quellcodedatei in einem Modul folgenden Befehl:

vbc /t:module StringUtil.vb 

Weitere Informationen zur Befehlszeilensyntax des Visual Basic-Compilers finden Sie unter Erstellen von der Befehlszeile aus (Visual Basic).

Verwenden Sie zum Kompilieren der C#-Quellcodedatei in einem Modul folgenden Befehl:

csc /t:module NumberUtil.cs

Weitere Informationen zur Befehlszeilensyntax des C#-Compilers finden Sie unter Erstellen über die Befehlszeile mit csc.exe.

Verwenden Sie dann das Linktool (Link.exe), um die beiden Module in eine Assembly zu kompilieren:

link numberutil.netmodule stringutil.netmodule /out:UtilityLib.dll /dll 

Das folgende Beispiel ruft dann die NumericLib.NearZero-Methode und die StringLib.ToTitleCase-Methode auf. Beachten Sie, dass sowohl der Visual Basic-Code als auch der C#-Code auf die Methoden in beiden Klassen zugreifen können.

using System;

public class Example
{
   public static void Main()
   {
      Double dbl = 0.0 - Double.Epsilon;
      Console.WriteLine(NumericLib.NearZero(dbl));

      string s = "war and peace";
      Console.WriteLine(s.ToTitleCase());
   }
}
// The example displays the following output: 
//       True 
//       War and Peace

Verwenden Sie zum Kompilieren des Visual Basic-Codes folgenden Befehl:

vbc example.vb /r:UtilityLib.dll

Zum Kompilieren mit C# ändern Sie den Namen des Compilers von vbc auf csc und die Dateierweiterung von ".vb" auf ".cs".

csc example.cs /r:UtilityLib.dll

Titel

Beschreibung

Sprachenunabhängigkeit und sprachunabhängige Komponenten

Erläutert, wie CLS-kompatible Softwarekomponenten erstellt werden, die von Apps unabhängig von der Programmiersprache, in der sie geschrieben wurden, genutzt werden können.

Allgemeines Typsystem

Beschreibt, wie Typen von der Common Language Runtime deklariert, verwendet und verwaltet werden.

Metadaten und selbstbeschreibende Komponenten

Erklärt den Mechanismus, mit dem die Common Language Runtime einen Typ beschreibt und diese Informationen mit dem Typ selbst speichert.

Fanden Sie dies hilfreich?
(1500 verbleibende Zeichen)
Vielen Dank für Ihr Feedback.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2015 Microsoft