关于ado.net entity framework 性能比较网上也有很多，这里我只是初步的介绍下ado.net entity framework使用不同的方法查询数据的不同性能

第一部分：重复查询单个实体

第一种：Linq To Entitiess

代码如下：

static　void　Main(string[]　args)
　　　　　　　　{
　　　　　　　　　　　　DateTime　time1;
　　　　　　　　　　　　DateTime　time2;
　　　　　　　　　　　　time1　=　DateTime.Now;
　　　　　　　　　　　　NorthwindEntities　context　=　new　NorthwindEntities();
　　　　　　　　　　　　for　(int　i　=　0;　i　<　1000;　i++)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　var　data　=　(from　c　in　context.Customers　where　c.CustomerID　==　"ALFKI"　select　c).FirstOrDefault();
　　　　　　　　　　　　　　　　string　addr　=　data.Address;
　　　　　　　　　　　　}
　　　　　　　　　　　　time2　=　DateTime.Now;
　　　　　　　　　　　　Console.WriteLine((time2-time1).ToString());
　　　　　　　　}

查询使用时间为6.2秒左右

第二种：使用Entity SQL

static　void　Main(string[]　args)
　　　　　　　　{
　　　　　　　　　　　　DateTime　time1;
　　　　　　　　　　　　DateTime　time2;
　　　　　　　　　　　　time1　=　DateTime.Now;
　　　　　　　　　　　　NorthwindEntities　context　=　new　NorthwindEntities();
　　　　　　　　　　　　for　(int　i　=　0;　i　<　1000;　i++)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　var　data　=　context.Customers.Where("it.CustomerID=@Id",　new　System.Data.Objects.ObjectParameter("Id",　"ALFKI")).FirstOrDefault();
　　　　　　　　　　　　　　　　string　addr　=　data.Address;
　　　　　　　　　　　　}
　　　　　　　　　　　　time2　=　DateTime.Now;
　　　　　　　　　　　　Console.WriteLine((time2-time1).ToString());
　　　　　　　　}
查询使用时间为6.2秒左右

第三种：使用EntityKey 来查询

　static　void　Main(string[]　args)
　　　　　　　　{
　　　　　　　　　　　　DateTime　time1;
　　　　　　　　　　　　DateTime　time2;
　　　　　　　　　　　　time1　=　DateTime.Now;
　　　　　　　　　　　　NorthwindEntities　context　=　new　NorthwindEntities();
　　　　　　　　　　　　for　(int　i　=　0;　i　<　1000;　i++)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　var　data　=　context.GetObjectByKey(new　System.Data.EntityKey("NorthwindEntities.Customers",　"CustomerID",　"ALFKI"))　as　Customers;
　　　　　　　　　　　　　　　　string　addr　=　data.Address;
　　　　　　　　　　　　}
　　　　　　　　　　　　time2　=　DateTime.Now;
　　　　　　　　　　　　Console.WriteLine((time2-time1).ToString());
　　　　　　　　}

查询使用时间为1秒，没错是一秒

总结：

前两种方法查询所使用的时间都差不多为6.2秒，时间比较长，但是使用第三种方法查询数据仅仅使用了1秒，为什么会相差那么多，区别在于前两种方法每次查询都要从数据库中查找，1000次查询每次的查询时间都一样，但是第三种方法只有第一次是从数据库中查数据，后面的999次都是在context通过主键直接取数据，速度当然会快很多啦，EF4.0之前的实体当含有外键引用时是自动生成对象引用的，而EF4.0现在多了一个外键ID，这样我们可以很方便的通过外键来查询数据

第二部分：查询不同是实体
第一种：Linq To Entitiess

　static　void　Main(string[]　args)
　　　　　　　　{
　　　　　　　　　　　　DateTime　time1;
　　　　　　　　　　　　DateTime　time2;
　　　　　　　　　　　　NorthwindEntities　context　=　new　NorthwindEntities();
　　　　　　　　　　　　//先将Customers所有的主键查询出来
　　　　　　　　　　　　List<string>　keys　=　context.Customers.Select(c　=>　c.CustomerID).Distinct().ToList();
　　　　　　　　　　　　//和上面的context以作区别
　　　　　　　　　　　　NorthwindEntities　　context_　=　new　NorthwindEntities();
　　　　　　　　　　　　time1　=　DateTime.Now;
　　　　　　　　　　　　foreach　(var　key　in　keys)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　var　data　=　context_.Customers.Where(c　=>　c.CustomerID　==　key).FirstOrDefault();
　　　　　　　　　　　　　　　　string　addr　=　data.Address;
　　　　　　　　　　　　}
　　　　　　　　　　　　time2　=　DateTime.Now;
　　　　　　　　　　　　Console.WriteLine((time2　-　time1).ToString());
　　　　　　　　}

查询使用时间0.68秒左右

第二种：使用Entity SQL

static　void　Main(string[]　args)
　　　　　　　　{
　　　　　　　　　　　　DateTime　time1;
　　　　　　　　　　　　DateTime　time2;
　　　　　　　　　　　　NorthwindEntities　context　=　new　NorthwindEntities();
　　　　　　　　　　　　//先将Customers所有的主键查询出来
　　　　　　　　　　　　List<string>　keys　=　context.Customers.Select(c　=>　c.CustomerID).Distinct().ToList();
　　　　　　　　　　　　//和上面的context以作区别
　　　　　　　　　　　　NorthwindEntities　　context_　=　new　NorthwindEntities();
　　　　　　　　　　　　time1　=　DateTime.Now;
　　　　　　　　　　　　foreach　(var　key　in　keys)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　var　data　=　context_.Customers.Where("it.CustomerID=@Id",　new　System.Data.Objects.ObjectParameter("Id",　key)).FirstOrDefault();
　　　　　　　　　　　　　　　　string　addr　=　data.Address;
　　　　　　　　　　　　}
　　　　　　　　　　　　time2　=　DateTime.Now;
　　　　　　　　　　　　Console.WriteLine((time2　-　time1).ToString());
　　　　　　　　}

查询使用时间0.5秒左右

第三种：使用EntityKey 来查询

static　void　Main(string[]　args)
　　　　　　　　{
　　　　　　　　　　　　DateTime　time1;
　　　　　　　　　　　　DateTime　time2;
　　　　　　　　　　　　NorthwindEntities　context　=　new　NorthwindEntities();
　　　　　　　　　　　　//先将Customers所有的主键查询出来
　　　　　　　　　　　　List<string>　keys　=　context.Customers.Select(c　=>　c.CustomerID).Distinct().ToList();
　　　　　　　　　　　　//和上面的context以作区别
　　　　　　　　　　　　NorthwindEntities　　context_　=　new　NorthwindEntities();
　　　　　　　　　　　　time1　=　DateTime.Now;
　　　　　　　　　　　　foreach　(var　key　in　keys)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　var　data　=　context_.GetObjectByKey(new　System.Data.EntityKey("NorthwindEntities.Customers",　"CustomerID",　key))　as　Customers;
　　　　　　　　　　　　　　　　string　addr　=　data.Address;
　　　　　　　　　　　　}
　　　　　　　　　　　　time2　=　DateTime.Now;
　　　　　　　　　　　　Console.WriteLine((time2　-　time1).ToString());
　　　　　　　　}

查询时间为0.18秒左右

总结：

通过比较第三种方法仍然比前两种来的快，查询效率更高

使用EntityKey来查询数据比其他两种方法来的更快，而且不是快一点点，而是相差有好几倍，这里的比较并没有使用存储过程来比较查询，但是从这里我们可以看出，在平常的应用中如果知道实体的主键尽量用主键来查询

