RuntimeHandles.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 / RuntimeHandles.cs / 5 / RuntimeHandles.cs

                            // ==++== 
//
//   Copyright(c) Microsoft Corporation.  All rights reserved.
//
// ==--== 
#define DEBUG_PTRS
 
namespace System 
{
    using System; 
    using System.Reflection;
    using System.Reflection.Emit;
    using System.Runtime.ConstrainedExecution;
    using System.Diagnostics; 
    using System.Runtime.Serialization;
    using System.Runtime.CompilerServices; 
    using System.Runtime.InteropServices; 
    using System.Threading;
    using System.Text; 
    using System.Globalization;
    using Microsoft.Win32.SafeHandles;
    using StackCrawlMark = System.Threading.StackCrawlMark;
 
    internal unsafe struct MethodDescChunkHandle
    { 
        private IntPtr m_ptr; 

        internal MethodDescChunkHandle(void* ptr) 
        {
            m_ptr = new IntPtr(ptr);
        }
 
        internal bool IsNullHandle()
        { 
            return m_ptr.ToPointer() == null; 
        }
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern void* _GetNextMethodDescChunk();
        internal MethodDescChunkHandle GetNextMethodDescChunk()
        { 
            return new MethodDescChunkHandle(_GetNextMethodDescChunk());
        } 
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern void* _GetMethodAt(int index); 
        internal RuntimeMethodHandle GetMethodAt(int index)
        {
            return new RuntimeMethodHandle(_GetMethodAt(index));
        } 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern int GetMethodCount(); 
    }
 
    internal struct FastArrayHandle
    {
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal static extern void SetValueAt(Array target, int index, object element); 
/*
        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal static extern void CopyArray (Array soruce, Array destination); 
*/
    } 

    [Serializable()]
    [System.Runtime.InteropServices.ComVisible(true)]
    public unsafe struct RuntimeTypeHandle : ISerializable 
    {
        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern bool IsInstanceOfType(Object o); 

        internal unsafe static IntPtr GetTypeHelper(IntPtr th, IntPtr pGenericArgs, int cGenericArgs, IntPtr pModifiers, int cModifiers) 
        {
            RuntimeTypeHandle typeHandle = new RuntimeTypeHandle(th.ToPointer());
            Type type = typeHandle.GetRuntimeType();
            if (type == null) 
                return th;
 
            if (cGenericArgs > 0) 
            {
                Type[] genericArgs = new Type[cGenericArgs]; 
                void** arGenericArgs = (void**)pGenericArgs.ToPointer();
                for (int i = 0; i < genericArgs.Length; i++)
                {
                    RuntimeTypeHandle genericArg = new RuntimeTypeHandle((void*)Marshal.ReadIntPtr((IntPtr)arGenericArgs, i * sizeof(void*))); 
                    genericArgs[i] = Type.GetTypeFromHandle(genericArg);
 
                    if (genericArgs[i] == null) 
                        return (IntPtr)0;
                } 

                type = type.MakeGenericType(genericArgs);
            }
 
            if (cModifiers > 0)
            { 
                int* arModifiers = (int*)pModifiers.ToPointer(); 
                for(int i = 0; i < cModifiers; i++)
                { 
                    if ((CorElementType)Marshal.ReadInt32((IntPtr)arModifiers, i * sizeof(int)) == CorElementType.Ptr)
                        type = type.MakePointerType();

                    else if ((CorElementType)Marshal.ReadInt32((IntPtr)arModifiers, i * sizeof(int)) == CorElementType.ByRef) 
                        type = type.MakeByRefType();
 
                    else if ((CorElementType)Marshal.ReadInt32((IntPtr)arModifiers, i * sizeof(int)) == CorElementType.SzArray) 
                        type = type.MakeArrayType();
 
                    else
                        type = type.MakeArrayType(Marshal.ReadInt32((IntPtr)arModifiers, ++i * sizeof(int)));
                }
            } 

            return type.GetTypeHandleInternal().Value; 
        } 

        public static bool operator ==(RuntimeTypeHandle left, object right) { return left.Equals(right); } 

        public static bool operator ==(object left, RuntimeTypeHandle right) { return right.Equals(left); }

        public static bool operator !=(RuntimeTypeHandle left, object right) { return !left.Equals(right); } 

        public static bool operator !=(object left, RuntimeTypeHandle right) { return !right.Equals(left); } 
/* 
        internal new Type GetType()
        { 
            Console.WriteLine("RuntimeTypeHandle.GetType() called");
            throw new Exception("RuntimeTypeHandle.GetType() called. Chances are you want to call GetRuntimeType()");
            return base.GetType();
        } 
*/
        private const int MAX_CLASS_NAME = 1024; 
        internal static readonly RuntimeTypeHandle EmptyHandle = new RuntimeTypeHandle(null); 

        // this is the TypeHandle/MethodTable for the type 
        private IntPtr m_ptr;

        public override int GetHashCode()
        { 
            return m_ptr.GetHashCode();
        } 
 
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        public override bool Equals(object obj) 
        {
            if(!(obj is RuntimeTypeHandle))
                return false;
 
            RuntimeTypeHandle handle =(RuntimeTypeHandle)obj;
            return handle.m_ptr == m_ptr; 
        } 

        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] 
        public bool Equals(RuntimeTypeHandle handle)
        {
            return handle.m_ptr == m_ptr;
        } 

        public IntPtr Value { get { return m_ptr; } } 
 
        internal RuntimeTypeHandle(void* rth)
        { 
            m_ptr = new IntPtr(rth);
        }

        internal bool IsNullHandle() 
        {
            return m_ptr.ToPointer() == null; 
        } 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
 	    internal static extern Object CreateInstance(RuntimeType type, bool publicOnly, bool noCheck, ref bool canBeCached, ref RuntimeMethodHandle ctor, ref bool bNeedSecurityCheck);

