InternalsVisibleToAttribute InternalsVisibleToAttribute InternalsVisibleToAttribute InternalsVisibleToAttribute Class

Definice

Určuje, že typy, které jsou obvykle viditelné pouze v rámci aktuálního sestavení, jsou viditelné v zadaném sestavení.Specifies that types that are ordinarily visible only within the current assembly are visible to a specified assembly.

public ref class InternalsVisibleToAttribute sealed : Attribute
[System.AttributeUsage(System.AttributeTargets.Assembly, AllowMultiple=true, Inherited=false)]
public sealed class InternalsVisibleToAttribute : Attribute
type InternalsVisibleToAttribute = class
    inherit Attribute
Public NotInheritable Class InternalsVisibleToAttribute
Inherits Attribute
Dědičnost
InternalsVisibleToAttributeInternalsVisibleToAttributeInternalsVisibleToAttributeInternalsVisibleToAttribute
Atributy

Příklady

Podepsaná sestaveníSigned assemblies

Následující příklad používá InternalsVisibleToAttribute atribut k internal vytvoření metody pojmenované AppendDirectorySeparator v podepsaném sestavení viditelném pro jiné podepsané sestavení.The following example uses the InternalsVisibleToAttribute attribute to make an internal method named AppendDirectorySeparator in a signed assembly visible to another signed assembly. Definuje FileUtilities třídu, která obsahuje interní AppendDirectorySeparator metodu.It defines a FileUtilities class that includes an internal AppendDirectorySeparator method. Atribut se použije na sestavení, které FileUtilities obsahuje třídu. InternalsVisibleToAttributeThe InternalsVisibleToAttribute attribute is applied to the assembly that contains the FileUtilities class. Atribut umožňuje sestavení s Friend1 přístupem k tomuto internímu členu.The attribute allows an assembly named Friend1 to access this internal member.

//
// The source code should be saved in a file named Example1.cs. It 
// can be compiled at the command line as follows:
//
//    csc /t:library /keyfile:<snkfilename> Assembly1.cs
//
// The public key of the Friend1 file should be changed to the full
// public key stored in your strong-named key file.
//
using System;
using System.IO;
using System.Runtime.CompilerServices;

[assembly: InternalsVisibleTo("Friend1, PublicKey=002400000480000094" + 
                              "0000000602000000240000525341310004000" +
                              "001000100bf8c25fcd44838d87e245ab35bf7" +
                              "3ba2615707feea295709559b3de903fb95a93" +
                              "3d2729967c3184a97d7b84c7547cd87e435b5" +
                              "6bdf8621bcb62b59c00c88bd83aa62c4fcdd4" +
                              "712da72eec2533dc00f8529c3a0bbb4103282" +
                              "f0d894d5f34e9f0103c473dce9f4b457a5dee" +
                              "fd8f920d8681ed6dfcb0a81e96bd9b176525a" +
                              "26e0b3")]

public class FileUtilities
{
   internal static string AppendDirectorySeparator(string dir)
   {
      if (! dir.Trim().EndsWith(Path.DirectorySeparatorChar.ToString()))
         return dir.Trim() + Path.DirectorySeparatorChar;
      else
         return dir;
   }
}
'
' The source code should be saved in a file named Example1.cs. It 
' can be compiled at the command line as follows:
'
'    vbc Assembly1.vb /t:library /keyfile:<snkfilename> 
'
' The public key of the Friend1 file should be changed to the full
' public key stored in your strong-named key file.
'
Imports System.IO
Imports System.Runtime.CompilerServices

<Assembly:InternalsVisibleTo("Friend1, PublicKey=002400000480000094" + _
                             "0000000602000000240000525341310004000" + _
                             "001000100bf8c25fcd44838d87e245ab35bf7" + _
                             "3ba2615707feea295709559b3de903fb95a93" + _
                             "3d2729967c3184a97d7b84c7547cd87e435b5" + _
                             "6bdf8621bcb62b59c00c88bd83aa62c4fcdd4" + _
                             "712da72eec2533dc00f8529c3a0bbb4103282" + _
                             "f0d894d5f34e9f0103c473dce9f4b457a5dee" + _
                             "fd8f920d8681ed6dfcb0a81e96bd9b176525a" + _
                             "26e0b3")>

