FieldInfo.IsFamilyOrAssembly Propriété

Définition

Espace de noms:: System.Reflection

Assemblys:: System.Reflection.dll, mscorlib.dll, netstandard.dll, System.Runtime.dll

Obtient une valeur indiquant si la visibilité potentielle de ce champ est décrite par FamORAssem, c'est-à-dire si le champ peut faire l'objet d'un accès par des classes dérivées où qu'elles se trouvent, et par des classes du même assembly.Gets a value indicating whether the potential visibility of this field is described by FamORAssem; that is, the field can be accessed by derived classes wherever they are, and by classes in the same assembly.

public:
 property bool IsFamilyOrAssembly { bool get(); };

public bool IsFamilyOrAssembly { get; }

member this.IsFamilyOrAssembly : bool

Public ReadOnly Property IsFamilyOrAssembly As Boolean

Valeur de propriété

Boolean

true si l'accès à ce champ est décrit exactement par FamORAssem ; sinon, false.true if access to this field is exactly described by FamORAssem; otherwise, false.

Implémente

IsFamilyOrAssembly

Exemples

L’exemple de code suivant définit des champs avec différents niveaux de visibilité et affiche les valeurs de IsAssemblyleurs IsFamilypropriétés IsFamilyOrAssembly,, IsFamilyAndAssembly et.The following code example defines fields with varying levels of visibility, and displays the values of their IsAssembly, IsFamily, IsFamilyOrAssembly, and IsFamilyAndAssembly properties.

Notes

Les Visual Basic et C# les langages ne peuvent FieldAttributes.FamANDAssem pas définir des champs avec visibilité ; ce niveau C++ d’accès s’affiche uniquement dans l’exemple.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

Remarques

Si un champ a FamORAssem une visibilité de niveau, il peut être appelé à partir de n’importe quel membre d’une classe dérivée ou d’un membre dans le même assembly, mais pas à partir d’un autre type.If a field has FamORAssem level visibility, it can be called from any member in a derived class or any member in the same assembly, but not from any other type.

La visibilité réelle d’un champ est limitée par la visibilité de son type.The actual visibility of a field is limited by the visibility of its type. La IsFamilyOrAssembly propriété peut être true pour un champ, mais s’il s’agit d’un champ d’un type imbriqué privé, le champ n’est pas visible à l’extérieur du type conteneur.The IsFamilyOrAssembly 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 visibilité d’un champ est décrite exactement par FieldAttributes.FamORAssem si le modificateur de visibilité protected internal est C# dansProtected Friend (dans Visual Basic protected public , C++dans).The visibility of a field is exactly described by FieldAttributes.FamORAssem if the visibility modifier is protected internal in C# (Protected Friend in Visual Basic, protected public in C++).