博客园_春夏秋冬

Silverlight桌面部署器及其使用

2012-01-16T10:00:00Z

一、文件简介

SL.ini 配置文件

InstallSL.exe 安装Silveright应用至桌面

RunSL.exe 运行Silverligh应用，无安装

UnInstallSL.exe 卸载Silverlight应用

二、配置文件说明

SL.ini文件内容如下：

[SL]
App=App.xap
Url=http://112.8.33.25:99/ClientBin/App.xap

其中App.xap文件应该放在当前路径下，Url为应用主程序在Web上的地址，可以位于Windows、Linux、 Mac等系统之上，且http://112.8.33.25:99/ClientBin/下允许有子模型、子应用。

三、使用方法

将App.xap（默认）复制到当前文件夹，并安装相应的Silverlight运行时(已有的版本有SL3、SL4、SL5 ，另外有mac版)，然后按上一节进行配置。

最后，若要安装至桌面则执行InstallSL.exe；若要无安装方式下直接运行该应用则执行RunSL.exe；若要卸载当前配置的应用则执行UnInstallSL.exe。

注：Silverlight本质上是winform的升级版本，也是wpf的子集，但其本身并不像winform/wpf那样方便的直接运行和部署，故此，本文提供的工具旨在解决该问题。

注：本程序在windows server 2003且无.net的环境下测试通过，需要安装silverlight运行时。

注：本文程序为绿色的win32程序，可使用installshield等软件打包成安装文件包。

下载地址：

http://files.cnblogs.com/chuncn/RunSLInDesktop.zip

本文链接

Silverlight桌面部署器的使用

2012-01-16T09:58:00Z

一、文件简介

SL.ini 配置文件

InstallSL.exe 安装Silveright应用至桌面

RunSL.exe 运行Silverligh应用，无安装 UnInstallSL.exe 卸载Silverlight应用

二、配置文件说明

SL.ini文件内容如下：

[SL]
App=App.xap
Url=http://112.8.33.25:99/ClientBin/App.xap

三、使用方法

将App.xap（默认）复制到当前文件夹，并安装相应的Silverlight运行时(已有的版本有SL3、SL4、SL5 ，另外有mac版)，然后按上一节进行配置。

最后，若要安装至桌面则执行InstallSL.exe；若要无安装方式下直接运行该应用则执行RunSL.exe；若要卸载当前配置的应用则执行UnInstallSL.exe。

注：Silverlight本质上是winform的升级版本，也是wpf的子集，但其本身并不像winform/wpf那样方便的直接运行和部署，故此，本文提供的工具旨在解决该问题。

本文链接

Silverlight5通过P/Invoke调用自定义win32 DLL(Lua)

2012-01-06T02:23:00Z

上一篇《Silverlight5通过P/Invoke调用系统win32的三个示例》展示了silverlight5通过P/Invoke调用系统win32的三个示例，本篇给出自定义win32 dll及其在Silverlight5中调用的代码。

注1：为了确保silverilght5在浏览器或桌面上成功调用win32 DLL，必须在项目属性中勾选相应的权限：

勾选Enable running application out of the browser及其Require elevated trust when running in-browser

勾选Require elevated trust when running in-browser

注2：win32 dll文件编译后放在\windows\system32或\windows\system目录下，win7 x64的系统放在后者。

注3：winform/wpf中调用类似

// The following ifdef block is the standard way of creating macros which make exporting 
// from a DLL simpler. All files within this DLL are compiled with the MYDLL_EXPORTS
// symbol defined on the command line. This symbol should not be defined on any project
// that uses this DLL. This way any other project whose source files include this file see 
// MYDLL_API functions as being imported from a DLL, whereas this DLL sees symbols
// defined with this macro as being exported.
#ifdef MYDLL_EXPORTS
#define MYDLL_API __declspec(dllexport)
#else
#define MYDLL_API __declspec(dllimport)
#endif

struct HHFC_SET 
{
 	;char* UID;
  	int     code;
};

// This class is exported from the MyDLL.dll
class MYDLL_API CMyDLL {
public:
	CMyDLL(void);
	// TODO: add your methods here.
};
//extern MYDLL_API int nMyDLL;
extern "C" MYDLL_API int nMyDLL; 
extern "C" MYDLL_API float fnMyDLL(float x ,float y);// 注意得加上extern  "C"，否则无法P/Invoke

.cpp

#include "stdafx.h"
#include "MyDLL.h"

#include <iostream>   
#include "LuaPlus.h" 
#include "LuaPlusHelper.h" 
#pragma comment(lib,"LuaPlusLib.lib")   
using namespace LuaPlus; 
using namespace std;

// This is an example of an exported variable
MYDLL_API int nMyDLL=0;
// This is an example of an exported function. 
MYDLL_API int fnMyDLL(float x ,float y)
{
 　　 //调用Lua脚本并计算
　　  string str;
　　  str.append("function Add(x, y)\n");
　　  str.append(" return x*y;\n");
　　  str.append("end\n");
　　  int iret = state->DoString(str.c_str());// state->DoFile("a.lua");
　　  LuaFunction Add = state->GetGlobal("Add");
　　  float myret = Add(x,y);
　　  return myret;
} 
extern "C" __declspec(dllexport)  int WINAPI add()
{
	return 101;
}

extern "C" __declspec(dllexport)  int WINAPI add2(HHFC_SET* stru )
 {
 	stru->UID="this is a win32 test about struct";
 	stru->code=3;
   	return 1;
 }

// This is the constructor of a class that has been exported.
// see MyDLL.h for the class definition
CMyDLL::CMyDLL()
{
	return;
}

.xaml

<Grid x:Name="LayoutRoot" Background="White">

        <StackPanel Orientation="Horizontal" VerticalAlignment="Top" Margin="24,24,0,0">
            <TextBlock Name="textBlock1" Text="add       函数结果:" Height="23" />
            <TextBox Name="textBox1" Width="120" Height="23" />
        </StackPanel>

        <StackPanel Orientation="Horizontal" VerticalAlignment="Top" Margin="24,64,0,0">
            <TextBlock Name="textBlock2" Text="fnMyDLL函数结果:" Height="23"/>
            <TextBox Name="textBox2" VerticalAlignment="Top" Width="120" Height="23"/>
        </StackPanel>
       

        <Button Content="Button" Height="32" Margin="120,101,202,0" Name="button1" VerticalAlignment="Top" Width="78" Click="button1_Click" />
    </Grid>

.cs

public partial class MainPage : UserControl
    {
        [DllImportAttribute("user32.dll", EntryPoint = "MessageBoxW")]
        public static extern int MessageBoxW(int hWnd, [In][MarshalAs(UnmanagedType.LPWStr)] string lpText, [In][MarshalAs(UnmanagedType.LPWStr)] string lpCaption, int uType);

        [DllImport("MyDll.dll", EntryPoint = "add", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall, SetLastError = false)]
        public static extern int add();

        [DllImport("MyDll.dll", EntryPoint = "fnMyDLL", CharSet = CharSet.Auto, CallingConvention = CallingConvention.Winapi, SetLastError = false)]
        public static extern int fnMyDLL(float x,float y);

        [DllImport("MyDLL.dll", EntryPoint = "add2", CharSet = CharSet.Auto, CallingConvention = CallingConvention.Winapi, SetLastError = false)]
        public static extern int add2(ref HHFC_SET stru);

//EntryPoint: 指定要调用的 DLL 入口点。默认入口点名称是托管方法的名称 。 
        //CharSet: 控制名称重整和封送 String 参数的方式 (默认是UNICODE) 
        //CallingConvention指示入口点的函数调用约定(默认WINAPI) 
        //SetLastError 指示被调用方在从属性化方法返回之前是否调用 SetLastError Win32 API 函数 (C#中默认false )

        public MainPage()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, RoutedEventArgs e)
        {
            this.textBox1.Text = add().ToString();
            this.textBox2.Text = fnMyDLL(12,2).ToString();
            MessageBoxW(0, "提交成功", "温馨提示", 0);

HHFC_SET stru = new HHFC_SET(); 
            stru.Uid = ""; 
            Console.WriteLine(stru.Uid); 
            int a = add2(ref stru); 
            Console.WriteLine(stru.Uid); 
        }
    }

[StructLayout(LayoutKind.Sequential)]
     public struct HHFC_SET
     {
         [MarshalAs(UnmanagedType.LPStr)]
         public String Uid;

         [MarshalAs(UnmanagedType.I4)]
         public int code;
     }

本文链接

Silverlight5通过P/Invoke调用系统win32的三个示例

2011-12-30T08:00:00Z

调用Win32函数

public partial class MainPage : UserControl
    {
        [DllImportAttribute("user32.dll", EntryPoint = "MessageBoxW")]
        public static extern int MessageBoxW(
            [In]System.IntPtr hWnd,
            [In][MarshalAs(UnmanagedType.LPWStr)] string lpText,
            [In][MarshalAs(UnmanagedType.LPWStr)] string lpCaption,
            uint uType);

        [DllImport("user32.dll", EntryPoint = "MessageBoxA")]
        static extern int MsgBox(int hWnd, string msg, string caption, int type);

        [DllImport("kernel32.dll")]
        public static extern bool Beep(int frequency, int duration);

        [DllImport("learnDll.dll")]//, EntryPoint = "fnlearnDll"
        public static extern int fnlearnDll();

        public void PlaySound()
        {
            Random random = new Random();
            for (int i = 0; i < 50; i++)
            {
                Beep(random.Next(10000), 100);
            }
        }

        public MainPage()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, RoutedEventArgs e)
        {
            PlaySound();
            MsgBox(0, "Hello", "Interop", 0);
            //MessageBoxW(IntPtr.Zero, "Hello", "Interop", 0);
            fnlearnDll();
        }
    }

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

USB设备插取识别

