Type.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / DotNET / DotNET / 8.0 / untmp / whidbey / REDBITS / ndp / clr / src / BCL / System / Type.cs / 1 / Type.cs
                        

                        
                            // ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 
////////////////////////////////////////////////////////////////////////////////
 
namespace System { 

    using System; 
    using System.Reflection;
    using System.Reflection.Emit;
    using System.Reflection.Cache;
    using System.Threading; 
    using System.Runtime.Remoting;
    using System.Runtime.InteropServices; 
    using System.Runtime.CompilerServices; 
    using System.Security.Permissions;
    using System.Collections.Generic; 
    using CultureInfo = System.Globalization.CultureInfo;
    using SignatureHelper = System.Reflection.Emit.SignatureHelper;
    using StackCrawlMark = System.Threading.StackCrawlMark;
    using DebuggerStepThroughAttribute = System.Diagnostics.DebuggerStepThroughAttribute; 

    [Serializable()] 
    [ClassInterface(ClassInterfaceType.None)] 
    [ComDefaultInterface(typeof(_Type))]
[System.Runtime.InteropServices.ComVisible(true)] 
    public abstract class Type : MemberInfo, _Type, IReflect
    {
        public static readonly MemberFilter FilterAttribute;
        public static readonly MemberFilter FilterName; 
        public static readonly MemberFilter FilterNameIgnoreCase;
 
        public static readonly Object Missing = System.Reflection.Missing.Value; 

        public static readonly char Delimiter = '.'; 

        // EmptyTypes is used to indicate that we are looking for someting without any parameters.
        public readonly static Type[] EmptyTypes = new Type[0];
 
        // The Default binder.  We create a single one and expose that.
        private static object 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.
        protected Type() {}
 

        // MemberInfo Methods.... 
        // The Member type Field. 
        public override MemberTypes MemberType {
                get {return System.Reflection.MemberTypes.TypeInfo;} 
        }

        // Return the class that declared this Field.
        public override Type DeclaringType { 
                get {return this;}
        } 
 
        public virtual MethodBase DeclaringMethod { get { return null; } }
 
        // Return the class that was used to obtain this field.
        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).
        ////

        // this method is required so Object.GetType is not made virtual by the compiler 
        //
        public new Type GetType() 
        { 
            return base.GetType();
        } 

        public static Type GetType(String typeName, bool throwOnError, bool ignoreCase) {
            unsafe
            { 
                StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
                return RuntimeType.PrivateGetType(typeName, throwOnError, ignoreCase, ref stackMark); 
            } 
        }
 
        public static Type GetType(String typeName, bool throwOnError) {
            unsafe
            {
                StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; 
                return RuntimeType.PrivateGetType(typeName, throwOnError, false, ref stackMark);
            } 
        } 

        public static Type GetType(String typeName) { 
            unsafe
            {
                StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
                return RuntimeType.PrivateGetType(typeName, false, false, ref stackMark); 
            }
        } 
 
        public static Type ReflectionOnlyGetType(String typeName, bool throwIfNotFound, bool ignoreCase)
        { 
            unsafe
            {
                StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
                return RuntimeType.PrivateGetType(typeName, throwIfNotFound, ignoreCase, true /*reflectionOnly*/, ref stackMark); 
            }
        } 
 
