FieldInfo.IsAssembly FieldInfo.IsAssembly FieldInfo.IsAssembly FieldInfo.IsAssembly Property

Definición

Obtiene un valor que indica si Assembly describe la visibilidad posible de este campo; es decir, el campo es visible como mucho para otros tipos del mismo ensamblado y no es visible para los tipos derivados fuera del ensamblado.Gets a value indicating whether the potential visibility of this field is described by Assembly; that is, the field is visible at most to other types in the same assembly, and is not visible to derived types outside the assembly.

public:
 property bool IsAssembly { bool get(); };
public bool IsAssembly { get; }
member this.IsAssembly : bool
Public ReadOnly Property IsAssembly As Boolean

Valor de propiedad

true si Assembly describe exactamente la visibilidad de este campo; de lo contrario, false.true if the visibility of this field is exactly described by Assembly; otherwise, false.

Implementaciones

Ejemplos

En el ejemplo de código siguiente se definen campos con distintos niveles de visibilidad y se muestran los IsAssemblyvalores IsFamilyde sus propiedades IsFamilyAndAssembly ,, IsFamilyOrAssemblyy.The following code example defines fields with varying levels of visibility, and displays the values of their IsAssembly, IsFamily, IsFamilyOrAssembly, and IsFamilyAndAssembly properties.

Nota

El Visual Basic y C# los lenguajes no pueden FieldAttributes.FamANDAssem definir campos con visibilidad; ese nivel de acceso C++ solo aparece en el ejemplo.The Visual Basic and C# languages cannot define fields with FieldAttributes.FamANDAssem visibility; that access level appears only in the C++ example.

using namespace System;
using namespace System::Reflection;

public ref class Example
{
public:
    int f_public;
internal:
    int f_internal;
protected:
    int f_protected;
protected public:
    int f_protected_public;
protected private:
    int f_protected_private;
};

void main()
{
    Console::WriteLine("\n{0,-30}{1,-18}{2}", "", "IsAssembly", "IsFamilyOrAssembly"); 
    Console::WriteLine("{0,-21}{1,-18}{2,-18}{3}\n", 
        "", "IsPublic", "IsFamily", "IsFamilyAndAssembly");

    for each (FieldInfo^ f in Example::typeid->GetFields(
        BindingFlags::Instance | BindingFlags::NonPublic | BindingFlags::Public))
    {
        Console::WriteLine("{0,-21}{1,-9}{2,-9}{3,-9}{4,-9}{5,-9}", 
            f->Name,
            f->IsPublic,
            f->IsAssembly,
            f->IsFamily,
            f->IsFamilyOrAssembly,
            f->IsFamilyAndAssembly
        );
    }
}

/* This code example produces output similar to the following:

                              IsAssembly        IsFamilyOrAssembly
                     IsPublic          IsFamily          IsFamilyAndAssembly

f_public             True     False    False    False    False
f_internal           False    True     False    False    False
f_protected          False    False    True     False    False
f_protected_public   False    False    False    True     False
f_protected_private  False    False    False    False    True
 */
using System;
using System.Reflection;

public class Example
{
    public int f_public;
    internal int f_internal;
    protected int f_protected;
    protected internal int f_protected_public;

    public static void Main()
    {
        Console.WriteLine("\n{0,-30}{1,-18}{2}", "", "IsAssembly", "IsFamilyOrAssembly"); 
        Console.WriteLine("{0,-21}{1,-18}{2,-18}{3}\n", 
            "", "IsPublic", "IsFamily", "IsFamilyAndAssembly");
   
        foreach (FieldInfo f in typeof(Example).GetFields(
            BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public))
        {
            Console.WriteLine("{0,-21}{1,-9}{2,-9}{3,-9}{4,-9}{5,-9}", 
                f.Name,
                f.IsPublic,
                f.IsAssembly,
                f.IsFamily,
                f.IsFamilyOrAssembly,
                f.IsFamilyAndAssembly
            );
        }
    }
}

/* This code example produces output similar to the following:

                              IsAssembly        IsFamilyOrAssembly
                     IsPublic          IsFamily          IsFamilyAndAssembly

f_public             True     False    False    False    False
f_internal           False    True     False    False    False
f_protected          False    False    True     False    False
f_protected_public   False    False    False    True     False
 */
Imports System.Reflection

Public class Example

    Public f_Public As Integer
    Friend f_Friend As Integer 
    Protected f_Protected As Integer
    Protected Friend f_Protected_Friend As Integer

    Public Shared Sub Main()
    
        Console.WriteLine(vbCrLf & _
            "{0,-30}{1,-18}{2}", "", "IsAssembly", "IsFamilyOrAssembly") 
        Console.WriteLine("{0,-21}{1,-18}{2,-18}{3}" & vbCrLf, _
            "", "IsPublic", "IsFamily", "IsFamilyAndAssembly")
   
        For Each f As FieldInfo In GetType(Example).GetFields( _
            BindingFlags.Instance Or BindingFlags.NonPublic Or BindingFlags.Public)
        
            Console.WriteLine("{0,-21}{1,-9}{2,-9}{3,-9}{4,-9}{5,-9}", _
                f.Name, _
                f.IsPublic, _
                f.IsAssembly, _
                f.IsFamily, _
                f.IsFamilyOrAssembly, _
                f.IsFamilyAndAssembly _
            )
        Next
    End Sub
End Class

' This code example produces output similar to the following:
'
'                              IsAssembly        IsFamilyOrAssembly
'                     IsPublic          IsFamily          IsFamilyAndAssembly
'
'f_Public             True     False    False    False    False
'f_Friend             False    True     False    False    False
'f_Protected          False    False    True     False    False
'f_Protected_Friend   False    False    False    True     False

Comentarios

La visibilidad real de un campo está limitada por la visibilidad de su tipo.The actual visibility of a field is limited by the visibility of its type. La IsAssembly propiedad puede ser true para un campo, pero si es un campo de un tipo anidado privado, el campo no es visible fuera del tipo contenedor.The IsAssembly property might be true for a field, but if it is a field of a private nested type then the field is not visible outside the containing type.

La visibilidad de un campo se describe exactamente mediante FieldAttributes.Assembly si el único modificador de visibilidad internal esFriend (en Visual Basic).The visibility of a field is exactly described by FieldAttributes.Assembly if the only visibility modifier is internal (Friend in Visual Basic). Esta propiedad es false para los campos que protected internal están C# enProtected Friend (en Visual Basic protected public , C++en); Utilice IsFamilyOrAssembly la propiedad para identificar dichos campos.This property is false for fields that are protected internal in C# (Protected Friend in Visual Basic, protected public in C++); use the IsFamilyOrAssembly property to identify such fields.

Se aplica a

Consulte también: