The System.Reflection.MethodBase class is an abstract derivation of MemberInfo that contains additional functionality to reflect on methods. Two concrete subclasses of MethodBase exist: ConstructorInfo and MethodInfo. The following example demonstrates how to obtain the public instance method and constructor information for the System.String class:

Type x_string_type = typeof(System.String);

ConstructorInfo[] x_constructors = x_string_type.GetConstructors();
foreach (ConstructorInfo x_into in x_constructors) {
    Console.WriteLine("Constructor: " + x_into);
}

Console.WriteLine();

MethodInfo[] x_methods = x_string_type.GetMethods();
foreach (MethodInfo x_info in x_methods) {
    Console.WriteLine("Method: " + x_info);
}

The first few lines of the output are listed next; the String class contains too many members to list completely:

Constructor: Void .ctor(Char*)
Constructor: Void .ctor(Char*, Int32, Int32)
Constructor: Void .ctor(SByte*)
Constructor: Void .ctor(SByte*, Int32, Int32)
Constructor: Void .ctor(SByte*, Int32, Int32, System.Text.Encoding)
Constructor: Void .ctor(Char[], Int32, Int32)
Constructor: Void .ctor(Char[])
Constructor: Void .ctor(Char, Int32)

Method: System.String ToString(System.IFormatProvider)
Method: System.TypeCode GetTypeCode()
Method: System.Object Clone()
Method: Int32 CompareTo(System.Object)
Method: Int32 GetHashCode()
Method: Boolean Equals(System.Object)
Method: System.String ToString()

The .NET ConstructorInfo class is equivalent to the Java java.lang.reflect.Constructor class. Table 12-5 compares these two classes.

The .NET MethodInfo class is equivalent to the java.lang.reflect.Method class. These two classes are compared in Table 12-6.

The MethodBase class defines convenience members implemented by ConstructorInfo and MethodInfo that provide more details about method-type members. These details can also be derived from inspecting the contents of the Attributes property of ConstructorInfo and MethodInfo. These methods are summarized in Table 12-7.

Properties are represented by the System.Reflection.PropertyInfo class; the members of this class are listed in Table 12-8.

Events are represented by the EventInfo class; Table 12-9 details the members of this class.

The ParameterInfo class is used to represent the definition of parameters that are passed into member functions. Table 12-10 details the methods used to obtain parameter information.

The ParameterInfo class is required to represent the modifiers that can be applied to parameters, such as out and ref. Java does not support parameter modifiers and thus has no equivalent class.

Table 12-11 lists the members available in the ParameterInfo class.

Fields are represented by the FieldInfo class, the equivalent of the java.lang.reflect.Field class. Table 12-12 contrasts these two classes.

Reflection is available only on custom attributes; it isn’t possible to determine whether a type or a member is annotated with one of the system attributes, such as Serializable. The System.Type class includes properties that go some way toward exposing system properties (such as IsSerializable), but the methods that expose attributes via reflection will return custom attributes only.

The MemberInfo class defines the GetCustomAttributes method, which returns an object array; each element in the array can be cast to an instance of an attribute that has been applied to the member. Once an instance of a custom attribute has been obtained, the values that were declared in the attribute annotation are available through direct member calls; it isn’t necessary to use reflection to work with attributes.

The System.Attribute class defines the static IsDefined method, which allows the programmer to determine whether a specific type of custom attribute has been applied to a member.