int WINAPI MessageBox(
  _In_opt_  HWND hWnd,
  _In_opt_  LPCTSTR lpText,
  _In_opt_  LPCTSTR lpCaption,
  _In_      UINT uType
);

using System;

// 使用平臺調(diào)用技術(shù)進行互操作性之前，首先需要添加這個命名空間
using System.Runtime.InteropServices;

namespace 平臺調(diào)用Demo
{
    class Program
    {
        // 在托管代碼中對非托管函數(shù)進行聲明，并且附加平臺調(diào)用所需要屬性 在默認(rèn)情況下，CharSet為CharSet.Ansi
        // 指定調(diào)用哪個版本的方法有兩種——通過DllImport屬性的CharSet字段和通過EntryPoint字段指定 在托管函數(shù)中聲明注意一定要加上 static 和extern 這兩個關(guān)鍵字

        //第一種指定方式，通過CharSet字段指定,在默認(rèn)情況下CharSet為CharSet.Ansi
        [DllImport("user32.dll")]
        public static extern int MessageBox(IntPtr hWnd, String text, String caption, uint type);

        [DllImport("user32.dll")]
        public static extern int MessageBoxA(IntPtr hWnd, String text, String caption, uint type);

        // [DllImport("user32.dll", CharSet = CharSet.Unicode)] public static extern int
        // MessageBox(IntPtr hWnd, String text, String caption, uint type);

        [DllImport("user32.dll", CharSet = CharSet.Unicode)]
        public static extern int MessageBoxW(IntPtr hWnd, String text, String caption, uint type);

        // 通過EntryPoint字段指定
        [DllImport("user32.dll", EntryPoint = "MessageBoxA")]
        public static extern int MessageBox3(IntPtr hWnd, String text, String caption, uint type);

        [DllImport("user32.dll", EntryPoint = "MessageBoxW", CharSet = CharSet.Unicode)]
        public static extern int MessageBox4(IntPtr hWnd, String text, String caption, uint type);

        static void Main(string[] args)
        {
            // 在托管代碼中直接調(diào)用聲明的托管函數(shù) 使用CharSet字段指定的方式，要求在托管代碼中聲明的函數(shù)名必須與非托管函數(shù)名一樣 否則就會出現(xiàn)找不到入口點的運行時錯誤

            // 下面的調(diào)用都可以運行正確
            MessageBox(new IntPtr(0), "Learning Hard", "歡迎", 0);
            MessageBoxA(new IntPtr(0), "Learning Hard", "歡迎", 0);
            MessageBoxW(new IntPtr(0), "Learning Hard", "歡迎", 0);

            //使用指定函數(shù)入口點的方式調(diào)用,OK
            MessageBox3(new IntPtr(0), "Learning Hard", "歡迎", 0);
            MessageBox4(new IntPtr(0), "Learning Hard", "歡迎", 0);
        }
    }
}

[DllImport("user32.dll", ExactSpelling=true)]
       public static extern int MessageBox(IntPtr hWnd, String text, String caption, uint type);

[DllImport("user32.dll")]
        public static extern int MessageBox1(IntPtr hWnd, String text, String caption, uint type);

            try
            {
                MessageBox1(new IntPtr(0), "Learning Hard", "歡迎", 0);
            }
            catch (DllNotFoundException dllNotFoundExc)
            {
                Console.WriteLine("DllNotFoundException 異常發(fā)生，異常信息為： " + dllNotFoundExc.Message);
            }
            catch (EntryPointNotFoundException entryPointExc)
            {
                Console.WriteLine("EntryPointNotFoundException 異常發(fā)生，異常信息為： " + entryPointExc.Message);
            }

    class Program
    {
        // Win32 API 
        //  DWORD WINAPI GetFileAttributes(
        //  _In_  LPCTSTR lpFileName
        //);

        // 在托管代碼中對非托管函數(shù)進行聲明
        [DllImport("Kernel32.dll",SetLastError=true,CharSet=CharSet.Unicode)]
        public static extern uint GetFileAttributes(string filename);

        static void Main(string[] args)
        {
            // 試圖獲得一個不存在文件的屬性
            // 此時調(diào)用Win32函數(shù)會發(fā)生錯誤
            GetFileAttributes("FileNotexist.txt");

            // 在應(yīng)用程序的Bin目錄下存在一個test.txt文件,此時調(diào)用會成功
            //GetFileAttributes("test.txt");

            // 獲得最后一次獲得的錯誤
            int lastErrorCode = Marshal.GetLastWin32Error();

            // 將Win32的錯誤碼轉(zhuǎn)換為托管異常
            //Win32Exception win32exception = new Win32Exception();
            Win32Exception win32exception = new Win32Exception(lastErrorCode);
            if (lastErrorCode != 0)
            {
                Console.WriteLine("調(diào)用Win32函數(shù)發(fā)生錯誤，錯誤信息為 : {0}", win32exception.Message);
            }
            else
            {
                Console.WriteLine("調(diào)用Win32函數(shù)成功,返回的信息為： {0}", win32exception.Message);
            }

            Console.Read();
        }
    }