public partial class SilverlightControl1 : UserControl
    {
        // Importing a set of necessary native methods from Win32 API.
        [DllImport("User32", EntryPoint = "CreateWindowEx", CharSet = CharSet.Auto, SetLastError = true)]
        static extern IntPtr CreateWindowEx(int dwExStyle, string lpszClassName, string lpszWindowName, int style, int x, int y, int width, int height,
            IntPtr hWndParent, IntPtr hMenu, IntPtr hInst,
            [MarshalAs(UnmanagedType.AsAny)] object pvParam);

        [DllImport("user32.dll")]
        static extern IntPtr DefWindowProc(IntPtr hWnd, int uMsg,
            IntPtr wParam, IntPtr lParam);

        [DllImport("user32", CharSet = CharSet.Auto, SetLastError = true)]
        public static extern short RegisterClass(WNDCLASS wc);

        // Marshaling the Window structure.
        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
        public class WNDCLASS
        {
            public int style;
            public WndProc lpfnWndProc;
            public int cbClsExtra;
            public int cbWndExtra;
            public IntPtr hInstance;
            public IntPtr hIcon;
            public IntPtr hCursor;
            public IntPtr hbrBackground;
            public string lpszMenuName;
            public string lpszClassName;
        }

        //system detects USB insertion/removal
        const int WM_DEVICECHANGE = 0x0219;
        // system detects a new device
        const int DBT_DEVICEARRIVAL = 0x8000;
        // device removed
        const int DBT_DEVICEREMOVECOMPLETE = 0x8004;

        // Callbacks must have AllowReversePInvokeCalls attribute.
        [AllowReversePInvokeCalls]
        private IntPtr Callback(IntPtr hWnd, int msg, IntPtr wparam, IntPtr lparam)
        {
            if (msg == WM_DEVICECHANGE)
            {
                if (wparam.ToInt32() == DBT_DEVICEARRIVAL)
                    textBlock1.Text = "USB inserted";
                if (wparam.ToInt32() == DBT_DEVICEREMOVECOMPLETE)
                    textBlock1.Text = "USB removed";
            }
            return DefWindowProc(hWnd, msg, wparam, lparam);
        }

        public delegate IntPtr WndProc(
            IntPtr hWnd, int msg, IntPtr wParam, IntPtr lParam);

        // Preventing garbage collection of the delegate
        private static WndProc dontGCthis;

        public SilverlightControl1()
        {
            InitializeComponent();

            WNDCLASS wc = new WNDCLASS();

            // Preventing garbage collection of the delegate
            dontGCthis = new WndProc(Callback);
            wc.lpfnWndProc = dontGCthis;

            // Note that you need to ensure unique names     // for each registered class.
            // For example, if you open the same plugin 
            // in two different tabs of the browser,
            // you still should not end up with 
            // two registered classes with identical names.
            wc.lpszClassName = "foobar" + (new Random()).Next();

            RegisterClass(wc);

            IntPtr createResult = CreateWindowEx(0, wc.lpszClassName, "Window title", 0, 100, 100, 500, 500, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, 0);
        }
    }

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

进程实时管理

<UserControl
  x:Class="SilverlightApplication10.MainPage"
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
  xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
  mc:Ignorable="d"
  d:DesignHeight="300"
  d:DesignWidth="400"
  xmlns:sdk="http://schemas.microsoft.com/winfx/2006/xaml/presentation/sdk"
  xmlns:local="clr-namespace:SilverlightApplication10">
  <UserControl.DataContext>
    <local:ProcessViewModel />
  </UserControl.DataContext>
  <Grid
    x:Name="LayoutRoot"
    Margin="6"
    Background="White">
    <Grid.RowDefinitions>
      <RowDefinition
        Height="Auto" />
      <RowDefinition />
    </Grid.RowDefinitions>
    <TextBlock
      Text="Process Information"
      FontSize="16" />
    <sdk:DataGrid
      Grid.Row="1"
      Margin="2"
      AutoGenerateColumns="true" 
      ItemsSource="{Binding Processes}"/>
  </Grid>
</UserControl>

public class PropertyChangeNotification : INotifyPropertyChanged
  {
    protected void RaisePropertyChanged(string property)
    {
      if (this.PropertyChanged != null)
      {
        this.PropertyChanged(this,
          new PropertyChangedEventArgs(property));
      }
    }
    public event PropertyChangedEventHandler PropertyChanged;
  }

using System.ComponentModel;
  using System.Collections.Generic;
  using System.Windows;
  using System.Collections.ObjectModel;
  using System.Linq;
  using System.Windows.Threading;
  using System;
  using System.Threading.Tasks;

  public class ProcessViewModel : PropertyChangeNotification
  {
    public ProcessViewModel()
    {
      if (Application.Current.HasElevatedPermissions)
      {
        BuildInitialProcessList();
      }
    }
    void BuildInitialProcessList()
    {
      this.Processes = new ObservableCollection<Process>();
      BuildProcessList();

      DispatcherTimer timer = new DispatcherTimer();
      timer.Interval = TimeSpan.FromMilliseconds(500);
      timer.Tick += (s, e) => BuildProcessList();
      timer.Start();
    }
    void BuildProcessList()
    {
      IEnumerable<Process> newProcesses = Process.EnumerateCurrentList();

      var newProcsOuterJoinedExisting =
        from np in newProcesses
        join op in this.Processes
        on np.Id equals op.Id into joinGroup
        from gp in joinGroup.DefaultIfEmpty()
        select new { NewProcess = np, OldProcess = gp };

      foreach (var item in newProcsOuterJoinedExisting.ToList())
      {
        if (item.OldProcess == null)
        {
          this.Processes.Add(item.NewProcess);
        }
        else
        {
          item.OldProcess.Refresh();
        }
      }

      var remainingListOuterJoinedNewProcs =
        from cp in this.Processes
        join np in newProcesses
        on cp.Id equals np.Id into joinGroup
        from gp in joinGroup.DefaultIfEmpty()
        select new { CurrentProcess = cp, NewProcess = gp };

      foreach (var item in remainingListOuterJoinedNewProcs.ToList())
      {
        if (item.NewProcess == null)
        {
          this.Processes.Remove(item.CurrentProcess);
        }
      }
    }
    public ObservableCollection<Process> Processes
    {
      get
      {
        return (_Processes);
      }
      set
      {
        _Processes = value;
        RaisePropertyChanged("Processes");
      }
    }
    ObservableCollection<Process> _Processes;
  }

