博客园-飘遥的Blog

仿Win7显示桌面的工具

飘遥(Zhenxing Zhou) — Fri, 29 Jan 2010 20:42:00 GMT

阅读: 1881 评论: 14 作者: 飘遥(Zhenxing Zhou) 发表于 2010-01-30 04:42 原文链接

Win7改进了许多用户体验，其中右下角显示桌面的按钮是最舒心的功能之一。为了在没装Win7的开发机上体验这个功能，写了下面的小工具。
Win7中，鼠标拖到最右下角，点击左键，便可以显示桌面。

在用户体验上，右下角是一个无限大的区域(黄色边框范围)，因为鼠标被限制在屏幕范围内；与屏幕中某块孤立范围相比，操作的命中率大大提高。
要实现这样的工具，思路非常简单：取得屏幕分辨率；在最右下角放置按钮或类似控件；点击时触发显示桌面；OK。当然还有一些细节如任务栏并不一定是在屏幕下方；最好不要影响到用户的正常操作，在用户不想看的时候甚至不要让用户看到；设置开机自动启动等。

按照这样的思路一点点实现即可。
取得任务栏，在上面添加子窗口：

hWndTray = FindWindow(TEXT("Shell_TrayWnd"), NULL);

CreateWindow(szWindowClass, szTitle, WS_CHILD,
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, hWndTray, NULL, hInstance, NULL);

根据任务栏的位置不同，设置子窗口的位置及大小：

RECT rectTray, rectWnd;
const int CTL_LENGTH = 10;

if(!GetWindowRect(hWndTray, &rectTray))
{
    MessageBox(hWnd, TEXT("Get task bar size failed!"), szTitle, MB_OK);
    return FALSE;
}

if(rectTray.bottom - rectTray.top < rectTray.right - rectTray.left)
{
    //horizon
    rectWnd.left = rectTray.right - rectTray.left - CTL_LENGTH;
    rectWnd.right = rectWnd.left + CTL_LENGTH;
    rectWnd.top = 0;
    rectWnd.bottom = rectTray.bottom - rectTray.top;
}
else
{
    //vertical
    rectWnd.left = 0;
    rectWnd.right = rectTray.right - rectTray.left;
    rectWnd.top = rectTray.bottom - rectTray.top - CTL_LENGTH;
    rectWnd.bottom = rectWnd.top + CTL_LENGTH;
}

SetWindowPos(hWnd, NULL, rectWnd.left, rectWnd.top, rectWnd.right - rectWnd.left, rectWnd.bottom - rectWnd.top, 0);

显示桌面调用SHELL的COM对象。

IShellDispatch4 * pshDsp4;
CoCreateInstance(CLSID_Shell, NULL, CLSCTX_SERVER, IID_IDispatch, (VOID**)&pshDsp4);
pshDsp4 ->ToggleDesktop();

如果设置为自动运行，在注册表HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Run下添加键值。
在程序运行中，如果主题修改或任务栏位置修改，需要更新窗口的位置，处理WM_SETTINGCHANGE消息即可。

要使子窗口透明，程序实现上比较麻烦，可以阻止系统对WM_ERASEBKGND消息的默认处理，以达到窗口“透明”的目的(不处理背景重绘，当然某些情况下会显示不正常)。

最终运行截图：(点右键显示的菜单)

在WinXP，Win7简单测试通过。

源码及可执行程序下载：点击下载

评论: 14　查看评论　发表评论

最新新闻：
· 京东商城刘强东：两个回合谈定1.5亿美元融资(2010-02-10 11:30)
· Google走到关键时刻：Buzz发布的背后(2010-02-10 11:30)
· 李开复创新工场发展基金曝光首单投移动互联(2010-02-10 11:28)
· Sun前CEO欲写自传称经济危机是Sun被购主因(2010-02-10 11:25)
· Google社会化产品Buzz发布会实录(2010-02-10 11:15)

编辑推荐：Google社会化产品Buzz发布会实录

网站导航：博客园首页个人主页新闻闪存小组博问社区知识库

Deep Zoom Composer初探

飘遥(Zhenxing Zhou) — Sun, 16 Aug 2009 09:50:00 GMT

阅读: 71 评论: 0 作者: 飘遥(Zhenxing Zhou) 发表于 2009-08-16 17:50 原文链接

安装Win7 RTM后发现很好用，查了下MS OS历史，顺手试验了一下Deep Zoom Composer，做了个查看MS OS历史的Silverlight应用。
运行效果：
http://www.xianfen.net/Article131.aspx
(貌似这里不能用iframe嵌入)
以上实现没有进行任何编码，并且生成的文件不再像以前的二进制格式，而是XML格式的纯文本件。
MS OS历史资料来源：http://www.levenez.com/windows

评论: 0　查看评论　发表评论

编辑推荐：Google社会化产品Buzz发布会实录

网站导航：博客园首页个人主页新闻闪存小组博问社区知识库

ASP.NET VirtualPathProvider (下)