using System.Runtime.InteropServices;

// 下面的結(jié)構(gòu)體也屬于可直接復(fù)制到本機結(jié)構(gòu)中的類型
[StructLayout(LayoutKind.Sequential)]
public struct Point {
   public int x;
   public int y;
}

    // 托管函數(shù)中的返回值封送回托管函數(shù)的例子
    class Program
    {

        // Win32 GetTempPath函數(shù)的定義如下：   
        //DWORD WINAPI GetTempPath(
        //  _In_   DWORD nBufferLength,
        //  _Out_  LPTSTR lpBuffer
        //);  

        // 主要是注意如何在托管代碼中定義該函數(shù)原型       
        [DllImport("Kernel32.dll", CharSet = CharSet.Unicode, SetLastError=true)]
        public static extern uint GetTempPath(int bufferLength, StringBuilder buffer);
        static void Main(string[] args)
        {
            StringBuilder buffer = new StringBuilder(300);
            uint tempPath=GetTempPath(300, buffer);
            string path = buffer.ToString();
            if (tempPath == 0)
            {
                int errorcode =Marshal.GetLastWin32Error();
                Win32Exception win32expection = new Win32Exception(errorcode);
                Console.WriteLine("調(diào)用非托管函數(shù)發(fā)生異常，異常信息為：" +win32expection.Message);
            }

            Console.WriteLine("調(diào)用非托管函數(shù)成功。");
            Console.WriteLine("Temp 路徑為：" + buffer); 
            Console.Read();
        }
    }

BOOL GetVersionEx( 
  LPOSVERSIONINFO lpVersionInformation
);

typedef struct  _OSVERSIONINFO{
    DWORD dwOSVersionInfoSize;       //在使用GetVersionEx之前要將此初始化為結(jié)構(gòu)的大小
    DWORD dwMajorVersion;               //系統(tǒng)主版本號
    DWORD dwMinorVersion;               //系統(tǒng)次版本號
    DWORD dwBuildNumber;               //系統(tǒng)構(gòu)建號
    DWORD dwPlatformId;                  //系統(tǒng)支持的平臺
    TCHAR szCSDVersion[128];          //系統(tǒng)補丁包的名稱
    WORD wServicePackMajor;            //系統(tǒng)補丁包的主版本
    WORD wServicePackMinor;            //系統(tǒng)補丁包的次版本
    WORD wSuiteMask;                      //標(biāo)識系統(tǒng)上的程序組
    BYTE wProductType;                    //標(biāo)識系統(tǒng)類型
    BYTE wReserved;                         //保留,未使用
} OSVERSIONINFO;

        // 因為Win32 GetVersionEx函數(shù)參數(shù)lpVersionInformation是一個指向 OSVERSIONINFO的數(shù)據(jù)結(jié)構(gòu)
        // 所以托管代碼中定義個結(jié)構(gòu)體，把結(jié)構(gòu)體對象作為非托管函數(shù)參數(shù)
        [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Unicode)]
        public struct OSVersionInfo
        {
            public UInt32 OSVersionInfoSize; // 結(jié)構(gòu)的大小，在調(diào)用方法前要初始化該字段
            public UInt32 MajorVersion; // 系統(tǒng)主版本號
            public UInt32 MinorVersion; // 系統(tǒng)此版本號
            public UInt32 BuildNumber;  // 系統(tǒng)構(gòu)建號
            public UInt32 PlatformId;  // 系統(tǒng)支持的平臺

            // 此屬性用于表示將其封送成內(nèi)聯(lián)數(shù)組
            [MarshalAs(UnmanagedType.ByValTStr,SizeConst=128)]
            public string CSDVersion; // 系統(tǒng)補丁包的名稱
            public UInt16 ServicePackMajor; // 系統(tǒng)補丁包的主版本
            public UInt16 ServicePackMinor;  // 系統(tǒng)補丁包的次版本
            public UInt16 SuiteMask;   //標(biāo)識系統(tǒng)上的程序組
            public Byte ProductType;    //標(biāo)識系統(tǒng)類型
            public Byte Reserved;  //保留,未使用
        }