using System;
  using System.Collections.Generic;
  using System.Runtime.InteropServices;
  using System.Text;
  using System.IO;

  internal class Win32Exception : Exception
  {
    public Win32Exception(string message, int errorCode)
      : base(message)
    {
      this.ErrorCode = errorCode;
    }
    public int ErrorCode { get; private set; }
  }
  public class Process : PropertyChangeNotification
  {
    [StructLayout(LayoutKind.Sequential)]
    struct PROCESS_MEMORY_COUNTERS
    {
      public UInt32 cb;
      public UInt32 PageFaultCount;
      public UIntPtr PeakWorkingSetSize;
      public UIntPtr WorkingSetSize;
      public UIntPtr QuotaPeakPagedPoolUsage;
      public UIntPtr QuotaPagedPoolUsage;
      public UIntPtr QuotaPeakNonPagedPoolUsage;
      public UIntPtr QuotaNonPagedPoolUsage;
      public UIntPtr PagefileUsage;
      public UIntPtr PeakPagefileUsage;
    };

    public Process(UInt32 processId)
    {
      this.Id = processId;
    }
    public UInt32 Id { get; private set; }

    public UInt64 WorkingSetBytes
    {
      get
      {
        PROCESS_MEMORY_COUNTERS counters;
        IntPtr handle = GetHandle();

        try
        {
          if (!GetProcessMemoryInfo(handle, out counters,
            (UInt32)Marshal.SizeOf(typeof(PROCESS_MEMORY_COUNTERS))))
          {
            throw new Win32Exception("Failed to get memory info",
              Marshal.GetLastWin32Error());
          }
        }
        finally
        {
          CloseHandle(handle);
        }
        return (counters.WorkingSetSize.ToUInt64());
      }
    }

    public void Refresh()
    {
      this.RaisePropertyChanged("WorkingSetBytes");
    }

    public string ImageName
    {
      get
      {
        if (string.IsNullOrEmpty(this.imageName))
        {
          UInt32 capacity = 128;
          StringBuilder builder = new StringBuilder((int)capacity);

          IntPtr handle = GetHandle();

          try
          {
            while (GetProcessImageFileName(handle, builder, capacity) == 0)
            {
              int errorCode = Marshal.GetLastWin32Error();

              if (errorCode == ERROR_INSUFFICIENT_BUFFER)
              {
                capacity *= 2;
                builder = new StringBuilder((int)capacity);
              }
              else
              {
                throw new Win32Exception("Failed to get image name", errorCode);
              }
            }
            this.imageName = Path.GetFileName(builder.ToString());
          }
          finally
          {
            CloseHandle(handle);
          }
        }
        return (this.imageName);
      }
    }
    string imageName;

    IntPtr GetHandle()
    {
      IntPtr handle = OpenProcess(PROCESS_QUERY_INFORMATION, false, this.Id);

      if (handle == IntPtr.Zero)
      {
        throw new Win32Exception("Failed to open process",
          Marshal.GetLastWin32Error());
      }
      return (handle);
    }
    static bool TryOpenProcess(UInt32 id)
    {
      IntPtr ptr = OpenProcess(PROCESS_QUERY_INFORMATION, false, id);

      if (ptr != IntPtr.Zero)
      {
        CloseHandle(ptr);
      }
      return (ptr != IntPtr.Zero);
    }
    public static IEnumerable<Process> EnumerateCurrentList()
    {
      foreach (var processId in EnumerateProcessIds())
      {
        if (TryOpenProcess(processId))
        {
          yield return new Process(processId);
        }
      }
    }
    static IEnumerable<UInt32> EnumerateProcessIds()
    {
      UInt32[] processIds = new UInt32[32];
      bool retry = true;

      while (retry)
      {
        processIds = new UInt32[processIds.Length * 2];

        UInt32 arraySize =
          (UInt32)(Marshal.SizeOf(typeof(UInt32)) * processIds.Length);

        UInt32 bytesCopied = 0;

        retry = EnumProcesses(processIds, arraySize, out bytesCopied);

        if (retry)
        {
          retry = (bytesCopied == arraySize);
        }
        else
        {
          throw new Win32Exception("Failed enumerating processes",
            Marshal.GetLastWin32Error());
        }
      }
      return (processIds);
    }

    [DllImport("psapi", SetLastError = true)]
    static extern bool EnumProcesses(
      [MarshalAs(UnmanagedType.LPArray)] [In] [Out] UInt32[] processIds,
      UInt32 processIdsSizeBytes,
      out UInt32 bytesCopied);

    [DllImport("kernel32", SetLastError = true)]
    static extern IntPtr OpenProcess(UInt32 dwAccess, bool bInheritHandle,
      UInt32 dwProcessId);

    [DllImport("kernel32")]
    static extern bool CloseHandle(IntPtr handle);

    [DllImport("psapi", SetLastError = true)]
    static extern UInt32 GetProcessImageFileName(
      IntPtr processHandle,
      [In] [Out] StringBuilder lpImageFileName,
      UInt32 bufferSizeCharacters);

    [DllImport("psapi", SetLastError = true)]
    static extern bool GetProcessMemoryInfo(
      IntPtr processHandle,
      out PROCESS_MEMORY_COUNTERS counters,
      UInt32 dwSize);

    static readonly UInt32 PROCESS_QUERY_INFORMATION = 0x0400;
    const int ERROR_ACCESS_DENIED = 5;
    const int ERROR_INVALID_PARAMETER = 87;
    const int ERROR_INSUFFICIENT_BUFFER = 122;
  }

本文链接

Visual Studio2010中使用IE调试Atl

2011-12-20T08:30:00Z

项目属性：

Command: C:\Program Files (x86)\Internet Explorer\iexplore.exe

