MethodBase.IsHideBySig Vlastnost

Definice

Obor názvů:

System.Reflection

Sestavení:

netstandard.dll, System.Runtime.dll

Zdroj:

MethodBase.cs

Získá hodnotu určující, zda je v odvozené třídě skrytý pouze člen stejného typu s přesně stejným podpisem.

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

public bool IsHideBySig { get; }

member this.IsHideBySig : bool

Public ReadOnly Property IsHideBySig As Boolean

Hodnota vlastnosti

Boolean

trueje-li člen skrytý podpisem; v opačném případě . false

Příklady

Následující příklad kódu obsahuje základní třídu s přetíženou metodou a odvozenou třídu, která skryje jednu z přetížení. Ve verzi jazyka Visual Basic příkladu IsHideBySig kódu vrátí false vlastnost člena v odvozené třídě. Ve verzi C# ukázky kódu vrátí true vlastnost člena v odvozené třídě.

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)

Poznámky

Pokud je člen v odvozené třídě deklarován modifikátorem jazyka C# new nebo modifikátorem jazyka Visual Basic Shadows , může skrýt člena stejného názvu v základní třídě. C# skryje členy základní třídy podpisem. To znamená, že pokud má člen základní třídy více přetížení, jediný, který je skrytý, je ten, který má identický podpis. Naproti tomu Visual Basic skryje všechna přetížení základní třídy. IsHideBySig Proto se vrátí false na člen deklarovaný s modifikátorem jazyka Visual Basic Shadows a true u člena deklarovaného pomocí modifikátoru jazyka C#new.

Výstraha

Tato vlastnost neurčí, zda metoda má NewSlot atribut. Metoda deklarovaná pomocí modifikátoru newShadows nebo modifikátoru bude mít NewSlot atribut, ale pouze metody deklarované s (tj. pouze metodami new jazyka C#) budou mít vlastnost nastavenou IsHideBySig na true. Chcete-li zjistit, zda má metoda NewSlot atribut, použijte kód podobný následujícímu: if ((myMethodInfo.Attributes & MethodAttributes.VtableLayoutMask) == MethodAttributes.NewSlot) v jazyce C# nebo If (myMethodInfo.Attributes And MethodAttributes.VtableLayoutMask) = MethodAttributes.NewSlot v jazyce Visual Basic. Mějte však na paměti, že ačkoli všechny metody deklarované s new nebo Shadows mají NewSlot atribut, ne všechny metody, které mají NewSlot atribut jsou deklarovány s new nebo Shadows.