using System;
using System.ComponentModel;
using System.Runtime.InteropServices;
namespace 封送結(jié)構(gòu)體的處理
{
    class Program
    {
        // 對GetVersionEx進行托管定義
        // 為了傳遞指向結(jié)構(gòu)體的指針并將初始化的信息傳遞給非托管代碼，需要用ref關(guān)鍵字修飾參數(shù)
        // 這里不能使用out關(guān)鍵字，如果使用了out關(guān)鍵字，CLR就不會對參數(shù)進行初始化操作，這樣就會導(dǎo)致調(diào)用失敗
        [DllImport("Kernel32",CharSet=CharSet.Unicode,EntryPoint="GetVersionEx")]
        private static extern Boolean GetVersionEx_Struct(ref  OSVersionInfo osVersionInfo);

        // 因為Win32 GetVersionEx函數(shù)參數(shù)lpVersionInformation是一個指向 OSVERSIONINFO的數(shù)據(jù)結(jié)構(gòu)
        // 所以托管代碼中定義個結(jié)構(gòu)體，把結(jié)構(gòu)體對象作為非托管函數(shù)參數(shù)
        [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Unicode)]
        public struct OSVersionInfo
        {
            public UInt32 OSVersionInfoSize; // 結(jié)構(gòu)的大小，在調(diào)用方法前要初始化該字段
            public UInt32 MajorVersion; // 系統(tǒng)主版本號
            public UInt32 MinorVersion; // 系統(tǒng)此版本號
            public UInt32 BuildNumber;  // 系統(tǒng)構(gòu)建號
            public UInt32 PlatformId;  // 系統(tǒng)支持的平臺

            // 此屬性用于表示將其封送成內(nèi)聯(lián)數(shù)組
            [MarshalAs(UnmanagedType.ByValTStr,SizeConst=128)]
            public string CSDVersion; // 系統(tǒng)補丁包的名稱
            public UInt16 ServicePackMajor; // 系統(tǒng)補丁包的主版本
            public UInt16 ServicePackMinor;  // 系統(tǒng)補丁包的次版本
            public UInt16 SuiteMask;   //標(biāo)識系統(tǒng)上的程序組
            public Byte ProductType;    //標(biāo)識系統(tǒng)類型
            public Byte Reserved;  //保留,未使用
        }

        // 獲得操作系統(tǒng)信息
        private static string GetOSVersion()
        {
            // 定義一個字符串存儲版本信息
            string versionName = string.Empty;

            // 初始化一個結(jié)構(gòu)體對象
            OSVersionInfo osVersionInformation = new OSVersionInfo();

            // 調(diào)用GetVersionEx 方法前，必須用SizeOf方法設(shè)置結(jié)構(gòu)體中OSVersionInfoSize 成員
            osVersionInformation.OSVersionInfoSize = (UInt32)Marshal.SizeOf(typeof(OSVersionInfo));

            // 調(diào)用Win32函數(shù)
            Boolean result = GetVersionEx_Struct(ref osVersionInformation);

            if (!result)
            {
                // 如果調(diào)用失敗，獲得最后的錯誤碼
                int errorcode = Marshal.GetLastWin32Error();
                Win32Exception win32Exc = new Win32Exception(errorcode);
                Console.WriteLine("調(diào)用失敗的錯誤信息為： " + win32Exc.Message);

                // 調(diào)用失敗時返回為空字符串
                return string.Empty;
            }
            else
            {
                Console.WriteLine("調(diào)用成功");
                switch (osVersionInformation.MajorVersion)
                {
                    // 這里僅僅討論 主版本號為6的情況，其他情況是一樣討論的
                    case 6:
                        switch (osVersionInformation.MinorVersion)
                        {
                            case 0:
                                if (osVersionInformation.ProductType == (Byte)0)
                                {
                                    versionName = " Microsoft Windows Vista";
                                }
                                else
                                {
                                    versionName = "Microsoft Windows Server 2008"; // 服務(wù)器版本
                                }
                                break;
                            case 1:
                                if (osVersionInformation.ProductType == (Byte)0)
                                {
                                    versionName = " Microsoft Windows 7";
                                }
                                else
                                {
                                    versionName = "Microsoft Windows Server 2008 R2";
                                }
                                break;
                            case 2:
                                versionName = "Microsoft Windows 8";
                                break;
                        }
                        break;
                    default:
                        versionName = "未知的操作系統(tǒng)";
                        break;
                }
                return versionName;
            }
        }