飘遥(Zhenxing Zhou) — Sun, 26 Jul 2009 11:42:00 GMT

阅读: 209 评论: 0 作者: 飘遥(Zhenxing Zhou) 发表于 2009-07-26 19:42 原文链接

上一篇介绍了VirtualPathProvider中虚拟文件的实现，参考：ASP.NET VirtualPathProvider (上)。
文件系统中，只有文件是不完整的，还要有目录。本篇介绍VirtualPathProvider中的虚拟目录实现。

实现代码：

using System.Collections;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using System.Web;
using System.Web.Caching;
using System.Web.Hosting;

namespace Xianfen.Net.MyVirtualPathProvider_Directory
{
    public class MyVirtualPathProvider : VirtualPathProvider
    {
        public static void AppInitialize()
        {
            HostingEnvironment.RegisterVirtualPathProvider(new MyVirtualPathProvider());
        }

        bool IsVirtualFile(string vPath)
        {
            return Regex.IsMatch(vPath, @".*vfile\d{1}\.aspx", RegexOptions.IgnoreCase);
        }

        bool IsVirtualDirectory(string vPath)
        {
            string relativePath = VirtualPathUtility.ToAppRelative(vPath);

            return Regex.IsMatch(relativePath, @"~/vdir\d{1}/.*", RegexOptions.IgnoreCase);
        }

        public override bool FileExists(string virtualPath)
        {
            if (IsVirtualFile(virtualPath))
            {
                return true;
            }
            else
            {
                return Previous.FileExists(virtualPath);
            }
        }

        public override CacheDependency GetCacheDependency(string virtualPath, IEnumerable virtualPathDependencies, System.DateTime utcStart)
        {
            if (IsVirtualFile(virtualPath))
            {
                return null;
            }
            else
            {
                return base.GetCacheDependency(virtualPath, virtualPathDependencies, utcStart);
            }
        }

        public override bool DirectoryExists(string virtualDir)
        {
            if (IsVirtualDirectory(virtualDir))
            {
                return true;
            }
            else
            {
                return base.DirectoryExists(virtualDir);
            }
        }

        public override VirtualDirectory GetDirectory(string virtualDir)
        {
            if (IsVirtualDirectory(virtualDir))
            {
                return new MyVirtualDirectory(virtualDir);
            }
            else
            {
                return Previous.GetDirectory(virtualDir);
            }
        }

        public override VirtualFile GetFile(string virtualPath)
        {
            virtualPath = virtualPath.ToLower();

            if (IsVirtualFile(virtualPath))
            {
                return new MyVirtualFile(virtualPath);
            }
            else
            {
                return Previous.GetFile(virtualPath);
            }
        }
    }
}

namespace Xianfen.Net.MyVirtualPathProvider_Directory
{
    public class MyVirtualFile : VirtualFile
    {
        private string myPath;

        public MyVirtualFile(string virtualPath)
            : base(virtualPath)
        {
            myPath = virtualPath;
        }

        public override Stream Open()
        {
            Stream stream = new MemoryStream();
            StreamWriter sw = new StreamWriter(stream);
            StreamReader sr = null;

            try
            {
                string content = File.ReadAllText(HttpContext.Current.Server.MapPath("~/App_Data/htm.txt"), Encoding.UTF8);
                content = content.Replace("$currentfile$", myPath);

                sw.Write(content);
                sw.Flush();
                stream.Seek(0, SeekOrigin.Begin);

                return stream;
            }
            finally
            {
                if (sr != null)
                {
                    sr.Close();
                    sr.Dispose();
                }
            }
        }
    }

    public class MyVirtualDirectory : VirtualDirectory
    {
        string vDir = null;
        ArrayList children = new ArrayList();
        ArrayList dirs = new ArrayList();
        ArrayList files = new ArrayList();

        public MyVirtualDirectory(string virtualDirectory)
            : base(virtualDirectory)
        {
            vDir = virtualDirectory;
            InitData();
        }

        private void InitData()
        {
            if (string.IsNullOrEmpty(vDir))
            {
                children.Add("vdir1");
                children.Add("vdir2");
                children.Add("vdir3");
                children.Add("vdir4");

                dirs.Add("vdir1");
                dirs.Add("vdir2");
                dirs.Add("vdir3");
                dirs.Add("vdir4");

                children.Add("vfile1.aspx");
                children.Add("vfile2.aspx");
                children.Add("vfile3.aspx");
                children.Add("vfile4.aspx");

                files.Add("vfile1.aspx");
                files.Add("vfile2.aspx");
                files.Add("vfile3.aspx");
                files.Add("vfile4.aspx");
            }
            else
            {
                children.Add("vfile1.aspx");
                children.Add("vfile2.aspx");
                children.Add("vfile3.aspx");
                children.Add("vfile4.aspx");

                files.Add("vfile1.aspx");
                files.Add("vfile2.aspx");
                files.Add("vfile3.aspx");
                files.Add("vfile4.aspx");
            }
        }