Command Arguments: c:\A1Atl\A2Atl\A2Ctl.htm

注册表：

在“HKEY_CURRENT_USER\Software\Microsoft\Internet Explorer\Main”下新建类型为DWORD(32)、名为TabProcGrowth、值为D的键。

策略：

运行gpedit.msc组策略管理器。在“计算机配置—》管理模板—》windows组件—》Internet Explore”中打开“选项卡进程增长”，设置为已启用，选项卡进程增长为0

调试：

最后，设置断点，按F5运行起来，就可以调试了。

本文链接

C#与C++之间类型的对应

2011-12-19T16:13:00Z

C#与C++之间类型的对应

Windows Data Type	.NET Data Type
BOOL, BOOLEAN	Boolean or Int32
BSTR	String
BYTE	Byte
CHAR	Char
DOUBLE	Double
DWORD	Int32 or UInt32
FLOAT	Single
HANDLE (and all other handle types, such as HFONT and HMENU)	IntPtr, UintPtr or HandleRef
HRESULT	Int32 or UInt32
INT	Int32
LANGID	Int16 or UInt16
LCID	Int32 or UInt32
LONG	Int32
LPARAM	IntPtr, UintPtr or Object
LPCSTR	String
LPCTSTR	String
LPCWSTR	String
LPSTR	String or StringBuilder*
LPTSTR	String or StringBuilder
LPWSTR	String or StringBuilder
LPVOID	IntPtr, UintPtr or Object
LRESULT	IntPtr
SAFEARRAY	.NET array type
SHORT	Int16
TCHAR	Char
UCHAR	SByte
UINT	Int32 or UInt32
ULONG	Int32 or UInt32
VARIANT	Object
VARIANT_BOOL	Boolean
WCHAR	Char
WORD	Int16 or UInt16
WPARAM	IntPtr, UintPtr or Object

另：在进行string转换时，需要加入前缀[MarshalAs(UnmanagedType.LPStr)]lpdword 对应于 ref int

C/C++	C#
HANDLE, LPDWORD, LPVOID, void*	IntPtr
LPCTSTR, LPCTSTR, LPSTR, char, const char, Wchar_t*, LPWSTR	String [in], StringBuilder [in, out]
DWORD, unsigned long, Ulong	UInt32, [MarshalAs(UnmanagedType.U4)]
bool	bool
LP<struct>	[In] ref <struct>
SIZE_T	uint
LPDWORD	out uint
LPTSTR	[Out] StringBuilder
PULARGE_INTEGER	out ulong
WORD	uInt16
Byte, unsigned char	byte
Short	Int16
Long, int	Int32
float	single
double	double
NULL pointer	IntPtr.Zero
Uint	Uint32

C#调用DLL文件时参数对应表

Wtypes.h中的非托管类型非托管 C语言类型        托管类名                说明
HANDLE           void*                     System.IntPtr                 32 位
BYTE             unsigned char             System.Byte                  8 位
SHORT            short                     System.Int16                16 位
WORD              unsigned short           System.UInt16                 16 位
INT               int                      System.Int32                  32 位
UINT               unsigned int            System.UInt32                 32 位
LONG              long                     System.Int32                  32 位
BOOL              long                     System.Int32                  32 位
DWORD             unsigned long            System.UInt32                 32 位
ULONG              unsigned long           System.UInt32                 32 位
CHAR              char                     System.Char                   用 ANSI 修饰。
LPSTR             char*              System.String 或 System.StringBuilder   用 ANSI 修饰。
LPCSTR            Const char*        System.String 或System.StringBuilder   用 ANSI 修饰。
LPWSTR            wchar_t*           System.String 或System.StringBuilder   用 Unicode 修饰。
LPCWSTR           Const wchar_t*     System.String 或System.StringBuilder   用 Unicode 修饰。
FLOAT              Float             System.Single                       32 位
DOUBLE             Double            System.Double                       64 位

习惯用C#写东西,但平时又会碰到很多要用win32 API的地方,所以经常要用DllImport,但win32函数的类型写法是很庞杂的,相信为之困扰的不止我一个,现在我整理一份我个人的理解如下,希望高人不吝赐教。
我的基本原则有如下几点:
1、下面都是针对32位系统的，所以int是32位.long也是32位；
2、各种句柄类的(H开头)，我认为一律是System.IntPtr，到目前为止没发现出错；如果哪位在使用中出错，请指出；
3、LP和P，我实在不懂(对C 不太了解)，对于LP和P开头的函数，如果是和STR有关的，一律写为System.String，像PLCID这样指向什么东西的，写为System.UInt32(因为指向另一个地址，那就是指针，指针是32位吧)，int之类的数值型，那我就写为int[]，以方便.net程序引用(写成System.UInt32的话，给API调用应该也不会出错，但.net程序就不好引用了)

如有意见，欢迎指教。谢谢