        [MethodImplAttribute(MethodImplOptions.InternalCall)]
	    internal extern Object CreateCaInstance(RuntimeMethodHandle ctor); 

	    [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern Object Allocate(); 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern Object CreateInstanceForAnotherGenericParameter(Type genericParameter);

        internal RuntimeType GetRuntimeType()
        { 
            if(!IsNullHandle())
                return(System.RuntimeType)Type.GetTypeFromHandle(this); 
            else 
                return null;
        } 

        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern CorElementType GetCorElementType();
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern void* _GetAssemblyHandle(); 
        internal AssemblyHandle GetAssemblyHandle() 
        {
            return new AssemblyHandle(_GetAssemblyHandle()); 
        }

        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] 
        private extern void* _GetModuleHandle();
 
        [CLSCompliant(false)] 
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        public ModuleHandle GetModuleHandle() 
        {
            return new ModuleHandle(_GetModuleHandle());
        }
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern void* _GetBaseTypeHandle(); 
        internal RuntimeTypeHandle GetBaseTypeHandle() 
        {
            return new RuntimeTypeHandle(_GetBaseTypeHandle()); 
        }

        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern TypeAttributes GetAttributes(); 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        private extern void* _GetElementType(); 
        internal RuntimeTypeHandle GetElementType()
        { 
            return new RuntimeTypeHandle(_GetElementType());
        }

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern RuntimeTypeHandle GetCanonicalHandle();
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern int GetArrayRank();
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern int GetToken();

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        private extern void* _GetMethodAt(int slot);
        internal RuntimeMethodHandle GetMethodAt(int slot) 
        { 
            return new RuntimeMethodHandle(_GetMethodAt(slot));
        } 

        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern void* _GetMethodDescChunk();
        internal MethodDescChunkHandle GetMethodDescChunk() 
        {
            return new MethodDescChunkHandle(_GetMethodDescChunk()); 
        } 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern bool GetFields(int** result, int* count);

        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern RuntimeTypeHandle[] GetInterfaces(); 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern RuntimeTypeHandle[] GetConstraints(); 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern IntPtr GetGCHandle(GCHandleType type);

        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern void FreeGCHandle(IntPtr handle); 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        private extern void* _GetMethodFromToken(int tkMethodDef); 
        internal RuntimeMethodHandle GetMethodFromToken(int tkMethodDef)
        { 
            return new RuntimeMethodHandle(_GetMethodFromToken(tkMethodDef));
        }

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern int GetNumVtableSlots();
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern int GetInterfaceMethodSlots();
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern int GetFirstSlotForInterface(IntPtr interfaceHandle);
        internal int GetFirstSlotForInterface(RuntimeTypeHandle interfaceHandle)
        { 
            return GetFirstSlotForInterface(interfaceHandle.Value);
        } 
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern int GetInterfaceMethodImplementationSlot(IntPtr interfaceHandle, IntPtr interfaceMethodHandle); 
        internal int GetInterfaceMethodImplementationSlot(RuntimeTypeHandle interfaceHandle, RuntimeMethodHandle interfaceMethodHandle)
        {
            return GetInterfaceMethodImplementationSlot(interfaceHandle.Value, interfaceMethodHandle.Value);
        } 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern bool IsComObject(bool isGenericCOM); 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern bool IsContextful();

        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern bool IsVisible(); 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern bool _IsVisibleFromModule(IntPtr module); 
        internal bool IsVisibleFromModule(ModuleHandle module)
        { 
            return _IsVisibleFromModule((IntPtr)module.Value);
        }

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern bool HasProxyAttribute();
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern string ConstructName(bool nameSpace, bool fullInst, bool assembly);
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern void* _GetUtf8Name();

        internal Utf8String GetUtf8Name() 
        {
            return new Utf8String(_GetUtf8Name()); 
        } 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        private extern bool CanCastTo(IntPtr target);
        internal bool CanCastTo(RuntimeTypeHandle target)
        {
            return CanCastTo(target.Value); 
        }
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern RuntimeTypeHandle GetDeclaringType();
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern void* _GetDeclaringMethod();
        internal RuntimeMethodHandle GetDeclaringMethod()
        { 
            return new RuntimeMethodHandle(_GetDeclaringMethod());
        } 
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern void* _GetDefaultConstructor(); 
        internal RuntimeMethodHandle GetDefaultConstructor()
        {
            return new RuntimeMethodHandle(_GetDefaultConstructor());
        } 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern bool SupportsInterface(object target); 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern static void* _GetTypeByName(string name, bool throwOnError, bool ignoreCase, bool reflectionOnly, ref StackCrawlMark stackMark, bool loadTypeFromPartialName);
        internal static RuntimeTypeHandle GetTypeByName(string name, bool throwOnError, bool ignoreCase, bool reflectionOnly, ref StackCrawlMark stackMark)
        {
            if (name == null || name.Length == 0) 
            {
                if (throwOnError) 
                    throw new TypeLoadException(Environment.GetResourceString("Arg_TypeLoadNullStr")); 

                return new RuntimeTypeHandle(); 
            }

            return new RuntimeTypeHandle(_GetTypeByName(name, throwOnError, ignoreCase, reflectionOnly, ref stackMark, false));
        } 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern static void* _GetTypeByNameUsingCARules(string name, IntPtr scope); 
        internal static Type GetTypeByNameUsingCARules(string name, Module scope)
        { 
            if (name == null || name.Length == 0)
                throw new ArgumentException();

            return new RuntimeTypeHandle(_GetTypeByNameUsingCARules(name, (IntPtr)scope.GetModuleHandle().Value)).GetRuntimeType(); 
        }
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern RuntimeTypeHandle[] GetInstantiation();
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern void* _Instantiate(RuntimeTypeHandle[] inst);
        internal RuntimeTypeHandle Instantiate(RuntimeTypeHandle[] inst)
        { 
            return new RuntimeTypeHandle(_Instantiate(inst));
        } 
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern void* _MakeArray(int rank); 
        internal RuntimeTypeHandle MakeArray(int rank)
        {
            return new RuntimeTypeHandle(_MakeArray(rank));
        } 
/*
        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        private static extern void* _GetCallersType(ref StackCrawlMark stackMark); 
        internal static RuntimeTypeHandle GetCallersType(ref StackCrawlMark stackMark)
        { 
            return new RuntimeTypeHandle(_GetCallersType(ref stackMark));
        }
*/
        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        private extern void* _MakeSZArray();
        internal RuntimeTypeHandle MakeSZArray() 
        { 
            return new RuntimeTypeHandle(_MakeSZArray());
        } 

        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern void* _MakeByRef();
        internal RuntimeTypeHandle MakeByRef() 
        {
            return new RuntimeTypeHandle(_MakeByRef()); 
        } 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        private extern void* _MakePointer();
        internal RuntimeTypeHandle MakePointer()
        {
            return new RuntimeTypeHandle(_MakePointer()); 
        }
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern bool HasInstantiation();
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern void* _GetGenericTypeDefinition();
        internal RuntimeTypeHandle GetGenericTypeDefinition()
        { 
            return new RuntimeTypeHandle(_GetGenericTypeDefinition());
        } 
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern bool IsGenericTypeDefinition(); 

        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern bool IsGenericVariable();
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern int GetGenericVariableIndex(); 
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern bool ContainsGenericVariables(); 

        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern bool SatisfiesConstraints(RuntimeTypeHandle[] typeContext, RuntimeTypeHandle[] methodContext, RuntimeTypeHandle toType);
 