        public override System.Collections.IEnumerable Children
        {
            get { return children; }
        }

        public override System.Collections.IEnumerable Directories
        {
            get { return dirs; }
        }

        public override System.Collections.IEnumerable Files
        {
            get { return files; }
        }
    }
}

首先定义了虚拟路径提供者，然后实现了虚拟文件和虚拟目录。值得一提的是，实现虚拟路径时，必须重载VirtualPathProvider的GetCacheDependency方法，可以实现自己的CacheDependency或直接返回null，否则会抛出找不到目录的异常。

运行截图：

评论: 0　查看评论　发表评论

编辑推荐：Google社会化产品Buzz发布会实录

网站导航：博客园首页个人主页新闻闪存小组博问社区知识库

Silverlight3离线运行

飘遥(Zhenxing Zhou) — Fri, 17 Jul 2009 11:21:00 GMT

阅读: 268 评论: 0 作者: 飘遥(Zhenxing Zhou) 发表于 2009-07-17 19:21 原文链接

Silverlight3几天前正式发布了，没有带来期待的惊喜。如果说Silverlight1是试验品，Silverlight2是半成品，那么Silverlight3就是半成品加补丁。难怪MS对Silverlight3的发布那么低调。
VS还是不支持可视化设计；3D功能太弱；离线运行很勉强；其他新特性几乎都是原有功能的补丁。

设置离线功能:
右键点击项目属性，可以看到Silverlight build options
选中Enable running application out of the browser.

可以点击Out-of-Browser Settings设置其它一些属性(有个复选框，是否启用GPU加速)。

运行项目，点击鼠标右键，可以看到有个快捷菜单:是否将XXXX安装到此计算机。点击后打开对话框：

确定后可以看到在开始菜单或桌面创建了快捷方式，打开可以运行，如果想删除，可以在快捷菜单中选择删除。

打开快捷方式的属性，可以看到目标为："C:\Program Files\Microsoft Silverlight\sllauncher.exe" 2217010316.localhost
其存储位置为：
C:\DOCUMENTS AND SETTINGS\ZHENXINGZ\LOCAL SETTINGS\APPLICATION DATA\MICROSOFT\SILVERLIGHT\OUTOFBROWSER\2217010316.LOCALHOST
(2217010316这串数字是随机的。)

示例：

评论: 0　查看评论　发表评论

编辑推荐：Google社会化产品Buzz发布会实录

网站导航：博客园首页个人主页新闻闪存小组博问社区知识库

[译]理解Windows消息循环

飘遥(Zhenxing Zhou) — Sat, 27 Jun 2009 10:15:00 GMT

阅读: 452 评论: 2 作者: 飘遥(Zhenxing Zhou) 发表于 2009-06-27 18:15 原文链接

理解消息循环和整个消息传送机制对Windows编程来说非常重要。如果对消息处理的整个过程不了解,在windows编程中会遇到很多令人困惑的地方。

什么是消息(Message)

每个消息是一个整型数值，如果查看头文件(查看头文件了解API是一个非常好的习惯和普遍的做法)可以发现如下一些宏定义：

#define WM_INITDIALOG                   0x0110
#define WM_COMMAND                      0x0111

#define WM_LBUTTONDOWN                  0x0201
//...

在Windows通信中，至少一些基本Windows通信，几乎都要用到消息。如果你想让窗口或控件(实质上，控件是特殊的窗口)执行何种动作，你应该传送一个消息给它；如果另一个窗口想让你执行何种操作，它可以传送一个消息给你。如果一个事件，如敲击键盘、移动鼠标、点击按钮等，系统将消息传送给窗口，如果你是这些窗口之一，你将接收到消息执行相应的操作。

每个Windows消息共有两个参数，wParam和lParam。最初的wParam是16位(Win16时代)的，lParam是32位的。在Win32中，两个参数都是32位的。并不是所有的消息都是用这两个参数，每个消息使用它们的方式也不尽相同。如WM_CLOSE消息会忽略上述两个参数；再如WM_COMMAND消息使用上述两个参数，wParam包含”两个”值，HIWORD(wParam)是通知信息(如果可用)，LOWORD(wParam)是发送消息的控件或菜单的ID，lParam是发送消息的控件的HWND(窗口句柄)，如果这个值为NULL，表示这个消息不是由控件发送的。

HIWORD()和LOWORD()是Windows定义的宏，分别取出一个32位整型值的高字和低字。在Win32中，一个”字”是一个16位整型，DWORD(Double WORD)是32位整型。

可以用PostMessage()或SendMessage()发送消息。PostMessage()把一个消息放入消息队列(Message Queue)后立即返回，也就是当调用PostMessage()，函数执行完成返回时，很可能消息尚未处理。SendMessage()直接将消息发送到窗口，直到这个消息处理完成才返回。如果要关闭一个窗口，可以给它发送一个WM_CLOSE消息，像PostMessage(hwnd, WM_CLOSE, 0, 0); 效果跟点击窗口右上角的(关闭)按钮是一样的。注意这里的wParam和lParam的值都是0，因为前面提到过，WM_CLOSE消息会忽略上述两个参数。