/*http://home.cnblogs.com/yangleiWPF/*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.IO;
using System.Drawing;
using System.Runtime.InteropServices;
using System.Threading;
using System.Drawing.Imaging;

namespace photoText
{
    /// <summary>
    /// Window1.xaml 的交互逻辑
    /// </summary>
    public partial class Window1 : Window
    {
        private delegate void UpImageCall(ImageSource Isource);
        private UpImageCall upimage;
        Bitmap ALL;
        public static int x = 16;
        public static int y = 8;
        public static int ScreenX;
        public static int ScreenY;
        public static int SpX;
        public static int SpY;
       //保存所以小张图片流      List<Bitmap> LBitmap = new List<Bitmap>();        public Window1()
        {
            InitializeComponent();
            upimage = Isource =>
            {
                image1.Source = Isource;
            };
                 //获取桌面大小
            ScreenX = GetScreenPixel()[0];
            ScreenY = GetScreenPixel()[1];
            //获取小张图片的长宽
            SpX = ScreenX / x;
            SpY = ScreenY / y;
            //初始化图片数组
            ALL = CaptureDesktopALL();
            CaptureDesktopT();
            Thread aa = new Thread(new ThreadStart(() =>
            {
                while (true)
                {
                    //每隔300毫秒截一张图
                    Thread.Sleep(300);
                    CaptureDesktop();

                }
            }));
            aa.Start();
            aa.IsBackground = true;
        }
        /// <summary>
        /// 获取屏幕分辨率
        /// </summary>
        public int[] GetScreenPixel()
        {
            System.Windows.Forms.Screen scr = System.Windows.Forms.Screen.PrimaryScreen;
            System.Drawing.Rectangle rc = scr.Bounds;
            int[] sp = new int[2] { rc.Width, rc.Height };
            return sp;
        }
        /// <summary>
        /// 截屏
        /// </summary>
        [DllImport("gdi32.dll")]
        public static extern bool BitBlt(IntPtr hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, IntPtr hdcSrc, int nXSrc, int nYSrc, System.Drawing.CopyPixelOperation dwRop);
       
        public void CaptureDesktop()
        {
            for (int j = 0; j < x; j++)
            {
                for (int k = 0; k < y; k++)
                {
                    try
                    {
                        Bitmap screenBitmap;
                        using (Graphics screenGraphic = Graphics.FromHwnd(IntPtr.Zero))
                        {
                            //根据屏幕大小建立位图，这就是最后截取到的*屏幕图像*
                            screenBitmap = new Bitmap(SpX, SpY, screenGraphic);
                            //建立位图相关Graphics
                            Graphics bitmapGraphics = Graphics.FromImage(screenBitmap);
                            //建立屏幕上下文
                            IntPtr hdcScreen = screenGraphic.GetHdc();
                            //建立位图上下文
                            IntPtr hdcBitmap = bitmapGraphics.GetHdc();
                            //将屏幕捕获保存在位图中
                            BitBlt(hdcBitmap, 0, 0, SpX, SpY, hdcScreen, j * SpX, k * SpY, CopyPixelOperation.CaptureBlt | CopyPixelOperation.SourceCopy);
                            //关闭位图句柄
                            bitmapGraphics.ReleaseHdc(hdcBitmap);
                            //关闭屏幕句柄
                            screenGraphic.ReleaseHdc(hdcScreen);
                            //释放位图对像
                            bitmapGraphics.Dispose();
                            //释放屏幕对像
                            screenGraphic.Dispose();
                            //比较之前的图片和现在的图片是否相同，不同则替换
                            if (ImageCompareString(LBitmap[j * 8 + k], screenBitmap))
                            {
                                //保存最新的图片
                                LBitmap[j * 8 + k] = screenBitmap;
                                Graphics g = Graphics.FromImage(ALL);
                                //覆盖原来的图片区域
                                g.DrawImageUnscaled(LBitmap[j * 8 + k], j * SpX, k * SpY);
                            }
                        }
                    }
                    catch
                    {
                        throw;
                    }
                }
            }
            MemoryStream stream = new MemoryStream();
            ALL.Save(stream, System.Drawing.Imaging.ImageFormat.Png);
            // MStream(ALL);
            ImageSourceConverter imageSourceConverter = new ImageSourceConverter();
            //显示整张图片
            image1.Dispatcher.Invoke(upimage, (ImageSource)imageSourceConverter.ConvertFrom(stream));
        }
        //获得压缩文件流 减少像素
        private MemoryStream MStream(Bitmap myBitmap)
        {
            ImageCodecInfo myImageCodecInfo;
            System.Drawing.Imaging.Encoder myEncoder;
            EncoderParameter myEncoderParameter;
            EncoderParameters myEncoderParameters;
            MemoryStream ms = new MemoryStream();
            //设置Mime类型
            myImageCodecInfo = GetEncoderInfo("image/jpeg");
            myEncoder = System.Drawing.Imaging.Encoder.Quality;
            myEncoderParameters = new EncoderParameters(1);
            //设置图片像素100L为最大
            myEncoderParameter = new EncoderParameter(myEncoder, 50L);
            myEncoderParameters.Param[0] = myEncoderParameter;
            myBitmap.Save(ms, myImageCodecInfo, myEncoderParameters);
            return ms;
        }
        private static ImageCodecInfo GetEncoderInfo(String mimeType)
        {
            int j;
            ImageCodecInfo[] encoders;
            encoders = ImageCodecInfo.GetImageEncoders();
            for (j = 0; j < encoders.Length; ++j)
            {
                if (encoders[j].MimeType == mimeType)
                    return encoders[j];
            }
            return null;
        }
        /// <summary>
        /// 抓取有鼠标的桌面,并且能抓到透明窗体
        /// </summary>
        /// <returns></returns>
        public void CaptureDesktopT()
        {
            for (int j = 0; j < x; j++)
            {
                for (int k = 0; k < y; k++)
                {
                    try
                    {
                        Bitmap screenBitmap;
                        using (Graphics screenGraphic = Graphics.FromHwnd(IntPtr.Zero))
                        {
                            //根据屏幕大小建立位图，这就是最后截取到的*屏幕图像*
                            //screenBitmap = new Bitmap(1280, 800, screenGraphic);
                            screenBitmap = new Bitmap(SpX, SpY, screenGraphic);
                            //建立位图相关Graphics
                            Graphics bitmapGraphics = Graphics.FromImage(screenBitmap);
                            //建立屏幕上下文
                            IntPtr hdcScreen = screenGraphic.GetHdc();
                            //建立位图上下文
                            IntPtr hdcBitmap = bitmapGraphics.GetHdc();
                            //将屏幕捕获保存在位图中
                            BitBlt(hdcBitmap, 0, 0, SpX, SpY, hdcScreen, j * SpX, k * SpY, CopyPixelOperation.CaptureBlt | CopyPixelOperation.SourceCopy);
                            //关闭位图句柄
                            bitmapGraphics.ReleaseHdc(hdcBitmap);
                            //关闭屏幕句柄
                            screenGraphic.ReleaseHdc(hdcScreen);
                            //释放位图对像
                            bitmapGraphics.Dispose();
                            //释放屏幕对像
                            screenGraphic.Dispose();
                            //初始化16*8张图片
                            LBitmap.Add(screenBitmap);
                        }
                    }
                    catch
                    {
                      
                    }
                }
            }
            //Graphics g = Graphics.FromImage(ALL);
            //g.DrawImageUnscaled(LBitmap[2], 200, 200);
            //MemoryStream stream = new MemoryStream();
            //ALL.Save(stream, System.Drawing.Imaging.ImageFormat.Png);
            //ImageSourceConverter imageSourceConverter = new ImageSourceConverter();
            //image1.Source = (ImageSource)imageSourceConverter.ConvertFrom(stream);
        }
        public Bitmap CaptureDesktopALL()
        {
            Bitmap screenBitmap;
            using (Graphics screenGraphic = Graphics.FromHwnd(IntPtr.Zero))
            {
                //根据屏幕大小建立位图，这就是最后截取到的*屏幕图像*
                //screenBitmap = new Bitmap(1280, 800, screenGraphic);
                screenBitmap = new Bitmap(GetScreenPixel()[0], GetScreenPixel()[1], screenGraphic);
                //建立位图相关Graphics
                Graphics bitmapGraphics = Graphics.FromImage(screenBitmap);
                //建立屏幕上下文
                IntPtr hdcScreen = screenGraphic.GetHdc();
                //建立位图上下文
                IntPtr hdcBitmap = bitmapGraphics.GetHdc();
                //将屏幕捕获保存在位图中
                BitBlt(hdcBitmap, 0, 0, GetScreenPixel()[0], GetScreenPixel()[1], hdcScreen, 0, 0, CopyPixelOperation.CaptureBlt | CopyPixelOperation.SourceCopy);
                //关闭位图句柄
                bitmapGraphics.ReleaseHdc(hdcBitmap);
                //关闭屏幕句柄
                screenGraphic.ReleaseHdc(hdcScreen);
                //释放位图对像
                bitmapGraphics.Dispose();
                //释放屏幕对像
                screenGraphic.Dispose();
                MemoryStream stream = new MemoryStream();
                screenBitmap.Save(stream, System.Drawing.Imaging.ImageFormat.Png);
                ImageSourceConverter imageSourceConverter = new ImageSourceConverter();
                image1.Source = (ImageSource)imageSourceConverter.ConvertFrom(stream);
                return screenBitmap;
            }
        }
        //图片比较类
        public static bool ImageCompareString(Bitmap firstImage, Bitmap secondImage)
        {
            MemoryStream ms = new MemoryStream();
            firstImage.Save(ms, System.Drawing.Imaging.ImageFormat.Jpeg);
            String firstBitmap = Convert.ToBase64String(ms.ToArray());
            ms.Position = 0;
            secondImage.Save(ms, System.Drawing.Imaging.ImageFormat.Jpeg);
            String secondBitmap = Convert.ToBase64String(ms.ToArray());
            if (firstBitmap.Equals(secondBitmap))
            {
                return false;
            }
            else
            {
                return true;
            }
        }
    }
}

原文来自：雨枫技术教程网 http://www.fengfly.com
原文网址：http://www.fengfly.com/plus/view-173177-1.html

单击此处可下载本文的代码示例。

本页内容

简介
概述
使用示例
在托管代码中获取并更改显示设置
小结

简介

有些情况下，应用程序需要更改屏幕方向，因为有的功能被设计为在特定模式下运行得最好。其中一个例子就是 Microsoft Office PowerPoint 中的“幻灯片放映”：PowerPoint 以横向模式运行。即使正在纵向模式下使用 Tablet PC，当开始幻灯片放映时，应用程序也会切换到横向方向。当用户结束幻灯片放映时，PowerPoint 会切换回原来的设置。

返回页首

概述

更改显示设置可以通过使用两个 Win32 API 来完成，这两个 API 都具有指向 DEVMODE 结构的指针，它们分别包含与显示设置有关的所有信息：

• 使用 EnumDisplaySettings 读取当前显示设置，并枚举所有受支持的显示设置。

• 使用 ChangeDisplaySettings 切换到新的显示设置。

返回页首

使用示例

要编译示例源代码，计算机中必须安装 Microsoft Visual Studio .NET 2003。该示例应用程序有一个用户界面，它具有以下功能：

• 查看当前显示设备所支持的所有显示设置。

• 查看当前显示设置的参数。

• 切换至任何受支持的显示设置。

• 顺时针和逆时针旋转屏幕方向。

获取当前显示设置

要获取当前显示设置，请将 iModeNum 参数中的 ENUM_CURRENT_SETTINGS 常量传递给 EnumDisplaySettings API，如以下 C++ 代码所示。

   DEVMODE dm;
// initialize the DEVMODE structure
ZeroMemory(&dm, sizeof(dm));
dm.dmSize = sizeof(dm);
if (0 != EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &dm))
{
// inspect the DEVMODE structure to obtain details
// about the display settings such as
//  - Orientation
//  - Width and Height
//  - Frequency
//  - etc.
}

枚举所有受支持的显示设置

要枚举当前显示设备支持的所有显示设置，请将 iModeNum 参数中的 0 传递给 EnumDisplaySettings API，然后继续以递增的 iModeNum 值调用它，直到该函数返回零，如以下 C++ 代码所示。

   int index = 0;
DEVMODE dm;
// initialize the DEVMODE structure
ZeroMemory(&dm, sizeof(dm));
dm.dmSize = sizeof(dm);
while (0 != EnumDisplaySettings(NULL, index++, &dm))
{
// inspect the DEVMODE structure to obtain details
// about the display settings such as
//  - Orientation
//  - Width and Height
//  - Frequency
//  - etc.
}

更改显示设置

要更改显示设置，请将指向有效 DEVMODE 结构的指针传递给 ChangeDisplaySettings API。以下 C++ 代码演示如何使屏幕方向顺时针旋转 90 度。请注意，这段代码只对支持相应显示设置的设备起作用。遵守 ChangeDisplaySettings API 的返回值十分重要，因为有些操作为了在图形模式下工作，需要计算机重启。

   DEVMODE dm;
// initialize the DEVMODE structure
ZeroMemory(&dm, sizeof(dm));
dm.dmSize = sizeof(dm);
if (0 != EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &dm))
{
// swap height and width
DWORD dwTemp = dm.dmPelsHeight;
dm.dmPelsHeight= dm.dmPelsWidth;
dm.dmPelsWidth = dwTemp;
// determine new orientaion
switch (dm.dmDisplayOrientation)
{
case DMDO_DEFAULT:
dm.dmDisplayOrientation = DMDO_270;
break;
case DMDO_270:
dm.dmDisplayOrientation = DMDO_180;
break;
case DMDO_180:
dm.dmDisplayOrientation = DMDO_90;
break;
case DMDO_90:
dm.dmDisplayOrientation = DMDO_DEFAULT;
break;
default:
// unknown orientation value
// add exception handling here
break;
}
long lRet = ChangeDisplaySettings(&dm, 0);
if (DISP_CHANGE_SUCCESSFUL != lRet)
{
// add exception handling here
}
}

返回页首

在托管代码中获取并更改显示设置

映射 API

为了在托管代码中更改显示设置，必须使用平台调用服务 (PInvoke) 调用 EnumDisplaySettings 和 ChangeDisplaySettings API。对此，一个好的做法是创建一个名为 NativeMethods 的类，该类可以将封装这些 API 的公共静态方法公开。该类应该包含 API 所对应的所有必需的常量定义。以下代码示例演示了这种做法。该类的完整实现可在 NativeMethods.cs 文件中找到，该文件是示例应用程序的一部分。

using System.Runtime.InteropServices;
...
public class NativeMethods
{
// PInvoke declaration for EnumDisplaySettings Win32 API
[DllImport("user32.dll", CharSet=CharSet.Ansi)]
public static extern int EnumDisplaySettings(
string lpszDeviceName,
int iModeNum,
ref DEVMODE lpDevMode);
// PInvoke declaration for ChangeDisplaySettings Win32 API
[DllImport("user32.dll, CharSet=CharSet.Ansi")]
public static extern int ChangeDisplaySettings(
ref DEVMODE lpDevMode,
int dwFlags);
// add more functions as needed ??
// constants
public const int ENUM_CURRENT_SETTINGS = -1;
public const int DMDO_DEFAULT = 0;
public const int DMDO_90 = 1;
public const int DMDO_180 = 2;
public const int DMDO_270 = 3;
// add more constants as needed ??
}

映射 DEVMODE 结构

在将 DEVMODE 结构映射到托管结构时，应该注意以下几个问题：

• 因为 DEVMODE 结构包含联合 (union)，所以必须挑选出我们所需要的那些成员。

• 在 .NET Framework 中映射到字符串的数组必须作为相同大小的字符串封送。

• 为简单起见，可以将嵌套结构平面化（例如，将 POINTL 结构替换为两个托管的 int 类型。）

[StructLayout(LayoutKind.Sequential, CharSet=CharSet.Ansi)]
public struct DEVMODE
{
[MarshalAs(UnmanagedType.ByValTStr,SizeConst=32)]
public string dmDeviceName;
public short  dmSpecVersion;
public short  dmDriverVersion;
public short  dmSize;
public short  dmDriverExtra;
public int    dmFields;
public int    dmPositionX;
public int    dmPositionY;
public int    dmDisplayOrientation;
public int    dmDisplayFixedOutput;
public short  dmColor;
public short  dmDuplex;
public short  dmYResolution;
public short  dmTTOption;
public short  dmCollate;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
public string dmFormName;
public short  dmLogPixels;
public short  dmBitsPerPel;
public int    dmPelsWidth;
public int    dmPelsHeight;
public int    dmDisplayFlags;
public int    dmDisplayFrequency;
public int    dmICMMethod;
public int    dmICMIntent;
public int    dmMediaType;
public int    dmDitherType;
public int    dmReserved1;
public int    dmReserved2;
public int    dmPanningWidth;
public int    dmPanningHeight;
};

在 .NET Framework 中初始化 DEVMODE 结构的新实例时，请确保 dmDeviceName、dmFormName 和 dmSize 值设置恰当。为此，我在示例应用程序的 NativeMethods 类中添加了以下方法：

public static DEVMODE CreateDevmode()
{
DEVMODE dm = new DEVMODE();
dm.dmDeviceName = new String(new char[32]);
dm.dmFormName = new String(new char[32]);
dm.dmSize = (short)Marshal.SizeOf(dm);
return dm;
}

在 C# 中旋转屏幕

以下 C# 代码将前面讨论的技术结合起来，并展示了如何在托管代码中顺时针旋转屏幕。请注意，这段代码只对支持相应显示设置的设备起作用。

// initialize the DEVMODE structure
DEVMODE dm = new DEVMODE();
dm.dmDeviceName = new string(new char[32]);
dm.dmFormName = new string(new char[32]);
dm.dmSize = Marshal.SizeOf(dm);
if (0 != NativeMethods.EnumDisplaySettings(
null,
NativeMethods.ENUM_CURRENT_SETTINGS,
ref dm))
{
// swap width and height
int temp = dm.dmPelsHeight;
dm.dmPelsHeight = dm.dmPelsWidth;
dm.dmPelsWidth = temp;
// determine new orientation
switch(dm.dmDisplayOrientation)
{
case NativeMethods.DMDO_DEFAULT:
dm.dmDisplayOrientation = NativeMethods.DMDO_270;
break;
case NativeMethods.DMDO_270:
dm.dmDisplayOrientation = NativeMethods.DMDO_180;
break;
case NativeMethods.DMDO_180:
dm.dmDisplayOrientation = NativeMethods.DMDO_90;
break;
case NativeMethods.DMDO_90:
dm.dmDisplayOrientation = NativeMethods.DMDO_DEFAULT;
break;
default:
// unknown orientation value
// add exception handling here
break;
}
int iRet = NativeMethods.ChangeDisplaySettings(ref dm, 0);
if (NativeMethods.DISP_CHANGE_SUCCESSFUL != iRet)
{
// add exception handling here
}
}

返回页首

小结

• 使用 EnumDisplaySettings API 来获取当前显示设置的相关信息。

• 使用 EnumDisplaySettings API 来枚举所有受支持的显示设置。

• DEVMODE 结构包含关于给定的显示模式的所有信息。

• 使用 ChangeDisplaySettings 来切换到由有效的 DEVMODE 结构指定的新显示模式。

• 使用平台调用服务以从托管代码实现。

本页内容

	引言
	简化和缩短窗体代码
	开始：从反射中检索属性列表
	将对象属性值绑定到控件
	用已知属性设置未知控件的值
	反转过程：BindControlsToObject
	性能和 FormBinding 方案的扩展
	结论
	参考资料

<script runat="server">
protected void Page_Load(Object Src, EventArgs E) {
if (!IsPostBack) {
Document document =
Documents.GetDocument(Request.QueryString["DocumentID"]);
Title.Text = document.Title;
Active.Checked = document.Active;
CreatedDate.Text = document.CreatedDate.ToString();
AuthorID.FindByValue(document.AuthorID.ToString()).Selected =
true;
// ... 等等
HtmlBody.Text = document.HtmlBody;
}
}
protected void SaveButton_Click(Object Src, EventArgs E) {
Document document =
Documents.GetDocument(Request.QueryString["DocumentID"]);
document.Title = Title.Text;
document.Active = Active.Checked;
document.CreatedDate = Convert.ToDateTime(CreatedDate.Text);
document.AuthorID = Convert.ToInt32(AuthorID.SelectedItem.Value);
// ... 等等
document.HtmlBody = HtmlBody.Text;
Documents.Update(document);
}
</script>

返回页首

简化和缩短窗体代码

在以上代码中，对每个控件进行显式转换，并将其设置为窗体控件的正确属性。根据属性和窗体控件的数量，这部分代码可能会变长并难以管理。代码还应包含类型转换的错误更正和 ListControl，这将进一步增加复杂性。即使窗体是由代码生成工具（例如 Eric J. Smith 的优秀的 CodeSmith）生成的，当需要任何自定义逻辑关系时，很容易引入错误。

使用反射，可以仅使用单行代码便将业务对象的所有属性绑定到相应的窗体控件，从而减少代码的行数并增强可读性。完成反射系统的建立后，以上代码将简化为：

protected void Page_Load(Object Src, EventArgs E) {
if (!IsPostBack) {
Document document =
Documents.GetDocument(Request.QueryString["DocumentID"]);
FormBinding.BindObjectToControls(document);
}
}
protected void Save_Click(Object Src, EventArgs E) {
Document document =
Documents.GetDocument(Request.QueryString["DocumentID"]);
FormBinding.BindControlsToObject(document);
Documents.Update(document);
}

此代码可用于所有标准的 ASP.NET 控件（TextBox、DropDownList、CheckBox 等）和许多第三方控件（例如 Free TextBox 和 Calendar Popup）。无论有多少业务对象属性和窗体控件，这一行代码都能提供所需的全部功能，只要窗体控件的 ID 与业务对象属性名相匹配。

返回页首

开始：从反射中检索属性列表

首先，我们需要检查业务对象的属性，并查找与业务对象属性名具有相同 ID 的 ASP.NET 控件。以下代码构成了绑定查找的基础：

public class FormBinding {
public static void BindObjectToControls(object obj,
Control container) {
if (obj == null) return;
Type objType = obj.GetType();
PropertyInfo[] objPropertiesArray =
objType.GetProperties();
foreach (PropertyInfo objProperty in objPropertiesArray) {
Control control =
container.FindControl(objProperty.Name);
if (control != null) {
// 处理控件 ...
}
}
}
}

在以上代码中，方法 BindObjectsToControls 接受了业务对象 obj 和一个容器控件。容器控件通常是当前 Web 窗体的 Page 对象。如果所用版本是会在运行时更改控件嵌套顺序的 ASP.NET 1.x MasterPages，您将需要指定窗体控件所在的 Content 控件。这是在 ASP.NET 1.x 中，FindControl 方法对嵌套控件和命名容器的处理方式导致的。

在以上代码中，我们获取了业务对象的 Type，然后使用该 Type 来获取 PropertyInfo 对象的数组。每个 PropertyInfo 对象都包含关于业务对象属性以及从业务对象获取和设置值的能力的信息。我们使用 foreach 循环检查具有与业务对象属性名 (PropertyInfo.Name) 对应的 ID 属性的 ASP.NET 控件的容器。如果找到控件，则尝试将属性值绑定到该控件。

返回页首

将对象属性值绑定到控件

过程中的大部分操作是在此阶段执行的。我们需要用对象的属性值来填充找到的控件。一种实现方法是为每种控件类型创建一个 if ... else 语句。派生自 ListControl（DropDownList、RadioButtonList、CheckBoxList 和 ListBox）的所有控件都具有可以统一访问的公用接口，所以可以将它们编组在一起。如果找到的控件是 ListControl，我们可以将其作为 ListControl 进行转换，然后设置选定项：

Control control = container.FindControl(objProperty.Name);
if (control != null) {
if (control is ListControl) {
ListControl listControl = (ListControl) control;
string propertyValue = objProperty.GetValue(obj,
null).ToString();
ListItem listItem =
listControl.Items.FindByValue(propertyValue);
if (listItem != null) listItem.Selected = true;
} else {
// 处理其他控件类型
}
}

不幸的是，其他控件类型并不从父类中派生。以下几个公用控件都具有 .Text 字符串属性：TextBox、Literal 和 Label。但该属性不是从公用父类中派生出来的，所以需要分别转换每种控件类型。我们还需要转换其他控件类型，例如 Calendar 控件，以便使用适当的属性（在 Calendar 的例子中，是 SelectedDate 属性）。要包含所有标准的 ASP.NET 窗体控件，并访问窗体控件的正确属性并不需要太多的代码行。

if (control is ListControl) {
ListControl listControl = (ListControl) control;
string propertyValue = objProperty.GetValue(obj,
null).ToString();
ListItem listItem = listControl.Items.FindByValue(propertyValue);
if (listItem != null) listItem.Selected = true;
} else if (control is CheckBox) {
if (objProperty.PropertyType == typeof(bool))
((CheckBox) control).Checked = (bool)
objProperty.GetValue(obj, null);
} else if (control is Calendar) {
if (objProperty.PropertyType == typeof(DateTime))
((Calendar) control).SelectedDate = (DateTime)
objProperty.GetValue(obj, null);
} else if (control is TextBox) {
((TextBox) control).Text = objProperty.GetValue(obj,
null).ToString();
} else if (control is Literal)(
//... 等等。还可用于标签等属性。
}

此方法完整地涵盖了标准的 ASP.NET 1.x 控件。从这个角度来看，我们拥有了功能齐全的 BindObjectToControls 方法。但在起作用的同时，此方法的应用范围会受到限制，因为它仅考虑内置的 ASP.NET 1.x 控件。如果要支持新的 ASP.NET 2.0 控件，或者要使用任何第三方控件，我们必须在 FormBinding 项目中引用控件的程序集，并将控件类型添加到 if ... else 列表。

此问题的解决方案是第二次使用反射，以查看各个控件的属性，并找出控件是否具有与业务对象的属性类型对应的属性类型。

返回页首

用已知属性设置未知控件的值

如上所述，有些控件共享字符串属性 .Text，大多数窗体控件以实质相同的方式使用此属性。该属性用于获取和设置用户输入的数据。有大量控件还使用了其他一些公用属性和属性类型。以下是这些属性中的一些：称为 .SelectedDate 的 DateTime 属性，它在许多日历和日期选取器控件中使用；称为 .Checked 的布尔属性，它在布尔型控件中使用；称为 .Value 的字符串属性，它常见于隐藏控件。这四个属性（string Text、string Value、bool Checked 和 DateTime SelectedDate）是最常见的控件属性。如果可以将系统设计成无论何种控件类型，都绑定到这些属性，那么我们的绑定方法将适用于使用那四个属性的任何控件。

在以下代码中，我们将第二次使用反射（这一次是对窗体控件使用，而不是对业务对象使用），以确定它是否具有任何常用属性。如果有，则尝试将业务对象的属性值设置为控件的属性。作为示例，我们将对整个 PropertyInfo 数组进行迭代，并查找称为 .Text 的字符串属性。如果控件具有该属性，则将数据从业务对象发送到该控件的属性。

if (control is ListControl) {
// ...
} else {
// 获取控件的类型和属性
//
Type controlType = control.GetType();
PropertyInfo[] controlPropertiesArray =
controlType.GetProperties();
// 查找 .Text 属性
//
foreach (PropertyInfo controlProperty
in controlPropertiesArray) {
if (controlPropertiesArray.Name == "Text" &&
controlPropertiesArray.PropertyType == typeof(String)) {
// 设置控件的 .Text 属性
//
controlProperty.SetValue(control,
(String) objProperty.GetValue(obj, null), null);
}
}
}

如果找到 .Text，则使用 PropertyInfo 类的 GetValue 方法从业务对象的属性中检索值。然后，使用控件的 .Text 属性的 SetValue 方法。在此，我们还使用 Type 命令将控件的属性设置为 typeof(String)，并使用 (String) 符号显式转换来自属性的值。

为了使 BindObjectToControls 方法完整，我们还需要处理其他公用属性，即 .Checked、.SelectedDate 和 .Value。在以下代码中，我们将控件属性搜索打包到称为 FindAndSetControlProperty 的辅助方法中，以简化代码。

if (control is ListControl) {
// ...
} else {
// 获取控件的属性
//
Type controlType = control.GetType();
PropertyInfo[] controlPropertiesArray =
controlType.GetProperties();
bool success = false;
success = FindAndSetControlProperty(obj,
objProperty, control, controlPropertiesArray,
"Checked", typeof(bool) );
if (!success)
success = FindAndSetControlProperty(obj,
objProperty, control, controlPropertiesArray,
"SelectedDate", typeof(DateTime) );
if (!success)
success = FindAndSetControlProperty(obj,
objProperty, control, controlPropertiesArray,
"Value", typeof(String) );
if (!success)
success = FindAndSetControlProperty(obj,
objProperty, control, controlPropertiesArray,
"Text", typeof(String) );
}
private static void FindAndSetControlProperty(object obj,
PropertyInfo objProperty, Control control,
PropertyInfo[] controlPropertiesArray, string propertyName,
Type type) {
// 在整个控件属性中进行迭代
foreach (PropertyInfo controlProperty in
controlPropertiesArray) {
// 检查匹配的名称和类型
if (controlPropertiesArray.Name == "Text" &&
controlPropertiesArray.PropertyType == typeof(String)) {
// 将控件的属性设置为
// 业务对象属性值
controlProperty.SetValue(control,
Convert.ChangeType(
objProperty.GetValue(obj, null), type) , null);
return true;
}
}
return false;
}

以上属性检查的顺序很重要，因为有些控件具有以上属性中的多个，但我们只想设置一个。例如，CheckBox 控件既有 .Text 属性也有 .Checked 属性。在此示例中，我们希望使用 .Checked 属性而不是 .Text 属性，所以将 .Checked 放在属性搜索顺序的首位。任何情况下，如果找到具有正确名称和类型的控件属性，则尝试将控件的属性设置为业务对象属性的值。

从这个角度来看，我们拥有了功能齐全的 BindObjectToControls 方法。利用该方法，我们可以在 ASPX 窗体上的任何地方，使用任何类和控件的任意组合进行调用，而这确实有效。现在，我们需要创建在提交窗体时进行反转的方法。我们需要从表示用户输入的控件中检索新值，而不是将控件属性的值设置为业务对象的值。

返回页首

反转过程：BindControlsToObject

在 BindControlsToObject 方法中，我们将以同样的方式开始，即从业务对象中检索属性的列表，然后使用 FindControl 方法找到具有与对象属性相匹配的 ID 的控件。如果找到控件，则检索值并将该值返回给业务对象。此部分还将包含 ListControl 的单独代码，因为这些控件具有公用接口。我们将使用另一种辅助方法来搜索并检索控件中的值，然后将该值返回给业务对象。

public static void BindControlsToObject(object obj,
Control container) {
Type objType = obj.GetType();
PropertyInfo[] objPropertiesArray = objType.GetProperties();
foreach (PropertyInfo objProperty in objPropertiesArray) {
if (control is ListControl) {
ListControl listControl = (ListControl) control;
if (listControl.SelectedItem != null)
objProperty.SetValue(obj,
Convert.ChangeType(list.SelectedItem.Value,
objProperty.PropertyType), null);
} else {
// 获取控件的属性
//
Type controlType = control.GetType();
PropertyInfo[] controlPropertiesArray =
controlType.GetProperties();
bool success = false;
success = FindAndGetControlProperty(obj,
objProperty, control, controlPropertiesArray,
"Checked", typeof(bool) );
if (!success)
success = FindAndGetControlProperty(obj,
objProperty, control, controlPropertiesArray,
"SelectedDate", typeof(DateTime) );
if (!success)
success = FindAndGetControlProperty(obj,
objProperty, control, controlPropertiesArray,
"Value", typeof(String) );
if (!success)
success = FindAndGetControlProperty(obj,
objProperty, control, controlPropertiesArray,
"Text", typeof(String) );
}
}
}
private static void FindAndGetControlProperty(object obj,
PropertyInfo objProperty, Control control, PropertyInfo[]
controlPropertiesArray, string propertyName, Type type) {
// 在整个控件属性中进行迭代
foreach (PropertyInfo controlProperty in
controlPropertiesArray) {
// 检查匹配的名称和类型
if (controlPropertiesArray.Name == "Text" &&
controlPropertiesArray.PropertyType == typeof(String)) {
// 将控件的属性设置为
// 业务对象属性值
try {
objProperty.SetValue(obj,
Convert.ChangeType(
controlProperty.GetValue(control, null),
objProperty.PropertyType) , null);
return true;
} catch {
// 无法将来自窗体控件
// 的数据转换为
// objProperty.PropertyType
return false;
}
}
}
return true;
}

完成这两种方法后，我们的窗体语法将得到简化，如以上简化和缩短窗体代码中所述。每个属性和控件的类型转换与错误更正都是自动进行的。这两种方法（BindObjectToControls 和 BindControlsToObject）为开发人员创建窗体提供了很大的灵活性。它们还可以用于处理以下这些常见方案：

•	如果将新属性添加到业务对象，并且需要在窗体上访问该新属性，那么开发人员只需将控件添加到页面，并将控件的 ID 设置为新属性的名称，FormBinding 方法将处理剩下的一切。
•	如果开发人员需要更改用于特定属性的控件的类型，例如从 TextBox 更改为第三方的 HTML 编辑器控件，他/她仅需要确保新控件具有以上属性之一（例如 .Text ），窗体将以与之前完全一致的方式进行工作。
•	全部使用 TextBox 控件也可以快速生成窗体，但输入仍将转换为适用于业务对象属性的正确类型。例如，可以用 TextBox 控件来代替 Calendar 控件或第三方的日期选取器控件。只要用户输入 DateTime 字符串作为值，便会将 TextBox 的 .Text 属性中的值转换为 DateTime，就如同它是日历控件上的 SelectedDate 属性一样。如果以后将 TextBox 更改为日期选取器控件，逻辑关系将保持不变。
•	通过将所有控件更改为 Literal 控件，开发人员还可以快速创建“视图”页面。Literal 的 .Text 属性将被设置为业务对象属性的值，就如同它是 TextBox 一样。
•	在实际方案中，窗体还包含其他数据类型和自定义配置。用于处理这些特定操作的代码可以放置在对 BindObjectToControls 和 BindControlsToObject 的调用之后。

返回页首

性能和 FormBinding 方案的扩展

有些开发人员可能想知道，使用反射引起的性能下降是否值得。在我的测试中，使用了具有七种属性（int DocumentID、bool Active、DateTime Created、int CategoryID、String Title、string Author 和 String htmlText）的对象，BindObjectToControls 用时约 1/3 毫秒，BindControlsToObject 用时大约 1 毫秒。这些值是通过循环运行 1000 次 BindObjectToControls 和 BindControlsToObject 方法得到的。对于常见的“添加”和“编辑”窗体方案，这样的性能应不会引起任何重大的问题，而且确实能够提高开发速度和灵活性。

尽管此方法几乎适用于每种窗体，但有时可能需要修改以上代码。在某些方案中，开发人员要使用的控件可能并不使用以上属性之一作为其主要接口。在此情形中，需要更新 FormBinding 方法，以包括该属性和类型。

返回页首

结论

这两种 FormBinding 方法（BindObjectToControls 和 BindControlsToObject）可用于极大地简化窗体代码，并为 ASP.NET 窗体的开发提供了最大的灵活性。对它们的使用使我获益良多，希望您的团队同样能够从中受益。

返回页首

参考资料

•	ASP.NET Unleashed
•	Programming Microsoft ASP.NET

namespace MyProcessSample
{
 /// <summary>
 /// Shell for the sample.
 /// </summary>
 class MyProcess
 {
  // These are the Win32 error code for file not found or access denied.
  const int ERROR_FILE_NOT_FOUND =2;
  const int ERROR_ACCESS_DENIED = 5;

  /// <summary>
  /// Prints a file with a .doc extension.
  /// </summary>
  void PrintDoc()
  {
   Process myProcess = new Process();
   
   try
   {
    // Get the path that stores user documents.
    string myDocumentsPath =
     Environment.GetFolderPath(Environment.SpecialFolder.Personal);

    myProcess.StartInfo.FileName = myDocumentsPath + "\\MyFile.doc";
    myProcess.StartInfo.Verb = "Print";
    myProcess.StartInfo.CreateNoWindow = true;
    myProcess.Start();
   }
   catch (Win32Exception e)
   {
    if(e.NativeErrorCode == ERROR_FILE_NOT_FOUND)
    {
     Console.WriteLine(e.Message + ". Check the path.");
    }

    else if (e.NativeErrorCode == ERROR_ACCESS_DENIED)
    {
     // Note that if your word processor might generate exceptions
     // such as this, which are handled first.
     Console.WriteLine(e.Message +
      ". You do not have permission to print this file.");
    }
   }
  }

  public static void Main()
  {
   MyProcess myProcess = new MyProcess();
   myProcess.PrintDoc();
  }
 }
}

 
C++  Copy Code
#using <System.dll>

using namespace System;
using namespace System::Diagnostics;
using namespace System::ComponentModel;

// These are the Win32 error code for file not found or access denied.
#define ERROR_FILE_NOT_FOUND 2
#define ERROR_ACCESS_DENIED  5
int main()
{
   Process^ myProcess = gcnew Process;
   try
   {
     
      // Get the path that stores user documents.
      String^ myDocumentsPath = Environment::GetFolderPath( Environment::SpecialFolder::Personal );
      myProcess->StartInfo->FileName = String::Concat( myDocumentsPath, "\\MyFile.doc" );
      myProcess->StartInfo->Verb = "Print";
      myProcess->StartInfo->CreateNoWindow = true;
      myProcess->Start();
   }
   catch ( Win32Exception^ e )
   {
      if ( e->NativeErrorCode == ERROR_FILE_NOT_FOUND )
      {
         Console::WriteLine( "{0}. Check the path.", e->Message );
      }
      else
      if ( e->NativeErrorCode == ERROR_ACCESS_DENIED )
      {
        
         // Note that if your word processor might generate exceptions
         // such as this, which are handled first.
         Console::WriteLine( "{0}. You do not have permission to print this file.", e->Message );
      }
   }

}

The following example uses the Process class itself and a static Start method to start a process.

Visual Basic  Copy Code
Imports System
Imports System.Diagnostics
Imports System.ComponentModel

Namespace MyProcessSample
    _
   '/ <summary>
   '/ Shell for the sample.
   '/ </summary>
   Class MyProcess
      '/ <summary>
      '/ Opens the Internet Explorer application.
      '/ </summary>
      Public Sub OpenApplication(myFavoritesPath As String)
         ' Start Internet Explorer. Defaults to the home page.
         Process.Start("IExplore.exe")
        
         ' Display the contents of the favorites folder in the browser.
         Process.Start(myFavoritesPath)
      End Sub 'OpenApplication
      
     
      '/ <summary>
      '/ Opens urls and .html documents using Internet Explorer.
      '/ </summary>
      Sub OpenWithArguments()
         ' url's are not considered documents. They can only be opened
         ' by passing them as arguments.
         Process.Start("IExplore.exe", "www.northwindtraders.com")
        
         ' Start a Web page using a browser associated with .html and .asp files.
         Process.Start("IExplore.exe", "C:\myPath\myFile.htm")
         Process.Start("IExplore.exe", "C:\myPath\myFile.asp")
      End Sub 'OpenWithArguments
     
     
      '/ <summary>
      '/ Uses the ProcessStartInfo class to start new processes, both in a minimized
      '/ mode.
      '/ </summary>
      Sub OpenWithStartInfo()
        
         Dim startInfo As New ProcessStartInfo("IExplore.exe")
         startInfo.WindowStyle = ProcessWindowStyle.Minimized
        
         Process.Start(startInfo)
        
         startInfo.Arguments = "www.northwindtraders.com"
        
         Process.Start(startInfo)
      End Sub 'OpenWithStartInfo
      
     
      Shared Sub Main()
         ' Get the path that stores favorite links.
         Dim myFavoritesPath As String = Environment.GetFolderPath(Environment.SpecialFolder.Favorites)
        
         Dim myProcess As New MyProcess()
        
         myProcess.OpenApplication(myFavoritesPath)
         myProcess.OpenWithArguments()
         myProcess.OpenWithStartInfo()
      End Sub 'Main
   End Class 'MyProcess
End Namespace 'MyProcessSample

 
C#  Copy Code
using System;
using System.Diagnostics;
using System.ComponentModel;

namespace MyProcessSample
{
 /// <summary>
 /// Shell for the sample.
 /// </summary>
 class MyProcess
 {
   
  /// <summary>
  /// Opens the Internet Explorer application.
  /// </summary>
  void OpenApplication(string myFavoritesPath)
  {
   // Start Internet Explorer. Defaults to the home page.
   Process.Start("IExplore.exe");
       
      // Display the contents of the favorites folder in the browser.
      Process.Start(myFavoritesPath);
 
  }
  
  /// <summary>
  /// Opens urls and .html documents using Internet Explorer.
  /// </summary>
  void OpenWithArguments()
  {
   // url's are not considered documents. They can only be opened
   // by passing them as arguments.
   Process.Start("IExplore.exe", "www.northwindtraders.com");
   
   // Start a Web page using a browser associated with .html and .asp files.
   Process.Start("IExplore.exe", "C:\\myPath\\myFile.htm");
   Process.Start("IExplore.exe", "C:\\myPath\\myFile.asp");
  }
  
  /// <summary>
  /// Uses the ProcessStartInfo class to start new processes, both in a minimized
  /// mode.
  /// </summary>
  void OpenWithStartInfo()
  {
   
   ProcessStartInfo startInfo = new ProcessStartInfo("IExplore.exe");
   startInfo.WindowStyle = ProcessWindowStyle.Minimized;
   
   Process.Start(startInfo);
   
   startInfo.Arguments = "www.northwindtraders.com";
   
   Process.Start(startInfo);
   
  }

  static void Main()
  {
              // Get the path that stores favorite links.
              string myFavoritesPath =
                 Environment.GetFolderPath(Environment.SpecialFolder.Favorites);
               
              MyProcess myProcess = new MyProcess();
        
   myProcess.OpenApplication(myFavoritesPath);
   myProcess.OpenWithArguments();
   myProcess.OpenWithStartInfo();

         } 
 }
}

　　一、.NET应用程序更新组件介绍

　　.NET 应用程序更新组件AppUpdater 是使用.NET框架开发的。尽管AppUpdater 不是微软的产品，但是只要你在VS.NET工具栏中添加了该组件，就可以象使用其它组件一样通过拖拽的方式将该组件从工具栏中拖放到你的应用程序中，并设置一些属性（比如获取更新的位置、频率等）之后就可以使得你的客户端应用程序具备自动更新的功能。

　　二、工作原理

　　要深入理解.NET客户端应用程序更新组件的工作原理，需要仔细研究一下实现客户端应用程序更新有那些必须要做的事情。第一步需要做的是检查是否有更新；当发现有更新时，开始第二步工作——下载更新；当更新下载完成时，进行是最后一步的工作——实现更新。

　　(一) 为更新做检查

　　作为开发者，首先你得告诉应用程序到什么地方去做更新检查，否则它岂不是要大海捞针？其次，确定何时做更新检查。不可能用户每次一运行客户端程序，而它就在后台不停的进行更新检查，那多浪费资源！最后还有一项重要的事情需要解决，那就是如何进行更新检查。.NET应用程序更新组件使用HTTP进行通讯，这就允许客户端应用程序穿透防火墙来进行更新。并且进行更新检查所需要的地址就成了已知的Web服务器的一个URL地址，第一个问题顺利解决。

　　.NET应用程序更新组件在组件生成的基础上产生一个线程，该线程负责进行更新检查。该线程在大多数时间处于休眠状态，但会在设置好的间隔苏醒并实现一次更新检查。应用程序为新的更新所做的检查的频率依赖于各应用自身。进行更新检查的间隔常用值的范围一般是从一个小时到几天。这种轮询的基本方法并不适合于所有情况。比如Microsoft Money只是在用户让它去进行更新检查时它才去检查。在这种情况下，更新轮询线程可被禁用。

　　通过用命令调用更新组件的CheckForUpdate()方法来实现更新检查。

　　关于如何进行更新检查的方法有这样几种：

　　方法一：直接文件检查——使用HTTP来比较服务器和客户端应用程序的最后的修改日期/时间戳是否一致。如果服务器上有更新的文件，客户端就知道可以更新自己了。对于Web浏览器来讲，也是同样的道理，它知道是否需要重新下载一个html页面或图片或是否可以
重复使用先前已下载的。当应用程序有一个新的版本可用时，管理员简单地拷贝一个更新的版本来覆盖Web服务器上的旧版本。这种方法的问题在于更新不是自动进行，由此会出现潜在的失败可能。比如，如果管理员正在更新Web服务器上的应用程序版本，同时有个客户正在下载更新之前的版本，那么这个客户的计算机上就会既存在更新之前的一些文件，也存在更新之后新版本的一些文件。基于上述原因，对于重要的应用程序不提倡使用直接文件检查来更新。

　　方法二：显式检查——在服务器上使用一个显式的配置文件。一个可和.NET应用程序更新组件使用的有效服务器显式文件大致是这个样子：..

＜VersionConfig＞
＜AvailableVersion＞1.0.0.0＜/AvailableVersion＞
＜ApplicationUrl＞http://localhost/demos/selfupdate/V1/＜/
ApplicationUrl＞
＜/VersionConfig＞

　　AvailableVersion指定最新的可用程序集的版本号。ApplicationURL属性指定该版本应用程序所在的URL地址。当管理员想要更新客户端应用程序时，他们就会将应用程序的新版本拷贝到Web服务器上并且适当地修改服务器显式文件。客户端自身会探测到服务器显式文件已被修改，然后下载显式文件。客户端随后比较显式文件中指定的程序集版本号与应用程序EXE文件的版本号。如果服务器显式文件中的可用版本号较新，应用程序就知道需要更新了。这种方法对大多数应用程序而言是推荐使用的方法。

　　方法三：XML Web Service 检查——XML WebServices提供一种更高级的更新检查方式。比如，假定你希望在进行更新你的其他用户之前先对一系列早期用户进行更新，如果客户端应用程序调用一个XML WebService来检查一项更新是否可用，那个XML Web Service还可以在数据库中查询该用户并判断该用户是否是早期用户。如果他们是早期用户，XML Web Service就返回一个值表示更新可用。如果不是，Web Service就返回一个值表示更新不可用。但本文介绍的.NET应用程序更新组件并不提供直接的XML Web Service支持。

　　要采用XML Web Service来进行更新检查，首先建立 XML Web Service并挂钩一个OnCheckForUpdate事件。这样就允许你自己的自定义检查代替轮询者线程更新检查。OnCheckForUpdate事件有一个返回值，该值表示更新是否被检测到。

　　(二) 下载更新

　　当.NET应用程序更新组件检测到一项新的更新可用时它会自动启动另一个线程并开始异步后台下载更新。

　　下载使用HTTP-DAV来完成。DAV 是一种扩展的HTTP，.. 它提供诸如目录和文件枚举这样的功能。一项完整的下载过程始于指定一个URL。采用URL来下载依赖于完成更新检查所使用的方式。比如，如果使用服务器显式文件，下载更新所用的URL通过在服务器显式文件 中的ApplicationURL属性指定。

　　更新下载显然需要一定的健壮性。在下载和更新之后让客户端应用程序处于任何不稳定的状态是不可接受的。下载过程中任何问题可能都会出现：更新文件所属的Web 服务器可能会宕机，客户端机器可能会崩溃，或者因为某种原因用户只是简单的关闭了应用程序。由于
应用程序正在进行下载，如果它被关闭的话，下载将会停止。一种可选的设计方案是使用单独的系统服务来进行应用程序的下载和更新。使用系统服务，即便应用程序自身没有在运行，更新下载也会继续。实际上，Windows XP就有一种称之为BITS的内建的下载服务，其目的即在此。BITS是Windows XP用来对Windows自身进行下载更新的。想查看更多关于BITS的信息，请参阅http://msdn.microsoft.com/library/en-us/dnwxp/html/WinXP_BITS.asp。在.NET应用程序更新组件中没有使用这种服务，因此它可以在不支持系统服务的Windows 9x中使用。

　　(三) 实现更新

　　.NET应用程序更新组件通过将下载和更新过程分为单独的两个阶段来获得健壮性。当每一阶段都完成时，在位于客户端应用程序目录下的一个更新显式文件（manifest file）中记载下来。如果下载或更新任何一个阶段中的过程被打断，它就会在下一次应用程序启动时从上一次完成的断点继续原来的工作。每一阶段都可以重新运行，因此如果在一个阶段中间出现失败，重新运行该阶段就可以成功。如果有错误发生，比如在下载过程中与服务器的链接丢失，.NET更新组件将会在稍后重试。如果报告了非常多的错误（例如web服务器再也没有回到在线状态），下载和更新将会被放弃并且报告出错误。

　　我们的第一个方法是简单地启动一个单独的进程来实现更新。这个单独的进程将会首先关闭应用程序进程，实现更新（因为这时候已被解锁），重启应用程序进程并且在完成之后关闭自己。因此，这种设计存在三个基本的问题：

　　. 在某些情况下它不起作用。在更新应用程序时，更新进程关闭原始的应用程序进程，更新进程自身也要被关闭，因此也就不会实现更新。

　　. 我们希望能够自动更新所有要实现更新的代码。我们希望自动安装修补的能力不仅仅发生在应用程序上，而且.NET应用程序更新组件自身也可以。使用这种模式，我们不能更新实现更新的进程。

　　. 强制用户关闭应用程序并在使用过程中等待，这是很不礼貌的。

　　用来实现应用程序更新的最后一种方法是使用.NET框架并行程序集模式。作为试图更新应用程序自身的替代方案，生成一个比目前存在版本新的应用程序版本。

　　新版本可以通过合并目前现存的应用程序目录与下载的更新版本来生成。当新版本完成时，用户在下次重新打开应用程序时会自动使用新版本。原始应用程序的拷贝就可以被移除了。棘手问题是弄清在某个指定时刻哪个版本该被载入。我们介绍一个名称为Appstart的应用程
序。Appstart是进入你应用程序的入口点，使用这种模式，你的应用程序目录看起来是这个样子：..

--＞ Program Files

--＞ MyApp

--＞ Appstart.exe

--＞ Appstart.config

--＞ V1 Folder

--＞ MyApp.exe

--＞ V1.1 Folder

--＞ MyApp.exe

　　要运行你的应用程序，你通常是启动Appstart.exe。如果你想在桌面上有个快捷键，那个快捷键必须应该指向Appstart而不是直接指向应用程序（注意，你可以重命名AppStart.exe 为任何你想要的名字，例如YourApp.exe）Appstart.exe是个非常简单的程序，它读取Appstart.config文件并且载入指定的应用程序。一个有效Appstart.config文件如下所示：

＜Config＞
　＜AppFolderName＞V1 Folder＜/AppFolderName＞
　＜AppExeName＞MyApp.exe＜/AppExeName＞
　＜AppLaunchMode＞appdomain＜/AppLaunchMode＞
＜/Config＞

　　AppFolderName指定包含当前要运行的应用程序版本的子文件夹。AppExeName包含在那个文件夹下要载入的exe文件名。当一个应用程序更新完成时，最后一步就是修改AppFolderName的值为指向应用程序的新版本。这样，下次用户运行应用程序时，就会运行新的应用程序更新后的版本。AppLaunchMode指定如何加载应用程序。有两种方式加载应用程序：第一种方式是使用AppDomains。AppDomains是.NET框架公
用语言运行时的特性，也是独立的逻辑单元和管理对象。公用语言运行时允许每个进程中存在多个应用程序域。这样Appstart.exe就能够在单独的AppDomain中同时却是相同的AppStart.exe进程中加载你的应用程序。尽管事实是两个不同的exe 程序在运行（即Appstart.exe和MyApp.exe），但只有一个进程在使用。对于大多数应用程序AppDomains会工作得很好，当然，在一个单独的AppDomain中运行和在一个单独
的进程中运行还是有些细微区别的。在这种情况下，AppLaunchMode可以设置为“process”，这样就会使应用程序在单独进程中加载。

　　一旦Appstart启动应用程序，它就会进入休眠状态等待应用程序终止。一旦应用程序终止，Appstart也会关闭。

　　三、实例演练

　　前面我们讨论了.NET应用程序更新是如何工作的，现在我们来将它应用在实例中。

　　第一步：建立应用程序来进行更新

　　1. 使用VS.NET生成一个新的Windows应用项目，命名为"SampleApp"。

　　2. 给窗体一个你选择的有趣的背景色。我们将使用背景色来与后面更新的版本区别。

　　3. 现在让我们给这个应用程序增加一个细微的功能，首先给你的窗体增加一个按钮。压缩文件中包含一个拥有简单Windows窗体的程序集。给压缩文件中Samples\SampleApp\SimpleForm 程序集增加一个引用。然后在你的按钮事件句柄中添加两行代码：

..
SimpleForm.Form1 F = new SimpleForm.Form1();
F.Show();

　　4. 将你的build标志从debug转换为RELEASE。这将允许我们避免稍后当我们生成一个应用程序的新版本而同时原始拷贝正在运行产生的pdb文件锁定问题。生成并测试你的应用程序。

　　第二步：添加.NET应用程序更新组件

　　1. 在VS.NET工具栏的组件标签上，右击选择“自定义工具栏”。选择“.NET框架组件”标签。点“浏览”并选择位于压缩文件中AppUpdater 项目下的AppUpdater.dll，单击OK。

　　2. 一个AppUpdater图标现在应该出现在工具栏的组件列表的底部。将AppUpdater 组件拖放到SampleApp窗体上。一个名为appUpdater1的.NET应用程序更新组件的实例会出现在窗体的底部。

　　第三步：设置.NET应用程序更新组件

　　在这一步我们将设置.NET应用程序更新组件。注意这个示例你只需改变最开始的四个属性，其它的采用默认值。

　　AppUpdater属性：这是.NET Application应用程序更新的核心，对于本程序需要做以下设置：

　　（1)AutoFileLoad：这个控制后面要描述的命令下载特征，现在将它设置为true。

　　（2）ChangeDetectionMode：该枚举决定如何为更新进行检查。在该例中，我们将使用一个服务器显式检查，因此将这个值设置为“ServerManifestCheck ”。

　　（3）ShowDefaultUI： .NET 应用程序更新组件具有一系列用户界面来通知用户一些事件，比如有一个新的更新可以使用了或者在更新期间发生错误等。这种用户界面可以通过设置默认的用户界面为无效而用自定义应用程序指定的用户界面来代替它，挂钩适当的事件（比如
OnUpdateComplete）并弹出自定义用户界面。对于该例我们将使用默认的用户界面，因此将这个值设置为true 。

　　（4）UpdateUrl ：UpdateUrl 是决定更新程序到何处去寻找更新的。在该例中我们使用一个服务器显式文件来检查更新，因此这个属性应当设置为服务器显式文件的URL 。

　　在该例中将它设置为：http://yourWebserver/SampleApp_ServerSetup/UpdateVersion.xml。请用你的Web 服务器名
称来代替“yourWebserver ”。

　　Downloader 属性:AppUpdater 组件有两个子组件。第一个称之为Downloader，它控制组件的下载和Poller属性：AppUpdater的第二个子组件是Poller,Poller控制更新检查。

　　(1)AutoStart:布尔值，在应用程序启动时控制Poller 是否应当开始轮询或它是否应当等待直到有计划的更新查询开始。

　　(2)DownloadOnDetection:布尔值，控制Poller 在一个新的更新发现时是否立即开始下载更新，或者是否通过调用DownloadUdpate() 方法开始显式下载。

　　(3)InitialPollInterval:应用程序启动后在第一次执行更新检查前等待的秒数。

　　(4)PollInterval:第一次更新检查之后，PollInterval 控制后续每次更新检查之间间隔的秒数，注意：默认为每30 秒进
行一次检查；显然，你会希望你的应用程序减少更新检查的频率。

　　所有这一切完成之后，你的属性表格看起来应当是下面这个样子：

Samples\SampleApp\SampleApp_Complete目录包含应用程序正确安装的一个版本。

　　安装：

　　(1)DownloadRetryAttempts:在下载期间如果有错误发生（比如Web 服务器宕机）downloader 会稍后重试。这个属性控制downloader 认为是彻底的应用程序更新错误之前重试网络请求的次数。

　　(2)SecondsBeteweenDownloadRety:重试网络请求之前等待的秒数。

　　(3)UpdateRetryAttempts: 在更新期间如果发生严重错误，（例如downloader 超过了试图重试的次数），就会产生一个应用程序更新错误。默认的，将会停止试图更新。但是在应用程序下一次启动时会试图恢复（比如更新Web 服务器可能会宕机好几天）。这个属性控制试图更新的次数。如果超过这个值，updater 就会取消更新，重置它的状态并返回更新检查。

　　(4)ValidateAssemblies: 这个属性控制下载程序集有效完成的级别。更多信息参见这篇文章的安全一节。

　　第四步：生成并在客户端部署应用程序V1版本。

　　在SampleApp项目中，打开AssemblyInfo.cs文件。将AssemblyVersion的值从“1.0”修改为“1.0.0.0”。这会引起在生成程序集时获得值为“1.0.0.0”.. 的标记，该标记代替VS.NET通常指定为递增的值。

　　1. 生成应用程序。

　　2.从压缩文件中将Samples\SampleApp\SampleApp_ClientSetup目录拷贝到你的本地机器上。要注意此目录已经包含了AppStart.exe。AppStart.config已经设置为指向1.0.0.0目录并且启动SampleApp.exe。

　　从SampleApp的release目录下拷贝SampleApp（Appupdater.dll，SimpleForm.dll和SampleApp.exe）

　　到客户端SampleApp_ClientSetup\1.0.0.0目录下。至此，一个功能完整的应用程序版本已被“安装”到了客户端，可以通过运行AppStart.exe来执行。

　　第五步：安装Web服务器

　　在这一步我们将安装Web服务器以提供更新轮询功能。.NET应用程序更新组件使用HTTP-DAV来下载应用程序更新，因此需要一个支持HTTP-DAV的Web服务器。Windows 2000上的IIS5.0和更新的操作系统都支持HTTP-DAV。

　　1.将Samples/SampleApp_ServerSetup目录拷贝到你的Web服务器上的wwwroot目录下。

　　2. 将SampleApp的V1版本拷贝到Web服务器的1.0.0.0文件夹。

　　3. 在Web服务器上为SampleApp_ServerSetup目录启用IIS的“目录浏览”权限。

　　第六步：自动更新应用程序

　　OK，.. 现在是时间来通过自动安装一个新版本来看看以上这些艰苦工作的结果了。

　　1. 如果你部署在客户端的SampleApp版本没有运行，加载它让它运行，记得使用AppStart.exe。

　　2. 回到VS.NET并在SampleApp窗体中做一些可以被注意到的修改（比如修改背景色）。

　　3. 将AssemblyInfo.cs的版本信息改为2.0.0.0。

　　4. 重新生成。

　　5. 回到Web服务器并生成一个和1.0.0.0目录同等的目录2.0.0.0。从release生成目录下将新版本应用程序拷贝到Web服务器上新建的2.0.0.0目录下。

　　6.打开UpdateVersion.xml 并修改AvailableVersion为2.0.0.0。修改ApplicationURL为指向新的2.0.0.0路径。

　　7. 保存对UpdateVersion.xml所做的修改。

　　一旦你保存了新的UpdateVersion.xml，在30秒之内，运行中的SampleApp拷贝将会探测到新的可用版本。

　　四、按需安装、安全、可扩展性及调试

　　(一)按需求安装

　　所谓按需求安装，指只有主可执行程序被显式安装到客户机上。应用程序剩下的部分可以根据基本需要自动下载和安装。

　　通过.NET应用程序更新组件的AutoFileLoad属性来启动按需求安装。你必须仔细考虑在你的应用程序中程序集边界所处的位置以及什么动作会引起程序集被下载。由于程序集的下载涉及到网络输入输出，因此下载所花费的时间是可变的。在程序集下载期间，应用程序会被冻结等待程序集下载完成。

　　(二)部署安全

　　自动安装应用程序更新的能力具备很多好处，但它也伴随着一些潜在的危险。当你使得安装更新变得简单时，如果不小心，你也可能使得安装恶意代码变得简单。有两种危险，第一种危险是有人会用自己的Web服务器欺骗用来部署更新的Web服务器。他们可能会利用那台Web服务器在你的应用程序路径安装一个病毒程序。阻止欺骗或其它通过网络进行的不正当干预的最简单的方法是使用HTTPS。要和.NET应用程序更新组件一起使用HTTPS，可以简单地用HTTPS URLs来代替HTTP URLs。当然，HTTPS 不是银弹。使用HTTPS有两个问题，第一是可伸缩性。使用HTTPS需要服务器加密所有从Web服务器上下载的文件。如果一个应用程序的更新文件很大，加密更新文件的代价会使服务器的负担过重。使用HTTPS的另一个问题是它对第二种安全危险毫无益处。第二种危险是黑客既可能从内部也可能从外部来攻击你的服务器。一旦攻击成功，则有可能意味着成百上千的客户端也通过自动更新遭受连累，这种情况将是灾难性的。

　　为解决这个问题，.NET应用程序更新组件使用给.NET程序集添加强名称的特性来验证所下载的程序集。如果.NET应用程序更新组件检测到下载期间一个程序集不是使用你的密钥签名的，下载就会取消。这意味着只有拥有你的应用程序私钥的人才能够建立可自动部署的更新文件。

　　要验证程序集有效，.NET应用程序更新组件验证你当前安装的应用程序可执行程序的公钥和下载的更新的公钥是否匹配。如果两个程序集以相同且保密的私钥签名，那么嵌入的公钥也就相同。因为被CLR加载的程序集为了验证它的公钥，CLR计算它正常的哈希值检查来保证程序集实际上就是真正的程序集而不是被做了手脚的程序集。为了能够在下载时验证，可以给你所有的应用程序集添加强名称并将.NET应用程序更新组件的ValidateAssemblies属性设置为true。

　　在下载时进行程序集验证会起很大的作用，但实际上，应用程序会经常有不同私钥签名的组件。比如，你的应用程序可能有两个文件：使用你的私钥签名的可执行程序集和另一个包含你购买的应用在你的应用程序中的第三方图表控件的dll程序集。第三方程序集可能使
用第三方而不是你自己的私钥来签名。使情况变得更为复杂的是，在你的应用程序中用来签名程序集的有效私钥的设置随着版本号的改变可能会发生变化。你该如何自动更新那些应用的类型？为解决这个问题，你可以在你的应用程序中生成一个包含有效公钥的列表的程序集。将该程序集使用应用程序的主私钥（应用程序的exe文件签名的密钥）签名并把该程序集放到Web服务器上和应用程序更新文件一起的目录下。在更新下载过程开始之前，.NET应用程序更新组件将会检查Web服务器上应用程序更新目录下一个名为"AppUpdaterKeys.dll"的的程序集。如果存在，该程序集就会被下载。该程序集会被拿来和主应用程序的公钥对比验证。如果签名有效，密钥列表会被提取出来。从此之后，任何处于该列表中的密钥会被认为是更新文件的有效签名。

　　有关安全方面推荐的方法是使用HTTPS URLs来实现更新检查。这会提供第一级别的欺骗保护。对于更新下载，最好不要使用HTTPS RLs以避免使你Web服务器的负荷过重。而是给你的应用程序的程序集添加强名称并使用程序集验证特性。

　　(三)可扩展性

　　在这篇文章前面讲过的示例中我们简单地通过拖放一个组件到应用程序中并设置一些属性来实现自动部署。

　　虽然这在许多应用程序中工作的很好，但在一些应用程序中会需要高级别的控制，这只能通过写代码来获得。我们可以编写自己的代码来替换掉.NET应用程序更新组件标准过程，使用重写的CheckForUpdate()和ApplyUpdate()方法来定制检查和更新行为。

　　(四)调试

　　这一节将指出一些首选的调试选项，以及描述使用该组件的用户大多数常见的问题。

　　.NET应用程序更新器在和AppStart.exe相同的目录下生成一个名为AppUpdate.log的隐藏日志文件。

　　所有的更新成功和失败信息都记录在该日志中。当有一个特殊的客户端不能成功更新时日志文件会特别有用。

　　你可以使用日志来判断在什么时间以及是如何更新失败的。另外，.NET应用程序更新组件使用.NET框架的Debug类来输出大量有用的信息。如果你在调试器中运行你的应用程序，你会在输出窗口中看到这些信息。你可以循着.NET应用程序更新器的记录重点观察并找到出
问题的地方。

　　如果由于某种原因，你无法使得.NET应用程序更新器工作，在你深入调试之前请确定以下几点，你遇到的问题很可能就是如下之一：..

　　. 你是否将IIS目录浏览给打开了？如果没有，更新器将不会下载安装任何文件。

　　. 你是否正确的部署了一切并正确设置了URL？

　　. 如果你的应用程序安装在program files目录下，确定你是该机的超级管理员或超级用户吗？如果不是，你将不会有写权限来更新应用程序。

　　. 你是在应用程序的主用户界面线程中生成AppUpdater对象的吗？如果不是，更新器将不能显示用户界面并且在激发事件回到用户界面时失败。

　　. 是否更新成功，但应用程序使用新的更新自动重启时失败？.NET 应用程序更新组件试图通过调用Application.Exit方法来退出应用程序。然而，该方法并不能保证关闭一个应用程序。如果你生成并遗留了单独的线程在运行，该方法就无法关闭进程。保证所有线程终止的解决的方案是通过调用Application.OnExit事件，或者挂钩.NET应用程序更新器的OnUpdateComplete事件并自己处理关闭。

　　五、总结

　　客户端应用程序部署方便是.NET框架第一个版本的重要的目标。用.NET框架建立解决部署问题的客户端应用程序是一种很好的技术。部署方便仍然是未来.NET框架新版本的一个重要目标。就方案而言，这里描述的.NET应用程序更新组件代表了我们的一些想法，在未来版本的.NET框架中我们将可以直接使用。然而，在那个时候到来之前的这段期间，.NET应用程序更新组件不失为开始建立自动更新应用程序的一种重要的方法。

　　然而，如果需要频繁地从一个应用程序调用另外一个应用程序，并且你主要关心的是性能，Remoting还是显得慢了一点。让Remoting变慢的，不是协议，而是序列化。

　　通常来说，Remoting是很不错的，但如果仅限于本地机器的两个进程间相互通信，其处理机制增加了不必要的开销。所以要考虑一些别的选择，比较好的是命名管道（Named Pipes），不会进行二进制序列化，所以提供了更快的IPC。

　　要记住，这个解决方案最有效的使用是在一个应用程序需要和另一个应用程序进行非常频繁的、短文本的消息通信的情况下，并且是在同一台机器或在同一局域网内部。对于结构化的数据交换，这些文本消息也可以是XML文档或序列化的.NET对象。通信时没有安全层，因为命名管道最多只能在局域网中运行，所以假定安全问题由别的层进行处理。

　　一、实现命名管道

　　以下是.NET命名管道解决方案中几个主要的类。

　　. NamedPipeNative：这个类和kernal32.dll联系实现命名管道的通信，其中包含一些常用方法和常量。
　
　　. NamedPipeWrapper ：这个类是NamedPipeNative的一个包装。

　　. ApipeConnection：这是一个抽象类，定义了命名管道连接、读、写数据的方法。这个类是从ClientPipeConnection 和ServerPipeConnection 继承的，分别在客户端和服务器端应用程序中使用。

　　. ClientPipeConnection：被客户端应用程序使用，使用命名管道和服务器通信。

　　. ServerPipeConnection：允许命名管道服务器创建连接，和客户端进行通信。

　　. PipeHandle：保存操作系统的本地句柄，以及管道连接的当前状态。

　　了解上述的类之后，需要了解一下命名管道的操作。

　　二、创建一个服务器端命名管道

　　服务器端管道名的语法是：\\.\pipe\PipeName。“PipeName”.. 部分是管道的具体名字。要连接管道，客户端应用程序需要创建一个同样名称的客户端命名管道。如果客户端在不同的机器上，服务器端管道的名称应该是\\SERVER\pipe\PipeName。下面的代码是NamedPipeWrapper的一个静态方法，被用来实例化一个服务器端命名管道。

public static PipeHandle Create(string name,uintoutBuffer, uintinBuffer){
　name = @"\.\pipe\" + name;
　PipeHandle handle = new PipeHandle();

　for(inti=1;i<=ATTEMPTS;i++){
　　handle.State=InterProcessConnectionState.Creating;
　　handle.Handle = NamedPipeNative.CreateNamedPipe( name,
　　　NamedPipeNative.PIPE_ACCESS_DUPLEX,
　　　NamedPipeNative.PIPE_TYPE_MESSAGE |
　　　NamedPipeNative.PIPE_READMODE_MESSAGE |
　　　NamedPipeNative.PIPE_WAIT,
　　　NamedPipeNative.PIPE_UNLIMITED_INSTANCES,
　　　outBuffer,
　　　inBuffer,
　　　NamedPipeNative.NMPWAIT_WAIT_FOREVER,
　　　IntPtr.Zero);
　　if(handle.Handle.ToInt32()!=NamedPipeNative.INVALID_HANDLE_VALUE){
　　　handle.State=InterProcessConnectionState.Created;
　　　break;
　}

　if (i >= ATTEMPTS) {
　　handle.State = InterProcessConnectionState.Error;
　　throw new NamedPipeIOException("Error creating named
pipe"+name+".Internalerror:"+NamedPipeNative.GetLastError().ToString(),NamedPipeNative.GetLastError());
　}
}
returnhandle;
} 

　　通过调用NamedPipeNative.CreateNamedPipe方法，上面的方法创建了一个双方互通的命名管道，并且指定管道可以有无限制的实例。常量的名称都是英语，不难看懂，就不一一解释了。

　　假定服务器端命名管道创建成功，它就可以开始监听客户端连接了。

　　三、连接到客户端管道

　　命名管道服务器需要设置成监听状态，以使客户端管道能够连接它。这可以由调用NamedPipeNative.ConnectNamedPipe方法完成。

　　调用NamedPipeNative.CreateFile方法，就可以创建一个命名管道客户端，并且连接到一个监听的服务器管道。下面的代码是NamedPipeWrapper.ConnectToPipe的一部分，可以阐释这一点。

public static PipeHandle ConnectToPipe(string pipeName, string serverName) {
　PipeHandle handle = new PipeHandle();
　//Buildthename ofthe pipe.
　string name = @"\" + serverName + @"\pipe\" + pipeName;
　for(inti=1;i<=ATTEMPTS;i++){
　　handle.State = InterProcessConnectionState.ConnectingToServer;
　　// Try to connect to the server
　　handle.Handle = NamedPipeNative.CreateFile(name, NamedPipeNative.GENERIC_READ | NamedPipeNative.
GENERIC_WRITE, 0,null,NamedPipeNative.OPEN_EXISTING,0,0);

　　在创建一个PipeHandle对象并建立管道名称后，我们调用NamedPipeNative.CreateFile方法来创建一个客户端命名管道，并连接到指定的服务器端管道。在我们的例子中，客户端管道被配置为可读可写的。

　　如果客户端管道被成功创建，NamedPipeNative.CreateFile方法返回其对应的本地句柄，这在以后的操作中会用到。如果由于某种原因创建失败，方法会返回1， 并把NamedPipeNative设为INVALID_HANDLE_VALUE常量。

　　在客户端命名管道可以用来读和写之前，还要做一件事情。我们需要把handle 设为PIPE_READMODE_MESSAGE。可以调用NamedPipeNative.SetNamed-PipeHandleState 实现。

if (handle.Handle.ToInt32() != NamedPipeNative.INVALID_HANDLE_VALUE){
　// The client managed to connect to the server pipe
　handle.State = InterProcessConnectionState.

　ConnectedToServer;
　// Set the read mode of the pipe channel
　uint mode = NamedPipeNative.PIPE_READMODE_MESSAGE;

　if(NamedPipeNative.SetNamedPipeHandleState(handle.Handle,refmode,IntPtr.Zero,IntPtr.Zero)){
　　break;
　} 

　　每个客户端管道和一个服务器管道的实例通信。若服务器端的实例达到最大数目，创建客户端管道会失败。

　　四、读写数据

　　从命名管道读数据时我们不能提前知道消息的长度。我们的解决方案不需要处理很长的消息，所以使用System.Int32变量来指定消息的长度。

　　NamedPipeWrapper.WriteBytes 方法可以将消息写到一个命名管道，消息按UTF8编码，然后按字节数组传递。

public static void WriteBytes(PipeHandle handle, byte[]bytes) {
　byte[] numReadWritten = new byte[4];
　uint len;

　if(bytes==null){
　　bytes=newbyte[0];
　}
　if (bytes.Length == 0) {
　　bytes = new byte[1];
　　bytes = System.Text.Encoding.UTF8.GetBytes(" ");
　}
　// 获取消息的长度：
　len= (uint)bytes.Length;

　handle.State = InterProcessConnectionState.Writing;
　// 获取消息长度的字节表示，先写这四字节
　if(NamedPipeNative.WriteFile(handle.Handle,BitConverter.GetBytes(len),4,numReadWritten,0)){
　　// 写余下的消息
　　if(!NamedPipeNative.WriteFile(handle.Handle,bytes,len,numReadWritten,0)){
　　　handle.State=InterProcessConnectionState.Error;
　　　thrownewNamedPipeIOException("Errorwritingtopipe. Internalerror:"+NamedPipeNative.GetLastError().ToString(), NamedPipeNative.GetLastError());
　　}
　}
　else{
　　handle.State=InterProcessConnectionState.Error;
　　thrownewNamedPipeIOException("Errorwritingtopipe.Internalerror:"+NamedPipeNative.GetLastError().ToString(),
NamedPipeNative.GetLastError());
　}

　handle.State =InterProcessConnectionState.Flushing;
　// 激活管道，保证任何缓存数据都被写入管道，不会丢失：
　Flush(handle);
　handle.State = InterProcessConnectionState.FlushedData;
} 

　　要从一个命名管道读数据，先要把前四个字节转化为整数以确定消息的长度。接着，就可以读余下的数据了，请看下面的NamedPipeWrapper.ReadBytes方法。

public static byte[] ReadBytes(PipeHandle handle, int maxBytes) {
　byte[]numReadWritten=newbyte[4];
　byte[]intBytes=newbyte[4];
　byte[]msgBytes=null;
　intlen;

　handle.State=InterProcessConnectionState.Reading;
　handle.State=InterProcessConnectionState.Flushing;
　// 读前四个字节并转化为整数：
　if(NamedPipeNative.ReadFile(handle.Handle, intBytes,4, numReadWritten, 0)) {
　　len=BitConverter.ToInt32(intBytes,0);
　　msgBytes=newbyte[len];
　　handle.State=InterProcessConnectionState.Flushing;
　　// 读余下的数据或抛出异常：
　　if(!NamedPipeNative.ReadFile(handle.Handle,msgBytes,(uint) len,numReadWritten,0)){
　　　handle.State=InterProcessConnectionState.Error;
　　　thrownewNamedPipeIOException("Error readingfrompipe. Internalerror:"+NamedPipeNative.GetLastError().ToString(), NamedPipeNative.GetLastError());
　　}
　}
　else {
　　handle.State=InterProcessConnectionState.Error;
　　thrownewNamedPipeIOException("Errorreadingfrompipe. Internalerror:"+NamedPipeNative.GetLastError().ToString(), NamedPipeNative.GetLastError());
　}
　handle.State=InterProcessConnectionState.ReadData;
　if(len>maxBytes){
　　returnnull; }
　returnmsgBytes;
}

　　以上就是命名管道的实现和一些主要的方法，下面介绍如何创建进行文本消息通信的命名管道服务器和客户端应用程序。

　　五、创建命名管道服务器

　　命名管道服务器是一个多线程的引擎，用来为并发的请求服务，创建新的线程和管道连接。

　　AppModule.NamedPipes assembly包含了一个基类ApipeConnection，是对普通命名管道操作的封装，例如创建管道、读写数据等等，这是一个抽象类。

　　另外，有两个从ApipeConnection继承的管道连接类ClientPipeConnection 和 ServerPipeConnection。它们重载了一些方法（例如连接和关闭）并为服务器和客户端命名管道分别提供实现。ClientPipeConnection 和ServerPipeConnection都有调用Dispose方法的析构器，
清除非管控的资源。

　　命名管道服务器负责创建命名管道，处理客户端连接。有两个主要的类提供了服务功能： ServerNamedPipe和PipeManager。

　　（1）ServerNamedPipe类

　　其构造器如下：..

internal ServerNamedPipe(stringname, uint outBuffer,uintinBuffer,intmaxReadBytes){
　PipeConnection=newServerPipeConnection(name,outBuffer,inBuffer,maxReadBytes);
　PipeThread=newThread(newThreadStart(PipeListener));
　PipeThread.IsBackground=true;

　PipeThread.Name ="PipeThread "+this.PipeConnection.NativeHandle.ToString();
　LastAction=DateTime.Now;
}

　　构造器创建了一个新的ServerPipeConnection实例，并调用PipeListener方法。随后的主要部分是循环监听客户端连接，以及读写数据。

private void PipeListener() {
　CheckIfDisposed();

　try{
　　Listen=Form1.PipeManager.Listen;
　　Form1.ActivityRef.AppendText("Pipe"+this.PipeConnection.NativeHandle.ToString() + ": new pipe started" + Environment.NewLine);
　　while(Listen){
　　　LastAction=DateTime.Now;
　　　// 从客户端管道读取数据：
　　　stringrequest=PipeConnection.Read();
　　　LastAction=DateTime.Now;
　　　if(request.Trim()!=""){
　　　　//PipeManager.HandleRequest 方法接受客户端请求处理之，
　　　　// 然后进行响应,这个响应接着就被写入管道。
　　　　PipeConnection.Write(Form1.PipeManager.HandleRequest(request));
　　　　Form1.ActivityRef.AppendText("Pipe"+this.PipeConnection.NativeHandle.ToString()+ ":requesthandled"+Environment.NewLine);
　　　}
　　　else{ PipeConnection.Write("Error:badrequest");}
　　　LastAction=DateTime.Now;
　　　// 从客户端管道断开连接
　　　PipeConnection.Disconnect();
　　　if(Listen){
　　　　Form1.ActivityRef.AppendText("Pipe"+this.PipeConnection. NativeHandle.ToString()+":listening"+Environment.NewLine);

　　　　// 开始监听一个新的连接：

　　　　Connect(); }
　　　Form1.PipeManager.WakeUp();
　　}
　}
　catch(System.Threading.ThreadAbortExceptionex){}
　catch(System.Threading.ThreadStateExceptionex){}
　catch(Exceptionex){
　　//Logexception
　}
　finally{
　　this.Close();}
　}

　　请注意不要关闭服务器管道，因为创建一个服务器管道是一个相对昂贵的操作，会引起比较昂贵的开销。

　　（2）PipeManager 类

　　PipeManager 类负责在必要的时候创建服务器管道，管理线程，并生成客户端请求的响应。下面代码中Initialize方法调用Start方法创建一个新的线程：

public void Initialize() {
　Pipes=Hashtable.Synchronized(_pipes);

　Mre =newManualResetEvent(false);
　MainThread =newThread(newThreadStart(Start));
　MainThread.IsBackground=true;
　MainThread.Name = "MainPipeThread";

　MainThread.Start();
　Thread.Sleep(1000);
}

　　PipeManager类只在获得请求的时候才创建新的管道连接和线程。这意味着ServerPipeConnection对象只在没有连接存在或所有连接都忙于响应请求的时候才被创建。通常2-3个命名管道实例就能处理很大负载的并发客户端请求，但这个主要取决于处理客户端请求和生
成响应的时间。

　　创建ServerPipeConnection对象的引用被保存在管道哈希表中。

private void Start() {
　try{

　　while(_listen){
　　　int[]keys=newint[Pipes.Keys.Count];
　　　Pipes.Keys.CopyTo(keys,0);

　　　// 循环检验ServerPipeConnection 对象是否还是可用：
　　　foreach(intkeyinkeys){
　　　　ServerNamedPipeserverPipe=(ServerNamedPipe)Pipes[key];
　　　　if(serverPipe!=null&& DateTime.Now.Subtract(serverPipe.LastAction).Milliseconds>
PIPE_MAX_STUFFED_TIME && serverPipe.PipeConnection.GetState()!=InterProcessConnectionState.WaitingForClient){
　　　　　serverPipe.Listen=false;
　　　　　serverPipe.PipeThread.Abort();
　　　　　RemoveServerChannel(serverPipe.PipeConnection.NativeHandle);
　　　　}
　　　}
　　　//NumberPipes 字段包含了可以在服务器上拥有的命名管道最大数目
　　　if(numChannels<=NumberPipes){
　　　　ServerNamedPipe pipe = new ServerNamedPipe(PipeName,OutBuffer,InBuffer,MAX_READ_BYTES);
　　　　try{
　　　　　//Connect 方法将新生成的管道置为监听模式。
　　　　　pipe.Connect();
　　　　　pipe.LastAction=DateTime.Now;
　　　　　System.Threading.Interlocked.Increment(refnumChannels);
　　　　　// 开始ServerPipeConnection 线程
　　　　　pipe.Start();
　　　　　Pipes.Add(pipe.PipeConnection.NativeHandle,pipe);
　　　　}
　　　　catch (InterProcessIOException ex) {
　　　　　RemoveServerChannel(pipe.PipeConnection.NativeHandle);
　　　　　pipe.Dispose();
　　　　}
　　　}
　　　else{ Mre.Reset(); Mre.WaitOne(1000,false); }
　　}
　}
　catch { //Logexception }
}

　　六、创建客户端管道连接

　　要使用命名管道把一个客户端应用程序连接到服务器，我们必须创建ClientPipeConnection类的一个实例，使用它的方法来读写数据。

IInterProcessConnectionclientConnection=null;

try{
　clientConnection=newClientPipeConnection("MyPipe",".");
　clientConnection.Connect();
　clientConnection.Write(textBox1.Text);
　clientConnection.Close();
}
catch{
　clientConnection.Dispose();
}

　　管道名称“MyPipe” 必须和服务器管道的名称一样，如果命名管道服务器也在同一台机器上，ClientPipeConnection构造器的第二个参数应该是“.”。如果不在同一台机器上，第二个参数就是服务器的网络名称。

　　以上，我介绍了命名管道的解决方案，我再重申一下，命名管道最有效的使用是在一个应用程序需要和另一个应用程序进行非常频繁的，短文本的消息通信的情况下，并且是在同一台机器或在局域网内部。如果您遇到了这样的情况，希望我的这些代码能给你启发和参考。

  public static void Run()
  {
   if(IsFirstInstance())
   {
    Application.ApplicationExit += new EventHandler(OnExit);
    Application.Run();
   }
  
  }
  public static void Run(ApplicationContext context)
  {
   if(IsFirstInstance())
   {
    Application.ApplicationExit += new EventHandler(OnExit);
    Application.Run(context);
   }
  }
  public static void Run(Form mainForm)
  {
   if(IsFirstInstance())
   {
   
    Application.ApplicationExit += new EventHandler(OnExit);
  
    Application.Run(mainForm);

  
   }
   else
   {
   
    MessageBox.Show("应用程序已启动,请在任务管理中关闭后再启动！","系统提示",MessageBoxButtons.OK,MessageBoxIcon.Warning);
   }
  }
  static bool IsFirstInstance()
  {
   m_Mutex = new Mutex(false,"SingletonApp Mutext");
   bool owned = false;
   owned = m_Mutex.WaitOne(TimeSpan.Zero,false);
   return owned ;
  }
  static void OnExit(object sender,EventArgs args)
  {
   m_Mutex.ReleaseMutex();
   m_Mutex.Close();
  }
 }
}

具体使用是如下

using System;
using System.Drawing;
using System.Windows.Forms;
namespace LogisticsSystem
{
 /// <summary>
 /// MainClass 的摘要说明。
 /// </summary>
 public class MainClass
 {
  /// <summary>
  /// 应用程序的主入口点。
  /// </summary>
  [STAThread]
  static void Main()
  {
   
  
   AppSingleton.Run(new mainForm());
   //Application.Run(new mainForm());
  }
 }
}

另一方法
/////////////
System.Threading.Mutex appSingleton = new System.Threading.Mutex(false, "MyProgInstance_PPP");
    if(appSingleton.WaitOne(0, false))
    {
      Application.Run(new FormMain(););
    }
   else
   {
      MessageBox.Show("程序已经运行");
   }

要获得更多的信息，需要取得Modules属性数组，但并不是每个进程都能获取Modules属性，所以必须要使用try..catch语句排除异常。该数组的第一个成员[ 0 ].FileName包含了执行程序的完整文件名，等同于ProcessModule；序号大于0的成员往往包含该程序调用的dll信息，得到的结果很有点像反木马程序。

Kill()方法用来杀进程，被杀的程序不会弹出类似保存文件的对话框，是个十足的冷血的快刀手。

StartInfo属性是用于启动新进程的，不适用于检索已运行的进程。

private void btnProcess_Click(object sender, System.EventArgs e)
{
System.Diagnostics.Process []myPs ;
myPs=System.Diagnostics.Process.GetProcesses();
this.richTextBox1.Clear();
foreach (System.Diagnostics.Process p in myPs)
{
if (p.Id!=0 )
{
string myS="进程名称" p.ProcessName " ID:" p.Id.ToString();
try//由于进程不同，有的进程不包含Modules信息，所以要用try保护
{
if (p.Modules !=null)
if (p.Modules.Count>0)
{
System.Diagnostics.ProcessModule pm=p.Modules[0];

myS ="\n Modules[0].FileName:" pm.FileName;
myS ="\n Modules[0].ModuleName:" pm.ModuleName;
myS ="\n Modules[0].FileVersionInfo:\n" pm.FileVersionInfo.ToString();
if (pm.FileName.ToLower()==this.textBox1.Text.Trim().ToLower())
p.Kill();
}
}
catch
{}
finally
{
this.richTextBox1.Text = myS "\n==========================\n";
}
}
}

程序的执行结果片段：

进程名称SearchNet ID:3092
Modules[0].FileName:C:\Program Files\SearchNet\SearchNet.exe
Modules[0].ModuleName:SearchNet.exe
Modules[0].FileVersionInfo:
File: C:\Program Files\SearchNet\SearchNet.exe
InternalName: SearchNet
OriginalFilename:
FileVersion: 1, 0, 2, 4
FileDescription: IE地址栏搜索程序
Product: 地址栏搜索
ProductVersion: 1, 0, 2, 4
Debug: False
Patched: False
PreRelease: False
PrivateBuild: False
SpecialBuild: False
Language 中文(中国)

==========================
进程名称svchost ID:1700
Modules[0].FileName:C:\WINDOWS\system32\svchost.exe
Modules[0].ModuleName:svchost.exe
Modules[0].FileVersionInfo:
File: C:\WINDOWS\system32\svchost.exe
InternalName: svchost.exe
OriginalFilename: svchost.exe
FileVersion: 5.1.2600.2180 (xpsp_sp2_rtm.040803-2158)
FileDescription: Generic Host Process for Win32 Services
Product: Microsoft® Windows® Operating System
ProductVersion: 5.1.2600.2180
Debug: False
Patched: False
PreRelease: False
PrivateBuild: False
SpecialBuild: False
Language 英语(美国)

　　本程序主要用到了 Assembly 类动态加载程序集，再得到程序集中包含类的 Type 类型，动态生成类实例，动态调用类方法．个人觉得这是一种提供高度松耦合，可随意扩展的程序结构框架，希望和大家探讨一下这种框架的应用前景！

　　关键性代码如下：
 using System;
 using System.Drawing;
 using System.IO;
 using System.Reflection;
 using System.Collections;
 using System.ComponentModel;
 using System.Windows.Forms;
 using System.Data;
 
 namespace WindowsFormTest
   {
      /// <summary>
     /// Form1 的摘要说明。
     /// </summary>
     public class FrmMain : System.Windows.Forms.Form
       {
         private int formNum;
         private ArrayList formTypes = new ArrayList();
         private ArrayList formObjects = new ArrayList();
 
         private System.Windows.Forms.MainMenu mnuMain;
         private System.Windows.Forms.MenuItem mnuItmRun;
         private System.Windows.Forms.MenuItem mnuItemWindow;
         private System.Windows.Forms.MenuItem mnuItmHelp;
         private System.Windows.Forms.MenuItem mnuItmCascade;
         private System.Windows.Forms.MenuItem mnuItmTileHorizontal;
         private System.Windows.Forms.MenuItem mnuItmTileVertical;
         private System.Windows.Forms.MenuItem menuItem1;
         private System.Windows.Forms.MenuItem mnuItmAbout;
         private System.Windows.Forms.StatusBar staBarMain;
         private System.Windows.Forms.StatusBarPanel pnlInfo;
         private System.Windows.Forms.StatusBarPanel pnlNum;
          /// <summary>
         /// 必需的设计器变量。
         /// </summary>
         private System.ComponentModel.Container components = null;
 
         public FrmMain()
           {
             //
             // Windows 窗体设计器支持所必需的
             //
             InitializeComponent();
 
             //
             // TODO: 在 InitializeComponent 调用后添加任何构造函数代码
             //
         }
 
          /// <summary>
         /// 清理所有正在使用的资源。
         /// </summary>
         protected override void Dispose( bool disposing )
           {
             if( disposing )
               {
                 if (components != null) 
                   {
                     components.Dispose();
                 }
             }
             base.Dispose( disposing );
         }
 
          Windows 窗体设计器生成的代码                                                                                                                                
 
         private void FrmMain_Load(object sender, System.EventArgs e)
           {
             Assembly assembly = null;
             string windowsPath = Path.Combine(Application.StartupPath, "Windows");
 
             foreach (string dllFile in Directory.GetFiles(windowsPath, "*.dll"))
               {
                 assembly = Assembly.LoadFile(dllFile);
                 Type[] types = assembly.GetTypes();
                 
                 foreach (Type t in types)
                   {
                     if (t.BaseType == typeof(Form))
                       {
                         this.formTypes.Add(t);
                         MenuItem item = this.mnuItmRun.MenuItems.Add(t.FullName);
                         item.Click += new EventHandler(menuItemNewItem_Click);
                     }
                 }
             }
         }
 
         private void menuItemNewItem_Click(object sender, EventArgs e)
           {
             MenuItem item = (MenuItem)sender;
 
             Type t = (Type)(this.formTypes[item.Index]);
 
             Object obj = Activator.CreateInstance(t);
             this.formObjects.Add(obj);
             formNum += 1;
 
              t.InvokeMember("MdiParent", BindingFlags.SetProperty, null, obj, new object[]  {this});
              t.InvokeMember("Text", BindingFlags.SetProperty, null, obj, new object[]  {t.FullName+"  窗体："+formNum});
              t.InvokeMember ("Show", BindingFlags.InvokeMethod, null, obj, new object []  {});
 
             ((Form)obj).Closing += new CancelEventHandler(FrmWindow_Closing);
             ((Form)obj).Activated += new EventHandler(FrmWindow_Activated);
             MenuItem menuItem = this.mnuItemWindow.MenuItems.Add(((Form)obj).Text);
             menuItem.Click += new EventHandler(menuItemWindow_Click);
 
             this.pnlNum.Text = "当前装载了"+this.formObjects.Count+"个窗体";
             this.pnlInfo.Text = "当前活动窗体："+this.ActiveMdiChild.Text;
         }
 
         private void menuItemWindow_Click(object sender, System.EventArgs e)
           {
             MenuItem item = (MenuItem)sender;
 
             ((Form)(this.formObjects[item.Index-4])).Activate();
 
             this.pnlNum.Text = "当前装载了"+this.formObjects.Count+"个窗体";
             this.pnlInfo.Text = "当前活动窗体："+this.ActiveMdiChild.Text;
         }
 
         private void FrmWindow_Activated(object sender, System.EventArgs e)
           {
             this.pnlNum.Text = "当前装载了"+this.formObjects.Count+"个窗体";
             this.pnlInfo.Text = "当前活动窗体："+this.ActiveMdiChild.Text;
         }
 
         private void FrmWindow_Closing(object sender, System.ComponentModel.CancelEventArgs e)
           {
             for (int i=0; i<this.formObjects.Count; i++)
               {
                 if (((Form)this.formObjects[i]).Text == ((Form)sender).Text)
                   {
                     this.formObjects.RemoveAt(i);
                     this.mnuItemWindow.MenuItems.RemoveAt(i+4);
 
                     this.pnlNum.Text = "当前装载了"+this.formObjects.Count+"个窗体";
                     this.pnlInfo.Text = "当前活动窗体："+this.ActiveMdiChild.Text;
                     break;
                 }
             }
         }
 
         private void mnuItmCascade_Click(object sender, System.EventArgs e)
           {
             this.LayoutMdi(MdiLayout.Cascade);
         }
 
         private void mnuItmTileHorizontal_Click(object sender, System.EventArgs e)
           {
             this.LayoutMdi(MdiLayout.TileHorizontal);
         }
 
         private void mnuItmTileVertical_Click(object sender, System.EventArgs e)
           {
             this.LayoutMdi(MdiLayout.TileVertical);
         }
 
         private void mnuItmAbout_Click(object sender, System.EventArgs e)
           {
             new FrmAbout().ShowDialog(this);
         }
    }
 }
 
程序源码下载：http://www.cnblogs.com/Files/Infinity/WindowsForm.rar
　　

 

MSTSCUI.NET is simply a graphical interface to Microsoft's command-line Remote Desktop Connection, mstsc.exe. This application makes it easier for those who use Remote Desktop sessions often through the day. It uses the .NET Framework v1.1.

Some of the things this app demonstrates:

• Reading a simple XML document
• Creating a systray application
• Dynamically populating a context menu

All in all, a very simple and useful little application.

• General Use
• MSTSCUI.NET.exe.config
• Server Configuration XML (mstscui_servers.xml)
• Select Code Samples

top

MSTSCUI.NET runs as a taskbar application to allow quick and easy access to RDP servers:

It's generally reccommended to place an entry in your startup group so that the application launches on startup.

Simply right-click on the taskbar icon to show the menu:

Select "Edit List" for a shortcut to edit your server configuration file, and "Refresh List" to reload it.

top

Use the app.config file to set the name of the server configuration file with the "ServerConfigFile" key, and set your preferred editor with the "Editor" key. It's not recommended you change the "ServerConfigFile" key. The "Editor" key should be a fully qualified path if the editor you're using is not already setup in your path environment variables.

Below is the listing of the default app.config file:

<xmp>
<configuration>
    <appSettings>

        <!-- path to XML Server Configuration File -->
        <add key="ServerConfigFile" value="mstscui_servers.xml" />
        
        <!-- XML File Editor to use -->
        <add key="Editor" value="notepad" />

     </appSettings>
</configuration>
</xmp>

top

Use the server configuration file to setup each server.

In order to display a horizontal separator bar on the menu, use:

<xmp>
    <server displayname="-" />
</xmp>

Each server element has an attribute called "displayname" - this is the name displayed on the menu. You can be as descriptive here as necessary.

• servername - server name or IP address
• port - default is 3389
• resolution - "fullscreen", or any resolution entered in this fashion: 1024x728
• console - 1 for yes, takeover console session, 0 for no, do not takeover console
• connectionfile - fully qualified path to the RDP file if you want to use one

Below is the listing of a sample server config file:

<xmp>
<servers>

    <server displayname="eventvan02 / secure">
        <servername>eventvan02</servername>
        <port>3389</port>
        <resolution>1024x768</resolution>
        <console>0</console>
        <connectionfile></connectionfile>
    </server>

    <server displayname="-" />

    <server displayname="vancorpbc1">
        <servername>vancorpbc1</servername>
        <port>3389</port>
        <resolution>fullscreen</resolution>
        <console>0</console>
        <connectionfile></connectionfile>
    </server>

</servers>
</xmp>

top

Launching msctsc.exe...

				Private
				Sub ConnectToServer(ByVal sServer AsString)
    TryDim sCommand AsString = _
          System.Environment.GetEnvironmentVariable("SystemRoot") & _
          "\system32\mstsc.exe"
        System.Diagnostics.Process.Start(sCommand, _
               GetArgumentsForServer(sServer))
    Catch ex As Exception
        MessageBox.Show(ex.Message)
    EndTryEndSub

Reading the XML configuration file...

Collapse

				Private
				Function GetArgumentsForServer(ByVal sServer AsString) AsStringDim sConnection AsStringDim sPort AsStringDim sResolution AsStringDim arrResolution() AsStringDim sConsole AsStringDim sConnectionFile AsStringDim sArguments AsStringDim parentnode As XmlNode = doc.SelectSingleNode("servers")
    Dim servernode As XmlNode = _
        SelectNode(parentnode, "displayname", sServer)
    Dim childnode As XmlNode

    ForEach childnode In servernode.ChildNodes
        SelectCase UCase(childnode.Name)
            Case"SERVERNAME"
                sConnection = " /v:" & Trim(childnode.InnerText)
            Case"PORT"If Trim(childnode.InnerText) <> "3389"And _
                        childnode.InnerText <> String.Empty Then
                    sPort = ":" & childnode.InnerText
                Else
                    sPort = String.Empty
                EndIfCase"RESOLUTION"If InStr(UCase(childnode.InnerText), "X") > 0Then
                    arrResolution = Split(UCase(childnode.InnerText), "X")
                    sResolution = " /w:" & arrResolution(0) & _
                                  " /h:" & arrResolution(1)
                Else'anything else, default to fullscreen
                    sResolution = " /f"EndIfCase"CONSOLE"IfCBool(childnode.InnerText) Then
                    sConsole = " /console"Else
                    sConsole = String.Empty
                EndIfCase"CONNECTIONFILE"
                sConnectionFile = childnode.InnerText
            CaseElse
                MessageBox.Show("Unrecognized node in XML: " & _
                                childnode.InnerText)
        EndSelectNext'build argument string
    sArguments = sConnection & sPort & sResolution & sConsole

    Return sArguments

EndFunctionPrivateFunction SelectNode(ByVal parentNode As XmlNode, _
        ByVal attributeName AsString, _
        ByVal attributeValue AsString) As XmlNode
    Dim node As XmlNode = NothingIf parentNode.HasChildNodes ThenDim nodeName AsString = parentNode.ChildNodes(0).Name
        Dim path AsString = nodeName + "[@" + _
            attributeName + "='" + attributeValue + "']"
        node = parentNode.SelectSingleNode(path)
    EndIfReturn node
EndFunction

• Online help here: MSTSCUI.NET Online Help
• Help forums here: Support Forums

SIP overview:

SIP is an application-layer control protocol that can establish,
modify, and terminate multimedia sessions (conferences) such as
Internet telephony calls. SIP can also invite participants to
already existing sessions, such as multicast conferences.
Normally SIP uses UDP and TCP port 5060 anf TCP 5061 for SSL communication.
SIP protocol is very similar to HTTP, so who has some knowledge about http
then easy to learn SIP.
SIP doesn't transfer session data like audio,video, RTP(real time protocol) is used
for that, SIP just helps to open RTP streams.

SIP message example:

INVITE sip:john@domain.com SIP/2.0
From: <sip:doe@domain.com>;tag=2084442460
To: <sip:john@1domain.com>
Via: SIP/2.0/UDP domain.com:5060;branch=z9hG4bK2df7b9194cd51e25
Call-ID: john@domain.com-4524j
CSeq: 1 INVITE
Contact: <sip:doe@domain.com:5060>
Content-Length: 226
Content-Type: application/sdp

<session description data, like RTP description>

SIP server types:

Basic SIP commands:

INVITE - Initiates a session. This method includes information about the calling and
called users and the type of media that is to be exchanged.

ACK - Sent by the client who sends the INVITE. ACK is sent to confirm that the
session is established. Media can then be exchanged.

BYE - Terminates a session. This method can be sent by either user.

CANCEL - Terminates a pending request, such as an outstanding INVITE. After a session is established, a BYE method needs to be used to terminate the session.

OPTIONS - Queries the capabilities of the server or other devices. It can be used to check media capabilities before issuing an INVITE.

REGISTER - Used by a client to login and register its address with a SIP registrar server.

Ok, some ABC done,there are many documents on net, so not good idea to rewrite these there.
If want more advanced info then see:
RFC 3261 (defines SIPv2)
http://www.iptel.org/sip/intro
http://www.sipdev.org/wiki/index.php/A_newcomer's_guide_to_SIP
http://www.tech-invite.com/

and also google.com is always your friend.

SIP proxy demo overview.
This SIP proxy example just implements fully functional simple statefull proxy.
You can use hardware SIP phones or soft phones to play with this proxy.
This is advanced example, code is well commeneted, so beginners don't hate me beacuse no more blaaa text here. Just read rfc 3216, see info links i noted before, if you then look
code all more nicer then.

Some free available softphones in www:
http://www.nch.com.au
http://www.counterpath.net

Introduction

Microsoft .NET contains many enhanced foundation classes that makes writing high performance socket applications easy. This project demonstrates how to use asynchronous sockets to write a high performance yet simple to use TCP tunneling application--mapping ports from one machine to many others.

I was looking for a simple TCP tunneling application but didn't find any on this site. My requirement is a high performance (low CPU utilization) application, that can run as a Windows Service, is easy to configure, and can handle many concurrent ports.

Overview

Using the code

Since WinTunnel is a Windows Service, the first step is to install it. You can pass a command line switch -install to install it as a service using the LocalSystem account. Optionally, you can pass in a user name and password via the -user and -password switches, respectively.

The program needs to read a configuration file called WinTunnel.ini in the current directory or the directory where the binary is located. The content of the configuration file is very simple. The first line defines a service name--can be anything because it is only used for printing debug messages. The second line defines where to listen for client connections. The third line defines the server connection information.

[HTTP]
accept  = 80               <====== defines which port to accept the 
                                   client connection--
                                   either <Port> or <IP:Port>
connect = 192.168.1.10:80  <====== defines the target of the connection
                                   --must be in the format <IP:Port>

[HTTPS]
accept  = 192.168.1.100:443
connect = 192.168.1.125:443

Interesting issues

One interesting problem I encountered is that .NET requires the use of InstallUtil.exe to put the C# service into the Global Assembly Cache (GAC) and register with the Service Control Manager (SCM). In order to just install it by running the binary, a background process is launched that calls InstallUtil.exe with all the required parameters. The output is then redirected to a buffer and printed out on the console--see the code below.

Collapse

				static
				void launchProcess(String binary, String argument)
{
    System.Diagnostics.ProcessStartInfo psInfo = 
     new System.Diagnostics.ProcessStartInfo(binary, argument);

    System.Console.WriteLine();
    System.Console.WriteLine(psInfo.FileName + 
                             " " + psInfo.Arguments);
    System.Console.WriteLine();

    psInfo.RedirectStandardOutput = true;
    psInfo.WindowStyle = 
           System.Diagnostics.ProcessWindowStyle.Hidden;
    psInfo.UseShellExecute = false;
    System.Diagnostics.Process ps;
    ps = System.Diagnostics.Process.Start(psInfo);
    System.IO.StreamReader msgOut = ps.StandardOutput;
    ps.WaitForExit(5000); //wait up to 5 seconds if (ps.HasExited)
    {
        //write the output
        System.Console.WriteLine(msgOut.ReadToEnd());
    }
    return;
}

In order to debug a Service application, a debug switch was added to the application. Generally, it is hard to debug a service application because there is no console. When the debug switch is set, log messages are printed on the console. In order to properly shutdown the service application in this mode, a Win32 API call is needed to capture the Ctrl-C key press. Once it is captured, an event object is signaled to properly shutdown--see ConsoleEvent.cs for details.

				//create a signal handler to detect Ctrl-C to stop the service
				if (m_debug)
{
    m_ctrl = new ConsoleCtrl();
    m_ctrl.ControlEvent += new 
       ConsoleCtrl.ControlEventHandler(consoleEventHandler);
}
  
publicstaticvoid consoleEventHandler(ConsoleCtrl.ConsoleEvent consoleEvent)
{
    if (ConsoleCtrl.ConsoleEvent.CTRL_C == consoleEvent)
    {
        Logger.getInstance().info("Received CTRL-C from" + 
                                  " Console. Shutting down...");
        WinTunnel.shutdownEvent.Set();
    }
    else
    {
        Logger.getInstance().warn("Received unknown" + 
               " event {0}.  Ignoring...", consoleEvent);
    }
}

Code discussion

ThreadPool

In order to make the application design simple, the ThreadPool class was created. It allows the application to be broken down to various tasks and executed by the Thread Pool. This design greatly reduces the need to synchronize--a big performance bottleneck. The idea of the thread pool is that an application should not create many threads. Instead, a small number of them should be created during startup, and reused over and over again until shutdown. Any work that needs to be done in the application will have to be added to a task list, and if there is a free thread, it should pick up the task and execute it.

A good analogy would be with the UPS delivery service. It will be terribly in-efficient if a new worker has to be hired every time a package needs to be delivered. Instead, UPS hires a bunch of them and asks them to deliver packages over and over again.

Similar to the package in the above analogy, a piece of work that needs to be done in the application is called a task. The task must implement the ITask interface--which has two methods: getName() and run(). The getName() method is used for debugging and returns the details of the task. The run() method is the entry point for a thread in the thread pool to perform the work.

				public
				interface ITask 
{
    void run();
    String getName();
}

In this application, there are only three types of tasks. The first task is to listen for client connections. This is implemented by the ProxyClientListenerTask. When the task executes, it creates a socket, and then calls the asynchronous BeginAccept() method. The call requires a callback method and also an object as a parameter (this).

				public
				void run()
{
    listenSocket = new Socket( AddressFamily.InterNetwork, 
                               SocketType.Stream, ProtocolType.Tcp);
    listenSocket.Bind(m_config.localEP);
    listenSocket.Listen(10); //allow up to 10 pending connections
    logger.info("[{0}] Waiting for client connection at {1}...", 
                m_config.serviceName, m_config.localEP.ToString());

    listenSocket.BeginAccept( new AsyncCallback(
                    ProxyClientListenerTask.acceptCallBack), this);
}

The callback is invoked when the client connects to the listening socket. The first thing is to retrieve the passed in object which gets the socket. EndAccept() is then called, and the second task is created.

Collapse

				public
				static
				void acceptCallBack(IAsyncResult ar)
{
    ProxyConnection conn = null;
    try
    {
        ProxyClientListenerTask listener = 
                 (ProxyClientListenerTask) ar.AsyncState;

        //create a new task for connecting to the server side.
        conn = m_mgr.getConnection();
        conn.serviceName = listener.m_config.serviceName;
        //accept the client connection
        conn.clientSocket = listener.listenSocket.EndAccept(ar);

        logger.info("[{0}] Conn#{1} Accepted new connection." + 
                    " Local: {2}, Remote: {3}.", 
            conn.serviceName,
            conn.connNumber,
            conn.clientSocket.LocalEndPoint.ToString(), 
            conn.clientSocket.RemoteEndPoint.ToString() );

        conn.serverEP = listener.m_config.serverEP;
                
        //Start listening for connection on this port again
        listener.listenSocket.BeginAccept( new AsyncCallback(
          ProxyClientListenerTask.acceptCallBack), listener);

        //now try to connect to the server
        ProxyServerConnectTask serverTask = 
                    new ProxyServerConnectTask(conn);
        ThreadPool.getInstance().addTask(serverTask);
    } 
    catch (SocketException se)
    {
        logger.error("[{0}] Conn# {1} Socket Error occurred" + 
                     " when accepting client socket. Error Code is: {2}",
                     conn.serviceName, conn.connNumber, se.ErrorCode);
        if (conn != null)
        {
            conn.Release();
        }
    }
    catch (Exception e)
    {
        logger.error("[{0}] Conn# {1} Error occurred when" + 
            " accepting client socket. Error is: {2}",
            conn.serviceName, conn.connNumber, e);
        if (conn != null)
        {
            conn.Release();
        }
    }
    finally
    {
        conn = null; //free reference to the object
    }
}

The second task is to connect to the server that the client's connection should be mapped to. This is implemented by the ProxyServerConnectTask. When the task executes, it creates a new socket, and makes an asynchronous BeginConnect() to connect to the server.

				public
				void run()
{
    m_conn.serverSocket = new Socket( AddressFamily.InterNetwork, 
                                      SocketType.Stream, ProtocolType.Tcp);
    m_conn.serverSocket.BeginConnect(m_conn.serverEP, 
         new AsyncCallback(connectCallBack), m_conn);    
}

The callback is invoked when the connection to the server is established and the third task is created.

				public
				static
				void connectCallBack(IAsyncResult ar)
{
    ProxyConnection conn = (ProxyConnection) ar.AsyncState;

    try
    {
        conn.serverSocket.EndConnect(ar); 
                        
        logger.info("[{0}] ProxyConnection#{1}--connected " + 
            "to Server.  Server: {2}, Local: {3}.",
            conn.serviceName,
            conn.connNumber,
            conn.serverSocket.RemoteEndPoint, 
            conn.serverSocket.LocalEndPoint);

        //create task for proxying data between //the client and server socket
        ProxySwapDataTask dataTask  = new ProxySwapDataTask(conn);
        ThreadPool.getInstance().addTask(dataTask);
    } 
    {...removed error handling code...}
}

The third task takes both the client socket and the server socket, and swaps data back and forth between them. This is implemented by the ProxySwapDataTask. There is a callback sending and receiving data for both the client and the server socket. There are also various checks to detect socket errors. When an error occurs, both the client and the server socket are shutdown.

Collapse

				public
				void run()
{
    //validate that both the client side and server //side sockets are ok. If so, do read/writeif (m_conn.clientSocket == null || m_conn.serverSocket == null)
    {
        logger.error("[{0}] ProxyConnection#{1}--Either" + 
                     " client socket or server socket is null.",
                     m_conn.serviceName, m_conn.connNumber);
        m_conn.Release();
        return;
    }

    if (m_conn.clientSocket.Connected && m_conn.serverSocket.Connected)
    {
        //Read data from the client socket
        m_conn.clientSocket.BeginReceive( m_conn.clientReadBuffer, 
               0, ProxyConnection.BUFFER_SIZE, 0,
               new AsyncCallback(clientReadCallBack), m_conn);
            
        //Read data from the server socket
        m_conn.serverSocket.BeginReceive( m_conn.serverReadBuffer, 
               0, ProxyConnection.BUFFER_SIZE, 0,
               new AsyncCallback(serverReadCallBack), m_conn);
    }
    else
    {
        logger.error("[{0}] ProxyConnection#{1}: Either" + 
            " the client or server socket got disconnected.", 
            m_conn.serviceName, m_conn.connNumber );
        m_conn.Release();
    }
    m_conn = null;
}

There is a callback for sending and receiving data for both the client and the server socket. There are also various checks to detect socket errors. When an error occurs, the connection is shutdown, and both the client and the server socket are closed.

End note

Unlike others, this project is the complete source of a fully functioning application. As such, there are various classes such as logging that I don't even cover in the discussion. I only try to point out the interesting things that I encountered when designing and implementing the application. Hopefully, it will be useful for someone doing something similar.

History

• 2006-06-28 - Initial implementation.
• 2006-07-10 - Enhanced to show more debug messages, added more error handling logic, and cleanup of objects. Also updated this documentation.

Han_Jun_Li

Introduction

I've been doing Windows programming for a long time, and I've always longed for the ability to do what some of the Unix guys have always been able to do: run commands on a remote machine. Although, there's a small twist. I really don't want to run some shell commands on a remote machine, but rather write some code, push it over to a remote machine, and have it execute over there without manually copying the files over. Not only that, but I'd like to interact with the process locally with standard in, standard out and standard error. What this will allow me to do is to write some administrative code and run the assembly on the remote machine(s) without any special hooks into my admin code. As well, if I have some process that will take a bunch of time to run, I can simply have it run on another machine, and report back the status and results without consuming time on my own machine. The latter approach leads to a more general subject of viewing any machine as a general computing resource.

Quick Example (output from the image above)

The image above is the output of an assembly that simply functions as a .NET version of "DIR". Basically, a search was issued for *.mp3 on the local machine and the results were displayed. Next, the search was issued in parallel to all the machines that matched the name "testwin*". In this case, two machines matched that name. I ran the second one just to show that it could be run explicitly as well.

Give it a try!

If you'd like to test it out, download the demo project from the link above into a folder. Here's the usage:

Collapse

Copyright (C) 2004-2005 Jim Wiese 
 
Executes the specified assembly on the remote machine and the remote 
application will function interactively. 
 
 Usage: \\machine[,\\machine2,[...]] [-port portNumber] [-serial]
   [-interactive] [-timeout [days.]HH:MM:SS] [-remoteUserId userId] 
   [-remotePassword password] [-unmanaged pathToZipFile.zip]
   [-debug] assembly [arguments] 
 
machine: The machine to run the assembly on. Note that this value can have 
    the '*' character to represent multiple machines. As well, \* will match
    all the machines in the domain. (eg HP* -> HP1, HP2) 
port:    The port number to use for the communication between processes 
    assembly: The assembly name to run on the remove machine. This assembly
    must have an entry point defined (ie Main). 
arguments: Any arguments to pass to the executed assembly. 
debug: Write debugging information to the standard out. 
serial:     Run the machines serially, one at a time. By default, all the 
    machines are run in parallel. 
interactive: Allow the process to interact with the desktop process 
timeout:     Allow the process to run for the specified amount of time 
    remoteUserId: The user ID to run under on the remote process 
    remotePassword: The password for the remote user ID 
unmanaged:     The path to a zip file with the unmanaged resources to 
    decompress on the remote machine

Possible uses for this library / tool

• Run-time deployment of Application servers (eg for business logic) to a specific set of machines
• Run-time deployment of web servers to a specific set of machinesPerform administrative functions on Windows Domain clients such as run time installation of software
• Determine if specific files are stored on Windows machines without the need for UNC shares (eg. C:\> runremote \\* quickdir.exe *.mp3)
• Create an on demand "Peer Grid" to solve problems such as sorting a large file before import into a database
• Force GPO updates on the client machines immeadiately
• Determine if someone is actually logged onto a console of a machine
• Log people off the console of the machine if they're logged in :) (eg for Kiosk purposes)

Sweetness, how does it work?

The main premise of the process is quite simple, but with a couple of small "gotchas". First, the process creates a temporary Windows service on the remote machine with a random name. I say random in the sense that a GUID is appended to the service name. This service creates a child process that will execute the specified assembly. The service waits for the child process to finish executing the assembly, then removes itself (i.e., the Service entry) from the remote machine, and exits.

The interesting premise comes in two different steps:

1. How does the service get the executable to run?
2. How are the assemblies shuffled over to the remote machine?

Pushing the executable to run the temp service

Here's the first of the two "gotchas" from above: the service code is copied over to the UNC folder file://remoteMachine/admin$/temp. Windows exposes the administrative share named Admin$ by default, and we make use of this share to get the executable over to the remote machine. We could have created a service that used \\sourceMachine\Admin$\temp (i.e., the machine from which the command was run), but any .NET code that is run under a UNC uses a much more restrict security policy. These temporary files will be removed when the entire process is finished. As a matter of fact, it goes to great length to try to make sure that the files are removed once all is finished.

The one main thing to keep in mind is that the sole purpose of the service is to create a remote process. Some people refer to this as a hack method of starting processes, but in this case, I consider it a feature.

But what about the assembly that I want you to run?

The next important thing to consider is that we have not actually copied the assembly that is going to be run over to the remote machine. This is where a small piece of elegance comes in the code. What the service shim does is attempt to load "YourAssembly". Since this assembly does not exist on the remote machine, a Loader exception will occur. There is a handy little event that is fired when this happens in an AppDomain named:

				/// <summary>
				/// Event that is called when the domain can not find an assembly.
				/// We want to lookup this assembly on the remote machine and return it.
				/// </summary>
				/// <param name="sender">The current AppDomain</param>
				/// <param name="args">Event arguments for this event</param>
				/// <returns>The assembly from the remote machine
				///          or null if it wasn't found</returns>
				private Assembly CurrentDomain_AssemblyResolve(object sender,
                                       ResolveEventArgs args)
{
  return ResolveAssemblyOnRemoteMachine( args.Name ) ;
}

This event gives the assembly name that was attempted to be loaded in the arguments, and allows the block of code a chance to locate it and return it. In this case, a small block of code is put in to connect back to the source machine and request the lookup on that machine.

Since the code does exist on the source machine, the bytes of the assembly are packaged up and sent back to the remote machine. The assembly is then loaded from these bytes and returned to the AppDomain loader.

Collapse

				/// <summary>
				/// Resolve the assembly from the remote machine (machine from which the 
/// command was run). If the assembly exists on the remote machine, it 
//  will be shuffled over to this process and then loaded and returned.
				/// </summary>
				/// <param name="assemblyName">The name of the assembly to resolve</param>
				/// <returns>The assembly if it existed, otherwise null</returns>
Assembly ResolveAssemblyOnSourceMachine( string assemblyName )
{
   //// This is the main point in which we shuffle// the assembly from the server to this// client. //byte[] assemblyBytes = server.GetAssembly( assemblyName ) ;
   if ( assemblyBytes != null && assemblyBytes.Length > 0 )
   {
     Assembly loaded = Assembly.Load( assemblyBytes ) ;
     return loaded ;
   }
   else
   {
     returnnull ;
   }
}

At this point, you'll notice that I referenced a small variable named "server" which seems to get the bytes of the assembly. This "server" variable is actually a .NET Remoted object that is being served up by our source machine. There are probably a variety of ways that this could be done, but the .NET remoting method was too clean and easy to pass up.

Once the assembly that you requested to be run is loaded, the EntryPoint is invoked with any command line arguments that you might want to pass in. Typically, the EntryPoint is the "Main" of your assembly. After your Main( string[] args ) is run, the return code is reported back to the source machine and the process on the remote machine exists. To appear like a local process, the "runremote.exe" process on the source machine exists with the same return code of the remote process so that you can use shell utilities to check the return code.

Now, your executing assembly might have also needed some other dependencies. If it references those dependencies, won't it cause a problem? Thankfully, the answer is no, it won't cause a problem. Any missing dependencies cause the ResolveAssembly event to be called and loaded by the same mechanism.

"Down by the water, out by the sea..." (??? grunge, circa 1993)

Now, if you've made this far in the article, I'm impressed and honored. Let's not delay and delve into the depths of the nitty and the gritty of the code:

All the code starts in the project RunRemote in the file RunRemote.cs in the class RemoteProcess. This is the main project if you'd like to run it programmatically, but if you're running the command version, then it's the class CommandLineRemoteProcess which actually calls RemoteProcess.ExecuteRemotely. Basically, it's all fairly simple to call from the outside. Here's the sample code to actually run an assembly remotely:

RemoteProcess  remote     = new RemoteProcess() ;
int            exitCodeOfRemoteProcess   =
                    remote.ExecuteRemotely(
                        "YourAssembly", // Note: partial assembly name  newstring[] { "-arg1", "-arg2" },
                        newstring[] { @"\\onMyMachine" },
                        0,
                        0,
                        false,
                        new TimeSpan( Timeout.Infinite ),
                        1 ) ;

//// NOTE: There are some other overloaded versions of this method with // more parameters, see the source code for details//

Now, I've described before that a file is copied and a service is created. I'm not going to outline the code to copy files and create the service, but I'll give some specifics that are interesting. First, the output of the project "ServiceOnRemoteMachine" generates "ServiceOnRemoteMachine.exe". Take a wild guess at what this file is used for :). After this file is copied to the remote machine, the service is created with the file name of "%SYSTEMROOT%\temp\ServiceOnRemoteMachine.exe". This path name is the resolved value of the mapped path \\remoteMachine\admin$\temp\ServiceOnRemoteMachine.exe, but with a local reference (e.g., C:\Windows\temp\ServiceOnRemoteMachine.exe). As well, the service name of the service that is running is passed as an argument as well as the remoting URI to connect back to the source machine. The last argument is the name of the assembly to load (i.e., the name of your assembly). For example, the path for the service might be:

"C:\WINDOWS\temp\serviceonremotemachine.exe" -fromService
         ExecRemote-e2088b28-330f-4ac6-9627-799ddd435004
         "tcp://dublin:3237/83c1ca40_8305_4583_bf5b_9265a03d9de4/RunRemote.rem"
         "runthisonothermachine"

When the service first starts up in the Main() method, the argument "-fromService" is noted. This tells the service to spawn a new process using itself as the executable, but removing the service name and the "-fromService" argument.

Process and AppDomain isloation for safety (Injecting the safe way)

Now, in the new child process, a remoting object named "Server" is hooked up by the Activator and uses the URI to get back to the source machine.

				//
				// Setup the formatters
				//
TcpChannel    channel        = new TcpChannel() ;
ChannelServices.RegisterChannel( channel );

// Create an instance on the remote server and call a method remotely
server = (Server)Activator.GetObject(   typeof ( Server ), // Type to create
                                        serverUri  );

The whole rest of the code and purpose for the entire class comes to the final method. This method loads up the assembly, hooks up STDIN, STDOUT, STDERR, and runs the sucker.

Collapse

				/// <SUMMARY>
				/// Believe it or not, the entire application reduces to this one method. By
				/// this point, we are running in a process on the remote machine
				/// </SUMMARY>
				/// The name of the assembly to execute. This name
				/// can be either a partial name such as "RunThisOnOtherMachine" or a fully
				/// qualified name.
				/// 
				/// Arguments to send to the main method, or null for no args
				/// <RETURNS>The return result from the entry
				///   point of the requested assembly</RETURNS>
				public
				object LoadAssemblyAndRunIt( string assemblyName, string[] args )
{

    //// Setup the readers/writers to use the server's streams.  This will allow// this process to read and write to the console of the process on the// machine from which the command was run.//

    TextWriter    stdErr    = AssemblyResolutionServer.StdErr ;
    TextWriter    stdOut    = AssemblyResolutionServer.StdOut ;
    TextReader    stdIn    = AssemblyResolutionServer.StdIn ;

    m_sponsorManager.Register( stdErr );
    m_sponsorManager.Register( stdOut ) ;
    m_sponsorManager.Register( stdIn ) ;

    Console.SetError( new NoExceptionTextWriter( stdErr ) ) ;
    Console.SetOut( new NoExceptionTextWriter( stdOut ) ) ;
    Console.SetIn( stdIn ) ;

    //// Setup the event handlers for the domain//
    AppDomain.CurrentDomain.ResourceResolve 
                += new ResolveEventHandler( CurrentDomain_ResourceResolve );
    AppDomain.CurrentDomain.AssemblyResolve    
                += new ResolveEventHandler( CurrentDomain_AssemblyResolve );
    AppDomain.CurrentDomain.DomainUnload    
                += new EventHandler(CurrentDomain_DomainUnload);

    //// Get any required unmanaged dependencies//
    RetrieveUnmanagedDependencies() ;

    Assembly    assemblyToExecute = AppDomain.CurrentDomain.Load( 
                                                           assemblyName ) ;

    object        result          = null ;

    //// Finally, execute the assembly//try
    {
        if ( assemblyToExecute != null )
        {
            if ( assemblyToExecute.EntryPoint.GetParameters().Length == 0 )
            {
                result    =
                    assemblyToExecute.EntryPoint.Invoke( null, null ) ;
            }
            else
            {
                result    =
                    assemblyToExecute.EntryPoint.Invoke( null,
                                               newobject[]{ args } ) ;
            }

            
        }
    }
    catch( Exception exp )
    {
        Trace.WriteLine( exp.Message + "\n" + exp.StackTrace, "Error" ) ;

        if ( exp.InnerException != null )
        {
            Trace.WriteLine( exp.InnerException.Message + "\n" + 
                            exp.InnerException.StackTrace, "Error" ) ;
        }
    }
    finally
    {
        Console.Error.Flush() ;
        Console.Out.Flush() ;
    }

    return result ;
}

What about console events?

Okay, this was a pain in the rear to implement, but console events, generally CTRL-C, is used to interact with the process. When remoting the process, these events need to be remoted as well. There is a background thread on each of the machines that waits for events from the server. The console application traps any console events, passes them in parallel to each remote application, and regenerates those events on the remote machine. This is particularly painful since this is all being run underneath a service. By default, services don't have consoles associated with them. Well, one might claim this is a fairly simple endeavor, simply create a console with AllocConsole() and move on. It just so happens that child processes share the same console as the parent process. In this scenario, the temporary service shares the console with the child process performing the work. If we generate the console event, then it will actually send it to the service as well. So in order to handle all of this, the service itself will not respond to any console events (i.e., CTRL-C, CTRL-BREAK, etc.). This is not a big deal since we don't want the user interacting with this process anyway. None-the-less, you'll see a DoNothithWithConsoleEvent() handler routine that has a fairly self explanatory name.

"Confession is the road to healing..." (DC Talk, circa 1994)

Now, at this point, some of the dirty laundry must be aired in order for my conscience to feel good. There are obviously some security ramifications of this process as well as the fact that it doesn't handle any PInvoked methods via the loading mechanism. We'll tackle each of these subjects one at a time:

Security??!!

Security, you say? Well, first I should mention that in order to copy files into the Admin$ share of the remote machine, you must be in Administrators group of the remote machine. Therefore, by default, hopefully, not everyone in the world is an Administrator of the remote machine. This is enforced by Windows default NTFS permissions.

The second security issue is the identity of which the remote process runs. Since the process is running as a service, it is running under the "LOCALSYSTEM" account. I can hear the gaffe all the way to Dublin, CA. Running code under this account can be problematic in the sense that the "NT AUTHORITY\SYSTEM" account can do just about everything on the remote system. If your code does something that you didn't want it to do, you'll have to live with the consequences. I did look into the ability to impersonate the current user on the source machine in the process on the remote machine, and it is all feasible, but beyond my current allotment of time for this article. If you have some time and would like to investigate it, refer to the article on MSDN.

The third and rather more obscure security issue is the fact that there isn't any authentication between the remote and source machine in the sense that the whole process could be liable to a man-in-the-middle attack. As well, there are moderate ways to transparently resolve this but they were beyond the time allotted for this article.

On the other hand, I have in mind to integrate some 3rd party components to solve this problem such as the Genuine Channels components to handle all the remoting infrastructure. Keep posted for more details.

Managing the Unmanaged

Gee, doesn't that title sound like something from a management seminar: "I will manage the unmanaged masses!" Anyway, there is a chance that you may have unmanaged method calls in your assembly. These calls will not proxy over the libraries from the source machine, but rather call the library from the local machine. If you're calling one of the system libraries, then this is actually a good thing. However, if you're making a call to a custom or third party unmanaged library, you must make sure it exists on the remote machine first. The only caveat to this is that there is an option to send over the unmanaged DLLs or any necesary files that are needed for your project. First zip them up into a zip file, then on the command line specify the file name with the argument:

-unmanaged myFiles.zip

... Or if your calling this method programatically, specify this file in the ExecRemote command under the "unmanaged" parameter:

Collapse

						public
						int ExecuteRemotely(
            string                      assemblyToRun,
            string[]                    argsForMain,
            string[]                    machineNames,
            int                         port,    
            int                         debugLevel,
            string                      remoteUserId,
            string                      remotePassword,
            bool                        interactive,
            TimeSpan                    allowedTime,
            int                         numberOfThreads,
            string                      unmanagedDependencies,
            string                      outputFolder,
            TextWriter                  consoleStdOut,
            TextWriter                  consoleStdErr,
            TextReader                  consoleStdIn,
            BeforeRunOnMachineDelegate  optionalBeforeHandler,
            AfterRunOnMachineDelegate   optionalAfterHandler,
            object                      optionalSource )
        

Nothin' but .NET (or lack thereof)

Lastly, if .NET is not installed on the remote machine, the process will fail. The correct version of the framework must be installed on the remote machine for the code to run. Again, I considered a loader that would detect if the correct version of .NET was installed and install it if it wasn't there; all of which is possible. Yet another thing I didn't exactly have time for :) However, I have in mind a bootstrapper project that will install .NET on the remote machine before the shim process is run. Keep posted for more details.

Disclaimer

This article and the accompanying code are provided as-is. You may use it as you please. You may not hold me liable for any damage caused to you, your company, your neighbors or anyone else, as a result of reading this article or using the code. Whatever you do with this article and the accompanying code is at your own risk.

Version History

1.3 - Feb 28th, 2005

• Added ability to send unmanaged code / resources to the remote machine. Basically, you can send legacy DLLs or any other resouce (ie plain old files) to the remote machine. All you need to do is zip up all the resources and supply a zip file on the argument "-unmanaged myfiles.zip" to the command line or to the "unmanaged" argument for ExecRemote() method.
• Added ability to pull back any modified files on the remote machine. If you modify any files during the processing of your code, then those files can be pulled back and placed in a directory as the same name of the remote machine.
• Added a couple of extra checks to make sure that the current user has Administrative access to the remote machine and the remote resources are cleaned up in the end. Special thanks to the people at ICSharpCode.net for this functionality (http://www.icsharpcode.net/)
• Added ability to redirect the output / input of the remote machine to a custom TextWriter / TextReader. A number of people had requested this feature, so I finally added it to the main method. However, by default, all the remote output/input are redirected to/from Console.StdOut, Console.StdIn, Console.StdErr.
• Fixed problem of running process on a source machine with multiple IP addresses. When using remoting and TCP, the source machine uses the "first" avilable IP address on that machine. For example, if you have two IP addresses "192.168.0.14" and "10.11.0.5", and your network is generally running on the 10.x.x.x network, the Uri for the remoting object is actually given out as tcp://192.168.0.14/YourRemoteObject.rem. I had a hard time believing this until I actually saw it in the debugger, but you can check out the article at http://www.glacialcomponents.com/ArticleDetail/CAOMN.aspx for more details.

1.2 - Jan 22nd, 2005

• Added ability to use a .NET configuration file that will be remoted (ie YourApp.exe.config will get proxied over)
• Added ability to use a license file (ie license.txt)
• Fixed problem with launching a program that defined main as Main() instead of Main( string[] args ). It will now function either way.
• All user assembly code is now loaded in a sepate AppDomain in the child process

1.1 - Dec 29^th, 2004

• Added usage for '-interactive' to allow application to interact with the desktop.
• Added the ability to issue a CTRL-C, CTRL-BREAK, etc. which will be echoed to all the remote applications.
• Added ability to use wildcards for the machine names(s) (e.g., \\testwin* will match \\testwin2k and \\testwinxp via LDAP lookup).
• Added ability to timeout on the remote application.
• Created a more useful demonstration application, quickdir.exe. This application will basically do a "dir" on the remote machine.

1.0 - Dec 10^th, 2004

• Initial version.

Special Recognition

I would like to thank Mark Russinovich for his article on Psexec which inspired me to write this article. As well, I'd like to thank Suzanne Cook for her blogs on the .NET runtime loader which was a good reference for some very difficult issues. Lastly, but not least, I'd like to thank everyone who contributes to PInvoke.net from which I get most of my PInvoke method definitions (such as those to create services on Windows).

In Memory of Don Langewisch

I'd like to humbly dedicate this article to the memory of Don Langewisch (1955? - Dec. 10^th, 2004). I received the news of his passing while finalizing this article. Don, a loving and dedicated man of God leaves behind a wife, two daughters and a son.

About Jim Wiese (aka Spunk)