C# EETypePtr.ToPointer方法代码示例

        public unsafe static object RhBox(EETypePtr pEEType, ref byte data)
        {
            EEType* ptrEEType = (EEType*)pEEType.ToPointer();
            int dataOffset = 0;
            object result;

            // If we're boxing a Nullable<T> then either box the underlying T or return null (if the
            // nullable's value is empty).
            if (ptrEEType->IsNullable)
            {
                // The boolean which indicates whether the value is null comes first in the Nullable struct.
                if (data == 0)
                    return null;

                // Switch type we're going to box to the Nullable<T> target type and advance the data pointer
                // to the value embedded within the nullable.
                dataOffset = ptrEEType->NullableValueOffset;
                ptrEEType = ptrEEType->NullableType;
            }

#if FEATURE_64BIT_ALIGNMENT
            if (ptrEEType->RequiresAlign8)
            {
                result = InternalCalls.RhpNewFastMisalign(ptrEEType);
            }
            else
#endif // FEATURE_64BIT_ALIGNMENT
            {
                result = InternalCalls.RhpNewFast(ptrEEType);
            }
            InternalCalls.RhpBox(result, ref Unsafe.Add(ref data, dataOffset));
            return result;
        }

        public unsafe static object RhNewArray(EETypePtr pEEType, int length)
        {
            EEType* ptrEEType = (EEType*)pEEType.ToPointer();
#if FEATURE_64BIT_ALIGNMENT
            if (ptrEEType->RequiresAlign8)
            {
                return InternalCalls.RhpNewArrayAlign8(ptrEEType, length);
            }
            else
#endif // FEATURE_64BIT_ALIGNMENT
            {
                return InternalCalls.RhpNewArray(ptrEEType, length);
            }
        }

        public unsafe static object RhNewObject(EETypePtr pEEType)
        {
            EEType* ptrEEType = (EEType*)pEEType.ToPointer();
#if FEATURE_64BIT_ALIGNMENT
            if (ptrEEType->RequiresAlign8)
            {
                if (ptrEEType->IsValueType)
                    return InternalCalls.RhpNewFastMisalign(ptrEEType);
                if (ptrEEType->IsFinalizable)
                    return InternalCalls.RhpNewFinalizableAlign8(ptrEEType);
                return InternalCalls.RhpNewFastAlign8(ptrEEType);
            }
            else
#endif // FEATURE_64BIT_ALIGNMENT
            {
                if (ptrEEType->IsFinalizable)
                    return InternalCalls.RhpNewFinalizable(ptrEEType);
                return InternalCalls.RhpNewFast(ptrEEType);
            }
        }

 static public unsafe bool RhBoxAndNullCheck(ref byte data, EETypePtr pEEType)
 {
     EEType* ptrEEType = (EEType*)pEEType.ToPointer();
     if (ptrEEType->IsValueType)
         return true;
     else
         return Unsafe.As<byte, Object>(ref data) != null;
 }

        public static unsafe RhEETypeClassification RhGetEETypeClassification(EETypePtr ptrEEType)
        {
            EEType* pEEType = ptrEEType.ToPointer();

            if (pEEType->IsArray)
                return RhEETypeClassification.Array;

            if (pEEType->IsGeneric)
                return RhEETypeClassification.Generic;

            if (pEEType->IsGenericTypeDefinition)
                return RhEETypeClassification.GenericTypeDefinition;

            if (pEEType->IsPointerTypeDefinition)
                return RhEETypeClassification.UnmanagedPointer;

            return RhEETypeClassification.Regular;
        }

 public static unsafe bool RhHasReferenceFields(EETypePtr ptrEEType)
 {
     EEType* pEEType = ptrEEType.ToPointer();
     return pEEType->HasReferenceFields;
 }

 public static unsafe bool RhIsNullable(EETypePtr ptrEEType)
 {
     EEType* pEEType = ptrEEType.ToPointer();
     return pEEType->IsNullable;
 }

 public static unsafe bool RhIsArray(EETypePtr ptrEEType)
 {
     EEType* pEEType = ptrEEType.ToPointer();
     return pEEType->IsArray;
 }

 public static unsafe bool RhHasCctor(EETypePtr ptrEEType)
 {
     EEType* pEEType = ptrEEType.ToPointer();
     return pEEType->HasCctor;
 }

 public static unsafe void RhSetInterface(EETypePtr ptrEEType, int index, EETypePtr ptrInterfaceEEType)
 {
     EEType* pEEType = ptrEEType.ToPointer();
     EEType* pInterfaceEEType = ptrInterfaceEEType.ToPointer();
     pEEType->InterfaceMap[index].InterfaceType = pInterfaceEEType;
 }

        public unsafe static void RhUnboxAny(object o, ref Hack_o_p data, EETypePtr pUnboxToEEType)
        {
            EEType* ptrUnboxToEEType = (EEType*)pUnboxToEEType.ToPointer();
            if (ptrUnboxToEEType->IsValueType)
            {
                // HACK: we would really want to take the address of o here,
                // but the rules of the C# language don't let us do that,
                // so we arrive at the same result by taking the address of p
                // and going back one pointer-sized unit
                fixed (IntPtr* pData = &data.p)
                {
                    bool isValid = false;

                    if (ptrUnboxToEEType->IsNullable)
                        isValid = (o == null) || (o.EEType == ptrUnboxToEEType->GetNullableType());
                    else
                        isValid = (o != null && o.EEType->CorElementType == ptrUnboxToEEType->CorElementType && TypeCast.IsInstanceOfClass(o, ptrUnboxToEEType) != null);

                    if (!isValid)
                    {
                        // Throw the invalid cast exception defined by the classlib, using the input unbox EEType* 
                        // to find the correct classlib.

                        ExceptionIDs exID = o == null ? ExceptionIDs.NullReference : ExceptionIDs.InvalidCast;

                        IntPtr addr = ptrUnboxToEEType->GetAssociatedModuleAddress();
                        Exception e = EH.GetClasslibException(exID, addr);

                        BinderIntrinsics.TailCall_RhpThrowEx(e);
                    }
                    InternalCalls.RhUnbox(o, pData - 1, ptrUnboxToEEType);
                }
            }
            else
                data.o = o;
        }

 public unsafe static object RhBoxAny(ref Hack_o_p data, EETypePtr pEEType)
 {
     EEType* ptrEEType = (EEType*)pEEType.ToPointer();
     if (ptrEEType->IsValueType)
     {
         // HACK: we would really want to take the address of o here,
         // but the rules of the C# language don't let us do that,
         // so we arrive at the same result by taking the address of p
         // and going back one pointer-sized unit
         fixed (IntPtr* pData = &data.p)
             return RhBox(pEEType, pData - 1);
     }
     else
         return data.o;
 }

 static unsafe public bool AreTypesEquivalent(EETypePtr pType1, EETypePtr pType2)
 {
     return (AreTypesEquivalentInternal(pType1.ToPointer(), pType2.ToPointer()));
 }

        public static void FailedAllocation(EETypePtr pEEType, bool fIsOverflow)
        {
            ExceptionIDs exID = fIsOverflow ? ExceptionIDs.Overflow : ExceptionIDs.OutOfMemory;

            // Throw the out of memory exception defined by the classlib, using the input EEType* 
            // to find the correct classlib.

            throw pEEType.ToPointer()->GetClasslibException(exID);
        }

 public unsafe static object RhBoxAny(ref byte data, EETypePtr pEEType)
 {
     EEType* ptrEEType = (EEType*)pEEType.ToPointer();
     if (ptrEEType->IsValueType)
     {
         return RhBox(pEEType, ref data);
     }
     else
     {
         return Unsafe.As<byte, Object>(ref data);
     }
 }