对话框(Dialogs)

如果使用对话框，为跟控件通信，你需要向控件发送消息。你或者可以使用GetDlgItem()函数根据控件的ID取得控件的句柄，然后调用SendMessage()函数发送消息；或者使用SendDlgItemMessage()组合了上面的步骤。传入一个窗口句柄和子控件的ID能够取得子控件的句柄，用这个句柄发送消息。跟SendDlgItemMessage()类似的API如GetDlgItemText()能够对所有的窗口进行操作，而不仅仅是对话框。

什么是消息队列(Message Queue)

假设一个场景：系统正在处理WM_PAINT消息，就在这时用户在键盘上敲击了一些按键，这时会发生什么呢？系统应该中断绘图操作然后处理按键消息还是应该丢弃按键的消息？很明显这些都是不合理的，因此我们引入了消息队列，当消息发送过来，将消息加入消息队列，当一个消息被处理时，将其从消息队列移除。这样确保消息不会丢失，当你正在处理一个消息时，其它到来的消息可以加入到消息队列直到被处理。

什么是消息循环(Message Loop)

while(GetMessage(&Msg, NULL, 0, 0) > 0)
{
TranslateMessage(&Msg);
DispatchMessage(&Msg);
}

上面代码的执行过程为：
1. 消息循环调用GetMessage()从消息队列中查找消息进行处理，如果消息队列为空，程序将停止执行并等待(程序阻塞)。
2. 事件发生时导致一个消息加入到消息队列(例如系统注册了一个鼠标点击事件)，GetMessage()将返回一个正值，这表明有消息需要被处理，并且消息已经填充到传入的MSG参数中；当传入WM_QUIT消息时返回0；如果返回值为负表明发生了错误。
3. 取出消息(在Msg变量中)并将其传递给TranslateMessage()函数，这个函数做一些额外的处理：将虚拟键值信息转换为字符信息。这一步实际上是可选的，但有些地方需要用到这一步。
4. 上面的步骤执行完后，将消息传递给DispatchMessage()函数。DispatchMessage()函数将消息分发到消息的目标窗口，并且查找目标窗口过程函数，给窗口过程函数传递窗口句柄、消息、wParam、lParam等参数然后调用该函数。
5. 在窗口过程函数中，检查消息和其他参数，你可以用它来实现你想要的操作。如果不想处理某些特殊的消息，你应该总是调用DefWindowProc()函数，系统将按按默认的方式处理这些消息(通常认为是不做任何操作)。
6. 一旦一个消息处理完成，窗口过程函数返回，DispatchMessage()函数返回，继续循环处理下一个消息。

消息循环对Windows编程来说是一个非常重要的概念。窗口过程函数并不是系统自动调用的，而是由开发人员自己通过调用DispatchMessage()间接的调用的。如果你愿意，可以调用GetWindowLong()函数通过窗口句柄查找到窗口过程函数直接调用达到消息处理的目的。

while(GetMessage(&Msg, NULL, 0, 0) > 0)
{
WNDPROC fWndProc = (WNDPROC)GetWindowLong(Msg.hwnd, GWL_WNDPROC);
fWndProc(Msg.hwnd, Msg.message, Msg.wParam, Msg.lParam);
}

我尝试着写了上面的代码，它确实能工作，但这里存在各种问题，像Unicode/ANSI编码转换、定时器回调等等都这样的代码都不适合，并且很可能导致很多打断很多程序的正常运行。因此这样的代码在这里仅仅是试验，真实项目中一定不能编写这样的代码。

注意这里我们用GetWindowLong()来获得相关窗口的窗口过程函数。为什么我们不直接调用WndProc()函数呢？消息循环会处理程序中所有窗口的消息，包括像按钮、列表框等有他们自己的窗口过程函数的控件，因此我们要保证调用正确的窗口过程函数。尽管有时几个窗口调用同一个窗口过程函数，但函数的第一个参数 (窗口的句柄) 通常用于告知窗口过程函数是那个窗口发送的消息。

代码可以看出，程序的大部分时间都在处理消息循环。窗口会不断的处理发过来的消息，但如果要退出程序该怎么做呢？因为我们用的是while()循环，如果GetMessage()返回的是FALSE(即0)会退出循环，程序能够执行到WinMain()结束处，即程序退出：这正是PostQuitMessage()函数完成的工作，该函数会将WM_QUIT消息添加到消息队列的队尾，GetMessage()从消息队列取出WM_QUIT消息，填充Msg结构，返回的不是正数，而是0。与此同时，结构Msg的成员wParam的值会被置为你传给PostQuitMessage()函数参数的值，你可以选择忽略它或做为WinMain()函数的返回值即进程的退出代码(Exit Code)。

