// ==++==
//
//
// Copyright (c) 2002 Microsoft Corporation. All rights reserved.
//
// The use and distribution terms for this software are contained in the file
// named license.txt, which can be found in the root of this distribution.
// By using this software in any fashion, you are agreeing to be bound by the
// terms of this license.
//
// You must not remove this notice, or any other, from this software.
//
//
// ==--==
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//
// Type is the root of all reflection and the Object that represents
// a type inside the system. Type is an abstract base class that allows multiple
// implementations. The system will always provide the subclass __RuntimeType.
// In Reflection all of the __RuntimeXXX classes are created only once per object
// in the system and support == comparisions.
//
// Date: March 98
//
namespace System {
using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Reflection.Cache;
using System.Runtime.Remoting;
using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;
using System.Security.Permissions;
using CultureInfo = System.Globalization.CultureInfo;
using SignatureHelper = System.Reflection.Emit.SignatureHelper;
using StackCrawlMark = System.Threading.StackCrawlMark;
using DebuggerStepThroughAttribute = System.Diagnostics.DebuggerStepThroughAttribute;
/// <include file='doc\Type.uex' path='docs/doc[@for="Type"]/*' />
[Serializable()]
public abstract class Type : MemberInfo, IReflect
{
// Member filters
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.FilterAttribute"]/*' />
public static readonly MemberFilter FilterAttribute;
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.FilterName"]/*' />
public static readonly MemberFilter FilterName;
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.FilterNameIgnoreCase"]/*' />
public static readonly MemberFilter FilterNameIgnoreCase;
// mark a parameter as a missing parameter.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.Missing"]/*' />
public static readonly Object Missing = System.Reflection.Missing.Value;
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.Delimiter"]/*' />
public static readonly char Delimiter = '.';
// EmptyTypes is used to indicate that we are looking for someting without any parameters.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.EmptyTypes"]/*' />
public readonly static Type[] EmptyTypes = new Type[0];
// The Default binder. We create a single one and expose that.
private static Binder defaultBinder;
// Because the current compiler doesn't support static delegates
// the _Filters object is an object that we create to contain all of
// the filters.
//private static final Type _filterClass = new RuntimeType();
static Type() {
__Filters _filterClass = new __Filters();
FilterAttribute = new MemberFilter(_filterClass.FilterAttribute);
FilterName = new MemberFilter(_filterClass.FilterName);
FilterNameIgnoreCase = new MemberFilter(_filterClass.FilterIgnoreCase);
}
// Prevent from begin created, and allow subclass
// to create.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.Type"]/*' />
protected Type() {}
// MemberInfo Methods....
// The Member type Field.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.MemberType"]/*' />
public override MemberTypes MemberType {
get {return System.Reflection.MemberTypes.TypeInfo;}
}
// Return the class that declared this Field.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.DeclaringType"]/*' />
public override Type DeclaringType {
get {return this;}
}
// Return the class that was used to obtain this field.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.ReflectedType"]/*' />
public override Type ReflectedType {
get {return this;}
}
////////////////////////////////////////////////////////////////////////////////
// This is a static method that returns a Class based upon the name of the class
// (this name needs to be fully qualified with the package name and is
// case-sensitive by default).
////
/************** PLEASE NOTE - THE GETTYPE METHODS NEED TO BE INTERNAL CALLS
// EE USES THE ECALL FRAME TO FIND WHO THE CALLER IS. THIS"LL BREAK IF A METHOD BODY IS ADDED */
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetType"]/*' />
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public static extern Type GetType(String typeName, bool throwOnError, bool ignoreCase);
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetType1"]/*' />
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public static extern Type GetType(String typeName, bool throwOnError);
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetType2"]/*' />
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public static extern Type GetType(String typeName);
/****************************/
// GetTypeCode
// This method will return a TypeCode for the passed
// type.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetTypeCode"]/*' />
public static TypeCode GetTypeCode(Type type)
{
if (type == null)
return TypeCode.Empty;
return type.GetTypeCodeInternal();
}
internal virtual TypeCode GetTypeCodeInternal()
{
Type type = this;
if (type is SymbolType)
return TypeCode.Object;
if (type is TypeBuilder)
{
TypeBuilder typeBuilder = (TypeBuilder) type;
if (typeBuilder.IsEnum == false)
return TypeCode.Object;
// if it is an Enum, just let the underlyingSystemType do the work
}
if (type != type.UnderlyingSystemType)
return Type.GetTypeCode(type.UnderlyingSystemType);
return TypeCode.Object;
}
// Property representing the GUID associated with a class.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GUID"]/*' />
public abstract Guid GUID {
get;
}
// Return the Default binder used by the system.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.DefaultBinder"]/*' />
static public Binder DefaultBinder {
get {
// Allocate the default binder if it hasn't been allocated yet.
if (defaultBinder == null)
{
lock(typeof(Type))
{
if (defaultBinder == null)
defaultBinder = new DefaultBinder();
}
}
return defaultBinder;
}
}
// Description of the Binding Process.
// We must invoke a method that is accessable and for which the provided
// parameters have the most specific match. A method may be called if
// 1. The number of parameters in the method declaration equals the number of
// arguments provided to the invocation
// 2. The type of each argument can be converted by the binder to the
// type of the type of the parameter.
//
// The binder will find all of the matching methods. These method are found based
// upon the type of binding requested (MethodInvoke, Get/Set Properties). The set
// of methods is filtered by the name, number of arguments and a set of search modifiers
// defined in the Binder.
//
// After the method is selected, it will be invoked. Accessability is checked
// at that point. The search may be control which set of methods are searched based
// upon the accessibility attribute associated with the method.
//
// The BindToMethod method is responsible for selecting the method to be invoked.
// For the default binder, the most specific method will be selected.
//
// This will invoke a specific member...
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.InvokeMember"]/*' />
abstract public Object InvokeMember(String name,BindingFlags invokeAttr,Binder binder,Object target,
Object[] args, ParameterModifier[] modifiers,CultureInfo culture,String[] namedParameters);
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.InvokeMember1"]/*' />
[DebuggerStepThroughAttribute]
[Diagnostics.DebuggerHidden]
public Object InvokeMember(String name,BindingFlags invokeAttr,Binder binder, Object target, Object[] args, CultureInfo culture)
{
return InvokeMember(name,invokeAttr,binder,target,args,null,culture,null);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.InvokeMember2"]/*' />
[DebuggerStepThroughAttribute]
[Diagnostics.DebuggerHidden]
public Object InvokeMember(String name,BindingFlags invokeAttr,Binder binder, Object target, Object[] args)
{
return InvokeMember(name,invokeAttr,binder,target,args,null,null,null);
}
// Module Property associated with a class.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.Module"]/*' />
public abstract Module Module {
get;
}
// Assembly Property associated with a class.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.Assembly"]/*' />
public abstract Assembly Assembly {
get;
}
// A class handle is a unique integer value associated with
// each class. The handle is unique during the process life time.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.TypeHandle"]/*' />
public abstract RuntimeTypeHandle TypeHandle {
get;
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetTypeHandle"]/*' />
public static RuntimeTypeHandle GetTypeHandle(Object o) {
return RuntimeType.InternalGetTypeHandleFromObject(o);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetTypeFromHandle"]/*' />
public static Type GetTypeFromHandle(RuntimeTypeHandle handle)
{
return RuntimeType.GetTypeFromHandleImpl(handle);
}
// Return the fully qualified name. The name does contain the namespace.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.FullName"]/*' />
public abstract String FullName {
get;
}
// Return the name space of the class.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.Namespace"]/*' />
public abstract String Namespace {
get;
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.AssemblyQualifiedName"]/*' />
public abstract String AssemblyQualifiedName {
get;
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetArrayRank"]/*' />
public virtual int GetArrayRank() {
throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride"));
}
// Returns the base class for a class. If this is an interface or has
// no base class null is returned. Object is the only Type that does not
// have a base class.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.BaseType"]/*' />
public abstract Type BaseType {
get;
}
// GetConstructor
// This method will search for the specified constructor. For constructors,
// unlike everything else, the default is to not look for static methods. The
// reason is that we don't typically expose the class initializer.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetConstructor"]/*' />
public ConstructorInfo GetConstructor(BindingFlags bindingAttr,
Binder binder,
CallingConventions callConvention,
Type[] types,
ParameterModifier[] modifiers)
{
// Must provide some types (Type[0] for nothing)
if (types == null)
throw new ArgumentNullException("types");
for (int i=0;i<types.Length;i++)
if (types[i] == null)
throw new ArgumentNullException("types");
return GetConstructorImpl(bindingAttr, binder, callConvention, types, modifiers);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetConstructor1"]/*' />
public ConstructorInfo GetConstructor(BindingFlags bindingAttr, Binder binder, Type[] types, ParameterModifier[] modifiers)
{
if (types == null)
throw new ArgumentNullException("types");
for (int i=0;i<types.Length;i++)
if (types[i] == null)
throw new ArgumentNullException("types");
return GetConstructorImpl(bindingAttr, binder, CallingConventions.Any, types, modifiers);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetConstructor2"]/*' />
public ConstructorInfo GetConstructor(Type[] types)
{
// The arguments are checked in the called version of GetConstructor.
return GetConstructor(BindingFlags.Public | BindingFlags.Instance, null, types, null);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetConstructorImpl"]/*' />
abstract protected ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr,
Binder binder,
CallingConventions callConvention,
Type[] types,
ParameterModifier[] modifiers);
// GetConstructors()
// This routine will return an array of all constructors supported by the class.
// Unlike everything else, the default is to not look for static methods. The
// reason is that we don't typically expose the class initializer.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetConstructors"]/*' />
public ConstructorInfo[] GetConstructors() {
return GetConstructors(BindingFlags.Public | BindingFlags.Instance);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetConstructors1"]/*' />
abstract public ConstructorInfo[] GetConstructors(BindingFlags bindingAttr);
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.TypeInitializer"]/*' />
public ConstructorInfo TypeInitializer {
get {
return GetConstructorImpl(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic,
null,
CallingConventions.Any,
Type.EmptyTypes,
null);
}
}
// Return a method based upon the passed criteria. The name of the method
// must be provided, and exception is thrown if it is not. The bindingAttr
// parameter indicates if non-public methods should be searched. The types
// array indicates the types of the parameters being looked for.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetMethod"]/*' />
public MethodInfo GetMethod(String name,
BindingFlags bindingAttr,
Binder binder,
CallingConventions callConvention,
Type[] types,
ParameterModifier[] modifiers)
{
if (name == null)
throw new ArgumentNullException("name");
if (types == null)
throw new ArgumentNullException("types");
for (int i = 0; i < types.Length; i++)
if (types[i] == null)
throw new ArgumentNullException("types");
return GetMethodImpl(name, bindingAttr, binder, callConvention, types, modifiers);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetMethod1"]/*' />
public MethodInfo GetMethod(String name,
BindingFlags bindingAttr,
Binder binder,
Type[] types,
ParameterModifier[] modifiers)
{
if (name == null)
throw new ArgumentNullException("name");
if (types == null)
throw new ArgumentNullException("types");
for (int i = 0; i < types.Length; i++)
if (types[i] == null)
throw new ArgumentNullException("types");
return GetMethodImpl(name, bindingAttr, binder, CallingConventions.Any, types, modifiers);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetMethod2"]/*' />
public MethodInfo GetMethod(String name, Type[] types, ParameterModifier[] modifiers)
{
if (name == null)
throw new ArgumentNullException("name");
if (types == null)
throw new ArgumentNullException("types");
for (int i=0;i<types.Length;i++)
if (types[i] == null)
throw new ArgumentNullException("types");
return GetMethodImpl(name, Type.DefaultLookup, null, CallingConventions.Any, types, modifiers);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetMethod3"]/*' />
public MethodInfo GetMethod(String name,Type[] types)
{
if (name == null)
throw new ArgumentNullException("name");
if (types == null)
throw new ArgumentNullException("types");
for (int i=0;i<types.Length;i++)
if (types[i] == null)
throw new ArgumentNullException("types");
return GetMethodImpl(name, Type.DefaultLookup, null, CallingConventions.Any, types, null);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetMethod4"]/*' />
public MethodInfo GetMethod(String name, BindingFlags bindingAttr)
{
if (name == null)
throw new ArgumentNullException("name");
return GetMethodImpl(name, bindingAttr, null, CallingConventions.Any, null, null);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetMethod5"]/*' />
public MethodInfo GetMethod(String name)
{
if (name == null)
throw new ArgumentNullException("name");
return GetMethodImpl(name, Type.DefaultLookup, null, CallingConventions.Any, null, null);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetMethodImpl"]/*' />
abstract protected MethodInfo GetMethodImpl(String name,
BindingFlags bindingAttr,
Binder binder,
CallingConventions callConvention,
Type[] types,
ParameterModifier[] modifiers);
// GetMethods
// This routine will return all the methods implemented by the class
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetMethods"]/*' />
public MethodInfo[] GetMethods() {
return GetMethods(Type.DefaultLookup);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetMethods1"]/*' />
abstract public MethodInfo[] GetMethods(BindingFlags bindingAttr);
// GetField
// Get Field will return a specific field based upon name
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetField"]/*' />
abstract public FieldInfo GetField(String name, BindingFlags bindingAttr);
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetField1"]/*' />
public FieldInfo GetField(String name) {
return GetField(name, Type.DefaultLookup);
}
// GetFields
// Get fields will return a full array of fields implemented by a class
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetFields"]/*' />
public FieldInfo[] GetFields() {
return GetFields(Type.DefaultLookup);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetFields1"]/*' />
abstract public FieldInfo[] GetFields(BindingFlags bindingAttr);
// GetInterface
// This method will return an interface (as a class) based upon
// the passed in name.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetInterface"]/*' />
public Type GetInterface(String name) {
return GetInterface(name,false);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetInterface1"]/*' />
abstract public Type GetInterface(String name, bool ignoreCase);
// GetInterfaces
// This method will return all of the interfaces implemented by a
// class
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetInterfaces"]/*' />
abstract public Type[] GetInterfaces();
// FindInterfaces
// This method will filter the interfaces supported the class
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.FindInterfaces"]/*' />
public virtual Type[] FindInterfaces(TypeFilter filter,Object filterCriteria)
{
if (filter == null)
throw new ArgumentNullException("filter");
Type[] c = GetInterfaces();
int cnt = 0;
for (int i = 0;i<c.Length;i++) {
if (!filter(c[i],filterCriteria))
c[i] = null;
else
cnt++;
}
if (cnt == c.Length)
return c;
Type[] ret = new Type[cnt];
cnt=0;
for (int i=0;i<c.Length;i++) {
if (c[i] != null)
ret[cnt++] = c[i];
}
return ret;
}
// GetEvent
// This method will return a event by name if it is found.
// null is returned if the event is not found
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetEvent"]/*' />
public EventInfo GetEvent(String name) {
return GetEvent(name,Type.DefaultLookup);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetEvent1"]/*' />
abstract public EventInfo GetEvent(String name,BindingFlags bindingAttr);
// GetEvents
// This method will return an array of EventInfo. If there are not Events
// an empty array will be returned.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetEvents"]/*' />
virtual public EventInfo[] GetEvents() {
return GetEvents(Type.DefaultLookup);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetEvents1"]/*' />
abstract public EventInfo[] GetEvents(BindingFlags bindingAttr);
// Return a property based upon the passed criteria. The nameof the
// parameter must be provided.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetProperty"]/*' />
public PropertyInfo GetProperty(String name,BindingFlags bindingAttr,Binder binder,
Type returnType, Type[] types, ParameterModifier[] modifiers)
{
if (name == null)
throw new ArgumentNullException("name");
if (types == null)
throw new ArgumentNullException("types");
return GetPropertyImpl(name,bindingAttr,binder,returnType,types,modifiers);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetProperty1"]/*' />
public PropertyInfo GetProperty(String name, Type returnType, Type[] types,ParameterModifier[] modifiers)
{
if (name == null)
throw new ArgumentNullException("name");
if (types == null)
throw new ArgumentNullException("types");
return GetPropertyImpl(name,Type.DefaultLookup,null,returnType,types,modifiers);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetProperty2"]/*' />
public PropertyInfo GetProperty(String name, BindingFlags bindingAttr)
{
if (name == null)
throw new ArgumentNullException("name");
return GetPropertyImpl(name,bindingAttr,null,null,null,null);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetProperty3"]/*' />
public PropertyInfo GetProperty(String name, Type returnType, Type[] types)
{
if (name == null)
throw new ArgumentNullException("name");
if (types == null)
throw new ArgumentNullException("types");
return GetPropertyImpl(name,Type.DefaultLookup,null,returnType,types,null);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetProperty4"]/*' />
public PropertyInfo GetProperty(String name, Type[] types)
{
if (name == null)
throw new ArgumentNullException("name");
if (types == null)
throw new ArgumentNullException("types");
return GetPropertyImpl(name,Type.DefaultLookup,null,null,types,null);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetProperty5"]/*' />
public PropertyInfo GetProperty(String name, Type returnType)
{
if (name == null)
throw new ArgumentNullException("name");
if (returnType == null)
throw new ArgumentNullException("returnType");
return GetPropertyImpl(name,Type.DefaultLookup,null,returnType,null,null);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetProperty6"]/*' />
public PropertyInfo GetProperty(String name)
{
if (name == null)
throw new ArgumentNullException("name");
return GetPropertyImpl(name,Type.DefaultLookup,null,null,null,null);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetPropertyImpl"]/*' />
abstract protected PropertyInfo GetPropertyImpl(String name, BindingFlags bindingAttr,Binder binder,
Type returnType, Type[] types, ParameterModifier[] modifiers);
// GetProperties
// This method will return an array of all of the properties defined
// for a Type.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetProperties"]/*' />
abstract public PropertyInfo[] GetProperties(BindingFlags bindingAttr);
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetProperties1"]/*' />
public PropertyInfo[] GetProperties()
{
return GetProperties(Type.DefaultLookup);
}
// GetNestedTypes()
// This set of method will return any nested types that are found inside
// of the type.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetNestedTypes"]/*' />
public Type[] GetNestedTypes()
{
return GetNestedTypes(Type.DefaultLookup);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetNestedTypes1"]/*' />
abstract public Type[] GetNestedTypes(BindingFlags bindingAttr);
// GetNestedType()
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetNestedType"]/*' />
public Type GetNestedType(String name)
{
return GetNestedType(name,Type.DefaultLookup);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetNestedType1"]/*' />
abstract public Type GetNestedType(String name, BindingFlags bindingAttr);
// GetMember
// This method will return all of the members which match the specified string
// passed into the method
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetMember"]/*' />
public MemberInfo[] GetMember(String name) {
return GetMember(name,Type.DefaultLookup);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetMember1"]/*' />
virtual public MemberInfo[] GetMember(String name, BindingFlags bindingAttr)
{
return GetMember(name,MemberTypes.All,bindingAttr);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetMember2"]/*' />
virtual public MemberInfo[] GetMember(String name, MemberTypes type, BindingFlags bindingAttr)
{
throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride"));
}
// GetMembers
// This will return a Member array of all of the members of a class
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetMembers"]/*' />
public MemberInfo[] GetMembers() {
return GetMembers(Type.DefaultLookup);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetMembers1"]/*' />
abstract public MemberInfo[] GetMembers(BindingFlags bindingAttr);
// GetDefaultMembers
// This will return a MemberInfo that has been marked with the
// DefaultMemberAttribute
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetDefaultMembers"]/*' />
public virtual MemberInfo[] GetDefaultMembers()
{
// See if we have cached the default member name
String defaultMember = (String)this.Cache[CacheObjType.DefaultMember];
if (defaultMember == null) {
// Get all of the custom attributes
Object[] attrs = GetCustomAttributes(typeof(DefaultMemberAttribute), true);
// We assume that there is only one DefaultMemberAttribute (Allow multiple = false)
if (attrs.Length > 1)
throw new ExecutionEngineException(Environment.GetResourceString("ExecutionEngine_InvalidAttribute"));
if (attrs.Length == 0)
return new MemberInfo[0];
defaultMember = ((DefaultMemberAttribute)attrs[0]).MemberName;
this.Cache[CacheObjType.DefaultMember] = defaultMember;
}
MemberInfo[] members = GetMember(defaultMember);
if (members == null)
members = new MemberInfo[0];
return members;
}
internal virtual String GetDefaultMemberName() {
// See if we have cached the default member name
String defaultMember = (String)this.Cache[CacheObjType.DefaultMember];
if (defaultMember == null)
{
Object[] attrs = GetCustomAttributes(typeof(DefaultMemberAttribute), true);
// We assume that there is only one DefaultMemberAttribute (Allow multiple = false)
if (attrs.Length > 1)
throw new ExecutionEngineException(Environment.GetResourceString("ExecutionEngine_InvalidAttribute"));
if (attrs.Length == 0)
return null;
defaultMember = ((DefaultMemberAttribute)attrs[0]).MemberName;
this.Cache[CacheObjType.DefaultMember] = defaultMember;
}
return defaultMember;
}
// FindMembers
// This will return a filtered version of the member information
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.FindMembers"]/*' />
public virtual MemberInfo[] FindMembers(MemberTypes memberType,BindingFlags bindingAttr,MemberFilter filter,Object filterCriteria)
{
// Define the work arrays
MethodInfo[] m = null;
ConstructorInfo[] c = null;
FieldInfo[] f = null;
PropertyInfo[] p = null;
EventInfo[] e = null;
Type[] t = null;
int i = 0;
int cnt = 0; // Total Matchs
// Check the methods
if ((memberType & System.Reflection.MemberTypes.Method) != 0) {
m = GetMethods(bindingAttr);
if (filter != null) {
for (i=0;i<m.Length;i++)
if (!filter(m[i],filterCriteria))
m[i] = null;
else
cnt++;
} else {
cnt+=m.Length;
}
}
// Check the constructors
if ((memberType & System.Reflection.MemberTypes.Constructor) != 0) {
c = GetConstructors(bindingAttr);
if (filter != null) {
for (i=0;i<c.Length;i++)
if (!filter(c[i],filterCriteria))
c[i] = null;
else
cnt++;
} else {
cnt+=c.Length;
}
}
// Check the fields
if ((memberType & System.Reflection.MemberTypes.Field) != 0) {
f = GetFields(bindingAttr);
if (filter != null) {
for (i=0;i<f.Length;i++)
if (!filter(f[i],filterCriteria))
f[i] = null;
else
cnt++;
} else {
cnt+=f.Length;
}
}
// Check the Properties
if ((memberType & System.Reflection.MemberTypes.Property) != 0) {
p = GetProperties(bindingAttr);
if (filter != null) {
for (i=0;i<p.Length;i++)
if (!filter(p[i],filterCriteria))
p[i] = null;
else
cnt++;
} else {
cnt+=p.Length;
}
}
// Check the Events
if ((memberType & System.Reflection.MemberTypes.Event) != 0) {
e = GetEvents();
if (filter != null) {
for (i=0;i<e.Length;i++)
if (!filter(e[i],filterCriteria))
e[i] = null;
else
cnt++;
} else {
cnt+=e.Length;
}
}
// Check the Types
if ((memberType & System.Reflection.MemberTypes.NestedType) != 0) {
t = GetNestedTypes(bindingAttr);
if (filter != null) {
for (i=0;i<t.Length;i++)
if (!filter(t[i],filterCriteria))
t[i] = null;
else
cnt++;
} else {
cnt+=t.Length;
}
}
// Allocate the Member Info
MemberInfo[] ret = new MemberInfo[cnt];
// Copy the Methods
cnt = 0;
if (m != null) {
for (i=0;i<m.Length;i++)
if (m[i] != null)
ret[cnt++] = m[i];
}
// Copy the Constructors
if (c != null) {
for (i=0;i<c.Length;i++)
if (c[i] != null)
ret[cnt++] = c[i];
}
// Copy the Fields
if (f != null) {
for (i=0;i<f.Length;i++)
if (f[i] != null)
ret[cnt++] = f[i];
}
// Copy the Properties
if (p != null) {
for (i=0;i<p.Length;i++)
if (p[i] != null)
ret[cnt++] = p[i];
}
// Copy the Events
if (e != null) {
for (i=0;i<e.Length;i++)
if (e[i] != null)
ret[cnt++] = e[i];
}
// Copy the Types
if (t != null) {
for (i=0;i<t.Length;i++)
if (t[i] != null)
ret[cnt++] = t[i];
}
return ret;
}
////////////////////////////////////////////////////////////////////////////////
//
// Attributes
//
// The attributes are all treated as read-only properties on a class. Most of
// these boolean properties have flag values defined in this class and act like
// a bit mask of attributes. There are also a set of boolean properties that
// relate to the classes relationship to other classes and to the state of the
// class inside the runtime.
//
////////////////////////////////////////////////////////////////////////////////
// The attribute property on the Type.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.Attributes"]/*' />
public TypeAttributes Attributes {
get {return GetAttributeFlagsImpl();}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsNotPublic"]/*' />
public bool IsNotPublic {
get {return ((GetAttributeFlagsImpl() & TypeAttributes.VisibilityMask) == TypeAttributes.NotPublic);}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsPublic"]/*' />
public bool IsPublic {
get {return ((GetAttributeFlagsImpl() & TypeAttributes.VisibilityMask) == TypeAttributes.Public);}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsNestedPublic"]/*' />
public bool IsNestedPublic {
get {return ((GetAttributeFlagsImpl() & TypeAttributes.VisibilityMask) == TypeAttributes.NestedPublic);}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsNestedPrivate"]/*' />
public bool IsNestedPrivate {
get {return ((GetAttributeFlagsImpl() & TypeAttributes.VisibilityMask) == TypeAttributes.NestedPrivate);}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsNestedFamily"]/*' />
public bool IsNestedFamily {
get {return ((GetAttributeFlagsImpl() & TypeAttributes.VisibilityMask) == TypeAttributes.NestedFamily);}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsNestedAssembly"]/*' />
public bool IsNestedAssembly {
get {return ((GetAttributeFlagsImpl() & TypeAttributes.VisibilityMask) == TypeAttributes.NestedAssembly);}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsNestedFamANDAssem"]/*' />
public bool IsNestedFamANDAssem {
get {return ((GetAttributeFlagsImpl() & TypeAttributes.VisibilityMask) == TypeAttributes.NestedFamANDAssem);}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsNestedFamORAssem"]/*' />
public bool IsNestedFamORAssem{
get {return ((GetAttributeFlagsImpl() & TypeAttributes.VisibilityMask) == TypeAttributes.NestedFamORAssem);}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsAutoLayout"]/*' />
public bool IsAutoLayout {
get {return ((GetAttributeFlagsImpl() & TypeAttributes.LayoutMask) == TypeAttributes.AutoLayout);}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsLayoutSequential"]/*' />
public bool IsLayoutSequential {
get {return ((GetAttributeFlagsImpl() & TypeAttributes.LayoutMask) == TypeAttributes.SequentialLayout);}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsExplicitLayout"]/*' />
public bool IsExplicitLayout {
get {return ((GetAttributeFlagsImpl() & TypeAttributes.LayoutMask) == TypeAttributes.ExplicitLayout);}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsClass"]/*' />
public bool IsClass {
get {return ((GetAttributeFlagsImpl() & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Class && !IsSubclassOf(Type.valueType));}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsInterface"]/*' />
public bool IsInterface {
get {return ((GetAttributeFlagsImpl() & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Interface);}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsValueType"]/*' />
public bool IsValueType {
get {return IsValueTypeImpl();}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsAbstract"]/*' />
public bool IsAbstract {
get {return ((GetAttributeFlagsImpl() & TypeAttributes.Abstract) != 0);}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsSealed"]/*' />
public bool IsSealed {
get {return ((GetAttributeFlagsImpl() & TypeAttributes.Sealed) != 0);}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsEnum"]/*' />
public bool IsEnum {
get {return IsSubclassOf(Type.enumType);}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsSpecialName"]/*' />
public bool IsSpecialName {
get {return ((GetAttributeFlagsImpl() & TypeAttributes.SpecialName) != 0);}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsImport"]/*' />
public bool IsImport {
get {return ((GetAttributeFlagsImpl() & TypeAttributes.Import) != 0);}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsSerializable"]/*' />
public bool IsSerializable {
get {return (((GetAttributeFlagsImpl() & TypeAttributes.Serializable) != 0) ||
(this.QuickSerializationCastCheck()));}
}
private bool QuickSerializationCastCheck() {
Type c = this.UnderlyingSystemType;
while (c!=null) {
if (c==typeof(Enum) || c==typeof(Delegate)) {
return true;
}
c = c.BaseType;
}
return false;
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsAnsiClass"]/*' />
public bool IsAnsiClass {
get {return ((GetAttributeFlagsImpl() & TypeAttributes.StringFormatMask) == TypeAttributes.AnsiClass);}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsUnicodeClass"]/*' />
public bool IsUnicodeClass {
get {return ((GetAttributeFlagsImpl() & TypeAttributes.StringFormatMask) == TypeAttributes.UnicodeClass);}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsAutoClass"]/*' />
public bool IsAutoClass {
get {return ((GetAttributeFlagsImpl() & TypeAttributes.StringFormatMask) == TypeAttributes.AutoClass);}
}
// These are not backed up by attributes. Instead they are implemented
// based internally.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsArray"]/*' />
public bool IsArray {
get {return IsArrayImpl();}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsByRef"]/*' />
public bool IsByRef {
get {return IsByRefImpl();}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsPointer"]/*' />
public bool IsPointer {
get {return IsPointerImpl();}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsPrimitive"]/*' />
public bool IsPrimitive {
get {return IsPrimitiveImpl();}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsCOMObject"]/*' />
public bool IsCOMObject {
get {return IsCOMObjectImpl();}
}
internal bool IsGenericCOMObject {
get {
if (this is RuntimeType)
return ((RuntimeType)this).IsGenericCOMObjectImpl();
else
return false;
}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.HasElementType"]/*' />
public bool HasElementType {
get {return HasElementTypeImpl();}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsContextful"]/*' />
public bool IsContextful {
get {return IsContextfulImpl();}
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsMarshalByRef"]/*' />
public bool IsMarshalByRef {
get {return IsMarshalByRefImpl();}
}
internal bool HasProxyAttribute {
get {return HasProxyAttributeImpl();}
}
// Protected routine to determine if this class represents a value class
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsValueTypeImpl"]/*' />
protected virtual bool IsValueTypeImpl() {
Type type = this;
if (type == Type.valueType || type == Type.enumType)
return false;
return IsSubclassOf(Type.valueType);
}
// Protected routine to get the attributes.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetAttributeFlagsImpl"]/*' />
abstract protected TypeAttributes GetAttributeFlagsImpl();
// Protected routine to determine if this class represents an Array
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsArrayImpl"]/*' />
abstract protected bool IsArrayImpl();
// Protected routine to determine if this class is a ByRef
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsByRefImpl"]/*' />
abstract protected bool IsByRefImpl();
// Protected routine to determine if this class is a Pointer
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsPointerImpl"]/*' />
abstract protected bool IsPointerImpl();
// Protected routine to determine if this class represents a primitive type
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsPrimitiveImpl"]/*' />
abstract protected bool IsPrimitiveImpl();
// Protected routine to determine if this class represents a COM object
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsCOMObjectImpl"]/*' />
abstract protected bool IsCOMObjectImpl();
// Protected routine to determine if this class is contextful
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsContextfulImpl"]/*' />
protected virtual bool IsContextfulImpl(){
return typeof(ContextBoundObject).IsAssignableFrom(this);
}
// Protected routine to determine if this class is marshaled by ref
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsMarshalByRefImpl"]/*' />
protected virtual bool IsMarshalByRefImpl(){
return typeof(MarshalByRefObject).IsAssignableFrom(this);
}
internal virtual bool HasProxyAttributeImpl()
{
// We will override this in RuntimeType
return false;
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetElementType"]/*' />
abstract public Type GetElementType();
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.HasElementTypeImpl"]/*' />
abstract protected bool HasElementTypeImpl();
// Return the underlying Type that represents the IReflect Object. For expando object,
// this is the (Object) IReflectInstance.GetType(). For Type object it is this.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.UnderlyingSystemType"]/*' />
public abstract Type UnderlyingSystemType {
get;
}
// IsLoaded
// This indicates if the class has been loaded into the runtime.
internal virtual bool IsLoaded()
{
return true;
}
// Returns true of this class is a true subclass of c. Everything
// else returns false. If this class and c are the same class false is
// returned.
//
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsSubclassOf"]/*' />
public virtual bool IsSubclassOf(Type c)
{
Type p = this;
if (p == c)
return false;
while (p != null) {
if (p == c)
return true;
p = p.BaseType;
}
return false;
}
// Returns true if the object passed is assignable to an instance of this class.
// Everything else returns false.
//
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsInstanceOfType"]/*' />
public virtual bool IsInstanceOfType(Object o)
{
if (o == null)
return false;
// For transparent proxies we have to check the cast
// using remoting specific facilities.
if(RemotingServices.IsTransparentProxy(o)) {
return (null != RemotingServices.CheckCast(o, this));
}
if (IsInterface && o.GetType().IsCOMObject) {
if (this is RuntimeType)
return ((RuntimeType) this).SupportsInterface(o);
}
return IsAssignableFrom(o.GetType());
}
// Returns true if an instance of Type c may be assigned
// to an instance of this class. Return false otherwise.
//
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.IsAssignableFrom"]/*' />
public virtual bool IsAssignableFrom(Type c)
{
if (c == null)
return false;
try {
RuntimeType fromType = c.UnderlyingSystemType as RuntimeType;
RuntimeType toType = this.UnderlyingSystemType as RuntimeType;
if (fromType == null || toType == null)
{
// special case for TypeBuilder
TypeBuilder fromTypeBuilder = c as TypeBuilder;
if (fromTypeBuilder == null)
{
return false;
}
if (TypeBuilder.IsTypeEqual(this, c))
return true;
// If fromTypeBuilder is a subclass of this class, then c can be cast to this type.
if (fromTypeBuilder.IsSubclassOf(this))
return true;
if (this.IsInterface == false)
{
return false;
}
// now is This type a base type on one of the interface impl?
Type[] interfaces = fromTypeBuilder.GetInterfaces();
for (int i = 0; i < interfaces.Length; i++)
{
if (TypeBuilder.IsTypeEqual(interfaces[i], this))
return true;
if (interfaces[i].IsSubclassOf(this))
return true;
}
return false;
}
bool b = RuntimeType.CanCastTo(fromType, toType);
return b;
}
catch (ArgumentException) {}
// Check for interfaces
if (IsInterface) {
Type[] ifaces = c.GetInterfaces();
for (int i=0;i<ifaces.Length;i++)
if (this == ifaces[i])
return true;
}
// Check the class relationship
else {
while (c != null) {
if (c == this)
return true;
c = c.BaseType;
}
}
return false;
}
// ToString
// Print the String Representation of the Type
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.ToString"]/*' />
public override String ToString()
{
return "Type: "+Name;
}
// This method will return an array of classes based upon the array of
// types.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetTypeArray"]/*' />
public static Type[] GetTypeArray(Object[] args) {
if (args == null)
throw new ArgumentNullException("args");
Type[] cls = new Type[args.Length];
for (int i=0;i<cls.Length;i++)
cls[i] = args[i].GetType();
return cls;
}
// Internal routine to TypeDef token.This rountine is called to update the
// runtime assembly information.
internal virtual int InternalGetTypeDefToken()
{
throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride"));
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.Equals"]/*' />
public override bool Equals(Object o) {
if (o == null)
return false;
if (!(o is Type))
return false;
return (this.UnderlyingSystemType == ((Type) o).UnderlyingSystemType);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.Equals1"]/*' />
public bool Equals(Type o) {
if (o == null)
return false;
return (this.UnderlyingSystemType == o.UnderlyingSystemType);
}
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetHashCode"]/*' />
public override int GetHashCode()
{
Type SystemType = UnderlyingSystemType;
if (SystemType != this)
return SystemType.GetHashCode();
return base.GetHashCode();
}
// GetInterfaceMap
// This method will return an interface mapping for the interface
// requested. It will throw an argument exception if the Type doesn't
// implemenet the interface.
/// <include file='doc\Type.uex' path='docs/doc[@for="Type.GetInterfaceMap"]/*' />
public virtual InterfaceMapping GetInterfaceMap(Type interfaceType)
{
throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride"));
}
// This is used by Remoting
internal static Type ResolveTypeRelativeTo(String typeName, Type serverType)
{
return ResolveTypeRelativeTo(typeName, 0, typeName.Length, serverType);
} // ResolveTypeRelativeTo
// This is used by Remoting
internal static Type ResolveTypeRelativeTo(String typeName, int offset, int count, Type serverType)
{
Type type = ResolveTypeRelativeToBaseTypes(typeName, offset, count, serverType);
if (type == null)
{
// compare against the interface list
// GetInterfaces() returns a complete list of interfaces this type supports
Type[] interfaces = serverType.GetInterfaces();
foreach (Type iface in interfaces)
{
String ifaceTypeName = iface.FullName;
if (ifaceTypeName.Length == count)
{
if (String.CompareOrdinal(typeName, offset, ifaceTypeName, 0, count) == 0)
{
return iface;
}
}
}
}
return type;
} // ResolveTypeRelativeTo
// This is used by Remoting
internal static Type ResolveTypeRelativeToBaseTypes(String typeName, int offset, int count, Type serverType)
{
// typeName is excepted to contain the full type name
// offset is the start of the full type name within typeName
// count us the number of characters in the full type name
// serverType is the type of the server object
if ((typeName == null) || (serverType == null))
return null;
String serverTypeName = serverType.FullName;
if (serverTypeName.Length == count)
{
if (String.CompareOrdinal(typeName, offset, serverTypeName, 0, count) == 0)
{
return serverType;
}
}
return ResolveTypeRelativeToBaseTypes(typeName, offset, count, serverType.BaseType);
} // ResolveTypeRelativeTo
// private convenience data
private const BindingFlags DefaultLookup = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public;
private static readonly Type valueType = typeof(System.ValueType);
private static readonly Type enumType = typeof(System.Enum);
private static readonly Type objectType = typeof(System.Object);
}
}
Printable
Source File