MethodBase.IsHideBySig MethodBase.IsHideBySig MethodBase.IsHideBySig MethodBase.IsHideBySig Property

定义

获取一个值,该值指示是否只有一个签名完全相同的同一种类的成员在派生类中是隐藏的。Gets a value indicating whether only a member of the same kind with exactly the same signature is hidden in the derived class.

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

属性值

如果此成员被签名隐藏,则为 true;否则为 falsetrue if the member is hidden by signature; otherwise, false.

实现

示例

下面的代码示例包含一个具有重载方法的基类和一个隐藏其中一个重载的派生类。The following code example contains a base class with an overloaded method, and a derived class that hides one of the overloads. 在代码示例的 Visual Basic 版本中, IsHideBySig属性为派生类中的成员返回。 falseIn the Visual Basic version of the code example, the IsHideBySig property returns false for the member in the derived class. 在代码C#示例的版本中,属性为派生类true中的成员返回。In the C# version of the code sample, the property returns true for the member in the derived class.

using namespace System;
using namespace System::Reflection;

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

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

int main()
{
    Child^ childInstance = gcnew Child();

    // 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 PrintCall in the " +
        "derived class Child ------");
    Type^ t = childInstance->GetType();
    for each(MethodInfo^ minfo in t->GetMethods())
    {
        if (minfo->Name == "PrintCall")
        {
            Console::WriteLine("Overload of PrintCall: {0}" +
                " IsHideBySig = {1}, DeclaringType = {2}", 
                minfo, minfo->IsHideBySig, minfo->DeclaringType);
        }
    }

    // The method PrintCall in the derived class hides one overload of the 
    // method in Parent.  Contrast this with Visual Basic, which hides by
    // name instead of by name and signature.  In Visual Basic, the
    // parameterless overload of PrintCall would be unavailable from Child.
    //
    Console::WriteLine(
        "------ Call the overloads of PrintCall available in Child ------");
    childInstance->PrintCall();
    childInstance->PrintCall(42);

    // If Child is cast to the base type Parent, both overloads of the 
    // shadowed method can be called.
    //
    Console::WriteLine(
        "------ Call the shadowed overloads of PrintCall ------");
    Parent^ parentInstance = childInstance;
    parentInstance->PrintCall();
    parentInstance->PrintCall(42);
}

/* This code example produces the following output:

------ List the overloads of PrintCall in the derived class Child ------
Overload of PrintCall: Void PrintCall(Int32) IsHideBySig = True, DeclaringType = Child
Overload of PrintCall: Void PrintCall() IsHideBySig = True, DeclaringType = Parent
Overload of PrintCall: Void PrintCall(Int32) IsHideBySig = True, DeclaringType = Parent
------ Call the overloads of PrintCall available in Child ------
Parent's PrintCall()
Child's PrintCall(42)
------ Call the shadowed overloads of PrintCall ------
Parent's PrintCall()
Parent's PrintCall(42)

*/

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 '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 = 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)

注解

当使用C# new修饰符或 Visual Basic Shadows修饰符声明派生类中的成员时,它可以隐藏基类中具有相同名称的成员。When a member in a derived class is declared with the C# new modifier or the Visual Basic Shadows modifier, it can hide a member of the same name in the base class. C#按签名隐藏基类成员。C# hides base class members by signature. 也就是说,如果基类成员具有多个重载,则只隐藏一个具有相同签名的重载。That is, if the base class member has multiple overloads, the only one that is hidden is the one that has the identical signature. 与此相反,Visual Basic 隐藏了所有基类重载。By contrast, Visual Basic hides all the base class overloads. 因此, IsHideBySig会在使用 Visual Basic Shadows修饰符声明的成员上以及C# new true使用修饰符声明的成员上返回falseThus, IsHideBySig returns false on a member declared with the Visual Basic Shadows modifier, and true on a member declared with the C# new modifier.

警告

此属性不确定方法是否具有NewSlot属性。This property does not determine whether a method has the NewSlot attribute. new使用C# IsHideBySig new NewSlot或修饰符声明的方法将具有属性,但仅使用(即,仅方法)声明的方法将属性设置为Shadows true.A method that is declared with either the new or the Shadows modifier will have the NewSlot attribute, but only methods declared with new (that is, only C# methods) will have the IsHideBySig property set to true. 若要确定某个方法是否有NewSlot特性,请使用与以下代码类似的if ((myMethodInfo.Attributes & MethodAttributes.VtableLayoutMask) == MethodAttributes.NewSlot)代码C# : If (myMethodInfo.Attributes And MethodAttributes.VtableLayoutMask) = MethodAttributes.NewSlot在或 Visual Basic 中。To determine whether a method has the NewSlot attribute, use code similar to the following: if ((myMethodInfo.Attributes & MethodAttributes.VtableLayoutMask) == MethodAttributes.NewSlot) in C# or If (myMethodInfo.Attributes And MethodAttributes.VtableLayoutMask) = MethodAttributes.NewSlot in Visual Basic. 但请注意,尽管使用newShadows声明的所有方法都具有NewSlot NewSlot属性,但并不是所有具有属性的方法都new使用Shadows或进行声明。Note, however, that although all methods declared with new or Shadows have the NewSlot attribute, not all methods that have the NewSlot attribute are declared with new or Shadows.

适用于