注意：如果发生错误，GetMessage()函数将返回-1。你应该记住这点，说不定你的程序会因此出错。尽管GetMessage()返回值位BOOL型，但它可以返回TRUE或FALSE之外的值，因为BOOL被定义成UINT(unsigned int)。下面的程序貌似能正常工作，但有些时候不能正常工作。

while(GetMessage(&Msg, NULL, 0, 0))

while(GetMessage(&Msg, NULL, 0, 0) != 0)

while(GetMessage(&Msg, NULL, 0, 0) == TRUE)

上面的代码都是错误的！有些程序中你会看到会使用第一中方式，使用这种方式你必须保证GetMessage()总是执行成功，否则应该使用下面这段代码：

while(GetMessage(&Msg, NULL, 0, 0) > 0)

希望你对Windows消息循环能有很好的理解，如果还没有，慢慢来，在使用过程中会逐渐理解的。

英文原文：http://winprog.org/tutorial/message_loop.html

译注：感觉这篇文章对消息循环讲述的不错。如果有翻译的疏漏之处请指出。

评论: 2　查看评论　发表评论

编辑推荐：Google社会化产品Buzz发布会实录

网站导航：博客园首页个人主页新闻闪存小组博问社区知识库

WPF BitmapImage与byte[]的转换

飘遥(Zhenxing Zhou) — Thu, 25 Jun 2009 11:16:00 GMT

阅读: 347 评论: 3 作者: 飘遥(Zhenxing Zhou) 发表于 2009-06-25 19:16 原文链接

有时要实现BitmapImage与byte[]相互转换，这里实现两个静态方法，直接调用即可。

byte[]转换为BitmapImage：

public static BitmapImage ByteArrayToBitmapImage(byte[] byteArray)
{
    BitmapImage bmp = null;

    try
    {
        bmp = new BitmapImage();
        bmp.BeginInit();
        bmp.StreamSource = new MemoryStream(byteArray);
        bmp.EndInit();
    }
    catch
    {
        bmp = null;
    }

    return bmp;
}

BitmapImage转换为byte[]：

public static byte[] BitmapImageToByteArray(BitmapImage bmp)
{
    byte[] byteArray = null;

    try
    {
        Stream sMarket = bmp.StreamSource;

        if (sMarket != null && sMarket.Length > 0)
        {
            //很重要，因为Position经常位于Stream的末尾，导致下面读取到的长度为0。
            sMarket.Position = 0;

            using (BinaryReader br = new BinaryReader(sMarket))
            {
                byteArray = br.ReadBytes((int)sMarket.Length);
            }
        }
    }
    catch
    {
        //other exception handling
    }

    return byteArray;
}

评论: 3　查看评论　发表评论

编辑推荐：Google社会化产品Buzz发布会实录

网站导航：博客园首页个人主页新闻闪存小组博问社区知识库

VC++中启用XP主题外观

飘遥(Zhenxing Zhou) — Wed, 17 Jun 2009 10:32:00 GMT

阅读: 186 评论: 0 作者: 飘遥(Zhenxing Zhou) 发表于 2009-06-17 18:32 原文链接

.NET Winform中，启用XP主题外观执行以下语句即可：

Application.EnableVisualStyles();

VC Win32项目，默认是不启用XP主题外观的，并不是每个人都喜欢简洁的Windows经典主题外观。
启用XP主题外观，需要用资源文件。有种更简单的方式：
头文件里加入以下语句：

#include <CommCtrl.h>
#pragma comment(lib, "ComCtl32.Lib")
#pragma comment(linker, "/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='x86' publicKeyToken='6595b64144ccf1df' language='*'\"")

在main函数最前面调用InitCommonControls函数：

int APIENTRY _tWinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPTSTR    lpCmdLine,
                     int       nCmdShow)
{
    InitCommonControls();
    MessageBox(NULL, L"Windows XP theme was enabled.", L"http://www.xianfen.net", 0 );
    return 0;
}

运行程序已经启用了XP主题外观，如图：

评论: 0　查看评论　发表评论

编辑推荐：Google社会化产品Buzz发布会实录

网站导航：博客园首页个人主页新闻闪存小组博问社区知识库

C#4.0初探：dynamic 关键字

飘遥(Zhenxing Zhou) — Thu, 28 May 2009 17:54:00 GMT

阅读: 1957 评论: 9 作者: 飘遥(Zhenxing Zhou) 发表于 2009-05-29 01:54 原文链接

C#新增了dynamic关键字，正因为这一个小小的关键字，C#动态特性向前迈进了一大步。
dynamic是一个类型关键字，声明为dynamic的类型与"静态类型"（这里的静态类型是指编译时确定的类型，下同）相比最大的特点它是"动态类型"，它会运行时尝试调用方法，这些方法的存在与否不是在编译时检查的，而是在运行时查找，如果方法存在并且参数正确，会正常调用，否则会抛出Microsoft.CSharp.RuntimeBinder.RuntimeBinderException异常。

看一个最简单的示例：

using System;