        private RuntimeTypeHandle(SerializationInfo info, StreamingContext context)
        { 
            if(info == null) 
                throw new ArgumentNullException("info");
 
            Type m = (RuntimeType)info.GetValue("TypeObj", typeof(RuntimeType));

            m_ptr = m.TypeHandle.Value;
 
            if(m_ptr.ToPointer() == null)
                throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientState")); 
        } 

        public void GetObjectData(SerializationInfo info, StreamingContext context) 
        {
            if(info == null)
                throw new ArgumentNullException("info");
 
            if(m_ptr.ToPointer() == null)
                throw new SerializationException(Environment.GetResourceString("Serialization_InvalidFieldState")); 
 
            RuntimeType type = (RuntimeType)Type.GetTypeFromHandle(this);
 
            info.AddValue("TypeObj", type, typeof(RuntimeType));
        }
    }
 
    [Serializable()]
[System.Runtime.InteropServices.ComVisible(true)] 
    public unsafe struct RuntimeMethodHandle : ISerializable 
    {
        internal static RuntimeMethodHandle EmptyHandle { get { return new RuntimeMethodHandle(null); } } 

        private IntPtr m_ptr;

        internal RuntimeMethodHandle(void* pMethod) 
        {
            m_ptr = new IntPtr(pMethod); 
        } 

        internal RuntimeMethodHandle(IntPtr pMethod) 
        {
            m_ptr = pMethod;
        }
 
        // ISerializable interface
        private RuntimeMethodHandle(SerializationInfo info, StreamingContext context) 
        { 
            if(info == null)
                throw new ArgumentNullException("info"); 

            MethodInfo m =(RuntimeMethodInfo)info.GetValue("MethodObj", typeof(RuntimeMethodInfo));

            m_ptr = m.MethodHandle.Value; 

            if(m_ptr.ToPointer() == null) 
                throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientState")); 
        }
 
        public void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            if (info == null)
                throw new ArgumentNullException("info"); 

            if (m_ptr.ToPointer() == null) 
                throw new SerializationException(Environment.GetResourceString("Serialization_InvalidFieldState")); 

            RuntimeMethodInfo methodInfo = (RuntimeMethodInfo)RuntimeType.GetMethodBase(this); 

            info.AddValue("MethodObj", methodInfo, typeof(RuntimeMethodInfo));
        }
 
        public IntPtr Value { get {  return m_ptr; } }
 
        public override int GetHashCode() 
        {
            return m_ptr.GetHashCode(); 
        }

        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        public override bool Equals(object obj) 
        {
            if (!(obj is RuntimeMethodHandle)) 
                return false; 

            RuntimeMethodHandle handle = (RuntimeMethodHandle)obj; 

            return handle.m_ptr == m_ptr;
        }
 
        public static bool operator ==(RuntimeMethodHandle left, RuntimeMethodHandle right)
        { 
            return left.Equals(right); 
        }
 
        public static bool operator !=(RuntimeMethodHandle left, RuntimeMethodHandle right)
        {
            return !left.Equals(right);
        } 

        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] 
        public bool Equals(RuntimeMethodHandle handle) 
        {
            return handle.m_ptr == m_ptr; 
        }

        internal bool IsNullHandle()
        { 
            return m_ptr.ToPointer() == null;
        } 
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        public extern IntPtr GetFunctionPointer(); 

        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private unsafe extern void _CheckLinktimeDemands(void* module, int metadataToken);
        internal void CheckLinktimeDemands(Module module, int metadataToken) 
        {
            _CheckLinktimeDemands((void*)module.ModuleHandle.Value, metadataToken); 
        } 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        private unsafe extern bool _IsVisibleFromModule(void* source);
        internal bool IsVisibleFromModule(Module source)
        {
            return _IsVisibleFromModule(source.ModuleHandle.Value); 
        }
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        private unsafe extern bool _IsVisibleFromType(IntPtr source);
        internal bool IsVisibleFromType(RuntimeTypeHandle source) 
        {
            return _IsVisibleFromType(source.Value);
        }
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private static extern void* _GetCurrentMethod(ref StackCrawlMark stackMark); 
        internal static RuntimeMethodHandle GetCurrentMethod(ref StackCrawlMark stackMark) 
        {
            return new RuntimeMethodHandle(_GetCurrentMethod(ref stackMark)); 
        }

        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern MethodAttributes GetAttributes(); 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern MethodImplAttributes GetImplAttributes(); 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern string ConstructInstantiation();

        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern RuntimeTypeHandle GetDeclaringType(); 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern int GetSlot(); 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern int GetMethodDef();

        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern string GetName(); 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        private extern void* _GetUtf8Name(); 

        internal Utf8String GetUtf8Name() 
        {
            return new Utf8String(_GetUtf8Name());
        }
 
        [DebuggerStepThroughAttribute]
        [Diagnostics.DebuggerHidden] 
        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        private extern object _InvokeMethodFast(
            object target, object[] arguments, ref SignatureStruct sig, MethodAttributes methodAttributes, RuntimeTypeHandle typeOwner); 

        [DebuggerStepThroughAttribute]
        [Diagnostics.DebuggerHidden]
        internal object InvokeMethodFast(object target, object[] arguments, Signature sig, MethodAttributes methodAttributes, RuntimeTypeHandle typeOwner) 
        {
              SignatureStruct _sig = sig.m_signature; 
              object obj1 = _InvokeMethodFast(target, arguments, ref _sig, methodAttributes, typeOwner); 
              sig.m_signature = _sig;
              return obj1; 
        }

        [DebuggerStepThroughAttribute]
        [Diagnostics.DebuggerHidden] 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern object _InvokeConstructor(object[] args, ref SignatureStruct signature, IntPtr declaringType); 
 
        [DebuggerStepThroughAttribute]
        [Diagnostics.DebuggerHidden] 
        internal object InvokeConstructor (object[] args, SignatureStruct signature, RuntimeTypeHandle declaringType)
        {
            return _InvokeConstructor(args, ref signature, declaringType.Value);
        } 

        [DebuggerStepThroughAttribute] 
        [Diagnostics.DebuggerHidden] 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern void _SerializationInvoke( 
            Object target, ref SignatureStruct declaringTypeSig, SerializationInfo info, StreamingContext context);

        [DebuggerStepThroughAttribute]
        [Diagnostics.DebuggerHidden] 
        internal void SerializationInvoke(
            Object target, SignatureStruct declaringTypeSig, SerializationInfo info, StreamingContext context) 
        { 
            _SerializationInvoke(target, ref declaringTypeSig, info, context);
        } 


        [MethodImplAttribute (MethodImplOptions.InternalCall)]
        internal extern bool IsILStub(); 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern RuntimeTypeHandle[] GetMethodInstantiation(); 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern bool HasMethodInstantiation();

        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern RuntimeMethodHandle GetInstantiatingStub(RuntimeTypeHandle declaringTypeHandle, RuntimeTypeHandle[] methodInstantiation); 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern RuntimeMethodHandle GetUnboxingStub(); 

        internal RuntimeMethodHandle GetInstantiatingStubIfNeeded(RuntimeTypeHandle declaringTypeHandle) 
        {
            return GetInstantiatingStub(declaringTypeHandle, null);
        }
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern RuntimeMethodHandle GetMethodFromCanonical(RuntimeTypeHandle declaringTypeHandle); 
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern bool IsGenericMethodDefinition(); 

        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern void* _GetTypicalMethodDefinition();
        internal RuntimeMethodHandle GetTypicalMethodDefinition() 
        {
            return new RuntimeMethodHandle(_GetTypicalMethodDefinition()); 
        } 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        private extern void* _StripMethodInstantiation();
        internal RuntimeMethodHandle StripMethodInstantiation()
        {
            return new RuntimeMethodHandle(_StripMethodInstantiation()); 
        }
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern bool IsDynamicMethod();
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern Resolver GetResolver();

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern void Destroy();
 
        [MethodImpl(MethodImplOptions.InternalCall)] 
        internal extern MethodBody _GetMethodBody(IntPtr declaringType);
        internal MethodBody GetMethodBody(RuntimeTypeHandle declaringType) 
        {
            return _GetMethodBody(declaringType.Value);
        }
 
        [MethodImpl(MethodImplOptions.InternalCall)]
        internal extern bool IsConstructor(); 
    } 

    [Serializable()] 
