Freigeben über

Vorgehensweise: Erstellen von unsignierten Friend-Assemblys

  • Artikel

Dieses Beispiel zeigt, wie Sie Friend-Assemblys mit unsignierten Assemblys verwenden.

Erstellen einer Assembly und einer Friend-Assembly

  1. Öffnen Sie eine Eingabeaufforderung.

  2. Erstellen Sie eine C#- oder eine Visual Basic-Datei mit dem Namen friend_unsigned_A, die den folgenden Code enthält. Der Code verwendet das Attribut InternalsVisibleToAttribute, um friend_unsigned_B als Friend-Assembly zu deklarieren.

    // 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");
    }
}

    ' friend_unsigned_A.vb
' Compile with:
' vbc -target:library friend_unsigned_A.vb
Imports System.Runtime.CompilerServices

<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

  3. Kompilieren und signieren Sie friend_unsigned_A mithilfe des folgenden Befehls:

    csc /target:library friend_unsigned_A.cs

    vbc -target:library friend_unsigned_A.vb

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

    // 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();
    }
}

    ' 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

  5. Kompilieren Sie friend_unsigned_B mithilfe des folgenden Befehls.

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

    vbc -r:friend_unsigned_A.dll friend_unsigned_B.vb

    Der Name der vom Compiler generierten Assembly muss mit dem Namen der Friend-Assembly übereinstimmen, die an das Attribut InternalsVisibleToAttribute übergeben wird. Sie müssen den Namen der Ausgabeassembly ( .exe oder .dll) explizit mit der -out-Compileroption angeben. Weitere Informationen finden Sie unter OutputAssembly (C# compiler options) ode -out (Visual Basic).

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

    Das Programm gibt zwei Zeichenfolgen aus: Class1.Test und Class2.Test.

.NET-Sicherheit

Es gibt Ähnlichkeiten zwischen dem Attribut InternalsVisibleToAttribute und der Klasse StrongNameIdentityPermission. Der Hauptunterschied besteht darin, dass StrongNameIdentityPermission Sicherheitsberechtigungen verlangen kann, um einen bestimmten Codeabschnitt auszuführen, während das Attribut InternalsVisibleToAttribute die Sichtbarkeit der internal- oder Friend-Typen und -Member steuert.

Siehe auch