        static void Main(string[] args)
        {
            string OS=GetOSVersion();
            Console.WriteLine("當(dāng)前電腦安裝的操作系統(tǒng)為：{0}", OS);
            Console.Read();
        }
    }
}

using System;
using System.ComponentModel;
using System.Runtime.InteropServices;

namespace 封送類的處理
{
    class Program
    {
        // 對GetVersionEx進行托管定義
        // 由于類的定義中CSDVersion為String類型，String是非直接復(fù)制到本機結(jié)構(gòu)類型，
        // 所以封送拆送器需要進行復(fù)制操作。
        // 為了是非托管代碼能夠獲得在托管代碼中對象設(shè)置的初始值(指的是OSVersionInfoSize字段，調(diào)用函數(shù)前首先初始化該值),
        // 所以必須加上[In]屬性；函數(shù)返回時，為了將結(jié)果復(fù)制到托管對象中，必須同時加上 [Out]屬性
        // 這里不能是用ref關(guān)鍵字，因為 OsVersionInfo是類類型，本來就是引用類型，如果加ref 關(guān)鍵字就是傳入的為指針的指針了，這樣就會導(dǎo)致調(diào)用失敗
        [DllImport("Kernel32", CharSet = CharSet.Unicode, EntryPoint = "GetVersionEx")]
        private static extern Boolean GetVersionEx_Struct([In, Out]  OSVersionInfo osVersionInfo);

        // 獲得操作系統(tǒng)信息
        private static string GetOSVersion()
        {
            // 定義一個字符串存儲操作系統(tǒng)信息
            string versionName = string.Empty;

            // 初始化一個類對象
            OSVersionInfo osVersionInformation = new OSVersionInfo();

            // 調(diào)用Win32函數(shù)
            Boolean result = GetVersionEx_Struct(osVersionInformation);

            if (!result)
            {
                // 如果調(diào)用失敗，獲得最后的錯誤碼
                int errorcode = Marshal.GetLastWin32Error();
                Win32Exception win32Exc = new Win32Exception(errorcode);
                Console.WriteLine("調(diào)用失敗的錯誤信息為： " + win32Exc.Message);

                // 調(diào)用失敗時返回為空字符串
                return string.Empty;
            }
            else
            {
                Console.WriteLine("調(diào)用成功");
                switch (osVersionInformation.MajorVersion)
                {
                    // 這里僅僅討論 主版本號為6的情況，其他情況是一樣討論的
                    case 6:
                        switch (osVersionInformation.MinorVersion)
                        {
                            case 0:
                                if (osVersionInformation.ProductType == (Byte)0)
                                {
                                    versionName = " Microsoft Windows Vista";
                                }
                                else
                                {
                                    versionName = "Microsoft Windows Server 2008"; // 服務(wù)器版本
                                }
                                break;
                            case 1:
                                if (osVersionInformation.ProductType == (Byte)0)
                                {
                                    versionName = " Microsoft Windows 7";
                                }
                                else
                                {
                                    versionName = "Microsoft Windows Server 2008 R2";
                                }
                                break;
                            case 2:
                                versionName = "Microsoft Windows 8";
                                break;
                        }
                        break;
                    default:
                        versionName = "未知的操作系統(tǒng)";
                        break;
                }
                return versionName;
            }
        }