[System.Runtime.InteropServices.ComVisible(true)]
    public unsafe struct RuntimeFieldHandle : ISerializable
    {
        private IntPtr m_ptr; 

        internal RuntimeFieldHandle(void* pFieldHandle) 
        { 
            m_ptr = new IntPtr(pFieldHandle);
        } 

        public IntPtr Value { get { return m_ptr; } }

        internal bool IsNullHandle() 
        {
            return m_ptr.ToPointer() == null; 
        } 

        public override  int GetHashCode() 
        {
            return m_ptr.GetHashCode();
        }
 
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        public override  bool Equals(object obj) 
        { 
            if (!(obj is RuntimeFieldHandle))
                return false; 

            RuntimeFieldHandle handle = (RuntimeFieldHandle)obj;

            return handle.m_ptr == m_ptr; 
        }
 
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] 
        public unsafe bool Equals(RuntimeFieldHandle handle)
        { 
            return handle.m_ptr == m_ptr;
        }

        public static bool operator ==(RuntimeFieldHandle left, RuntimeFieldHandle right) 
        {
            return left.Equals(right); 
        } 

        public static bool operator !=(RuntimeFieldHandle left, RuntimeFieldHandle right) 
        {
            return !left.Equals(right);
        }
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern String GetName(); 
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern unsafe void* _GetUtf8Name(); 

        internal unsafe Utf8String GetUtf8Name() { return new Utf8String(_GetUtf8Name()); }

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern FieldAttributes GetAttributes();
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern RuntimeTypeHandle GetApproxDeclaringType();
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern int GetToken();

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern Object GetValue(Object instance, RuntimeTypeHandle fieldType, RuntimeTypeHandle declaringType, ref bool domainInitialized);
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern Object GetValueDirect(RuntimeTypeHandle fieldType, TypedReference obj, RuntimeTypeHandle contextType);
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern void SetValue(Object obj, Object value, RuntimeTypeHandle fieldType, FieldAttributes fieldAttr, RuntimeTypeHandle declaringType, ref bool domainInitialized);

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern void SetValueDirect(RuntimeTypeHandle fieldType, TypedReference obj, Object value, RuntimeTypeHandle contextType);
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern RuntimeFieldHandle GetStaticFieldForGenericType(RuntimeTypeHandle declaringType);
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern bool AcquiresContextFromThis();

        // ISerializable interface 
        private RuntimeFieldHandle(SerializationInfo info, StreamingContext context)
        { 
            if(info==null) 
                throw new ArgumentNullException("info");
 
            FieldInfo f =(RuntimeFieldInfo) info.GetValue("FieldObj", typeof(RuntimeFieldInfo));

            if( f == null)
                throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientState")); 

            m_ptr = f.FieldHandle.Value; 
 
            if (m_ptr.ToPointer() == null)
                throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientState")); 
        }

        public void GetObjectData(SerializationInfo info, StreamingContext context)
        { 
            if (info == null)
                throw new ArgumentNullException("info"); 
 
            if (m_ptr.ToPointer() == null)
                throw new SerializationException(Environment.GetResourceString("Serialization_InvalidFieldState")); 

            RuntimeFieldInfo fldInfo = (RuntimeFieldInfo)RuntimeType.GetFieldInfo(this);

            info.AddValue("FieldObj",fldInfo, typeof(RuntimeFieldInfo)); 
        }
    } 
 
    internal unsafe struct AssemblyHandle
    { 
        #region Private Data Members
        private IntPtr m_ptr;
        #endregion
 
        internal void* Value { get { return m_ptr.ToPointer(); } }
 
        #region Constructor 
        internal AssemblyHandle(void* pAssembly)
        { 
            m_ptr = new IntPtr(pAssembly);
        }
        #endregion
 
        #region Internal Members
 
        public override  int GetHashCode() 
        {
            return m_ptr.GetHashCode(); 
        }

        public override  bool Equals(object obj)
        { 
            if (!(obj is AssemblyHandle))
                return false; 
 
            AssemblyHandle handle = (AssemblyHandle)obj;
 
            return handle.m_ptr == m_ptr;
        }

        public unsafe bool Equals(AssemblyHandle handle) 
        {
            return handle.m_ptr == m_ptr; 
        } 

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern Assembly GetAssembly();

        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern void* _GetManifestModule(); 
        internal ModuleHandle GetManifestModule()
        { 
            return new ModuleHandle(_GetManifestModule()); 
        }
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern bool _AptcaCheck(IntPtr sourceAssembly);
        internal bool AptcaCheck(AssemblyHandle sourceAssembly)
        { 
            return _AptcaCheck((IntPtr)sourceAssembly.Value);
        } 
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern int GetToken(); 
        #endregion
    }

