UnmanagedMarshal.cs source code in C# .NET

                        Code:
                         / FXUpdate3074 / FXUpdate3074 / 1.1 / untmp / whidbey / QFE / ndp / clr / src / BCL / System / Reflection / Emit / UnmanagedMarshal.cs / 1 / UnmanagedMarshal.cs
                        
                        
                            // ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 
namespace System.Reflection.Emit
{ 
    using System.Runtime.InteropServices; 
   using System;
    using System.Security.Permissions; 

    // This class is describing the fieldmarshal.
   [Serializable()]
    [HostProtection(MayLeakOnAbort = true)] 
    [System.Runtime.InteropServices.ComVisible(true)]
    [Obsolete("An alternate API is available: Emit the MarshalAs custom attribute instead. http://go.microsoft.com/fwlink/?linkid=14202")] 
    public sealed class UnmanagedMarshal 
    {
        /****************************** 
[System.Runtime.InteropServices.ComVisible(true)]
        * public static constructors. You can only construct
        * UnmanagedMarshal using these static constructors.
        ******************************/ 
        public static UnmanagedMarshal DefineUnmanagedMarshal(UnmanagedType unmanagedType)
        { 
            if (unmanagedType == UnmanagedType.ByValTStr || 
#if FEATURE_COMINTEROP
                unmanagedType == UnmanagedType.SafeArray || 
#endif //FEATURE_COMINTEROP
                unmanagedType == UnmanagedType.ByValArray ||
                unmanagedType == UnmanagedType.LPArray ||
                unmanagedType == UnmanagedType.CustomMarshaler) 
            {
                // not a simple native marshal 
                throw new ArgumentException(Environment.GetResourceString("Argument_NotASimpleNativeType")); 
            }
            return new UnmanagedMarshal(unmanagedType, Guid.Empty, 0, (UnmanagedType) 0); 
        }
        public static UnmanagedMarshal DefineByValTStr(int elemCount)
        {
            return new UnmanagedMarshal(UnmanagedType.ByValTStr, Guid.Empty, elemCount, (UnmanagedType) 0); 
        }
 
#if FEATURE_COMINTEROP 
        public static UnmanagedMarshal DefineSafeArray(UnmanagedType elemType)
        { 
            return new UnmanagedMarshal(UnmanagedType.SafeArray, Guid.Empty, 0, elemType);
        }
#endif //FEATURE_COMINTEROP
 
        public static UnmanagedMarshal DefineByValArray(int elemCount)
        { 
            return new UnmanagedMarshal(UnmanagedType.ByValArray, Guid.Empty, elemCount, (UnmanagedType) 0); 
        }
 
        public static UnmanagedMarshal DefineLPArray(UnmanagedType elemType)
        {
            return new UnmanagedMarshal(UnmanagedType.LPArray, Guid.Empty, 0, elemType);
        } 

 
 

 

        // accessor function for the native type
      public UnmanagedType GetUnmanagedType
      { 
         get { return m_unmanagedType; }
      } 
 
      public Guid IIDGuid
       { 
         get
         {
                if (m_unmanagedType != UnmanagedType.CustomMarshaler)
                { 
                    // throw exception here. There is Guid only if CustomMarshaler
                    throw new ArgumentException(Environment.GetResourceString("Argument_NotACustomMarshaler")); 
                } 
                return m_guid;
            } 
      }
      public int ElementCount
       {
         get 
          {
                if (m_unmanagedType != UnmanagedType.ByValArray && 
                    m_unmanagedType != UnmanagedType.ByValTStr) 
                {
                    // throw exception here. There is NumElement only if NativeTypeFixedArray 
                    throw new ArgumentException(Environment.GetResourceString("Argument_NoUnmanagedElementCount"));
                }
                return m_numElem;
            } 
      }
      public UnmanagedType BaseType 
      { 
         get
          { 
#if FEATURE_COMINTEROP
                if (m_unmanagedType != UnmanagedType.LPArray && m_unmanagedType != UnmanagedType.SafeArray)
#else
                if (m_unmanagedType != UnmanagedType.LPArray) 
#endif //!FEATURE_COMINTEROP
                { 
                    // throw exception here. There is NestedUnmanagedType only if LPArray or SafeArray 
                    throw new ArgumentException(Environment.GetResourceString("Argument_NoNestedMarshal"));
                } 
                return m_baseType;
            }
      }
 
        private UnmanagedMarshal(UnmanagedType unmanagedType, Guid guid, int numElem, UnmanagedType type)
        { 
            m_unmanagedType = unmanagedType; 
            m_guid = guid;
            m_numElem = numElem; 
            m_baseType = type;
        }

        /************************ 
        *
        * Data member 
        * 
        *************************/
        internal UnmanagedType       m_unmanagedType; 
        internal Guid                m_guid;
        internal int                 m_numElem;
        internal UnmanagedType       m_baseType;
 

        /************************ 
        * this function return the byte representation of the marshal info. 
        *************************/
        internal byte[] InternalGetBytes() 
        {
            byte[] buf;
#if FEATURE_COMINTEROP
            if (m_unmanagedType == UnmanagedType.SafeArray || m_unmanagedType == UnmanagedType.LPArray) 
#else
            if (m_unmanagedType == UnmanagedType.LPArray) 
#endif //!FEATURE_COMINTEROP 
         {
 
                // syntax for NativeTypeSafeArray is
                //  
                //
                int     cBuf = 2; 
                buf = new byte[cBuf];
                buf[0] = (byte) (m_unmanagedType); 
                buf[1] = (byte) (m_baseType); 
                return buf;
            } 
            else
         if (m_unmanagedType == UnmanagedType.ByValArray ||
                    m_unmanagedType == UnmanagedType.ByValTStr)
         { 
                //  
                // 
                int     cBuf; 
                int     iBuf = 0;
 
                if (m_numElem <= 0x7f)
                    cBuf = 1;
                else if (m_numElem <= 0x3FFF)
                    cBuf = 2; 
                else
                    cBuf = 4; 
 
                // the total buffer size is the one byte + encoded integer size
                cBuf = cBuf + 1; 
                buf = new byte[cBuf];


                buf[iBuf++] = (byte) (m_unmanagedType); 
                if (m_numElem <= 0x7F)
             { 
                    buf[iBuf++] = (byte)(m_numElem & 0xFF); 
                } else if (m_numElem <= 0x3FFF)
            { 
                    buf[iBuf++] = (byte)((m_numElem >> 8) | 0x80);
                    buf[iBuf++] = (byte)(m_numElem & 0xFF);
                } else if (m_numElem <= 0x1FFFFFFF)
             { 
                    buf[iBuf++] = (byte)((m_numElem >> 24) | 0xC0);
                    buf[iBuf++] = (byte)((m_numElem >> 16) & 0xFF); 
                    buf[iBuf++] = (byte)((m_numElem >> 8)  & 0xFF); 
                    buf[iBuf++] = (byte)((m_numElem)     & 0xFF);
                } 
                return buf;
            }
            buf = new byte[1];
            buf[0] = (byte) (m_unmanagedType); 
            return buf;
        } 
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
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
UnmanagedMarshal.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