        static void Main(string[] args)
        {
            string OS = GetOSVersion();
            Console.WriteLine("當(dāng)前電腦安裝的操作系統(tǒng)為：{0}", OS);
            Console.Read();
        }
    }

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public class OSVersionInfo
    {
        public UInt32 OSVersionInfoSize = (UInt32)Marshal.SizeOf(typeof(OSVersionInfo));
        public UInt32 MajorVersion = 0;
        public UInt32 MinorVersion = 0;
        public UInt32 BuildNumber = 0;
        public UInt32 PlatformId = 0;

        // 此屬性用于表示將其封送成內(nèi)聯(lián)數(shù)組
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
        public string CSDVersion = null;

        public UInt16 ServicePackMajor = 0;
        public UInt16 ServicePackMinor = 0;
        public UInt16 SuiteMask = 0;

        public Byte ProductType = 0;
        public Byte Reserved;
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using Excel = Microsoft.Office.Interop.Excel;
using Word = Microsoft.Office.Interop.Word;


namespace OfficeProgramminWalkthruComplete
{
    class Walkthrough
    {
        static void Main(string[] args)
        {
            // Create a list of accounts.
            var bankAccounts = new List<Account> 
            {
                new Account { 
                              ID = 345678,
                              Balance = 541.27
                            },
                new Account {
                              ID = 1230221,
                              Balance = -127.44
                            }
            };

            // Display the list in an Excel spreadsheet.
            DisplayInExcel(bankAccounts);

            // Create a Word document that contains an icon that links to
            // the spreadsheet.
            CreateIconInWordDoc();
        }

        static void DisplayInExcel(IEnumerable<Account> accounts)
        {
            var excelApp = new Excel.Application();
            // Make the object visible.
            excelApp.Visible = true;

            // Create a new, empty workbook and add it to the collection returned 
            // by property Workbooks. The new workbook becomes the active workbook.
            // Add has an optional parameter for specifying a praticular template. 
            // Because no argument is sent in this example, Add creates a new workbook. 
            excelApp.Workbooks.Add();

            // This example uses a single workSheet. 
            Excel._Worksheet workSheet = excelApp.ActiveSheet;

            // Earlier versions of C# require explicit casting.
            //Excel._Worksheet workSheet = (Excel.Worksheet)excelApp.ActiveSheet;

            // Establish column headings in cells A1 and B1.
            workSheet.Cells[1, "A"] = "ID Number";
            workSheet.Cells[1, "B"] = "Current Balance";

            var row = 1;
            foreach (var acct in accounts)
            {
                row++;
                workSheet.Cells[row, "A"] = acct.ID;
                workSheet.Cells[row, "B"] = acct.Balance;
            }

            workSheet.Columns[1].AutoFit();
            workSheet.Columns[2].AutoFit();

            // Call to AutoFormat in Visual C#. This statement replaces the 
            // two calls to AutoFit.
            workSheet.Range["A1", "B3"].AutoFormat(
                Excel.XlRangeAutoFormat.xlRangeAutoFormatClassic2);

            // Put the spreadsheet contents on the clipboard. The Copy method has one
            // optional parameter for specifying a destination. Because no argument  
            // is sent, the destination is the Clipboard.
            workSheet.Range["A1:B3"].Copy();
        }

        static void CreateIconInWordDoc()
        {
            var wordApp = new Word.Application();
            wordApp.Visible = true;

            // The Add method has four reference parameters, all of which are 
            // optional. Visual C# allows you to omit arguments for them if
            // the default values are what you want.
            wordApp.Documents.Add();

            // PasteSpecial has seven reference parameters, all of which are 
            // optional. This example uses named arguments to specify values 
            // for two of the parameters. Although these are reference 
            // parameters, you do not need to use the ref keyword, or to create 
            // variables to send in as arguments. You can send the values directly.
            wordApp.Selection.PasteSpecial(Link: true, DisplayAsIcon: true);
        }
    }

    public class Account
    {
        public int ID { get; set; }
        public double Balance { get; set; }
    }
}

            try
            {
                // 如果文檔不存在時，就會出現(xiàn)調(diào)用COM對象失敗的情況
                // 打開Word文檔
                wordDoc = wordApp.Documents.Open(wordPath);
                // 向Word中插入文本
                Range wordRange = wordDoc.Range(0, 0);
                wordRange.Text = "這是插入的文本";

                // 保存文檔
                wordDoc.Save();
            }
            catch(Exception ex)
            {          
                // 獲得異常相對應(yīng)的HRESULT值
                // 因為COM中根據(jù)方法返回的HRESULT來判斷調(diào)用是否成功的
                int HResult = Marshal.GetHRForException(ex);
                // 設(shè)置控制臺的前景色，即輸出文本的顏色
                Console.ForegroundColor = ConsoleColor.Red;
                // 下面把HRESULT值以16進制輸出
                Console.WriteLine("調(diào)用拋出異常，異常類型為：{0}, HRESULT= 0x{1:x}", ex.GetType().Name, HResult);
                Console.WriteLine("異常信息為：" + ex.Message.Replace('\r', ' '));
            }
            finally
            {
                // 關(guān)閉文檔并
                if (wordDoc != null)
                {
                    wordDoc.Close();
                }
                // 退出Word程序
                wordApp.Quit();
            }