namespace Xianfen.Net.TestDynamic
{
    class Program
    {
        static void Main()
        {
            dynamic d = Console.Out;
            dynamic a;
            a = new Int32();
            int b = a;
            a++;
            a--;

            d.WriteLine("http://www.xianfen.net/");
            d.WriteLine(d.GetType());
            d.writeln("test"); //抛出Microsoft.CSharp.RuntimeBinder.RuntimeBinderException异常
        }
    }
}

对dynamic类型的操作只能有以下几种：
·赋值
·方法调用
·自增
·自减
·接受"静态类型"的构造器创建的对象

与关键字var的比较
从表面上看，dynamic与var关键字的用法很像，但实质上有本质区别。
var关键字被称为：隐含类型局部变量(Local Variable Type Inference)，var只能用作局部变量，不能用于字段、参数等；声明的同时必须初始化；初始化时类型就已经明确了，并且不能再被赋值不能进行隐式类型转换的类型的数据；编译时编译器会对var定义的变量进行类型推断，这时变量的类型已经被确定。
dynamic可用于类型的字段，方法参数，方法返回值，可用于泛型的类型参数等；可以赋值给或被赋值任何类型并且不需显式的强制类型转换，因为这些是运行时执行的，这要得益于dynamic类型的动态特性。

与反射的比较
首先能看到的是，dynamic与反射相比，执行相同操作所需的代码少的多。
如调用类Me中的GetName()方法。

class Me
{
    public string Blog { get; set; }

    public string GetName()
    {
        return "Zhenxing Zhou";
    }
}

用反射调用GetName()方法：

Assembly a = Assembly.GetExecutingAssembly();
object instance = a.CreateInstance("Xianfen.Net.TestDynamic.Me");
Type type = instance.GetType();
MethodInfo mi = type.GetMethod("GetName");
object result = mi.Invoke(instance, null);

同样的dynamic调用：

dynamic myInfo = new Me();
string result = myInfo.GetName();

dynamic类型与反射相比能进行的操作要少的多。
目前dynamic类型对属性调用是不可用的，但我们知道，属性生成IL时，对属性的读或写会生成对应的在属性名前加上get_或set_前缀生成相应的方法，尝试调用两个方法来访问属性：

dynamic myInfo = new Me();
myInfo.set_Blog("http://www.xianfen.net/");
string result = myInfo.get_Blog();

会抛出异常，提示找不到get/set_Blog方法。这点比较遗憾，同样，对有参属性的访问也是不行的。
反射还可以访问私有方法字段以及其它类型成员及取得类型及类型成员的信息等。

dynamic类型的效率
效率问题应该是大家很关心的，我的感觉：不要对动态语言有很高的效率抱有太大的希望，但另一方面，算法的设计对效率的影响非常大，功能与性能经常存在一个平衡点。
要分析其效率，就要看看编译后内部都干了些啥，方法是写些简单的代码，查看IL。
代码：

using System;

namespace Xianfen.Net.TestDynamic
{
    class Program
    {
        static void Main()
        {
            dynamic d = "str";
            d.ToString();
        }
    }
}

对应的IL代码：

