/// <summary>
        /// 指定したオブジェクトに指定した型のハンドルを割り当てます
        /// </summary>
        /// <param name="value">GCの対象からはずすオブジェクト</param>
        /// <param name="type">作成する System.Runtime.InteropServices.GCHandle の型を示す、System.Runtime.InteropServices.GCHandleType 値の 1 つ</param>
#else
        /// <summary>
        /// 
        /// </summary>
        /// <param name="value"></param>
        /// <param name="type"></param>
#endif
        public ScopedGCHandle(object value, GCHandleType type)
        {
            if (value != null)
            {
                this.Handle = GCHandle.Alloc(value, type);
            }
        }

 internal static IntPtr RhHandleAlloc(Object value, GCHandleType type)
 {
     IntPtr h = RhpHandleAlloc(value, type);
     if (h == IntPtr.Zero)
         throw new OutOfMemoryException();
     return h;
 }

		internal GCHandle(object value, GCHandleType type)
		{
			// MS does not crash/throw on (most) invalid GCHandleType values (except -1)
			if ((type < GCHandleType.Weak) || (type > GCHandleType.Pinned))
				type = GCHandleType.Normal;
			handle = GetTargetHandle (value, 0, type);
		}

        // Allocate a handle storing the object and the type.
        private UnsafeGCHandle(Object value, GCHandleType type)
        {
            Debug.Assert((uint)type <= (uint)GCHandleType.Normal, "unexpected handle type");

            _handle = InternalCalls.RhpHandleAlloc(value, type);
            if (_handle == IntPtr.Zero)
                throw new OutOfMemoryException();
        }

        // Allocate a handle storing the object and the type.
        internal GCHandle(Object value, GCHandleType type)
		{
			m_handle = InternalAlloc(value, type);

			// Record if the handle is pinned.
			if (type == GCHandleType.Pinned)
                SetIsPinned();
		}  

        /// <summary>
        /// 指定したオブジェクトに指定した型のハンドルを割り当てます
        /// </summary>
        /// <param name="value">GCの対象からはずすオブジェクト</param>
        /// <param name="type">作成する System.Runtime.InteropServices.GCHandle の型を示す、System.Runtime.InteropServices.GCHandleType 値の 1 つ</param>
#else
        /// <summary>
        /// 
        /// </summary>
        /// <param name="value"></param>
        /// <param name="type"></param>
#endif
        public ScopedGCHandle(object value, GCHandleType type)
        {
            if (value != null)
            {
                handle = GCHandle.Alloc(value, type);
            }
            disposed = false;
        }

 internal GCHandle(object value, GCHandleType type)
 {
     if (type > GCHandleType.Pinned)
     {
         throw new ArgumentOutOfRangeException("type", Environment.GetResourceString("ArgumentOutOfRange_Enum"));
     }
     this.m_handle = InternalAlloc(value, type);
     if (type == GCHandleType.Pinned)
     {
         this.SetIsPinned();
     }
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="SafeGCHandle"/> class referring to the target in the given way.
 /// </summary>
 /// <param name="target">The object to reference.</param>
 /// <param name="type">The way to reference the object.</param>
 public SafeGCHandle(object target, GCHandleType type)
     : base(IntPtr.Zero, true)
 {
     RuntimeHelpers.PrepareConstrainedRegions();
     try
     {
         // The StyleCop warning for this try block is incorrect; it is required to create a Constrained Execution Region
     }
     finally
     {
         this.SetHandle(GCHandle.ToIntPtr(GCHandle.Alloc(target, type)));
     }
 }

        [System.Security.SecurityCritical]  // auto-generated
        internal GCHandle(Object value, GCHandleType type)
        {
            // Make sure the type parameter is within the valid range for the enum.
            if ((uint)type > (uint)MaxHandleType)
                throw new ArgumentOutOfRangeException("type", Environment.GetResourceString("ArgumentOutOfRange_Enum"));
            Contract.EndContractBlock();

            m_handle = InternalAlloc(value, type);

            // Record if the handle is pinned.
            if (type == GCHandleType.Pinned)
                SetIsPinned();
        }  

        // Allocate a handle storing the object and the type.
        internal GCHandle(Object value, GCHandleType type)
        {
            // Make sure the type parameter is within the valid range for the enum.
            if ((uint)type > (uint)MaxHandleType)
            {
                throw new ArgumentOutOfRangeException(); // "type", SR.ArgumentOutOfRange_Enum;
            }

            if (type == GCHandleType.Pinned)
                GCHandleValidatePinnedObject(value);

            _handle = RuntimeImports.RhHandleAlloc(value, type);

            // Record if the handle is pinned.
            if (type == GCHandleType.Pinned)
                SetIsPinned();
        }

        public static IntPtr RhHandleAlloc(object value, GCHandleType type)
        {
            IntPtr h = InternalCalls.RhpHandleAlloc(value, type);

            if (h == IntPtr.Zero)
            {
                // Throw the out of memory exception defined by the classlib, using the return address of this method
                // to find the correct classlib.

                ExceptionIDs exID = ExceptionIDs.OutOfMemory;

                IntPtr returnAddr = BinderIntrinsics.GetReturnAddress();
                Exception e = EH.GetClasslibException(exID, returnAddr);
                throw e;
            }

            return h;
        }

 public static GCHandle Alloc (object value, GCHandleType type) {
     throw new NotImplementedException();
 }

 public AutoFreeGCHandle(object targetObject, GCHandleType type = GCHandleType.Pinned)
 {
     _handle = GCHandle.Alloc(targetObject, type);
 }

		internal IntPtr GetGCHandle(GCHandleType type)
		{
			return RuntimeTypeHandle.GetGCHandle(this.GetNativeHandle(), type);
		}

 [System.Security.SecurityCritical]  // auto-generated_required
 public static GCHandle Alloc(Object value, GCHandleType type)
 {
     return new GCHandle(value, type);
 }

 internal static extern IntPtr RhHandleAlloc(Object value, GCHandleType type);

 /// <include file='../../_Doc/mscorlib.xml' path='doc/members/member[@name="M:System.Runtime.InteropServices.GCHandle.Alloc(System.Object,System.Runtime.InteropServices.GCHandleType)"]/*' />
 public static GCHandle Alloc(object value, GCHandleType type)
 {
     throw new PlatformNotSupportedException("PCL");
 }

	public static GCHandle Alloc(Object obj, GCHandleType type)
			{
				return new GCHandle(obj, type);
			}

 private extern static IntPtr GetGCHandle(RuntimeTypeHandle handle, GCHandleType type);

		private extern static int GetTargetHandle(object obj, int handle, GCHandleType type);