Public Class FileUtilities
   Friend Shared Function AppendDirectorySeparator(dir As String) As String
      If Not dir.Trim().EndsWith(Path.DirectorySeparatorChar) Then
         Return dir.Trim() + Path.DirectorySeparatorChar
      Else
         Return dir
      End If   
   End Function
End Class

Pokud je následující příklad zkompilován do sestavení se silným názvem s názvem Friend1 Example.Main , metoda FileUtilities.AppendDirectorySeparator v Friend1 nástroji může úspěšně zavolat metodu, i když je metoda interní pro Assembly1 sestavení.If the following example is compiled into a strong-named assembly named Friend1, the Example.Main method in Friend1 can successfully call the FileUtilities.AppendDirectorySeparator method, although the method is internal to the Assembly1 assembly. Všimněte si, že pokud kompilujete C# z příkazového řádku, je nutné použít přepínač kompilátoru /out pro ujištění, že název sestavení typu Friend je k dispozici, když se kompilátor váže k externím odkazům.Note that if you are compiling in C# from the command line, you must use the /out compiler switch to ensure that the name of the friend assembly is available when the compiler binds to external references.

//
// The assembly that exposes its internal types to this assembly should be
// named Assembly1.dll.
//
// The public key of this assembly should correspond to the public key
// specified in the class constructor of the InternalsVisibleTo attribute in the
// Assembly1 assembly.
//
#using <Assembly1.dll> as_friend

using namespace System;

void main()
{
   String^ dir = L"C:\\Program Files";
   dir = FileUtilities::AppendDirectorySeparator(dir);
   Console::WriteLine(dir);
}
// The example displays the following output:
//       C:\Program Files\
//
// The source code should be saved in a file named Friend1.cs. It 
// can be compiled at the command line as follows:
//
//    csc /r:Assembly1.dll /keyfile:<snkfilename> /out:Friend1.dll Friend1.cs
//
// The public key of the Friend1 assembly should correspond to the public key
// specified in the class constructor of the InternalsVisibleTo attribute in the
// Assembly1 assembly.
//
using System;

public class Example
{
   public static void Main()
   {
      string dir = @"C:\Program Files";
      dir = FileUtilities.AppendDirectorySeparator(dir);
      Console.WriteLine(dir);
   }
}
// The example displays the following output:
//       C:\Program Files\
'
' The source code should be saved in a file named Friend1.vb. It 
' can be compiled at the command line as follows:
'
'    vbc Friend1.vb /r:Assembly1.dll /keyfile:<snkfilename> 
'
' The public key of the Friend1 assembly should correspond to the public key
' specified in the class constructor of the InternalsVisibleTo attribute in the
' Assembly1 assembly.
'
Module Example
   Public Sub Main()
      Dim dir As String = "C:\Program Files"
      dir = FileUtilities.AppendDirectorySeparator(dir)
      Console.WriteLine(dir)
   End Sub
End Module
' The example displays the following output:
'       C:\Program Files\

Nepodepsaná sestaveníUnsigned assemblies

Následující příklad používá InternalsVisibleToAttribute atribut k internal vytvoření člena nepodepsaného sestavení viditelného pro jiné nepodepsané sestavení.The following example uses the InternalsVisibleToAttribute attribute to make an internal member of an unsigned assembly visible to another unsigned assembly. internal Atribut zajišťuje, že StringLib.IsFirstLetterUpperCase metoda v sestavení s názvem UtilityLib je viditelná pro kód v sestavení s názvem Friend2.The attribute ensures that the internal StringLib.IsFirstLetterUpperCase method in an assembly named UtilityLib is visible to the code in an assembly named Friend2. Následuje zdrojový kód pro UtilityLib. dll:The following is the source code for UtilityLib.dll:

using System;
using System.Runtime.CompilerServices;

[assembly: InternalsVisibleToAttribute("Friend2")]

namespace Utilities.StringUtilities
{
   public class StringLib
   {
      internal static bool IsFirstLetterUpperCase(String s)
      {
         string first = s.Substring(0, 1);
         return first == first.ToUpper();
      }
   }
}

Imports System.Runtime.CompilerServices