.class private auto ansi beforefieldinit Program
    extends [mscorlib]System.Object
{
    .method public hidebysig specialname rtspecialname instance void .ctor() cil managed
    {
        .maxstack 8
        L_0000: ldarg.0
        L_0001: call instance void [mscorlib]System.Object::.ctor()
        L_0006: ret
    }

    .method private hidebysig static void Main() cil managed
    {
        .entrypoint
        .maxstack 9
        .locals init (
            [0] object d,
            [1] class [Microsoft.CSharp]Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo[] CS$0$0000)
        L_0000: ldstr "str"
        L_0005: stloc.0
        L_0006: ldsfld class [System.Core]System.Runtime.CompilerServices.CallSite`1<class [mscorlib]System.Action`2<class [System.Core]System.Runtime.CompilerServices.CallSite, object>> Xianfen.Net.TestDynamic.Program/

o__SiteContainer0::<>p__Site1
        L_000b: brtrue.s L_003f
        L_000d: ldc.i4.0
        L_000e: ldstr "ToString"
        L_0013: ldtoken Xianfen.Net.TestDynamic.Program
        L_0018: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
        L_001d: ldnull
        L_001e: ldc.i4.1
        L_001f: newarr [Microsoft.CSharp]Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo
        L_0024: stloc.1
        L_0025: ldloc.1
        L_0026: ldc.i4.0
        L_0027: ldc.i4.0
        L_0028: ldnull
        L_0029: newobj instance void [Microsoft.CSharp]Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo::.ctor(valuetype [Microsoft.CSharp]Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfoFlags, string)
        L_002e: stelem.ref
        L_002f: ldloc.1
        L_0030: newobj instance void [Microsoft.CSharp]Microsoft.CSharp.RuntimeBinder.CSharpInvokeMemberBinder::.ctor(valuetype [Microsoft.CSharp]Microsoft.CSharp.RuntimeBinder.CSharpCallFlags, string, class [mscorlib]System.Type, class [mscorlib]System.Collections.Generic.IEnumerable`1<class [mscorlib]System.Type>, class [mscorlib]System.Collections.Generic.IEnumerable`1<class [Microsoft.CSharp]Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo>)
        L_0035: call class [System.Core]System.Runtime.CompilerServices.CallSite`10> [System.Core]System.Runtime.CompilerServices.CallSite`1<class [mscorlib]System.Action`2<class [System.Core]System.Runtime.CompilerServices.CallSite, object>>::Create(class [System.Core]System.Runtime.CompilerServices.CallSiteBinder)
        L_003a: stsfld class [System.Core]System.Runtime.CompilerServices.CallSite`1<class [mscorlib]System.Action`2<class [System.Core]System.Runtime.CompilerServices.CallSite, object>> Xianfen.Net.TestDynamic.Program/

o__SiteContainer0::<>p__Site1
L_003f: ldsfld class [System.Core]System.Runtime.CompilerServices.CallSite`1<class [mscorlib]System.Action`2<class [System.Core]System.Runtime.CompilerServices.CallSite, object>> Xianfen.Net.TestDynamic.Program/

o__SiteContainer0::<>p__Site1
L_0044: ldfld !0 [System.Core]System.Runtime.CompilerServices.CallSite`1<class [mscorlib]System.Action`2<class [System.Core]System.Runtime.CompilerServices.CallSite, object>>::Target
L_0049: ldsfld class [System.Core]System.Runtime.CompilerServices.CallSite`1<class [mscorlib]System.Action`2<class [System.Core]System.Runtime.CompilerServices.CallSite, object>> Xianfen.Net.TestDynamic.Program/

o__SiteContainer0::<>p__Site1
        L_004e: ldloc.0
        L_004f: callvirt instance void [mscorlib]System.Action`2<class [System.Core]System.Runtime.CompilerServices.CallSite, object>::Invoke(!0, !1)
        L_0054: ret
    }

    .class abstract auto ansi sealed nested private beforefieldinit

o__SiteContainer0
        extends [mscorlib]System.Object
    {
        .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor()
        .field public static class [System.Core]System.Runtime.CompilerServices.CallSite`1<class [mscorlib]System.Action`2<class [System.Core]System.Runtime.CompilerServices.CallSite, object>> <>p__Site1

    }
}

可以看出生成的IL代码确实不美观，不过大体能看出端倪。为了方便查看，用Reflector查看，把反编译结果设置为.net2.0，代码清晰多了：

01. internal class Program
02. {
03.     // Methods
04.     private static void Main()
05.     {
06.         object d = "str";
07.         if (<Main>o__SiteContainer0.<>p__Site1 == null)
08.         {
09.             <Main>o__SiteContainer0.<>p__Site1 = CallSite<Action<CallSite, object>>.
10. Create(new CSharpInvokeMemberBinder(CSharpCallFlags.None, "ToString", typeof(Program),
11. null, new CSharpArgumentInfo[] { new CSharpArgumentInfo(CSharpArgumentInfoFlags.None, null) }));
12.         }
13.         <Main>o__SiteContainer0.<>p__Site1.Target(<Main>o__SiteContainer0.<>p__Site1, d);
14.     }
15. // Nested Types
16.     [CompilerGenerated]
17.     private static class <Main>o__SiteContainer0
18.     {
19.         // Fields
20.         public static CallSite<Action<CallSite, object>> <>p__Site1;
21.     }
22. }

06行先把赋值给dynamic的值赋给object类型，检查编译器生成的静态类

o__SiteContainer0的静态字段<>p__Site1是否为null，如果是，则对其赋值，赋值的内容在这里不详细研究。然后调用<>p__Site1进行操作。
这里会发现两个问题：赋值给dynamic的值赋给object类型，对于值类型会不会执行同样的操作，会执行装箱操作吗；编译器生成的静态类

o__SiteContainer0的静态字段<>p__Site1应该是缓存作用。这两个问题稍后验证。

1)对值类型进行的操作
如下代码：

using System;

namespace Xianfen.Net.TestDynamic
{
    class Program
    {
        static void Main()
        {
            dynamic d = 5;
            d.ToString();
        }
    }
}

反编译代码：

可见确实对值类型进行了装箱操作，效率可想而知。

2)编译器生成的缓存类
代码如下：

using System;

namespace Xianfen.Net.TestDynamic
{
    class Program
    {
        static void Main()
        {
            dynamic d = 5;
            d.ToString();
            d.ToString();
        }
    }
}

反编译的代码：

