MethodBase.IsHideBySig Tulajdonság

Definíció

Névtér:

System.Reflection

Szerelvények:

netstandard.dll, System.Runtime.dll

Forrás:

MethodBase.cs

Egy értéket kap, amely azt jelzi, hogy csak egy azonos típusú, pontosan azonos aláírással rendelkező tag van-e elrejtve a származtatott osztályban.

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

public bool IsHideBySig { get; }

member this.IsHideBySig : bool

Public ReadOnly Property IsHideBySig As Boolean

Tulajdonság értéke

Boolean

trueha a tag aláírással van elrejtve; egyéb esetben. false

Példák

Az alábbi példakód egy túlterhelt metódussal rendelkező alaposztályt és egy származtatott osztályt tartalmaz, amely elrejti az egyik túlterhelést. A példakód Visual Basic verziójában a IsHideBySig tulajdonság a származtatott osztály tagjának false ad vissza. A kódminta C#-verziójában a tulajdonság a származtatott osztály tagját adja vissza true .

using System;
using System.Reflection;

// The base class B contains an overloaded method M.
//
public class B
{
    public virtual void M()
    {
        Console.WriteLine("B's M()");
    }
    public virtual void M(int x)
    {
        Console.WriteLine("B's M({0})", x);
    }
}

// The derived class D hides one overload of the inherited 
// method M.
//
public class D:
    B
{
    new public void M(int i)
    {
        Console.WriteLine("D's M({0})", i);
    }
}

public class Test
{
    public static void Main()
    {
        D dinst = new D();
        // In C#, the method in the derived class hides by name and by
        // signature, so the overload in the derived class hides only one
        // of the overloads in the base class.
        //
        Console.WriteLine("------ List the overloads of M in the derived class D ------");
        Type t = dinst.GetType();
        foreach( MethodInfo minfo in t.GetMethods() )
        {
            if (minfo.Name=="M") {Console.WriteLine("Overload of M: {0}  IsHideBySig = {1}, DeclaringType = {2}", minfo, minfo.IsHideBySig, minfo.DeclaringType);}
        }

        // The method M in the derived class hides one overload of the 
        // method in B.  Contrast this with Visual Basic, which hides by
        // name instead of by name and signature.  In Visual Basic, the
        // parameterless overload of M would be unavailable from D.
        //
        Console.WriteLine("------ Call the overloads of M available in D ------");
        dinst.M();
        dinst.M(42);
        
        // If D is cast to the base type B, both overloads of the 
        // shadowed method can be called.
        //
        Console.WriteLine("------ Call the shadowed overloads of M ------");
        B binst = dinst;
        binst.M();
        binst.M(42);
    } //Main
} //Test

/* This code example produces the following output:

------ List the overloads of M in the derived class D ------
Overload of M: Void M(Int32)  IsHideBySig = True, DeclaringType = B
Overload of M: Void M()  IsHideBySig = True, DeclaringType = B
Overload of M: Void M(Int32)  IsHideBySig = True, DeclaringType = D
------ Call the overloads of M available in D ------
B's M()
D's M(42)
------ Call the shadowed overloads of M ------
B's M()
B's M(42)
*/

Imports System.Reflection

' The base class B contains an overloaded method M.
'
Public Class B
    Public Overridable Sub M()
        Console.WriteLine("B's M()")
    End Sub
    Public Overridable Sub M(ByVal x As Integer)
        Console.WriteLine("B's M({0})", x)
    End Sub
End Class

' The derived class D hides the inherited method M.
'
Public Class D
    Inherits B
    Shadows Public Sub M(ByVal i As Integer)
        Console.WriteLine("D's M({0})", i)
    End Sub
End Class

Public Class Test
    Public Shared Sub Main()
        Dim dinst As New D()
        ' In Visual Basic, the method in the derived class hides by
        ' name, rather than by signature.  Thus, although a list of all the 
        ' overloads of M shows three overloads, only one can be called from
        ' class D.  
        '
        Console.WriteLine("------ List the overloads of M in the derived class D ------")
        Dim t As Type = dinst.GetType()
        For Each minfo As MethodInfo In t.GetMethods()
            If minfo.Name = "M" Then Console.WriteLine( _
                "Overload of M: {0}  IsHideBySig = {1}, DeclaringType = {2}", _
                minfo, minfo.IsHideBySig, minfo.DeclaringType)
        Next

        ' The method M in the derived class hides the method in B.
        '
        Console.WriteLine("------ Call the overloads of M available in D ------")
        ' The following line causes a compile error, because both overloads
        ' in the base class are hidden.  Contrast this with C#, where only 
        ' one of the overloads of B would be hidden.
        'dinst.M()
        dinst.M(42)
        
        ' If D is cast to the base type B, both overloads of the 
        ' shadowed method can be called.
        '
        Console.WriteLine("------ Call the shadowed overloads of M ------")
        Dim binst As B = dinst
        binst.M()
        binst.M(42)         
    End Sub
End Class

' This code example produces the following output:
' ------ List the overloads of M in the derived class D ------
' Overload of M: Void M(Int32)  IsHideBySig = False, DeclaringType = B
' Overload of M: Void M()  IsHideBySig = False, DeclaringType = B
' Overload of M: Void M(Int32)  IsHideBySig = False, DeclaringType = D
' ------ Call the overloads of M available in D ------
' D's M(42)
' ------ Call the shadowed overloads of M ------
' B's M()
' B's M(42)

Megjegyzések

Ha egy származtatott osztály egy tagját a C# new módosítóval vagy a Visual Basic Shadows módosítóval deklarálja, elrejtheti az azonos nevű tagot az alaposztályban. A C# aláírással elrejti az alaposztálytagokat. Ez azt jelzi, hogy ha az alaposztály tagjának több túlterhelése van, az egyetlen rejtett, amelyik azonos aláírást használ. Ezzel szemben Visual Basic elrejti az alaposztály túlterheléseit. Így IsHideBySig a Visual Basic false módosítóval deklarált tagon Shadows, a C# true módosítóval deklarált tagon pedig new ad vissza.

Warning

Ez a tulajdonság nem határozza meg, hogy egy metódus rendelkezik-e attribútummal NewSlot . A módosítóval deklarált new metódusok attribútummal Shadows rendelkeznekNewSlot, de csak a (azaz csak C# metódusokkal new ) deklarált metódusok rendelkeznek a IsHideBySig tulajdonsággaltrue. Annak megállapításához, hogy egy metódus rendelkezik-e a NewSlot attribútummal, használja a következőhöz hasonló kódot: if ((myMethodInfo.Attributes & MethodAttributes.VtableLayoutMask) == MethodAttributes.NewSlot) c# vagy If (myMethodInfo.Attributes And MethodAttributes.VtableLayoutMask) = MethodAttributes.NewSlot Visual Basic. Vegye figyelembe azonban, hogy bár az attribútummal deklarált összes metódus rendelkezik az attribútummalnew, nem minden olyan metódus van deklarálva, amely rendelkezik az attribútummal vagy Shadowsa NewSlotNewSlot .newShadows