<assembly: InternalsVisibleTo("Friend2")>

Namespace Utilities.StringUtilities
   Public Class StringLib
      Friend Shared Function IsFirstLetterUpperCase(s As String) As Boolean
         Dim first As String = s.Substring(0, 1)
         Return first = first.ToUpper()
      End Function
   End Class
End Namespace

Následující příklad poskytuje zdrojový kód pro Friend2 sestavení.The following example provides the source code for the Friend2 assembly. Všimněte si, že pokud kompilujete C# z příkazového řádku, je nutné použít přepínač kompilátoru /out pro ujištění, že název sestavení typu Friend je k dispozici, když se kompilátor váže k externím odkazům.Note that if you are compiling in C# from the command line, you must use the /out compiler switch to ensure that the name of the friend assembly is available when the compiler binds to external references.

#using <UtilityLib.dll> as_friend

using namespace System;
using namespace Utilities::StringUtilities;

void main()
{
   String^ s = "The Sign of the Four";
   Console::WriteLine(StringLib::IsFirstLetterUpperCase(s));
}
using System;
using Utilities.StringUtilities;

public class Example
{
   public static void Main()
   {
      String s = "The Sign of the Four";
      Console.WriteLine(StringLib.IsFirstLetterUpperCase(s));
   }
}
Imports Utilities.StringUtilities

Module Example
   Public Sub Main()
      Dim s As String = "The Sign of the Four"
      Console.WriteLine(StringLib.IsFirstLetterUpperCase(s))
   End Sub
End Module

Poznámky

