FieldInfo.IsFamily Proprietà

Definizione

Ottiene un valore che indica se la visibilità di questo campo è descritta da Family, ovvero se il campo è visibile solo all'interno della relativa classe e delle classi derivate.Gets a value indicating whether the visibility of this field is described by Family; that is, the field is visible only within its class and derived classes.

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

Valore della proprietà

true se l'accesso al campo è descritto esattamente da Family; in caso contrario false.true if access to this field is exactly described by Family; otherwise, false.

Implementazioni

Esempi

Nell'esempio di codice seguente vengono definiti campi con diversi livelli di visibilità e vengono visualizzati i valori delle proprietà IsAssembly, IsFamily, IsFamilyOrAssemblye IsFamilyAndAssembly.The following code example defines fields with varying levels of visibility, and displays the values of their IsAssembly, IsFamily, IsFamilyOrAssembly, and IsFamilyAndAssembly properties.

Nota

Il Visual Basic e C# i linguaggi non possono definire campi con visibilità FieldAttributes.FamANDAssem; tale livello di accesso viene visualizzato solo C++ nell'esempio.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

Commenti

La visibilità di un campo è descritta esattamente da FieldAttributes.Family se l'unico modificatore di visibilità è protected.The visibility of a field is exactly described by FieldAttributes.Family if the only visibility modifier is protected. Questa proprietà è false per i campi protected internal in C# (Protected Friend in Visual Basic, protected public in C++); utilizzare la proprietà IsFamilyOrAssembly per identificare questi campi.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.

Si applica a

Vedi anche