C#调用非托管的DLL文件

写了段C#代码实现了调用C++写的非托管DLL

using System;
 using System.IO;
 using System.Collections.Generic;
 using System.Text;
 using System.Reflection;
 using System.Reflection.Emit;
 /*
  The most important attributes of namespace System.Runtime.InteropServices are 
  DllImportAttribute, which you use to define platform invoke methods for accessing unmanaged APIs, 
  and MarshalAsAttribute, which you use to specify how data is marshaled between managed and unmanaged memory.
 */
 using System.Runtime.InteropServices;

 namespace TransDLLProxyNameSpace
{
    public struct SampleStruct
    {
        public Int32 value;
    };

    class TransDLLProxy 
    {
        // Dynamic Call the export function of a Native DLL.

        // Declare the external method firstly.
 
        [DllImport("Kernel32")]
        // Retrieve the address of an exported function or variable from the specified DLL.
        public static extern int GetProcAddress(int handle, String funcname);

        [DllImport("Kernel32")]
        // Map the specified executable module into the address space of the calling process.
        public static extern int LoadLibrary(String funcname);
        
        [DllImport("Kernel32")]
        // Decrement the reference count of the loaded DLL. 
        // When the reference count reaches zero, the module is unmapped from the address space of the calling process.
        public static extern int FreeLibrary(int handle);

        // Get the address of the function.
        private static Delegate GetAddress(int dllModule, string funcName, Type t)
        {
            int addr = GetProcAddress(dllModule, funcName);

            if (addr == 0)
                return null;
            else
                //Convert an unmanaged function pointer to a delegate.
                return Marshal.GetDelegateForFunctionPointer(new IntPtr(addr), t);
        }

        //DLL function pointers.
        private delegate int DLL_GPFunc(string inStr);
        private delegate int DLL_SPFunc(ref StringBuilder outStr);
        private delegate int DLL_TransFunc(IntPtr header, byte[] inArray, Int32 inLength, ref IntPtr outPtr, ref Int32 outLength);
        private delegate int DLL_Release();
        //A handle to the DLL module that contains the function or variable.
        private int m_hModule;                     
        private DLL_GPFunc m_pGPFunc;
        private DLL_SPFunc m_pSPFunc;
        private DLL_TransFunc m_pTransFunc;
        private DLL_Release m_pRelease;
    
        //Constructor
        public TransDLLProxy()
        {
            m_hModule = 0;
            m_pGPFunc = null;
            m_pSPFunc = null;
            m_pTransFunc = null;
            m_pRelease = null;
        }
        ~TransDLLProxy()
        {
            UnloadDLL();
        }

        //Load DLL.
        public bool LoadDLL(string strDllName)
        {
            //Release handle firstly.
            if (m_hModule != 0)    
            {
                Release();  
            }
            //Get the handle to the DLL module.
            m_hModule = LoadLibrary(strDllName);
            if (m_hModule == 0)
            {
                return false;
            }
            //Get the address of the function.
            m_pGPFunc = (DLL_GPFunc)GetAddress(m_hModule, "GPFunc", typeof(DLL_GPFunc));
            m_pSPFunc = (DLL_SPFunc)GetAddress(m_hModule, "SPFunc", typeof(DLL_SPFunc));
            m_pTransFunc = (DLL_TransFunc)GetAddress(m_hModule, "TransFunc", typeof(DLL_TransFunc));
            m_pRelease = (DLL_Release)GetAddress(m_hModule, "Release", typeof(DLL_Release));
            return true;
        }

        //Unload DLL.
        public void UnloadDLL()
        {
            if (m_hModule != 0)
            {
                FreeLibrary(m_hModule);
                m_hModule = 0;
            }
        }
        
        //Proxy Functions

        //Call DLL interface with getting parameters.
        public int GPFunc(string inStr)
        {
            if (m_hModule == 0|| m_pGPFunc == null)
            {
                return -1;
            }
            return m_pGPFunc(inStr);
        }
        //Call DLL interface with setting parameters.
        public int SPFunc(ref string outStr)
        {
            if (m_hModule == 0 || m_pSPFunc == null)
            {
                return -1;
            }
            StringBuilder tStr;
            tStr = new StringBuilder(256);
            int nResult = m_pHelp(tStr);
            outStr = tStr.ToString();
            return nResult;
        }
　　　　//Call DLL interface to transfer struct.
        public int TransFunc(SampleStruct header, MemoryStream instream, ref MemoryStream outstream)
        {
            if (m_hModule == 0 || m_pTransFunc == null)
            {
                return -1;
            }
            
            // Create a managed array.
            byte[] managedArray = null;
            int length = 0;
            //Assume that instream.Length == outstream.Length.
        　  IntPtr ptrOut = Marshal.AllocHGlobal((int)(instream.Length));    
            IntPtr pHeader = Marshal.AllocHGlobal(Marshal.SizeOf(header));

            try 
            {
                Marshal.StructureToPtr(header, pHeader, true);
                int nResult = m_pTransFunc(pHeader, instream.ToArray(), (int)(instream.Length), ref ptrOut, ref length);
                if (nResult == 0 && length != 0)
                {
                    managedArray = new byte[length];
                    /*Copy data from a managed array to an unmanaged memory pointer, 
                    or from an unmanaged memory pointer to a managed array. */
                    Marshal.Copy(ptrOut, managedArray, 0, length * sizeof(byte));
                    outstream.Write(managedArray, 0, length);
                    // Free the unmanaged memory.
                    Marshal.FreeHGlobal(ptrOut);
                    ptrOut = IntPtr.Zero;
                }
            }
            finally
            {
                Marshal.FreeHGlobal(pHeader);
                pHeader = IntPtr.Zero;
            }
            return nResult;
        }
        // Release the Resources.
        public int Release()
        {
            if (m_hModule == 0 || m_pRelease == null)
            {
                return -1;
            }
            return m_pRelease();
        }
    }
}

---------------------------------------------

System.Runtime.InteropServices Namespace

http://msdn.microsoft.com/en-us/library/9esea608%28v=VS.80%29.aspx

MinGW下DLL编写与调用

http://tingxx.ycool.com/post.2023760.html

MinGW中定义DLL

http://blog.sina.com.cn/s/blog_4ac2a65901000brf.html

VC++动态链接库(DLL)编程深入浅出

http://pcedu.pconline.com.cn/empolder/gj/vc/0509/699672.html

在C#中动态调用native dll的导出函数

http://dotnet.chinaitlab.com/CSharp/727142.html

C#调用C++的DLL

http://www.cnblogs.com/virusswb/archive/2008/05/30/1210520.html

Delegate比较全面的例子(原创)

http://www.cnblogs.com/idior/articles/100666.html

如何：创建和使用 C# DLL（C# 编程指南）

http://msdn.microsoft.com/zh-cn/library/3707x96z(VS.80).aspx

在VC中创建DLL文件的方法步骤

http://dev.yesky.com/475/7667475.shtml