MethodBase.IsHideBySigとは何？わかりやすく解説 Weblio辞書

.NET Framework クラスライブラリリファレンス

索引トップ用語の索引ランキング

MethodBase.IsHideBySig プロパティ

派生クラスで、正確に同じシグネチャを持つ同じ種類のメンバだけが隠しメンバになるかどうかを示す値を取得します。

名前空間: System.Reflection
アセンブリ: mscorlib (mscorlib.dll 内)
構文

Visual Basic (宣言)

Public ReadOnly Property
 IsHideBySig As Boolean

Visual Basic (使用法)

Dim instance As MethodBase
Dim value As Boolean

value = instance.IsHideBySig

public bool IsHideBySig { get;
 }

C++

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

/** @property */
public final boolean get_IsHideBySig ()

JScript

public final function get
 IsHideBySig () : boolean

プロパティ値
メンバがシグネチャで隠される場合は true。それ以外の場合は false。

解説

派生クラスのメンバが C# の new 修飾子または Visual Basic の Shadows 修飾子で宣言されている場合、そのメンバは基本クラスの同じ名前のメンバを隠すことができます。C# では、シグネチャによって基本クラスのメンバを隠します。つまり、基本クラスのメンバに複数のオーバーロードがある場合、同一のシグネチャを持つオーバーロードだけが隠されます。これに対して、Visual Basic では基本クラスのすべてのオーバーロードを隠します。したがって、IsHideBySig は、Visual Basic の Shadows 修飾子で宣言されたメンバに対して false を返し、C# の new 修飾子で宣言されたメンバに対しては true を返します。

使用例

オーバーロードされたメソッドを持つ基本クラスと、オーバーロードのいずれかを隠す派生クラスを含むコード例を次に示します。このコード例の Visual Basic バージョンでは、IsHideBySig プロパティは派生クラスのメンバに対して false を返します。このコード例の C# バージョンでは、派生クラスのメンバに対して true を返します。

Visual Basic

Imports System
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 '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()
    {
        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)
*/

C++

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)

*/

import System.*;
import System.Reflection.*;

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

    public void M(int x)
    {
        Console.WriteLine("B's M({0})", (Int32)x);
    } //M
} //B

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

public class Test
{
    public static void main(String[]
 args)
    {
        D dInst = new D();
        // In VJ#, 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();
        for (int iCtr = 0; iCtr < t.GetMethods().get_Length();
 iCtr++) {
            MethodInfo mInfo = (MethodInfo)t.GetMethods().get_Item(iCtr);
            if (mInfo.get_Name().Equals("M")) {
                Console.WriteLine("Overload of M: {0}  IsHideBySig = {1}, "
                    + "DeclaringType = {2}", mInfo, 
                    (System.Boolean)mInfo.get_IsHideBySig(), 
                    mInfo.get_DeclaringType().ToString());
            }
        }
        // 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 = D
Overload of M: Void M()  IsHideBySig = True, DeclaringType = B
------ Call the overloads of M available in D ------
B's M()
D's M(42)
------ Call the shadowed overloads of M ------
B's M()
D's M(42)

*/

プラットフォーム

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile for Pocket PC, Windows Mobile for Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報

.NET Framework
サポート対象 : 2.0、1.1、1.0
.NET Compact Framework
サポート対象 : 2.0、1.0

参照

関連項目
MethodBase クラス
MethodBase メンバ
System.Reflection 名前空間

_MethodBase.IsHideBySig プロパティ

メモ : このプロパティは、.NET Framework version 2.0 で新しく追加されたものです。

COM オブジェクトに、IsHideBySig プロパティへのバージョンに依存しないアクセスが用意されています。

このプロパティは、CLS に準拠していません。

名前空間: System.Runtime.InteropServices
アセンブリ: mscorlib (mscorlib.dll 内)
構文

Visual Basic (宣言)

ReadOnly Property IsHideBySig As
 Boolean

Visual Basic (使用法)

Dim instance As _MethodBase
Dim value As Boolean

value = instance.IsHideBySig

bool IsHideBySig { get; }

C++

property bool IsHideBySig {
    bool get ();
}

/** @property */
boolean get_IsHideBySig ()

JScript

function get IsHideBySig () : boolean

プロパティ値
メンバがシグネチャで隠される場合は true。それ以外の場合は false。

解説

このプロパティは、アンマネージコードからマネージクラスにアクセスするためのプロパティであるため、マネージコードからは呼び出さないでください。

IsHideBySig プロパティは、派生クラスで、正確に同じシグネチャを持つ同じ名前のメンバだけが隠しメンバになるかどうかを示す値を取得します。

プラットフォーム

バージョン情報

.NET Framework
サポート対象 : 2.0

参照

関連項目
_MethodBase インターフェイス
_MethodBase メンバ
System.Runtime.InteropServices 名前空間

>> 「MethodBase.IsHideBySig」を含む用語の索引
MethodBase.IsHideBySigのページへのリンク

MethodBase.IsHideBySigとは？わかりやすく解説

MethodBase.IsHideBySig プロパティ

_MethodBase.IsHideBySig プロパティ

「MethodBase.IsHideBySig」の関連用語


	© 2025 Microsoft.All rights reserved.

MethodBase.IsHideBySigとは？ わかりやすく解説

MethodBase.IsHideBySig プロパティ

_MethodBase.IsHideBySig プロパティ

急上昇のことば

「MethodBase.IsHideBySig」の関連用語

MethodBase.IsHideBySigとは？わかりやすく解説