Gewusst wie: Erstellen von nicht signierten Friend-Assemblys (C# und Visual Basic)

In diesem Beispiel wird veranschaulicht, wie Friend-Assemblys mit unsignierten Assemblys verwendet werden.

So erstellen Sie in Visual Studio eine Assembly und eine Friend-Assembly

1. Öffnen Sie die Visual Studio-Eingabeaufforderung.

2. Erstellen Sie in Visual Basic oder C# eine Datei mit dem Namen friend_signed_A, die den folgenden Code enthält. Im Code wird friend_signed_B mit dem InternalsVisibleToAttribute-Attribut als Friend-Assembly deklariert.

   ' friend_unsigned_A.vb
   ' Compile with: 
   ' Vbc /target:library friend_unsigned_A.vb
   Imports System.Runtime.CompilerServices
   Imports System
   
   <Assembly: InternalsVisibleTo("friend_unsigned_B")> 
   
   ' Friend type.
   Friend Class Class1
       Public Sub Test()
           Console.WriteLine("Class1.Test")
       End Sub
   End Class
   
   ' Public type with Friend member.
   Public Class Class2
       Friend Sub Test()
           Console.WriteLine("Class2.Test")
       End Sub
   End Class
   

   // friend_unsigned_A.cs
   // Compile with: 
   // csc /target:library friend_unsigned_A.cs
   using System.Runtime.CompilerServices;
   using System;
   
   [assembly: InternalsVisibleTo("friend_unsigned_B")]
   
   // Type is internal by default.
   class Class1
   {
       public void Test()
       {
           Console.WriteLine("Class1.Test");
       }
   }
   
   // Public type with internal member.
   public class Class2
   {
       internal void Test()
       {
           Console.WriteLine("Class2.Test");
       }
   }
   

3. Kompilieren und signieren Sie friend_signed_A mit dem folgenden Befehl.

   Vbc /target:library friend_unsigned_A.vb
   

   csc /target:library friend_unsigned_A.cs
   

4. Erstellen Sie in Visual Basic oder C# eine Datei mit dem Namen friend_unsigned_B, die den folgenden Code enthält. Da friend_unsigned_B im Code von friend_unsigned_A als Friend-Assembly angegeben wird, kann der Code in friend_unsigned_B auf die als Friend (Visual Basic) bzw. als internal (C#) gekennzeichneten Typen und Member zugreifen.

   ' friend_unsigned_B.vb
   ' Compile with: 
   ' Vbc /r:friend_unsigned_A.dll friend_unsigned_B.vb
   Module Module1
       Sub Main()
           ' Access a Friend type.
           Dim inst1 As New Class1()
           inst1.Test()
   
           Dim inst2 As New Class2()
           ' Access a Friend member of a public type.
           inst2.Test()
   
           System.Console.ReadLine()
       End Sub
   End Module
   

   // friend_unsigned_B.cs
   // Compile with: 
   // csc /r:friend_unsigned_A.dll /out:friend_unsigned_B.exe friend_unsigned_B.cs
   public class Program
   {
       static void Main()
       {
           // Access an internal type.
           Class1 inst1 = new Class1();
           inst1.Test();
   
           Class2 inst2 = new Class2();
           // Access an internal member of a public type.
           inst2.Test();
   
           System.Console.ReadLine();
       }
   }
   

5. Kompilieren Sie friend_signed_B mit dem folgenden Befehl.

   Vbc /r:friend_unsigned_A.dll friend_unsigned_B.vb
   

   csc /r:friend_unsigned_A.dll /out:friend_unsigned_B.exe friend_unsigned_B.cs
   

   Der Name der vom Compiler erstellten Assembly muss mit dem Namen der Friend-Assembly übereinstimmen, der an das InternalsVisibleToAttribute-Attribut übergeben wird. Sie können die Assembly mithilfe der /out-Compileroption explizit festlegen.

   In C# müssen Sie den Namen der Ausgabeassembly mit der /out-Compileroption explizit angeben (EXE- oder DLL-Datei). In Visual Basic ist dies optional. Weitere Informationen finden Sie unter /out (Visual Basic) und unter /out (C#-Compileroptionen).

6. Führen Sie die Datei friend_signed_B.exe aus.

   Das Programm druckt zwei Zeichenfolgen: "Class1.Test" und "Class2.Test".

Sicherheit

Das InternalsVisibleToAttribute-Attribut ist mit der StrongNameIdentityPermission-Klasse vergleichbar. Der Hauptunterschied liegt darin, dass von der StrongNameIdentityPermission-Klasse Sicherheitsberechtigungen für die Ausführung einzelner Codeabschnitte angefordert werden können, während das InternalsVisibleToAttribute-Attribut die Sichtbarkeit der als Friend (Visual Basic) bzw. als internal (C#) gekennzeichneten Typen und Member steuert.

Siehe auch

Aufgaben

Gewusst wie: Erstellen von signierten Friend-Assemblys (C# und Visual Basic)

Referenz

Assemblys und der globale Assemblycache (C# und Visual Basic)

Friend-Assemblys (C# und Visual Basic)

InternalsVisibleToAttribute

Konzepte

C#-Programmierhandbuch

Weitere Ressourcen

Visual Basic-Programmierhandbuch