TypedReference.cs source code in C# .NET

Source code for the .NET framework in C#



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

                            // ==++== 
//   Copyright (c) Microsoft Corporation.  All rights reserved.
// ==--== 
namespace System {
    // TypedReference is basically only ever seen on the call stack, and in param arrays. 
    //  These are blob that must be dealt with by the compiler.
    using System; 
    using System.Reflection;
    using System.Runtime.CompilerServices;
    using CultureInfo = System.Globalization.CultureInfo;
    using FieldInfo = System.Reflection.FieldInfo; 
    using System.Security.Permissions;
    public struct TypedReference 
        private IntPtr Value;
        private IntPtr Type;
        [ReflectionPermission(SecurityAction.LinkDemand, MemberAccess=true)] 
        public static TypedReference MakeTypedReference(Object target, FieldInfo[] flds) { 
            if (target == null)
                throw new ArgumentNullException("target"); 
            if (flds == null)
                throw new ArgumentNullException("flds");
            if (flds.Length == 0)
                throw new ArgumentException(Environment.GetResourceString("Arg_ArrayZeroError")); 
            else {
                RuntimeFieldHandle[] fields = new RuntimeFieldHandle[flds.Length]; 
          // For proper handling of Nullable don't change GetType() to something like 'IsAssignableFrom' 
          // Currently we can't make a TypedReference to fields of Nullable, which is fine.
                Type targetType = target.GetType(); 
                for (int i = 0; i < flds.Length; i++) {
                    FieldInfo field = flds[i];
                    if (!(field is RuntimeFieldInfo))
                        throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeFieldInfo")); 
                    else if (field.IsInitOnly || field.IsStatic)
                        throw new ArgumentException(Environment.GetResourceString("Argument_TypedReferenceInvalidField")); 
                    if (targetType != field.DeclaringType && !targetType.IsSubclassOf(field.DeclaringType))
                        throw new MissingMemberException(Environment.GetResourceString("MissingMemberTypeRef")); 

                    Type fieldType = field.FieldType;
                    if (fieldType.IsPrimitive)
                        throw new ArgumentException(Environment.GetResourceString("Arg_TypeRefPrimitve")); 

                    if (i < flds.Length - 1) 
                        if (!fieldType.IsValueType) 
                            throw new MissingMemberException(Environment.GetResourceString("MissingMemberNestErr"));
                    fields[i] = field.FieldHandle;
                    targetType = fieldType;
                TypedReference result = new TypedReference (); 
                // reference to TypedReference is banned, so have to pass result as pointer
                    InternalMakeTypedReference(&result, target, fields, targetType.TypeHandle);
                return result;
        // reference to TypedReference is banned, so have to pass result as pointer 
        private unsafe static extern void InternalMakeTypedReference(void * result, Object target, RuntimeFieldHandle[] flds, RuntimeTypeHandle lastFieldType); 

        public override int GetHashCode() 
            if (Type == IntPtr.Zero)
                return 0;
                return __reftype(this).GetHashCode();
        public override bool Equals(Object o)
            throw new NotSupportedException(Environment.GetResourceString("NotSupported_NYI"));

        public unsafe static Object ToObject(TypedReference value) 
            return InternalToObject(&value); 

        internal unsafe extern static Object InternalToObject(void * value);

        internal bool IsNull
                return Value.IsNull() && Type.IsNull(); 

        public static Type GetTargetType (TypedReference value)
            return __reftype(value); 
        public static RuntimeTypeHandle TargetTypeToken (TypedReference value) 
            return __reftype(value).TypeHandle; 

        //  This may cause the type to be changed.
        public unsafe static void SetTypedReference(TypedReference target, Object value)
            InternalSetTypedReference(&target, value); 
        internal unsafe extern static void InternalSetTypedReference(void * target, Object value);




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