Obvykle jsou typy a členy s internal nebo private protected oborem ( C#v) Friend a Private Protected a Scope (v Visual Basic) viditelné pouze v sestavení, ve kterém jsou definovány.Ordinarily, types and members with internal or private protected scope (in C#) and Friend and Private Protected scope (in Visual Basic) are visible only in the assembly in which they are defined. InternalsVisibleToAttribute Atribut je také viditelný pro typy v zadaném sestavení, které je známé jako sestavení typu Friend.The InternalsVisibleToAttribute attribute makes them also visible to the types in a specified assembly, which is known as a friend assembly. To platí pouze pro internal (Friend pouze v jazyce VB private protected)Private Protected nebo (pouze v jazyce VB) pouze private pro metody, ale ne na ty.This only applies to internal (Friend in VB) or private protected(Private Protected in VB) methods only, but not private ones.

Atribut je použit na úrovni sestavení.The attribute is applied at the assembly level. To znamená, že může být vložen na začátek souboru zdrojového kódu nebo může být zahrnut do souboru AssemblyInfo v projektu sady Visual Studio.This means that it can be included at the beginning of a source code file, or it can be included in the AssemblyInfo file in a Visual Studio project. Atribut lze použít k určení jediného sestavení typu Friend, které má přístup k interním typům a členům aktuálního sestavení.You can use the attribute to specify a single friend assembly that can access the internal types and members of the current assembly. Více sestavení typu Friend můžete definovat dvěma způsoby.You can define multiple friend assemblies in two ways. Můžou se zobrazit jako jednotlivé atributy na úrovni sestavení, jak ukazuje následující příklad.They can appear as individual assembly-level attributes, as the following example illustrates.

[assembly:InternalsVisibleTo("Friend1a")]
[assembly:InternalsVisibleTo("Friend1b")]
<assembly:InternalsVisibleTo("Friend1a")>
<assembly:InternalsVisibleTo("Friend1b")>

Můžou se také zobrazovat s oddělenými InternalsVisibleToAttribute značkami, ale s jediným assembly klíčovým slovem, jak ukazuje následující příklad.They can also appear with separate InternalsVisibleToAttribute tags but a single assembly keyword, as the following example illustrates.

[assembly:InternalsVisibleTo("Friend2a"), 
          InternalsVisibleTo("Friend2b")]
<Assembly:InternalsVisibleTo("Friend2a"), _
 Assembly:InternalsVisibleTo("Friend2b")>

Sestavení typu Friend je identifikováno InternalsVisibleToAttribute konstruktorem.The friend assembly is identified by the InternalsVisibleToAttribute constructor. Aktuální sestavení i sestavení typu Friend musí být podepsané, nebo musí být oba sestavení podepsáno silným názvem.Both the current assembly and the friend assembly must be unsigned, or both assemblies must be signed with a strong name.

Pokud jsou obě sestavení bez znaménka assemblyName , argument se skládá z názvu sestavení typu Friend, které je zadáno bez cesty k adresáři nebo přípony názvu souboru.If both assemblies are unsigned, the assemblyName argument consists of the name of the friend assembly, specified without a directory path or file name extension.

Pokud jsou obě sestavení podepsána se silným názvem, argument InternalsVisibleToAttribute konstruktoru musí být tvořen názvem sestavení bez jeho cesty k adresáři nebo příponou názvu souboru spolu s úplným veřejným klíčem (a nikoli tokenem veřejného klíče).If both assemblies are signed with a strong name, the argument to the InternalsVisibleToAttribute constructor must consist of the name of the assembly without its directory path or file name extension, along with the full public key (and not its public key token). Chcete-li získat úplný veřejný klíč sestavení se silným názvem, přečtěte si část získání úplného veřejného klíče dále v tomto článku.To get the full public key of a strong-named assembly, see the Getting the full public key section later in this article. Další informace o použití InternalsVisibleToAttribute se sestaveními InternalsVisibleToAttribute se silným názvem naleznete v konstruktoru.For more information about using InternalsVisibleToAttribute with strong-named assemblies, see the InternalsVisibleToAttribute constructor.

Nezahrnujte hodnoty CultureInfopro pole, ProcessorArchitecture Version, nebo v argumentu; Visual Basic, C#a C++ kompilátory tyto hodnoty považují za chybu kompilátoru.Do not include values for the CultureInfo, Version, or ProcessorArchitecture field in the argument; the Visual Basic, C#, and C++ compilers treat this as a compiler error. Použijete-li kompilátor, který jej nepovažuje za chybu (například IL Assembler (Ilasm. exe)) a sestavení jsou silně pojmenované, je vyvolána MethodAccessException výjimka, když zadané Friend sestavení přistupuje k sestavení, které obsahuje InternalsVisibleToAttribute atribut.If you use a compiler that does not treat it as an error (such as the IL Assembler (ILAsm.exe)) and the assemblies are strong-named, a MethodAccessException exception is thrown the first time the specified friend assembly accesses the assembly that contains the InternalsVisibleToAttribute attribute.

Další informace o použití tohoto atributu naleznete v následujících tématech:For more information about how to use this attribute, see the following topics:

Získání úplného veřejného klíčeGetting the full public key

Pomocí nástroje Strong Name (Sn. exe) můžete načíst úplný veřejný klíč ze souboru s klíčem se silným názvem (. snk).You can use the Strong Name Tool (Sn.exe) to retrieve the full public key from a strong-named key (.snk) file. Uděláte to tak, že provedete následující kroky:To do this, you perform the following steps:

  1. Extrahujte veřejný klíč ze souboru klíče se silným názvem do samostatného souboru:Extract the public key from the strong-named key file to a separate file:

    Sn-p snk_file soubor .Sn -p snk_file outfile

  2. Zobrazit úplný veřejný klíč pro konzolu:Display the full public key to the console:

    Sn-TP soubor .Sn -tp outfile

  3. Zkopírujte a vložte hodnotu úplného veřejného klíče do zdrojového kódu.Copy and paste the full public key value into your source code.

Kompilování sestavení typu Friend sC#Compiling the friend assembly with C#

Použijete-li C# kompilátor ke kompilaci sestavení typu Friend, je nutné explicitně zadat název výstupního souboru (. exe nebo. dll) pomocí možnosti kompilátoru /out .If you use the C# compiler to compile the friend assembly, you must explicitly specify the name of the output file (.exe or .dll) by using the /out compiler option. To je nutné, protože kompilátor ještě negeneroval název sestavení, který sestaví, v době, kdy je svázán s externími odkazy.This is required because the compiler has not yet generated the name for the assembly it is building at the time it is binding to external references. Možnost kompilátoru /out je pro kompilátor Visual Basic volitelná a při kompilování Friend sestavení s F# kompilátorem by se neměla používat odpovídající možnost kompilátoru -o .The /out compiler option is optional for the Visual Basic compiler, and the corresponding -out or -o compiler option should not be used when compiling friend assemblies with the F# compiler.

Kompilování sestavení typu Friend sC++Compiling the friend assembly with C++

Chcete C++-li, aby interní členové, kteří jsou InternalsVisibleToAttribute povoleni atributem přístupný pro sestavení typu Friend, je nutné použít as_friend atribut v C++ direktivě.In C++, in order to make the internal members enabled by the InternalsVisibleToAttribute attribute accessible to a friend assembly, you must use the as_friend attribute in the C++ directive. Další informace naleznete v tématu Friend Assemblies (C++).For more information, see Friend Assemblies (C++).

Konstruktory

InternalsVisibleToAttribute(String) InternalsVisibleToAttribute(String) InternalsVisibleToAttribute(String) InternalsVisibleToAttribute(String)

Inicializuje novou instanci InternalsVisibleToAttribute třídy s názvem zadaného sestavení typu Friend.Initializes a new instance of the InternalsVisibleToAttribute class with the name of the specified friend assembly.

Vlastnosti

AllInternalsVisible AllInternalsVisible AllInternalsVisible AllInternalsVisible

Tato vlastnost není implementována.This property is not implemented.

AssemblyName AssemblyName AssemblyName AssemblyName

Získá název sestavení typu Friend, ke kterému mají být viditelné všechny typy a členy typu, které jsou internal označeny klíčovým slovem.Gets the name of the friend assembly to which all types and type members that are marked with the internal keyword are to be made visible.

TypeId TypeId TypeId TypeId

Při implementaci v odvozené třídě získá jedinečný identifikátor Attribute.When implemented in a derived class, gets a unique identifier for this Attribute.

(Inherited from Attribute)

Metody

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Vrací hodnotu, která určuje, zda je tato instance rovna zadanému objektu.Returns a value that indicates whether this instance is equal to a specified object.

(Inherited from Attribute)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Vrátí kód hash této instance.Returns the hash code for this instance.

(Inherited from Attribute)
GetType() GetType() GetType() GetType()

Type Získá aktuální instanci.Gets the Type of the current instance.

(Inherited from Object)
IsDefaultAttribute() IsDefaultAttribute() IsDefaultAttribute() IsDefaultAttribute()

Při přepsání v odvozené třídě označuje, zda je hodnota této instance výchozí hodnotou pro odvozenou třídu.When overridden in a derived class, indicates whether the value of this instance is the default value for the derived class.

(Inherited from Attribute)
Match(Object) Match(Object) Match(Object) Match(Object)

Při přepsání v odvozené třídě vrátí hodnotu, která označuje, zda je tato instance rovna zadanému objektu.When overridden in a derived class, returns a value that indicates whether this instance equals a specified object.

(Inherited from Attribute)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Vytvoří kopii aktuálního Objectseznamu.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Vrací řetězec, který představuje aktuální objekt.Returns a string that represents the current object.

(Inherited from Object)

Explicitní implementace rozhraní

_Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mapuje sadu názvů na odpovídající sadu identifikátorů pro rozesílání.Maps a set of names to a corresponding set of dispatch identifiers.

(Inherited from Attribute)
_Attribute.GetTypeInfo(UInt32, UInt32, IntPtr) _Attribute.GetTypeInfo(UInt32, UInt32, IntPtr) _Attribute.GetTypeInfo(UInt32, UInt32, IntPtr) _Attribute.GetTypeInfo(UInt32, UInt32, IntPtr)

Načte informace o typu pro objekt, který lze použít k získání informací o typu pro rozhraní.Retrieves the type information for an object, which can be used to get the type information for an interface.

(Inherited from Attribute)
_Attribute.GetTypeInfoCount(UInt32) _Attribute.GetTypeInfoCount(UInt32) _Attribute.GetTypeInfoCount(UInt32) _Attribute.GetTypeInfoCount(UInt32)

Získá počet rozhraní typu informací, které objekt poskytuje (0 nebo 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Inherited from Attribute)
_Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Poskytuje přístup k vlastnostem a metodám vystaveným objektem.Provides access to properties and methods exposed by an object.

(Inherited from Attribute)

Platí pro