BOOL=System.Int32
BOOLEAN=System.Int32
BYTE=System.UInt16
CHAR=System.Int16
COLORREF=System.UInt32
DWORD=System.UInt32
DWORD32=System.UInt32
DWORD64=System.UInt64
FLOAT=System.Float
HACCEL=System.IntPtr
HANDLE=System.IntPtr
HBITMAP=System.IntPtr
HBRUSH=System.IntPtr
HCONV=System.IntPtr
HCONVLIST=System.IntPtr
HCURSOR=System.IntPtr
HDC=System.IntPtr
HDDEDATA=System.IntPtr
HDESK=System.IntPtr
HDROP=System.IntPtr
HDWP=System.IntPtr
HENHMETAFILE=System.IntPtr
HFILE=System.IntPtr
HFONT=System.IntPtr
HGDIOBJ=System.IntPtr
HGLOBAL=System.IntPtr
HHOOK=System.IntPtr
HICON=System.IntPtr
HIMAGELIST=System.IntPtr
HIMC=System.IntPtr
HINSTANCE=System.IntPtr
HKEY=System.IntPtr
HLOCAL=System.IntPtr
HMENU=System.IntPtr
HMETAFILE=System.IntPtr
HMODULE=System.IntPtr
HMONITOR=System.IntPtr
HPALETTE=System.IntPtr
HPEN=System.IntPtr
HRGN=System.IntPtr
HRSRC=System.IntPtr
HSZ=System.IntPtr
HWINSTA=System.IntPtr
HWND=System.IntPtr
INT=System.Int32
INT32=System.Int32
INT64=System.Int64
LONG=System.Int32
LONG32=System.Int32
LONG64=System.Int64
LONGLONG=System.Int64
LPARAM=System.IntPtr
LPBOOL=System.Int16[]
LPBYTE=System.UInt16[]
LPCOLORREF=System.UInt32[]
LPCSTR=System.String
LPCTSTR=System.String
LPCVOID=System.UInt32
LPCWSTR=System.String
LPDWORD=System.UInt32[]
LPHANDLE=System.UInt32
LPINT=System.Int32[]
LPLONG=System.Int32[]
LPSTR=System.String
LPTSTR=System.String
LPVOID=System.UInt32
LPWORD=System.Int32[]
LPWSTR=System.String
LRESULT=System.IntPtr
PBOOL=System.Int16[]
PBOOLEAN=System.Int16[]
PBYTE=System.UInt16[]
PCHAR=System.Char[]
PCSTR=System.String
PCTSTR=System.String
PCWCH=System.UInt32
PCWSTR=System.UInt32
PDWORD=System.Int32[]
PFLOAT=System.Float[]
PHANDLE=System.UInt32
PHKEY=System.UInt32
PINT=System.Int32[]
PLCID=System.UInt32
PLONG=System.Int32[]
PLUID=System.UInt32
PSHORT=System.Int16[]
PSTR=System.String
PTBYTE=System.Char[]
PTCHAR=System.Char[]
PTSTR=System.String
PUCHAR=System.Char[]
PUINT=System.UInt32[]
PULONG=System.UInt32[]
PUSHORT=System.UInt16[]
PVOID=System.UInt32
PWCHAR=System.Char[]
PWORD=System.Int16[]
PWSTR=System.String
REGSAM=System.UInt32
SC_HANDLE=System.IntPtr
SC_LOCK=System.IntPtr
SHORT=System.Int16
SIZE_T=System.UInt32
SSIZE_=System.UInt32
TBYTE=System.Char
TCHAR=System.Char
UCHAR=System.

Wtypes.h 中的非托管类型	非托管 C 语言类型	托管类名	说明
HANDLE	void*	System.IntPtr	在 32 位 Windows 操作系统上为 32 位，在 64 位 Windows 操作系统上为 64 位。
BYTE	unsigned char	System.Byte	8 位
SHORT	short	System.Int16	16 位
WORD	unsigned short	System.UInt16	16 位
INT	int	System.Int32	32 位
UINT	unsigned int	System.UInt32	32 位
LONG	long	System.Int32	32 位
BOOL	long	System.Int32	32 位
DWORD	unsigned long	System.UInt32	32 位
ULONG	unsigned long	System.UInt32	32 位
CHAR	char	System.Char	用 ANSI 修饰。
LPSTR	char*	System.String 或 System.Text.StringBuilder	用 ANSI 修饰。
LPCSTR	Const char*	System.String 或 System.Text.StringBuilder	用 ANSI 修饰。
LPWSTR	wchar_t*	System.String 或 System.Text.StringBuilder	用 Unicode 修饰。
LPCWSTR	Const wchar_t*	System.String 或 System.Text.StringBuilder	用 Unicode 修饰。
FLOAT	Float	System.Single	32 位
DOUBLE	Double	System.Double	64 位

本文链接

Apple Mac Os 10.6 雪豹--VirtualBox+AMD CPU

2011-12-10T14:06:00Z

一、PC环境配置(本文的测试环境)

　　操作系统：Windows 7 x64
　　虚拟机：VirtualBox 4.1.6
　　CPU：AMD K12 Athlon II X4 631四核
　　内存：金士顿 DDR3 1333 4G x 2
　　主板：技嘉GA-A55-S3P(AMD K12)
　　显卡：NVIDIA GeForce 210(1GB)
　　声卡：瑞昱ALC 887 高保真音频
　　网卡：瑞昱RTL8168E PCI-E Gigabit Ethernet NIC/技嘉

二、相关资源的下载

　　查看CPU是否支持虚拟化技术的软件：Securable
　　虚拟机软件：VirtualBox
　　Apple Mac OS X：Snow Leopard Universal 10.6(432)GM (下载地址1，下载地址2)
　　启动盘：LegacyBootCD.iso (EmpireEFI1085_AMD.zip)

不同类型的CPU需要下载对应的启动盘镜像文件，请参考 Empire EFI v 1.085 is out 页面的详细说明。

三、安装步骤

1、开启CPU的虚拟化技术支持

虚拟机安装Mac OS系统须CPU支持虚拟技术，故需先测试CPU是否已经开启虚拟技术，如果还未开启则需先开启；如果CPU不支持虚拟技术，本文基本上就不适用了。这时可以参考网上说的使用 VMLite 的另类安装方法，这个就没试过了。

　　运行上面下载的 Securable.exe 文件，界面如下：

当测试结果显示为“Hardware Virtualization YES”或者“Hardware Virtualization Locked On”之类的字眼就证明已经开启了CPU的虚拟技术支持了。我使用的是华硕m4a88t-m主板，bois中需要将 Advanced/Secure Virtual Machine Mode 的值设置为Enabled （默认是Disabled）。

2、新建 VirtualBox 虚拟机

新建的虚拟机，操作系统选择 Mac OS X，操作系统版本选择 Mac OS X Server，内存不小于1024MB，硬盘大小不小于20GB即可，参考下图：

3、编辑新建的虚拟机配置

打开虚拟机的配置页面，设置如下几项：

“系统/主板/启动顺序”设置为光驱排头、硬盘第二，“系统/主板/扩展特征”中将“启用 EFI”禁用；“显示/显卡/显存大小”调到最大128MB，“显示/显卡/扩展特征”中将“启用3D加速”启用；“Storage/存储树”中添加上面下载的 LegacyBootCD.iso 镜像文件到第一启动光驱；

截图参考如下：

4、启动新建的虚拟机

启动上面配置好的虚拟机，等待一会后，将启动到如下界面：

　　此时鼠标右键点击右下角的光驱图标，卸载 LegacyBootCD.iso 后再加载上面下载的 Snow Leopard Universal 10.6(432)GM 对应的dmg镜像文件。dmg文件选择后，按 F5 键后，界面中的 Legacy EmpireEFI 图标将变为 Mac OS X Install DVD 图标,如下：

　　此时按回车键，待那个青蛙界面过后就可以进入系统的安装界面了。

5、开始安装 Mac OS X

　　直到安装到如下界面，由于硬盘没格式化，需要进行处理：

　　此时点击顶部的菜单“实用工具/磁盘工具...”，对硬盘按如下图执行抹掉操作，然后点击顶部的菜单“磁盘工具/退出磁盘工具”。

　　此时就可以看到可选的硬盘了，如下图所示，选中后按继续按钮开始漫长的安装过程，大约需要30分钟：

　　安装完毕后将看到如下界面：

　　虽然提示安装失败，但其实已经成功安装完毕了。在这个界面将右下角的光驱重新加载为LegacyBootCD.iso，然后重新启动虚拟机（可能需要先强制关闭虚拟机），重新启动后的界面如下图：

　　启动菜单中已经多出了 MacOSX 选项，选中后回车就可正常启动到 Mac OS X 系统了。首次启动到 Mac OS X 会要求填写一些基本的信息、创建帐号等，最后将到达Mac的桌面了，如下图所示：

　　至此Mac OS X系统安装完毕！

VirtualBox设置注意：

　　常用-基本-版本Mac OS Server(64 bit)

　　系统-主板-启动顺序勾选“光驱”、“硬盘”；扩展特性勾选“启用 IO APIC”、“Enable absolute pointing device”,不勾选“启用EFI(只针对某些操作系统)”和“Hardware clock in UTC time”

　　　　-硬件加速-硬件虚拟-勾选“启用VT-x/AMD-V”、“启用Nested Paging”

　　显示-显卡-显存大小调到最大（128MB）;扩展特性勾选“启用3D加速”。

引导注意：

　　LegacyBootCD引导后如进入到命令行“Shell>”，注意"VirtualBox设置注意"；引导并开始安装系统如长时间出现青蛙画面，则退出虚拟机，重新操作一遍即可。

其它：

　　进入系统后，进入腾迅主页下载QQ，百度搜索一下"Chinaese BP"(五笔输入法)，用上一会儿，熟悉一下，况且当是新的windows，过过新鲜感吧，虽然也就一阵子。新的系统，感觉是少了点什么，比如开发工具，可xcode太大、一下下载不了，只能够下一回合再摸上一摸了。

　　需要续传下载，可以安装个mac版迅雷，地址是http://www.chinamac.com/download/mac8980.html

驱动：

　　http://www.son1c.cn/show/350.html

本文链接

win32中调用Atl控件

2011-12-07T12:08:00Z

问了多位c++程序员，win32群里的朋友如何在Win32中调用Atl控件，也游了开源网站一回，均无结果，按照微软msdn给出的步骤也没有搞定。搜索引擎找了无数篇文件，终于找到可行的方法，故记录于此。

第一步、创建Win32 Project项目，Application Settings窗口中勾选“ATL”

第二步、添加引用

#pragma comment(lib, "atl.lib")
//#include <atldef.h>
//#include <atliface.h>
//#define _ATL_DLL_IMPL
//using namespace ATL

第三步、调用ATL

//“{}”中为被调用Atl控件的guid

CComModule _Module;
_Module.Init(NULL, hInst);
HWND hWnd1 = CreateWindow("AtlAxWin", "",WS_CHILD|WS_VISIBLE|WS_OVERLAPPEDWINDOW, 10, 10,300, 300,
	hWnd, NULL, hInst, NULL );
USES_CONVERSION;
CComPtr<IUnknown> spUnk;
CoInitialize(spUnk);
HRESULT hRet = AtlAxCreateControl(T2COLE("{FCB4D80C-E22E-41AB-8C0F-0E7B9377B6F8}"), hWnd, NULL, &spUnk);
//if(FAILED(hRet))
//	return -1;
//_Module.Terminate();
_Module.Term();

其它方式（调用未成功）