internal class Program
{
    // Methods
    private static void Main()
    {
        object d = 5;
        if (<Main>o__SiteContainer0.<>p__Site1 == null)
        {
            <Main>o__SiteContainer0.<>p__Site1 = CallSite<Action<CallSite, object>>.Create(new CSharpInvokeMemberBinder(CSharpCallFlags.None, "ToString", typeof(Program), null, new CSharpArgumentInfo[] { new CSharpArgumentInfo(CSharpArgumentInfoFlags.None, null) }));
        }
        <Main>o__SiteContainer0.<>p__Site1.Target(<Main>o__SiteContainer0.<>p__Site1, d);
        if (<Main>o__SiteContainer0.<>p__Site2 == null)
        {
            <Main>o__SiteContainer0.<>p__Site2 = CallSite<Action<CallSite, object>>.Create(new CSharpInvokeMemberBinder(CSharpCallFlags.None, "ToString", typeof(Program), null, new CSharpArgumentInfo[] { new CSharpArgumentInfo(CSharpArgumentInfoFlags.None, null) }));
        }
        <Main>o__SiteContainer0.<>p__Site2.Target(<Main>o__SiteContainer0.<>p__Site2, d);
    }

    // Nested Types
    [CompilerGenerated]
    private static class <Main>o__SiteContainer0
    {
        // Fields
        public static CallSite<Action<CallSite, object>> <>p__Site1;
        public static CallSite<Action<CallSite, object>> <>p__Site2;
    }
}

代码调用了ToString方法，但编译器生成了两份缓存。

如果是在循环中：
代码：

using System;

namespace Xianfen.Net.TestDynamic
{
    class Program
    {
        static void Main()
        {
            dynamic d = 5;

            for (int i = 0; i < 100; i++)
            {
                d.ToString();
            }
        }
    }
}

反编译代码：

internal class Program
{
    // Methods
    private static void Main()
    {
        object d = 5;
        for (int i = 0; i < 100; i++)
        {
            if (<Main>o__SiteContainer0.<>p__Site1 == null)
            {
                <Main>o__SiteContainer0.<>p__Site1 = CallSite<Action<CallSite, object>>.Create(new CSharpInvokeMemberBinder(CSharpCallFlags.None, "ToString", typeof(Program), null, new CSharpArgumentInfo[] { new CSharpArgumentInfo(CSharpArgumentInfoFlags.None, null) }));
            }
            <Main>o__SiteContainer0.<>p__Site1.Target(<Main>o__SiteContainer0.<>p__Site1, d);
        }
    }

    // Nested Types
    [CompilerGenerated]
    private static class <Main>o__SiteContainer0
    {
        // Fields
        public static CallSite<Action<CallSite, object>> <>p__Site1;
    }
}

可见在循环中，相同的操作做了一次缓存；但非循环环境下，调用一次会缓存一次，猜测原因是，重复调用一个方法的次数不会太多，并且很多情况准确查找起来比较困难。
(以上代码在VS2010Beta1下测试通过)
URL: http://www.xianfen.net/
Author: Zhenxing Zhou

评论: 9　查看评论　发表评论

编辑推荐：Google社会化产品Buzz发布会实录

网站导航：博客园首页个人主页新闻闪存小组博问社区知识库

四个字节整型转换为IP格式

飘遥(Zhenxing Zhou) — Mon, 27 Apr 2009 16:00:00 GMT

阅读: 219 评论: 2 作者: 飘遥(Zhenxing Zhou) 发表于 2009-04-28 00:00 原文链接

常规的四个字节整型转换为IP格式比较麻烦，用非托管的方式及一点小窍门，转换实现会变得非常的简单，代码如下：

static unsafe string ConvertIP(int i)
{
byte* b = (byte*)&i;

return string.Format("{0}.{1}.{2}.{3}", *b, *(b + 1), *(b + 2), *(b + 3));
}

调用ConvertIP(723830963)，结果为：179.200.36.43

原理：参数i保存在栈上，占连续的四个字节；byte占一个字节。让byte指针指向i的起始地址，则指针指向的连续的四个字节都是i的内存空间，取出每个字节的内容转换为十进制然后格式化为IP地址格式即可。

评论: 2　查看评论　发表评论

编辑推荐：Google社会化产品Buzz发布会实录

网站导航：博客园首页个人主页新闻闪存小组博问社区知识库

拯救开启桌面效果后白屏的openSUSE

飘遥(Zhenxing Zhou) — Mon, 27 Apr 2009 15:59:00 GMT

阅读: 194 评论: 0 作者: 飘遥(Zhenxing Zhou) 发表于 2009-04-27 23:59 原文链接

我用的是openSUSE 11.1，桌面环境为GNOME,由于驱动没有安装完善，开启桌面效果后屏幕变成全白色，按Alt+Tab切换窗口能隐约看到窗口的边界，重启后刚进入登录界面就白屏了。
进入白屏后，按Ctrl+Alt+F1，root身份登录，运行sax2，重新配置图形系统，重启后仍然白屏。
最后一招：进入白屏后，按Ctrl+Alt+F1，root身份登录，cd到默认登录用户的目录，然后进入
.config/compiz/，将该目录下的enable-compiz文件重命名，如：

mv enable-compiz enable-compizbak

重启X，重新找回了绿色的的可爱的桌面了。

评论: 0　查看评论　发表评论

编辑推荐：Google社会化产品Buzz发布会实录

网站导航：博客园首页个人主页新闻闪存小组博问社区知识库