[System.Runtime.InteropServices.ComVisible(true)] 
    public unsafe struct ModuleHandle
    { 
        #region Public Static Members 
        public static readonly ModuleHandle EmptyHandle = new ModuleHandle(null);
        #endregion 

        #region Private Data Members
        private IntPtr m_ptr;
        #endregion 

        #region Constructor 
        internal ModuleHandle(void* pModule) 
        {
            m_ptr = new IntPtr(pModule); 
        }
        #endregion

        #region Internal FCalls 
        internal void* Value { get { return m_ptr.ToPointer(); } }
 
        internal bool IsNullHandle() 
        {
            return m_ptr.ToPointer() == null; 
        }

        public override  int GetHashCode()
        { 
            return m_ptr.GetHashCode();
        } 
 
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        public override bool Equals(object obj) 
        {
            if (!(obj is ModuleHandle))
                return false;
 
            ModuleHandle handle = (ModuleHandle)obj;
 
            return handle.m_ptr == m_ptr; 
        }
 
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        public unsafe bool Equals(ModuleHandle handle)
        {
            return handle.m_ptr == m_ptr; 
        }
 
        public static bool operator ==(ModuleHandle left, ModuleHandle right) 
        {
            return left.Equals(right); 
        }

        public static bool operator !=(ModuleHandle left, ModuleHandle right)
        { 
            return !left.Equals(right);
        } 
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal static extern RuntimeTypeHandle GetCallerType(ref StackCrawlMark stackMark); 

        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal static extern void* GetDynamicMethod(void* module, string name, byte[] sig, Resolver resolver);
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern int GetToken(); 
 
        internal static RuntimeTypeHandle[] CopyRuntimeTypeHandles(RuntimeTypeHandle[] inHandles)
        { 
            if (inHandles == null || inHandles.Length == 0) return inHandles;
            RuntimeTypeHandle[] outHandles = new RuntimeTypeHandle[inHandles.Length];
            for (int i=0; i < inHandles.Length; i++)
            { 
                outHandles[i] = inHandles[i];
            } 
            return outHandles; 
        }
 
        private void ValidateModulePointer()
        {
            // Make sure we have a valid Module to resolve against.
            if (IsNullHandle()) 
                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NullModuleHandle"));
        } 
 
        // SQL-CLR LKG9 Compiler dependency
        public RuntimeTypeHandle GetRuntimeTypeHandleFromMetadataToken(int typeToken) { return ResolveTypeHandle(typeToken); } 
        public RuntimeTypeHandle ResolveTypeHandle(int typeToken) { return ResolveTypeHandle(typeToken, null, null); }
        public RuntimeTypeHandle ResolveTypeHandle(int typeToken, RuntimeTypeHandle[] typeInstantiationContext, RuntimeTypeHandle[] methodInstantiationContext)
        {
            ValidateModulePointer(); 
            if (!GetMetadataImport().IsValidToken(typeToken))
                throw new ArgumentOutOfRangeException("metadataToken", 
                    String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_InvalidToken", typeToken, this))); 

            // defensive copy to be sure array is not mutated from the outside during processing 
            typeInstantiationContext = CopyRuntimeTypeHandles(typeInstantiationContext);
            methodInstantiationContext = CopyRuntimeTypeHandles(methodInstantiationContext);

            unsafe 
            {
                if (typeInstantiationContext == null || typeInstantiationContext.Length == 0) 
                { 
                    if (methodInstantiationContext == null || methodInstantiationContext.Length == 0)
                    { 
                        // no context
                        return ResolveType(typeToken, null, 0, null, 0);
                    }
                    // only method context available 
                    int instCount = methodInstantiationContext.Length;
                    fixed (RuntimeTypeHandle* instArgs = methodInstantiationContext) { 
                        return ResolveType(typeToken, null, 0, instArgs, instCount); 
                    }
                } 
                if (methodInstantiationContext == null || methodInstantiationContext.Length == 0)
                {
                    // only type context available
                    int instCount = typeInstantiationContext.Length; 
                    fixed (RuntimeTypeHandle* instArgs = typeInstantiationContext) {
                        return ResolveType(typeToken, instArgs, instCount, null, 0); 
                    } 
                }
                // pin both 
                int typeInstCount = typeInstantiationContext.Length;
                int methodInstCount = methodInstantiationContext.Length;
                fixed (RuntimeTypeHandle* typeInstArgs = typeInstantiationContext, methodInstArgs = methodInstantiationContext) {
                    return ResolveType(typeToken, typeInstArgs, typeInstCount, methodInstArgs, methodInstCount); 
                }
            } 
        } 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern unsafe RuntimeTypeHandle ResolveType(int typeToken, 
                                                            RuntimeTypeHandle* typeInstArgs,
                                                            int typeInstCount,
                                                            RuntimeTypeHandle* methodInstArgs,
                                                            int methodInstCount); 

        // SQL-CLR LKG9 Compiler dependency 
        public RuntimeMethodHandle GetRuntimeMethodHandleFromMetadataToken(int methodToken) { return ResolveMethodHandle(methodToken); } 
        public RuntimeMethodHandle ResolveMethodHandle(int methodToken) { return ResolveMethodHandle(methodToken, null, null); }
        public RuntimeMethodHandle ResolveMethodHandle(int methodToken, RuntimeTypeHandle[] typeInstantiationContext, RuntimeTypeHandle[] methodInstantiationContext) 
        {
            ValidateModulePointer();
            if (!GetMetadataImport().IsValidToken(methodToken))
                throw new ArgumentOutOfRangeException("metadataToken", 
                    String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_InvalidToken", methodToken, this)));
 
 
            // defensive copy to be sure array is not mutated from the outside during processing
            typeInstantiationContext = CopyRuntimeTypeHandles(typeInstantiationContext); 
            methodInstantiationContext = CopyRuntimeTypeHandles(methodInstantiationContext);

            unsafe
            { 
                if (typeInstantiationContext == null || typeInstantiationContext.Length == 0)
                { 
                    if (methodInstantiationContext == null || methodInstantiationContext.Length == 0) 
                    {
                        // no context 
                        return ResolveMethod(methodToken, null, 0, null, 0);
                    }
                    // only method context available
                    int instCount = methodInstantiationContext.Length; 
                    fixed (RuntimeTypeHandle* instArgs = methodInstantiationContext) {
                        return ResolveMethod(methodToken, null, 0, instArgs, instCount); 
                    } 
                }
                if (methodInstantiationContext == null || methodInstantiationContext.Length == 0) 
                {
                    // only type context available
                    int instCount = typeInstantiationContext.Length;
                    fixed (RuntimeTypeHandle* instArgs = typeInstantiationContext) { 
                        return ResolveMethod(methodToken, instArgs, instCount, null, 0);
                    } 
                } 
                // pin both
                int typeInstCount = typeInstantiationContext.Length; 
                int methodInstCount = methodInstantiationContext.Length;
                fixed (RuntimeTypeHandle* typeInstArgs = typeInstantiationContext, methodInstArgs = methodInstantiationContext) {
                    return ResolveMethod(methodToken, typeInstArgs, typeInstCount, methodInstArgs, methodInstCount);
                } 
            }
        } 
        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        private extern RuntimeMethodHandle ResolveMethod(int methodToken,
                                                        RuntimeTypeHandle* typeInstArgs, 
                                                        int typeInstCount,
                                                        RuntimeTypeHandle* methodInstArgs,
                                                        int methodInstCount);
 
        // SQL-CLR LKG9 Compiler dependency
        public RuntimeFieldHandle GetRuntimeFieldHandleFromMetadataToken(int fieldToken) { return ResolveFieldHandle(fieldToken); } 
        public RuntimeFieldHandle ResolveFieldHandle(int fieldToken) { return ResolveFieldHandle(fieldToken, null, null); } 
        public RuntimeFieldHandle ResolveFieldHandle(int fieldToken, RuntimeTypeHandle[] typeInstantiationContext, RuntimeTypeHandle[] methodInstantiationContext)
        { 
            ValidateModulePointer();
            if (!GetMetadataImport().IsValidToken(fieldToken))
                throw new ArgumentOutOfRangeException("metadataToken",
                    String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_InvalidToken", fieldToken, this))); 

            // defensive copy to be sure array is not mutated from the outside during processing 
            typeInstantiationContext = CopyRuntimeTypeHandles(typeInstantiationContext); 
            methodInstantiationContext = CopyRuntimeTypeHandles(methodInstantiationContext);
 
            unsafe
            {
                if (typeInstantiationContext == null || typeInstantiationContext.Length == 0)
                { 
                    if (methodInstantiationContext == null || methodInstantiationContext.Length == 0)
                    { 
                        // no context 
                        return ResolveField(fieldToken, null, 0, null, 0);
                    } 
                    // only method context available
                    int instCount = methodInstantiationContext.Length;
                    fixed (RuntimeTypeHandle* instArgs = methodInstantiationContext) {
                        return ResolveField(fieldToken, null, 0, instArgs, instCount); 
                    }
                } 
                if (methodInstantiationContext == null || methodInstantiationContext.Length == 0) 
                {
                    // only type context available 
                    int instCount = typeInstantiationContext.Length;
                    fixed (RuntimeTypeHandle* instArgs = typeInstantiationContext) {
                        return ResolveField(fieldToken, instArgs, instCount, null, 0);
                    } 
                }
                // pin both 
                int typeInstCount = typeInstantiationContext.Length; 
                int methodInstCount = methodInstantiationContext.Length;
                fixed (RuntimeTypeHandle* typeInstArgs = typeInstantiationContext, methodInstArgs = methodInstantiationContext) { 
                    return ResolveField(fieldToken, typeInstArgs, typeInstCount, methodInstArgs, methodInstCount);
                }
            }
        } 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern RuntimeFieldHandle ResolveField(int fieldToken, 
                                                      RuntimeTypeHandle* typeInstArgs, 
                                                      int typeInstCount,
                                                      RuntimeTypeHandle* methodInstArgs, 
                                                      int methodInstCount);

//        [MethodImplAttribute(MethodImplOptions.InternalCall)]
//        private extern void* _GetAssemblyHandle(); 
//        internal AssemblyHandle GetAssemblyHandle()
//        { 
//            return new AssemblyHandle(_GetAssemblyHandle()); 
//        }
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern Module GetModule();

        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern void* _GetModuleTypeHandle();
 
        internal RuntimeTypeHandle GetModuleTypeHandle() 
        {
            return new RuntimeTypeHandle(_GetModuleTypeHandle()); 
        }

        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern void _GetPEKind(out int peKind, out int machine); 

        // making this internal, used by Module.GetPEKind 
        internal void GetPEKind(out PortableExecutableKinds peKind, out ImageFileMachine machine) 
        {
            int _peKind; 
            int _machine;

            _GetPEKind(out _peKind, out _machine);
 
            peKind = (PortableExecutableKinds)_peKind;
            machine = (ImageFileMachine)_machine; 
        } 

	[MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern int _GetMDStreamVersion();
        public int MDStreamVersion
        {
 	    get {  return _GetMDStreamVersion(); } 
        }
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern void * _GetMetadataImport();
        internal MetadataImport GetMetadataImport() 
        {
            return new MetadataImport((IntPtr)_GetMetadataImport());
        }
        #endregion 
    }
 
 
    internal unsafe class Signature
    { 
        #region Implict Cast Operators
        public static implicit operator SignatureStruct(Signature pThis) { return pThis.m_signature; }
        #endregion
 
        #region Definitions
        internal enum MdSigCallingConvention : byte 
        { 
            Generics            = 0x10,
            HasThis             = 0x20, 
            ExplicitThis        = 0x40,
            CallConvMask        = 0x0F,
            Default             = 0x00,
            C                   = 0x01, 
            StdCall             = 0x02,
            ThisCall            = 0x03, 
            FastCall            = 0x04, 
            Vararg              = 0x05,
            Field               = 0x06, 
            LocalSig            = 0x07,
            Property            = 0x08,
            Unmgd               = 0x09,
            GenericInst         = 0x0A, 
            Max                 = 0x0B,
        } 
        #endregion 

        #region FCalls 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private static extern void _GetSignature(
            ref SignatureStruct signature, // This parameter must be passed as a pointer to the stack to prevent GC holes
            void* pCorSig, int cCorSig, 
            IntPtr fieldHandle, IntPtr methodHandle, IntPtr declaringTypeHandle);
        private static void GetSignature( 
            ref SignatureStruct signature, // This parameter must be passed as a pointer to the stack to prevent GC holes 
            void* pCorSig, int cCorSig,
            RuntimeFieldHandle fieldHandle, RuntimeMethodHandle methodHandle, RuntimeTypeHandle declaringTypeHandle) 
        {
            _GetSignature(ref signature, pCorSig, cCorSig, fieldHandle.Value, methodHandle.Value, declaringTypeHandle.Value);
        }
 
        internal static void GetSignatureForDynamicMethod(
            ref SignatureStruct signature, // This parameter must be passed as a pointer to the stack to prevent GC holes 
            RuntimeMethodHandle methodHandle) 
        {
            _GetSignature(ref signature, null, 0, (IntPtr)0, methodHandle.Value, (IntPtr)0); 
        }

        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private static extern void GetCustomModifiers( 
            ref SignatureStruct signature, int parameter,
            out RuntimeTypeHandle[] required, out RuntimeTypeHandle[] optional); 
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private static extern bool CompareSig(ref SignatureStruct left, ref SignatureStruct right); 
        #endregion

        #region Private Data Members
        internal SignatureStruct m_signature; 
        #endregion
 
        #region Constructors 
        public Signature (
            RuntimeMethodHandle method, 
            RuntimeTypeHandle[] arguments,
            RuntimeTypeHandle returnType,
            CallingConventions callingConvention)
        { 
            SignatureStruct pinnedSignature = new SignatureStruct(
                method, arguments, returnType, callingConvention); 
            GetSignatureForDynamicMethod(ref pinnedSignature, method); 
            m_signature = pinnedSignature;
        } 

        public Signature(RuntimeMethodHandle methodHandle, RuntimeTypeHandle declaringTypeHandle)
        {
            SignatureStruct pinnedSignature = new SignatureStruct(); 
            GetSignature(ref pinnedSignature, null, 0, new RuntimeFieldHandle(null), methodHandle, declaringTypeHandle);
            m_signature = pinnedSignature; 
        } 

        public Signature(RuntimeFieldHandle fieldHandle, RuntimeTypeHandle declaringTypeHandle) 
        {
            SignatureStruct pinnedSignature = new SignatureStruct();
            GetSignature(ref pinnedSignature, null, 0, fieldHandle, new RuntimeMethodHandle(null), declaringTypeHandle);
            m_signature = pinnedSignature; 
        }
 
        public Signature(void* pCorSig, int cCorSig, RuntimeTypeHandle declaringTypeHandle) 
        {
            SignatureStruct pinnedSignature = new SignatureStruct(); 
            GetSignature(ref pinnedSignature, pCorSig, cCorSig, new RuntimeFieldHandle(null), new RuntimeMethodHandle(null), declaringTypeHandle);
            m_signature = pinnedSignature;
        }
        #endregion 

        #region Internal Members 
        internal CallingConventions CallingConvention { get { return m_signature.m_managedCallingConvention &(CallingConventions)0x000000FF; } } 
        internal RuntimeTypeHandle[] Arguments { get { return m_signature.m_arguments; } }
        internal RuntimeTypeHandle ReturnTypeHandle { get { return m_signature.m_returnTypeORfieldType; } } 
        internal RuntimeTypeHandle FieldTypeHandle { get { return m_signature.m_returnTypeORfieldType; } }
        internal bool DiffSigs(object o)
        {
            if(o is Signature) 
            {
                Signature sig = o as Signature; 
                SignatureStruct pinnedSig = sig; 
                SignatureStruct pinnedThis = this;
                return CompareSig(ref pinnedThis, ref pinnedSig); 
            }

            return false;
        } 

        public Type[] GetCustomModifiers(int position, bool required) 
        { 
            RuntimeTypeHandle[] req = null, opt = null;
 
            SignatureStruct pinnedSig = this;
            GetCustomModifiers(ref pinnedSig, position, out req, out opt);

            Type[] custMod = new Type[required ? req.Length : opt.Length]; 

            if(required) 
            { 
                for(int i = 0; i < custMod.Length; i++)
                    custMod[i] = req[i].GetRuntimeType(); 
            }
            else
            {
                for(int i = 0; i < custMod.Length; i++) 
                    custMod[i] = opt[i].GetRuntimeType();
            } 
 
            return custMod;
        } 
        #endregion
    }

    // 
    // WARNING: SignatureStructs should not be share between methods! Call targets are cachded!
    // 
    internal unsafe struct SignatureStruct 
    {
        #region Constructor 
        public SignatureStruct (
            RuntimeMethodHandle method,
            RuntimeTypeHandle[] arguments,
            RuntimeTypeHandle returnType, 
            CallingConventions callingConvention)
        { 
            m_pMethod = method; 
            m_arguments = arguments;
            m_returnTypeORfieldType = returnType; 
            m_managedCallingConvention = callingConvention;
            m_sig = null;
            m_pCallTarget = null;
            m_csig = 0; 
            m_numVirtualFixedArgs = 0;
            m_64bitpad = 0; 
            m_declaringType = new RuntimeTypeHandle(); 
        }
        #endregion 

        #region Pivate Data Members
        internal RuntimeTypeHandle[] m_arguments;
        internal void* m_sig; 
        internal void* m_pCallTarget;
        internal CallingConventions m_managedCallingConvention; 
        internal int m_csig; 
        internal int m_numVirtualFixedArgs;
        internal int m_64bitpad; 
        internal RuntimeMethodHandle m_pMethod;
        internal RuntimeTypeHandle m_declaringType;
        internal RuntimeTypeHandle m_returnTypeORfieldType;
        #endregion 
    }
 
 
    internal abstract class Resolver
    { 
        internal struct CORINFO_EH_CLAUSE
        {
            internal int Flags;
            internal int TryOffset; 
            internal int TryLength;
            internal int HandlerOffset; 
            internal int HandlerLength; 
            internal int ClassTokenOrFilterOffset;
        } 

        internal const int COR_ILEXCEPTION_CLAUSE_CACHED_CLASS     = 0x10000000;
        internal const int COR_ILEXCEPTION_CLAUSE_MUST_CACHE_CLASS = 0x20000000;
 
        internal const int TypeToken    = 0x1;
        internal const int MethodToken  = 0x2; 
        internal const int FieldToken   = 0x4; 

        // ILHeader info 
        internal abstract void GetJitContext(ref int securityControlFlags,
                                             ref RuntimeTypeHandle typeOwner,
                                             ref CompressedStack securityContext);
        internal abstract byte[] GetCodeInfo(ref int stackSize, ref int initLocals, ref int EHCount); 
        internal abstract byte[] GetLocalsSignature();
        internal abstract unsafe void GetEHInfo(int EHNumber, void* exception); 
        internal abstract unsafe byte[] GetRawEHInfo(); 
        // token resolution
        internal abstract String GetStringLiteral(int token); 
        internal abstract unsafe void* ResolveToken(int token);
        internal abstract unsafe int ParentToken(int token);
        internal abstract byte[] ResolveSignature(int token, int fromMethod);
        internal abstract int IsValidToken(int token); 
        internal abstract unsafe void* GetInstantiationInfo(int token);
        // 
        internal abstract MethodInfo GetDynamicMethod(); 
    }
 
}
                        

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