        public virtual Type MakePointerType() { throw new NotSupportedException(); }
        public virtual StructLayoutAttribute StructLayoutAttribute { get { throw new NotSupportedException(); } } 
        public virtual Type MakeByRefType() { throw new NotSupportedException(); }
        public virtual Type MakeArrayType() { throw new NotSupportedException(); }
        public virtual Type MakeArrayType(int rank) { throw new NotSupportedException(); }
 
#if FEATURE_COMINTEROP
        //////////////////////////////////////////////////////////////////////////////// 
        // This will return a class based upon the progID.  This is provided for 
        // COM classic support.  Program ID's are not used in COM+ because they
        // have been superceded by namespace.  (This routine is called this instead 
        // of getClass() because of the name conflict with the first method above.)
        //
        //   param progID:     the progID of the class to retrieve
        //   returns:          the class object associated to the progID 
        ////
        [SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)] 
        public static Type GetTypeFromProgID(String progID) 
        {
                return RuntimeType.GetTypeFromProgIDImpl(progID, null, false); 
        }

        ////////////////////////////////////////////////////////////////////////////////
        // This will return a class based upon the progID.  This is provided for 
        // COM classic support.  Program ID's are not used in COM+ because they
        // have been superceded by namespace.  (This routine is called this instead 
        // of getClass() because of the name conflict with the first method above.) 
        //
        //   param progID:     the progID of the class to retrieve 
        //   returns:          the class object associated to the progID
        ////
        [SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)]
        public static Type GetTypeFromProgID(String progID, bool throwOnError) 
        {
                return RuntimeType.GetTypeFromProgIDImpl(progID, null, throwOnError); 
        } 

        [SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)] 
        public static Type GetTypeFromProgID(String progID, String server)
        {
                return RuntimeType.GetTypeFromProgIDImpl(progID, server, false);
        } 

        [SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)] 
        public static Type GetTypeFromProgID(String progID, String server, bool throwOnError) 
        {
                return RuntimeType.GetTypeFromProgIDImpl(progID, server, throwOnError); 
        }

        ////////////////////////////////////////////////////////////////////////////////
        // This will return a class based upon the CLSID.  This is provided for 
        // COM classic support.
        // 
        //   param CLSID:      the CLSID of the class to retrieve 
        //   returns:          the class object associated to the CLSID
        //// 
        public static Type GetTypeFromCLSID(Guid clsid)
        {
                return RuntimeType.GetTypeFromCLSIDImpl(clsid, null, false);
        } 

        public static Type GetTypeFromCLSID(Guid clsid, bool throwOnError) 
        { 
                return RuntimeType.GetTypeFromCLSIDImpl(clsid, null, throwOnError);
        } 

        public static Type GetTypeFromCLSID(Guid clsid, String server)
        {
                return RuntimeType.GetTypeFromCLSIDImpl(clsid, server, false); 
        }
 
        public static Type GetTypeFromCLSID(Guid clsid, String server, bool throwOnError) 
        {
                return RuntimeType.GetTypeFromCLSIDImpl(clsid, server, throwOnError); 
        }
#endif // FEATURE_COMINTEROP

        internal string SigToString() 
        {
            Type elementType = this; 
 
            while(elementType.HasElementType)
                elementType = elementType.GetElementType(); 

            if (elementType.IsNested)
                return Name;
 
            string sigToString = ToString();
 
            if (elementType.IsPrimitive || 
                elementType == typeof(void) ||
                elementType == typeof(TypedReference)) 
                sigToString = sigToString.Substring(@"System.".Length);

            return sigToString;
        } 

        // GetTypeCode 
        // This method will return a TypeCode for the passed 
        //  type.
        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.
        public abstract Guid GUID {
            get;
        } 

        // Return the Default binder used by the system. 
        static public Binder DefaultBinder { 
            get {
                // Allocate the default binder if it hasn't been allocated yet. 
                if (defaultBinder == null)
                    CreateBinder();
                return defaultBinder as Binder;
            } 
        }
 
        static private void CreateBinder() 
        {
            if (defaultBinder == null) 
            {
                object binder = new DefaultBinder();
                Interlocked.CompareExchange(ref defaultBinder, binder, null);
            } 
        }
 
       // 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... 

        abstract public Object InvokeMember(String name,BindingFlags invokeAttr,Binder binder,Object target,
                                    Object[] args, ParameterModifier[] modifiers,CultureInfo culture,String[] namedParameters);
 
        [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); 
        }

        [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.
        public new abstract Module Module { get; }
 
        // Assembly Property associated with a class.
        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.
        public virtual extern RuntimeTypeHandle TypeHandle {
            [MethodImplAttribute(MethodImplOptions.InternalCall)] 
            get;
        } 
 
        internal virtual RuntimeTypeHandle GetTypeHandleInternal() {
            return TypeHandle; 
        }

        [MethodImpl(MethodImplOptions.InternalCall)]
        public static extern RuntimeTypeHandle GetTypeHandle(Object o); 

        // Given a class handle, this will return the class for that handle. 
        [MethodImpl(MethodImplOptions.InternalCall)] 
        public static extern Type GetTypeFromHandle(RuntimeTypeHandle handle);
 
        // Return the fully qualified name.  The name does contain the namespace.
        public abstract String FullName {
            get;
        } 

        // Return the name space of the class. 
        public abstract String Namespace { 
            get;
        } 


        public abstract String AssemblyQualifiedName {
            get; 
        }
 
 
        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.
        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.
[System.Runtime.InteropServices.ComVisible(true)] 
        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 attrs = CustomAttributeData.GetCustomAttributes(t);
                    for (int i = 0; i < attrs.Count; i++) 
                    {
                        if (attrs[i].Constructor.DeclaringType == typeof(DefaultMemberAttribute))
                        {
                            attr = attrs[i]; 
                            break;
                        } 
                    } 

                    if (attr != null) 
                        break;
                }

                if (attr == null) 
                    return new MemberInfo[0];
                defaultMember = attr.ConstructorArguments[0].Value as string; 
                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
        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

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK