MethodBase.IsSpecialName-Eigenschaft
Ruft einen Wert ab, der angibt, ob diese Methode einen besonderen Namen hat.
Namespace: System.Reflection
Assembly: mscorlib (in mscorlib.dll)
Syntax
'Declaration
Public ReadOnly Property IsSpecialName As Boolean
'Usage
Dim instance As MethodBase
Dim value As Boolean
value = instance.IsSpecialName
public bool IsSpecialName { get; }
public:
virtual property bool IsSpecialName {
bool get () sealed;
}
/** @property */
public final boolean get_IsSpecialName ()
public final function get IsSpecialName () : boolean
Eigenschaftenwert
true, wenn diese Methode einen besonderen Namen hat, andernfalls false.
Hinweise
Das SpecialName-Bit ist auf Flagmember festgelegt, die von einigen Compilern (z. B. Eigenschaftenaccessoren und Operatorüberladungsmethoden) besonders behandelt werden.
Beispiel
In diesem Beispiel wird IsSpecialName zum Filtern einer Liste nach internen oder privaten Membern verwendet.
Imports System
Imports System.IO
Imports System.Reflection
Imports System.Text
Public Class Sample
Protected ShowMethods As Boolean
Protected myWriter As StreamWriter
Private Sub DumpMethods(ByVal aType As Type)
If Not ShowMethods Then
Return
End If
Dim mInfo As MethodInfo() = aType.GetMethods()
myWriter.WriteLine("Methods")
Dim found As Boolean = False
If mInfo.Length <> 0 Then
Dim i As Integer
For i = 0 To mInfo.Length - 1
' Only display methods declared in this type. Also
' filter out any methods with special names, because these
' cannot be generally called by the user. That is, their
' functionality is usually exposed in other ways, for example,
' property get/set methods are exposed as properties.
If mInfo(i).DeclaringType Is aType _
And Not mInfo(i).IsSpecialName Then
found = True
Dim modifiers As New StringBuilder()
If mInfo(i).IsStatic Then
modifiers.Append("static ")
End If
If mInfo(i).IsPublic Then
modifiers.Append("public ")
End If
If mInfo(i).IsFamily Then
modifiers.Append("protected ")
End If
If mInfo(i).IsAssembly Then
modifiers.Append("internal ")
End If
If mInfo(i).IsPrivate Then
modifiers.Append("private ")
End If
myWriter.WriteLine("{0} {1}", modifiers, mInfo(i))
End If
Next i
End If
If Not found Then
myWriter.WriteLine("(none)")
End If
End Sub
End Class
using System;
using System.IO;
using System.Reflection;
using System.Text;
public class Sample
{
protected bool ShowMethods;
protected StreamWriter myWriter;
private void DumpMethods(Type aType)
{
if (!ShowMethods)
return;
MethodInfo[] mInfo = aType.GetMethods();
myWriter.WriteLine("Methods");
bool found = false;
if (mInfo.Length != 0)
{
for (int i=0; i < mInfo.Length; i++)
{
// Only display methods declared in this type. Also
// filter out any methods with special names, because these
// cannot be generally called by the user. That is, their
// functionality is usually exposed in other ways, for example,
// property get/set methods are exposed as properties.
if (mInfo[i].DeclaringType == aType && !mInfo[i].IsSpecialName)
{
found = true;
StringBuilder modifiers = new StringBuilder();
if (mInfo[i].IsStatic) {modifiers.Append("static ");}
if (mInfo[i].IsPublic) {modifiers.Append("public ");}
if (mInfo[i].IsFamily) {modifiers.Append("protected ");}
if (mInfo[i].IsAssembly) {modifiers.Append("internal ");}
if (mInfo[i].IsPrivate) {modifiers.Append("private ");}
myWriter.WriteLine("{0} {1}", modifiers, mInfo[i]);
}
}
}
if (!found)
{
myWriter.WriteLine("(none)");
}
}
}
using namespace System;
using namespace System::IO;
using namespace System::Reflection;
using namespace System::Text;
public ref class Sample
{
protected:
bool ShowMethods;
StreamWriter^ myWriter;
private:
void DumpMethods( Type^ aType )
{
if ( !ShowMethods )
return;
array<MethodInfo^>^mInfo = aType->GetMethods();
myWriter->WriteLine( "Methods" );
bool found = false;
if ( mInfo->Length != 0 )
{
for ( int i = 0; i < mInfo->Length; i++ )
{
// Only display methods declared in this type. Also
// filter out any methods with special names, because these
// cannot be generally called by the user. That is, their
// functionality is usually exposed in other ways, for example,
// property get/set methods are exposed as properties.
if ( mInfo[ i ]->DeclaringType == aType && !mInfo[ i ]->IsSpecialName )
{
found = true;
StringBuilder^ modifiers = gcnew StringBuilder;
if ( mInfo[ i ]->IsStatic )
{
modifiers->Append( "static " );
}
if ( mInfo[ i ]->IsPublic )
{
modifiers->Append( "public " );
}
if ( mInfo[ i ]->IsFamily )
{
modifiers->Append( "protected " );
}
if ( mInfo[ i ]->IsAssembly )
{
modifiers->Append( "internal " );
}
if ( mInfo[ i ]->IsPrivate )
{
modifiers->Append( "private " );
}
myWriter->WriteLine( "{0} {1}", modifiers, mInfo[ i ] );
}
}
}
if ( !found )
{
myWriter->WriteLine( "(none)" );
}
}
};
import System.*;
import System.IO.*;
import System.Reflection.*;
import System.Text.*;
public class Sample
{
protected boolean showMethods;
protected StreamWriter myWriter;
private void DumpMethods(Type aType)
{
if (!(showMethods)) {
return ;
}
MethodInfo mInfo[] = aType.GetMethods();
myWriter.WriteLine("Methods");
boolean found = false;
if ( mInfo.length != 0 ) {
for(int i=0;i < mInfo.length;i++) {
// Only display methods declared in this type. Also
// filter out any methods with special names, because these
// cannot be generally called by the user. That is, their
// functionality is usually exposed in other ways, for example,
// property get/set methods are exposed as properties.
if ( mInfo[i].get_DeclaringType().Equals(aType) &&
!(mInfo[i].get_IsSpecialName()) ) {
found = true;
StringBuilder modifiers = new StringBuilder();
if ( mInfo[i].get_IsStatic() ) {
modifiers.Append("static ");
}
if ( mInfo[i].get_IsPublic() ) {
modifiers.Append("public ");
}
if ( mInfo[i].get_IsFamily() ) {
modifiers.Append("protected ");
}
if ( mInfo[i].get_IsAssembly()) {
modifiers.Append("internal ");
}
if ( mInfo[i].get_IsPrivate() ) {
modifiers.Append("private ");
}
myWriter.WriteLine("{0} {1}",
modifiers, mInfo.get_Item(i));
}
}
}
if (!(found) ) {
myWriter.WriteLine("(none)");
}
} //DumpMethods
} //Sample
private function DumpMethods(aType : Type) : void
{
if (!ShowMethods)
return;
var mInfo : MethodInfo[] = aType.GetMethods();
myWriter.WriteLine("Methods");
var found : boolean = false;
if (mInfo.Length != 0)
{
for ( var i:int =0; i < mInfo.Length; i++ )
{
// Only display methods declared in this type. Also
// filter out any methods with special names, because these
// cannot be generally called by the user. That is, their
// functionality is usually exposed in other ways, for example,
// property get/set methods are exposed as properties.
if (mInfo[i].DeclaringType.Equals(aType) && !mInfo[i].IsSpecialName)
{
found = true;
var modifiers : StringBuilder = new StringBuilder();
if (mInfo[i].IsStatic) {modifiers.Append("static ");}
if (mInfo[i].IsPublic) {modifiers.Append("public ");}
if (mInfo[i].IsFamily) {modifiers.Append("protected ");}
if (mInfo[i].IsAssembly) {modifiers.Append("internal ");}
if (mInfo[i].IsPrivate) {modifiers.Append("private ");}
myWriter.WriteLine("{0} {1}", [modifiers, mInfo[i]]);
}
}
}
if (!found)
{
myWriter.WriteLine("(none)");
}
}
Plattformen
Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition
.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.
Versionsinformationen
.NET Framework
Unterstützt in: 2.0, 1.1, 1.0
.NET Compact Framework
Unterstützt in: 2.0, 1.0
Siehe auch
Referenz
MethodBase-Klasse
MethodBase-Member
System.Reflection-Namespace
Boolean
MethodAttributes-Enumeration