#include <atlbase.h>
#include <atlwin.h>
CAxWindow wnd;
RECT rect = {240,240,240,240};
HWND hh= wnd.Create(hWnd, rect, "{FCB4D80C-E22E-41AB-8C0F-0E7B9377B6F8}",WS_CHILD|WS_VISIBLE,NULL,0U,NULL);

其它方式（调用未成功）

CreateAxControl

参考资料

http://support.microsoft.com/kb/218442/EN-US

http://www.codeguru.com/cpp/com-tech/atl/activex/article.php/c69

http://support.microsoft.com/kb/192560

http://social.msdn.microsoft.com/Forums/zh-CN/windowssdk/thread/88a981ea-8125-4917-a45e-87cfbc7fd1dd

http://tieba.baidu.com/f?kz=1123748307

本文链接

html5的迷人之处

2011-12-02T09:00:00Z

移动互联网领域，随着Adobo放弃flash、转投html5以及微软Silveright仅发展到5.0版，注定了html5将成为新的热门，虽然尚需要一段时间。

第一，html5是在已有技术基础之上的新版本，上手较苹果、c++容易得多，且性能接近桌面应用。

其二，html5只要有个记事本和支持它的浏览器就可以开发、调试和运行，简化了对特定环境的依赖，和诸如编译之类的等待过程。

第三，html5不仅可以在支持它的浏览器，包括PC和移动设备，上面跑起来，也可以在桌面上像桌面应该一样跑起来，甚至让你认为它就是桌面应用。

第四，无须交费成为商店会员，还要通过认证才能够发布应用，省去很多麻烦。众所周知，应用商店（特别是app store)有一定门槛的，不符合规定意味着无法发布；android商店除了有官方的也还有很多地区的、各种各样的，而且要成为会员到发布，门槛多多，不容易。金融时报为此，就曾下架其在app store上的应用，改用html5，因此短时间积累了大量的用户，大赚一笔;全球最大婚恋网站之一Match.com的iOS应用，理由是该应用允许用户通过一个网页绕开苹果应用内支付使用信用卡直接付帐，这意味着苹果无法从支付中取得30%的分成。

如何将html5包装成桌面应用？

初中末期，就有把html当做桌面应用来玩，很简单的，把扩展名改为.hta即可。内容可以用htm5来写，但可惜调用的内核用的是ie的，所以webgl等微软不支持的部分无法使用。

总之，一个新事情，若能够达到甚至超越已有事物所能够带来的，同时简介其实现的过程，那没有不受欢迎的，最终到底如何，试目（用）以试吧！

最后介绍几个html5相关的框架：

Appcelerator http://www.oschina.net/p/appcelerator

PhoneGap http://phonegap.com/

weinre

本文链接

silveright使用配置文件-转

2011-12-02T06:23:00Z

首先，在工程中创建一个XML文件，可以取名为app.config。
 
　　记得放在工程的根目录，方便后面设置路径。把Build Action设成Resource，关于Build Action的说明可以在这里找到。
 
　　随便在app.config中写点东西
 
<?xml version="1.0" encoding="utf-8" ?>
 
<configuration>
 
  <appSettings>
 
    <add key="name" value="srzhz"/>
 
    <add key="university" value="Tsinghua University"/>
 
  </appSettings>
 
</configuration>
 
　　然后要开始创建这个ConfigurationManager类了。
 
　　首先在工程上按右键点击Add Reference，之后选择System.Xml.Linq。(如果没加的话无法引入命名空间System.Xml.Linq)
 
　　然后在ConfigurationManager类中写入如下代码
 
using System;
 using System.Windows;
 using System.Collections.Generic;
 using System.Windows.Resources;
 using System.IO;
 using System.Xml.Linq;
 using System.Reflection;
 
namespace Model
 {
     /// <summary>
 
    /// Access appSettings from a configuration file
 
    /// </summary>
 
    /// <remarks>Your appConfig file must be in the root of your applcation</remarks>
 
    public static class ConfigurationManager
     {
         static ConfigurationManager()
         {
             AppSettings = new Dictionary<string, string>();
             ReadSettings();
         }
 
        public static Dictionary<string, string> AppSettings { get; set; }
         private static void ReadSettings()
         {
             // Get the name of the executing assemby - we are going to be looking in the root folder for
             // a file called app.config
             string assemblyName = Assembly.GetExecutingAssembly().FullName;
             assemblyName = assemblyName.Substring(0, assemblyName.IndexOf(','));
             string url = String.Format("{0};component/app.config", assemblyName);
             StreamResourceInfo configFile = Application.GetResourceStream(new Uri(url, UriKind.Relative));
             if (configFile != null && configFile.Stream != null)
             {
                 Stream stream = configFile.Stream;
                 XDocument document = XDocument.Load(stream);
                 foreach (XElement element in document.Descendants("appSettings").DescendantNodes())
                 {
                     AppSettings.Add(element.Attribute("key").Value, element.Attribute("value").Value);
                 }
             }
         }
     }
 }
 
　　之后你就可以通过调用这个类来获得配置信息了。例如：
 
String name = ConfigurationManager.AppSettings["name"];

Build Action为Content的文件读取方式为：

//Uri uri = new Uri("/SilverlightApplication7;component/remark.txt", UriKind.Relative);
            Uri uri = new Uri("app.config", UriKind.Relative);
            StreamResourceInfo sri = Application.GetResourceStream(uri);
            System.IO.StreamReader reader = new System.IO.StreamReader(sri.Stream);
            MessageBox.Show(reader.ReadToEnd());

本文链接