FieldInfo.IsFamilyOrAssembly FieldInfo.IsFamilyOrAssembly FieldInfo.IsFamilyOrAssembly FieldInfo.IsFamilyOrAssembly Property

Définition

Espace de noms:
System.Reflection System.Reflection System.Reflection System.Reflection
Assemblies:
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 Boolean Boolean 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 les champs avec des niveaux de visibilité et affiche les valeurs de leurs IsAssembly, IsFamily, IsFamilyOrAssembly, et IsFamilyAndAssembly propriétés.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 langages Visual Basic et C# ne peut pas définir des champs avec FieldAttributes.FamANDAssem visibilité ; que le niveau d’accès apparaît uniquement dans l’exemple C++.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
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 niveau de visibilité, elle peut être appelée à partir de n’importe quel membre dans une classe dérivée ou n’importe quel membre dans le même assembly, mais pas à partir de n’importe quel 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. Le IsFamilyOrAssembly propriété peut être true pour un champ, mais si c’est un champ d’un type imbriqué privé, le champ n’est pas visible en dehors 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é est protected internal en C# (Protected Friend en Visual Basic, protected public dans C++).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++).

S’applique à

Voir aussi