MethodBase.IsHideBySig Property

Property Value

Type: System.Boolean
true if the member is hidden by signature; otherwise, false.

Imports System.Reflection

' The base class B contains an overloaded method M.
'
Public Class B
   Public Overridable Sub M()
      outputBlock.Text &= "B's M()" & vbCrLf
   End Sub
   Public Overridable Sub M(ByVal x As Integer)
      outputBlock.Text &= String.Format("B's M({0})", x) & vbCrLf
   End Sub

   Friend Shared outputBlock As System.Windows.Controls.TextBlock
End Class

' The derived class D hides the inherited method M.
'
Public Class D
   Inherits B
   Public Shadows Sub M(ByVal i As Integer)
      outputBlock.Text &= String.Format("D's M({0})", i) & vbCrLf
   End Sub

End Class

Public Class Example
   Public Shared Sub Demo(ByVal outputBlock As System.Windows.Controls.TextBlock)
      B.outputBlock = outputBlock

      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.  
      '
      outputBlock.Text &= "------ List the overloads of M in the derived class D ------" & vbCrLf
      Dim t As Type = dinst.GetType()
      For Each minfo As MethodInfo In t.GetMethods()
         If minfo.Name = "M" Then outputBlock.Text &= String.Format( _
             "Overload of M: {0}  IsHideBySig = {1}, DeclaringType = {2}", _
             minfo, minfo.IsHideBySig, minfo.DeclaringType) & vbCrLf
      Next

      ' The method M in the derived class hides the method in B.
      '
      outputBlock.Text &= "------ Call the overloads of M available in D ------" & vbCrLf
      ' 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.
      '
      outputBlock.Text &= "------ Call the shadowed overloads of M ------" & vbCrLf
      Dim binst As B = dinst
      binst.M()
      binst.M(42)
   End Sub 'Main
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)

using System;
using System.Reflection;

// The base class B contains an overloaded method M.
//
public class B
{
   public virtual void M()
   {
      outputBlock.Text += "B's M()" + "\n";
   }
   public virtual void M(int x)
   {
      outputBlock.Text += String.Format("B's M({0})", x) + "\n";
   }

   internal static System.Windows.Controls.TextBlock outputBlock;
}

// The derived class D hides one overload of the inherited 
// method M.
//
public class D :
    B
{
   new public void M(int i)
   {
      outputBlock.Text += String.Format("D's M({0})", i) + "\n";
   }
}

public class Example
{
   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {
      B.outputBlock = outputBlock;

      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.
      //
      outputBlock.Text += "------ List the overloads of M in the derived class D ------" + "\n";
      Type t = dinst.GetType();
      foreach (MethodInfo minfo in t.GetMethods())
      {
         if (minfo.Name == "M") { outputBlock.Text += String.Format("Overload of M: {0}  IsHideBySig = {1}, DeclaringType = {2}", minfo, minfo.IsHideBySig, minfo.DeclaringType) + "\n"; }
      }

      // 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.
      //
      outputBlock.Text += "------ Call the overloads of M available in D ------" + "\n";
      dinst.M();
      dinst.M(42);

      // If D is cast to the base type B, both overloads of the 
      // shadowed method can be called.
      //
      outputBlock.Text += "------ Call the shadowed overloads of M ------" + "\n";
      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)
*/