BlogJava-苍穹之铁十字-随笔分类-C#

DataGrid的数据过滤示例

苦笑枯 — Thu, 18 Jan 2007 16:16:00 GMT

这个示例演示了怎么样在DataGrid中筛选数据

/*DataDridFilterForm.aspx

前台程序

<%@ Page language="c#" Codebehind="DataGridFilterForm.aspx.cs" AutoEventWireup="false" Inherits="DataDridFilterDemo.DataDridFilterForm" %>

  WebForm1





  http://schemas.microsoft.com/intellisense/ie5">

/*DataDridFilterForm.aspx.cs

后台处理程序

using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Data.SqlClient;
using System.Drawing;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;

namespace DataDridFilterDemo
{
///

/// WebForm1 的摘要说明。
///

public class DataDridFilterForm : System.Web.UI.Page
{
  protected System.Web.UI.WebControls.DropDownList ddlCategory;
  protected System.Web.UI.WebControls.Label lblCategory;
  protected System.Web.UI.WebControls.Label lblPrice;
  protected System.Web.UI.WebControls.DropDownList ddlPrice;
  protected System.Web.UI.WebControls.DataGrid dgProduct;
  public static string strCategory="CategoryID=1";
  public static string strPrice="UnitPrice>0";

  private void Page_Load(object sender, System.EventArgs e)
  {
   // 在此处放置用户代码以初始化页面
   if(!IsPostBack)
   {
    FillDropDownList();
    DataFiller();
   }
  }

  #region Web 窗体设计器生成的代码
  override protected void OnInit(EventArgs e)
  {
   //
   // CODEGEN: 该调用是 ASP.NET Web 窗体设计器所必需的。
   //
   InitializeComponent();
   base.OnInit(e);
  }

  ///

  /// 设计器支持所需的方法 - 不要使用代码编辑器修改
  /// 此方法的内容。
  ///

  private void InitializeComponent()
  {
   this.ddlCategory.SelectedIndexChanged += new System.EventHandler(this.FilterChange);
   this.ddlPrice.SelectedIndexChanged += new System.EventHandler(this.FilterChange);
   this.Load += new System.EventHandler(this.Page_Load);

}
#endregion

  private void FillDropDownList()
  {
   string strCon="server=JOSEN;database=NorthWind;integrated security=true";
   string strSqlCategory="select CategoryName,CategoryID from Categories";

   SqlConnection objCon=new SqlConnection(strCon);
   SqlDataAdapter objAdpt=new SqlDataAdapter(strSqlCategory,objCon);

DataSet ds=new DataSet();
objAdpt.Fill(ds);

   ddlCategory.DataSource=ds;
   ddlCategory.DataTextField="CategoryName";
   ddlCategory.DataValueField="CategoryID";
   ddlCategory.DataBind();
  }

  private void DataFiller()
  {
   string strCon="server=JOSEN;database=NorthWind;integrated security=true";
   string strSqlProduct="select ProductID,ProductName,CategoryID,UnitPrice from Products";
   SqlConnection objCon=new SqlConnection(strCon);
   SqlDataAdapter objAdpt=new SqlDataAdapter(strSqlProduct,objCon);

DataSet objds=new DataSet();
objAdpt.Fill(objds,"dtProduct");

DataView dvUK=new DataView(objds.Tables["dtProduct"]);
dvUK.RowFilter=strCategory+" and "+strPrice;

   this.dgProduct.DataSource=dvUK;
   dgProduct.DataBind();
  }

  private void FilterChange(object sender, System.EventArgs e)
  {
   FilterByPrice(ddlPrice.SelectedItem.Text.ToString());
   FilterByCategory(ddlCategory.SelectedItem.Value.ToString());//注意这里，用的是CategoryID而不是CategoryName
   DataFiller();
  }
  private void FilterByPrice(string strChoice)
  {
   switch(strChoice)
   {
    case "Any Price":
     strPrice="UnitPrice>0";
     break;
    case "Cheap":
     strPrice="UnitPrice<20";
     break;
    case "Moderate":
     strPrice="UnitPrice>19 and UnitPrice<50";
     break;
    case "Expensive":
     strPrice="UnitPrice>=50";
     break;
    case "Absurdly Expensive":
     strPrice="UnitPrice>100";
     break;
   }
  }

  private void FilterByCategory(string strChoice)
  {
   strCategory="CategoryID="+strChoice;
  }
}
}

苦笑枯 2007-01-19 00:16 发表评论

文章来源:http://www.blogjava.net/kuxiaoku/articles/94809.html

苦笑枯 2007-01-19 00:16 发表评论

DataGrid控件分页显示的示例

苦笑枯 — Thu, 18 Jan 2007 16:16:00 GMT

实现DataGrid控件分页显示的示例

前台处理程序

//DataGridPageDemo.aspx

<%@ Page language="c#" Codebehind="DataGridPageDemo.aspx.cs" AutoEventWireup="false" Inherits="DataGridPageDemo.DataGridPageDemo" %>

  WebForm1



  http://schemas.microsoft.com/intellisense/ie5">

//下面的是后台处理程序

DataGridPageDemo.aspx.cs

namespace DataGridPageDemo
{
///

/// WebForm1 的摘要说明。
///

public class DataGridPageDemo : System.Web.UI.Page
{
  protected System.Web.UI.WebControls.DataGrid dgDemo;

  private void Page_Load(object sender, System.EventArgs e)
  {
   // 在此处放置用户代码以初始化页面
   if(!IsPostBack)
   {
    DataFiller();
   }
  }

  /// 设计器支持所需的方法 - 不要使用代码编辑器修改
  /// 此方法的内容。
  ///

  private void InitializeComponent()
  {
   this.dgDemo.PageIndexChanged += new System.Web.UI.WebControls.DataGridPageChangedEventHandler(this.dgDemo_PageIndexChanged);
   this.Load += new System.EventHandler(this.Page_Load);

}
#endregion

  private void DataFiller()
  {
   string strConn="server=JOSEN;database=NorthWind;integrated security=true";
   string strSql="select * from orders";
   SqlConnection objCon=new SqlConnection(strConn);
   SqlDataAdapter objAdapter=new SqlDataAdapter(strSql,objCon);
   DataSet ds=new DataSet();
   objAdapter.Fill(ds,"dtorder");

dgDemo.DataSource=ds.Tables["dtorder"];
dgDemo.DataBind();

}

  private void dgDemo_PageIndexChanged(object source, System.Web.UI.WebControls.DataGridPageChangedEventArgs e)
  {
   dgDemo.CurrentPageIndex=e.NewPageIndex;
   DataFiller();
  }
}
}

苦笑枯 2007-01-19 00:16 发表评论

文章来源:http://www.blogjava.net/kuxiaoku/articles/94810.html

苦笑枯 2007-01-19 00:16 发表评论

使用DataGrid控件更新删除数据示例

苦笑枯 — Thu, 18 Jan 2007 16:15:00 GMT

/*UpdateDelForm.aspx

前台程序代码

<%@ Page language="c#" Codebehind="UpdateDelForm.aspx.cs" AutoEventWireup="false" Inherits="UpdateDelDbDemo.UpdateDelForm" %>

  WebForm1




  http://schemas.microsoft.com/intellisense/ie5">

/*UpdateDelForm.aspx.cs

后台程序代码

namespace UpdateDelDbDemo
{
///

/// WebForm1 的摘要说明。
///

public class UpdateDelForm : System.Web.UI.Page
{
  protected System.Web.UI.WebControls.DataGrid dgDemo;
  private string strCon="server=JOSEN;database=testDb;integrated security=true";
  private string strSqlSelect="select * from UserInfo";
  private SqlConnection objCon;

  private void Page_Load(object sender, System.EventArgs e)
  {
   // 在此处放置用户代码以初始化页面
   if(!IsPostBack)
    LoadGrid();
  }

  /// 设计器支持所需的方法 - 不要使用代码编辑器修改
  /// 此方法的内容。
  ///

  private void InitializeComponent()
  {
   this.dgDemo.CancelCommand += new System.Web.UI.WebControls.DataGridCommandEventHandler(this.dgDemo_CancelCommand);
   this.dgDemo.EditCommand += new System.Web.UI.WebControls.DataGridCommandEventHandler(this.dgDemo_EditCommand);
   this.dgDemo.UpdateCommand += new System.Web.UI.WebControls.DataGridCommandEventHandler(this.dgDemo_UpdateCommand);
   this.dgDemo.DeleteCommand += new System.Web.UI.WebControls.DataGridCommandEventHandler(this.dgDemo_DeleteCommand);
   this.Load += new System.EventHandler(this.Page_Load);

  }
  #endregion
  //读取数据并帮定到ＤａｔａＧｒｉｄ
  private void LoadGrid()
  {
   Connect();
   SqlDataAdapter objAdpt=new SqlDataAdapter(strSqlSelect,objCon);
   DataSet ds=new DataSet();
   objAdpt.Fill(ds,"dtUserInfo");

   dgDemo.DataSource=ds;
   dgDemo.DataBind();
  }
  //建立数据库的连接
  private void Connect()
  {
   if(objCon==null)
    objCon=new SqlConnection(strCon);
   if(objCon.State==ConnectionState.Closed)
    objCon.Open();

  }
  //断开数据库的连接
  private void Disconnect()
  {
   objCon.Close();
  }

  private void dgDemo_EditCommand(object source, System.Web.UI.WebControls.DataGridCommandEventArgs e)
  {
   dgDemo.EditItemIndex=e.Item.ItemIndex;
   LoadGrid();
  }

  private void dgDemo_CancelCommand(object source, System.Web.UI.WebControls.DataGridCommandEventArgs e)
  {
   dgDemo.EditItemIndex=-1;
   LoadGrid();
  }

  private void dgDemo_UpdateCommand(object source, System.Web.UI.WebControls.DataGridCommandEventArgs e)
  {
   string strUserID=e.Item.Cells[0].Text;
   //string strUserID=((TextBox)e.Item.Cells[0].Controls[0]).Text;
   string strFirstName=((TextBox)e.Item.Cells[1].Controls[0]).Text;
   string strLastName=((TextBox)e.Item.Cells[2].Controls[0]).Text;
   string strAddress=((TextBox)e.Item.Cells[3].Controls[0]).Text;

   dgDemo.EditItemIndex=-1;
   //此方法具体处理数据库的更新
   UpdateRecord(strUserID,strFirstName,strLastName,strAddress);
   //调用此方法从数据库读取数据
   LoadGrid();

}

  private void UpdateRecord(string strUserID, string strFirstName, string strLastName, string strAddress)
  {
   Connect();
   SqlDataAdapter objAdpt=new SqlDataAdapter(strSqlSelect,objCon);
   DataSet ds=new DataSet();
   objAdpt.Fill(ds,"dtUserInfo");
   Disconnect();

   DataTable tbl=ds.Tables["dtUserInfo"];

   //设定表的主键
   DataColumn[] myKey=new DataColumn[1];
   myKey[0]=tbl.Columns["ID"];
   tbl.PrimaryKey=myKey;

   DataRow dr=tbl.Rows.Find(strUserID);
   //dr["ID"]=strUserID;
   dr["FirstName"]=strFirstName;
   dr["LastName"]=strLastName;
   dr["address"]=strAddress;

   SqlCommandBuilder cb=new SqlCommandBuilder(objAdpt);
   Connect();
   objAdpt.Update(ds,"dtUserInfo");
   Disconnect();
  }

private void dgDemo_DeleteCommand(object source, System.Web.UI.WebControls.DataGridCommandEventArgs e)
{

string strUserID=e.Item.Cells[0].Text;

   dgDemo.EditItemIndex=-1;
   DelRecord(strUserID);
   //调用此方法从数据库读取数据
   LoadGrid();
  }
  private void DelRecord(string strUserID)
  {
   Connect();
   SqlDataAdapter objAdpt=new SqlDataAdapter(strSqlSelect,objCon);
   DataSet ds=new DataSet();
   objAdpt.Fill(ds,"dtUserInfo");
   Disconnect();

   SqlCommandBuilder cb=new SqlCommandBuilder(objAdpt);
   Connect();
   objAdpt.Update(ds,"dtUserInfo");
   Disconnect();
  }
}
}

苦笑枯 2007-01-19 00:15 发表评论

文章来源:http://www.blogjava.net/kuxiaoku/articles/94807.html

苦笑枯 2007-01-19 00:15 发表评论

日历程序的使用示例

苦笑枯 — Thu, 18 Jan 2007 16:15:00 GMT

/*CalendarForm2.aspx

前台程序

<%@ Page language="c#" Codebehind="CalendarForm2.aspx.cs" AutoEventWireup="false" Inherits="CalendarDemo.CalendarForm2" %>

  CalendarForm2



  http://schemas.microsoft.com/intellisense/ie5">

/*CalendarForm2.aspx.cs

日历控件使用后台程序

namespace CalendarDemo
{
///

/// CalendarForm2 的摘要说明。
///

public class CalendarForm2 : System.Web.UI.Page
{
  protected System.Web.UI.WebControls.ListBox lbxEmployee;
  protected System.Web.UI.WebControls.Calendar calHire;
  protected System.Web.UI.WebControls.Label lblInfo;

  private void Page_Load(object sender, System.EventArgs e)
  {
   // 在此处放置用户代码以初始化页面
   string strCon="server=JOSEN;database=NorthWind;integrated security=true";
   string strSql="select EmployeeID,LastName,FirstName,HireDate from Employees";

SqlConnection objCon=new SqlConnection(strCon);
SqlDataAdapter objAdpt=new SqlDataAdapter(strSql,objCon);

DataSet ds=new DataSet();
objAdpt.Fill(ds,"dtEmployee");

   if(!IsPostBack)
   {
    this.lbxEmployee.DataSource=ds;
    lbxEmployee.DataTextField="LastName";
    lbxEmployee.DataBind();
   }
   else
   {
    DateTime datHireDate;
    datHireDate=Convert.ToDateTime(ds.Tables["dtEmployee"].Rows[lbxEmployee.SelectedIndex]["HireDate"]);

lblInfo.Text=ds.Tables["dtEmployee"].Rows[lbxEmployee.SelectedIndex]["LastName"].ToString();

    this.calHire.VisibleDate=datHireDate;
    calHire.SelectedDate=datHireDate;
    lblInfo.Text+="hired on "+datHireDate;
   }
  }

  /// 设计器支持所需的方法 - 不要使用代码编辑器修改
  /// 此方法的内容。
  ///

  private void InitializeComponent()
  {
   this.Load += new System.EventHandler(this.Page_Load);

}
#endregion
}
}

苦笑枯 2007-01-19 00:15 发表评论

文章来源:http://www.blogjava.net/kuxiaoku/articles/94808.html

苦笑枯 2007-01-19 00:15 发表评论

一个魔术矩阵的例子

苦笑枯 — Thu, 18 Jan 2007 16:14:00 GMT

魔术矩阵是一个n*n的矩阵，其中N必须为奇数，然后将1至n的平方的整数依照指定的规则放入矩阵，完成后矩阵的各行各列以及对角线的元素值总和均会相同。

放置规则，第一个整数1一律被放置在第一行的中间位置，第二个值得位置必须放置在第一个值得左上角，因此，由1的位置往左一格，再往上一格，此时超出数组的范围，因此回到同一列的最下方。

同样，3必须放在2的左上角，4放在3的左上角，此时超出数组范围回到同一行的最右边空格。同此规则，来到5的位置，当我们要填入6的时候，其位置已被数字1占据，因此将其放置到5的下方，接下来的数字则依规则一一放置到合适的位置，当填到15的时候，其左方与上方均没有位置，因此下一个数直接放置于15的下方，完成了填入16的值，接下来的数目，均可以依上述的规则填写完成。

下面看看这个魔术矩阵的示例代码：

/*此类是主窗口，接受输入的奇数

MagicSquare.cs

using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;

namespace MagicSquare
{
///

/// Form1 的摘要说明。
///

public class MagicSquare : System.Windows.Forms.Form
{
///

/// 必需的设计器变量。
///

  private System.ComponentModel.Container components = null;
  private System.Windows.Forms.Label lblNumber;
  private System.Windows.Forms.TextBox txbNumber;
  private System.Windows.Forms.Button btnOK;
  public int number=0;
  public MagicSquare()
  {
   //
   // Windows 窗体设计器支持所必需的
   //
   InitializeComponent();

   //
   // TODO: 在 InitializeComponent 调用后添加任何构造函数代码
   //
  }

///

/// 清理所有正在使用的资源。
///

  protected override void Dispose( bool disposing )
  {
   if( disposing )
   {
    if (components != null)
    {
     components.Dispose();
    }
   }
   base.Dispose( disposing );
  }

#region Windows 窗体设计器生成的代码
///

  /// 设计器支持所需的方法 - 不要使用代码编辑器修改
  /// 此方法的内容。
  ///

  private void InitializeComponent()
  {
   this.lblNumber = new System.Windows.Forms.Label();
   this.txbNumber = new System.Windows.Forms.TextBox();
   this.btnOK = new System.Windows.Forms.Button();
   this.SuspendLayout();
   //
   // lblNumber
   //
   this.lblNumber.Location = new System.Drawing.Point(48, 32);
   this.lblNumber.Name = "lblNumber";
   this.lblNumber.TabIndex = 0;
   this.lblNumber.Text = "请输入奇数：";
   //
   // txbNumber
   //
   this.txbNumber.Location = new System.Drawing.Point(192, 32);
   this.txbNumber.Name = "txbNumber";
   this.txbNumber.TabIndex = 1;
   this.txbNumber.Text = "";
   //
   // btnOK
   //
   this.btnOK.Location = new System.Drawing.Point(144, 80);
   this.btnOK.Name = "btnOK";
   this.btnOK.TabIndex = 2;
   this.btnOK.Text = "OK";
   this.btnOK.Click += new System.EventHandler(this.btnOK_Click);
   //
   // MagicSquare
   //
   this.AutoScaleBaseSize = new System.Drawing.Size(6, 14);
   this.ClientSize = new System.Drawing.Size(432, 117);
   this.Controls.Add(this.btnOK);
   this.Controls.Add(this.txbNumber);
   this.Controls.Add(this.lblNumber);
   this.Name = "MagicSquare";
   this.Text = "MagicSquare";
   this.ResumeLayout(false);

}
#endregion

///

/// 应用程序的主入口点。
///

  [STAThread]
  static void Main()
  {
   Application.Run(new MagicSquare());
  }

  private void btnOK_Click(object sender, System.EventArgs e)
  {
   number=Convert.ToInt32(txbNumber.Text.Trim());
   if(number%2==1)
   {
    this.Hide();
    ShowResult result=new ShowResult(number);
    result.Show();

   }
   else
   {
    MessageBox.Show("您输入的不是奇数，请重新输入奇数！","输入错误");
   }
  }
}
}

/*这个类用来处理魔术矩阵的生成，以及在窗体上显示出来

Show.cs

using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;

namespace MagicSquare
{
///

/// Show 的摘要说明。
///

public class ShowResult : System.Windows.Forms.Form
{
///

/// 必需的设计器变量。
///

  private System.ComponentModel.Container components = null;
  private int n;
  private int[,] mm;
  public ShowResult ()
  {
   //
   // Windows 窗体设计器支持所必需的
   //
   InitializeComponent();

   //
   // TODO: 在 InitializeComponent 调用后添加任何构造函数代码
   //
  }
  public ShowResult (int number)
  {
   n=number;
   mm=new int[n,n];
   AssignValue(n);
  }
  ///

/// 清理所有正在使用的资源。
///

  protected override void Dispose( bool disposing )
  {
   if( disposing )
   {
    if(components != null)
    {
     components.Dispose();
    }
   }
   base.Dispose( disposing );
   Application.Exit();
  }

#region Windows 窗体设计器生成的代码
///

  /// 设计器支持所需的方法 - 不要使用代码编辑器修改
  /// 此方法的内容。
  ///

  private void InitializeComponent()
  {
   this.components = new System.ComponentModel.Container();
   this.Size = new System.Drawing.Size(300,300);
   this.Text = "ShowResult";
  }
  #endregion

  public void AssignValue(int n)
  {
   int assignValue=1;
   int p=n-1;
   int col=p/2;
   int row=0;
   //初始化数组
   for(int i=0;i   {
    for(int j=0;j    {
     mm[i,j]=0;
    }
   }
   mm[row,col]=assignValue;
   do
   {
    assignValue++;
    col--;
    row--;
    if(col<0&&row<0)
    {
     row+=2;
     col+=1;
    }
    else
    {
     if(col<0)
      col=p;
     if(row<0)
      row=p;
    }
    if(mm[row,col]!=0)
    {
     col+=1;
     row+=2;
    }
    mm[row,col]=assignValue;
   }while(assignValue  }

  protected override void OnPaint(PaintEventArgs e)
  {
   base.OnPaint (e);
   Graphics g=this.CreateGraphics();
   for(int i=0;i    for(int j=0;j    {
     g.DrawString(mm[i,j].ToString(),new Font(FontFamily.GenericSansSerif.ToString(),15f),Brushes.YellowGreen,j*40+20,i*40+20);
    }
   g.Dispose();

}

}
}

苦笑枯 2007-01-19 00:14 发表评论

文章来源:http://www.blogjava.net/kuxiaoku/articles/94805.html

苦笑枯 2007-01-19 00:14 发表评论

Beginner with C#(来源csdn kamphkb 的 Blog )

苦笑枯 — Thu, 18 Jan 2007 16:14:00 GMT

                                  1 绪论
c# 是一种简练，时髦（？），面向对象（object oriented），类型可靠（type-safe）的
编程语言。它（发音：C sharp）是从c/c++发展而来的（？俺觉得更象是java），和c/c++
是一个语系。所以，很容易被c/c++的程序员接受。c#的目标是结合Visual Basic的高产和
C++质朴的力量。

c#将会是vs7的一分子。vs7还支持vb,vc和标记语言——VBScript和JScript。所有这些语言
都会在Next Generation Windows Services (NWGS) platform 中得到支持（c#就需要一个
NWGS SDK包，可以在m$的网站上下载）。有了这个东东（NWGS），c#就不需要自己的类库，
而使用vc或vb这样一些成熟的库。c#也确实没有自己的类库。
废话完了。

1。1 一个老土的例子（就不能换换吗？）*/
/* idontlikeHelloworld.cs : such a out sample :( */
1: using System;
2: class idontlikeHelloworld
3: {
4: static void Main() {
5: Console.WriteLine("i dont like Hello world");
6: Console.ReadLine();
7: }
8: }
/* 如果俺要出书的话，会考虑换个好点的例子。 ^&^

先说说怎样运行。首先，你需要windows2000！（是的，就是它，请各位不要随地丢果皮——
整个香蕉丢给俺就可以了。）然后，需要NWGS SDK！（82.4mb，不算很大噢。嘿嘿，好在
它没有自己的类库。）安装后，在你的程序所在的目录下键入：

csc idontlikeHelloworld.cs (加上一个回车键）

是不是有点复古的味道？这个操作会在和你的*.cs相同目录下产生一个
idontlikeHelloworld.exe文件。双击它，距可以看见：

i dont like Hello world

回车就可以结束它，非常简单。不过，也可以这样：把它存成后缀为.c的文件更好
（即：idontlikeHelloworld.c）。这样就可以用vc的IDE进行打字，编辑。vc的
txt editor是最棒的噢（又要vc，NO!!!）。然后：

csc idontlikeHelloworld.c (加上一个回车键）

最终效果是完全一样的。好，现在分析语法：（c#在语法上完全没有新意 :-| ）

1: using System;

using 其实是c++的关键字，在c#中的含义也相仿（就是说俺还不敢100%肯定，抱歉）。using
用在另一个关键字namespace之后。还是先看看namespace。
语法（syntax）：（from MSDN）

namespace [identifier] { namespace-body }

俺的理解：
identifier：在这里就是System（请记住：c#和c/c++一样，是区分大小写的！）。System
            必须在使用它的范围内是唯一的。即，不能够有第二个System，但可以有system。
            而“它的范围”，俺不想详细解说，只有在实践中才可能掌握。而且，初学者根本
            不必知道！俺也是近来才知道还有个namespace和using。：）

在{ namespace-body }中的是真正有用的东东，包括第五行的“Console.WriteLine”的声明和
定义（后面还会提到）。System是由NWGS定义的，咱们只需用（using）它即可。至于System在
什么文件里定义，咱就不用管了！交给编译器（就是刚才那个“csc.exe”）去寻找。这就代替
了c/c++中的“＃i nclude”，可以说是近了一步，避免大量烦人的细节。如果你没学过c/c++，
就不用理会。namespace 在后面还会谈到。

2: class idontlikeHelloworld

class：是c语系中另一个关键字“类”。表示一系列的特性（官方说法：属性）和行为方法，有
了它你的程序就可以“另类”，创造与别不同的有你特色的东东噢！在这里，俺就定义了
“idontlikeHelloworld”。注意：这也是c#强制的，对于每一个可执行的程序都必须有。你想干
的事就可以记录在紧跟着你定义的class后面的一对花括号。注意：“{”和“}”一一对应的，
“(”和“)”同样。

4: static void Main() {

Main()是本例子第一个动作（行为方法），干的第一件事。它是属于俺定义的idontlikeHelloworld
类的方法。并且是c#强制的，是程序的真正开始！在紧跟在它后面的“{}”中的语句顺序，就是程序
的运行顺序！本例中只有一行（第六行干嘛用？你可以去掉再编译一次看看），输出一句话。

5: Console.WriteLine("i dont like Hello world");

非常奇怪，Console（再次提醒：注意大小写）不是俺定义的，从何而来？它其实是属于System
namespace 的一个class。WriteLine()是Console类中的一个方法，用来显示一句话（字符串）。
这里只是用了这个方法的1/18！并且是最简单之一！其他的有机会再说。你也可以用
“Console.WriteLine”在“NGWS SDK Documentaion”中搜索“Console.WriteLine”，记住复选
“仅搜索标题”，它会列出19项。好啦，完了！其实，还有“.”没说呢！呵呵...lei si la!!!!
（续前）
“.”被称为分隔符（separator），用来连接名字，如上面的“Console.WriteLine”，就把类和它的
方法连接。通过这种方式，咱们就可以使用现成方法集合。这里再回顾一下俺的例子，看看namespace和
“.”是如何连用的，还有为什么要使用namespace这个关键字。把例子稍微改一下：*/
/* idontlikeHelloworld.cs */
1: //using System;
2: class idontlikeHelloworld
3: {
4: static void Main() {
5: System.Console.WriteLine("i dont like Hello world");
6: System.Console.ReadLine();
7: }
8: }

/* 看见了，当俺注销掉“using System;”后，在第五行和第六行加了“System”。程序的结果不会改
变。但是，很明显的这样比较罗嗦，所以引入了“namespace”。其实，class应该可以完成同样的功能。
不过，设计者可能不想让一个关键字涵盖太多的功能。记得在c向c++发展的时候，引入了“class”，而
不是扩展“struct”关键字的功能；又比如“=”只用于赋值，“==”只用于判断相等。这是c/c++和c#
在语法上其中一个重要的特点。这样设计的好处很多。有机会再聊噢。
如果你没学过c/c++，以下的内容可以跳过。c#与c/c++在语法上还是有区别的，比如：
1。c#根本没有“::”；“->”只在程序中很小的片断中。在c#中应采用“.”。
2。c#无须先声明定义，再使用。与java相同。
3。c#取消了用“＃i nclude”导入其他的程序文本文件，而采用象征性的句柄引入他人的代码。这样一来，
   就排除了编程语言间的障碍，方便地使用其它语言编写的库。如“Console”类可以是c#或者是其他任一种语言编写的。

1。2 自动化的内存管理（Automatic memory management）
手动管理内存需要程序员自行分配和释放内存块。这要求程序员有清晰的头脑和对整个运行过程有十分的
把握（好难！）。而c#把程序员从这难以承担的任务中解放出来。在多数的情况下，这种自动内存管理提
高代码的质量和程序员的生产力。并且，不会对程序的意图和执行产生幅面的影响（？俺可不相信m$的鬼
话）。不过，估计比java的回收站好一点吧。因为c#出道迟嘛（尽胡扯）。好了，来看看例子。*/

using System;
public class Stack
{
private Node first = null;
public bool Empty {
    get {
          return (first == null);
        }
}
public object Pop() {
    if (first == null)
      throw new Exception("Can't Pop from an empty Stack.");
    else {
            object temp = first.Value;
            first = first.Next;
            return temp;
         }
}
public void Push(object o) {
    first = new Node(o, first);
}
class Node
{
    public Node Next;
    public object Value;
    public Node(object value): this(value, null) {}
    public Node(object value, Node next) {
      Next = next;
      Value = value;
    }
}
}

class Test
{
static void Main() {
    Stack s = new Stack();
    for (int i = 0; i < 10; i++)
      s.Push(i);
    while (!s.Empty)
      Console.WriteLine(s.Pop());
}
}
/*
stack类实现了一系列Node的实例。大家可以看看stack类的Push方法。Node的实例就是在Push方法中创建的。
就是“first = new Node(o, first);”。请记住这个“new”噢。它就是用来创建类实例的。相关的语法太
多，遛到后面用一节详细讲。这里只是要了解自动内存管理（Automatic memory management）好处？！“new”
是负责初始化类实例。而在c/c++中释放这些实例要用另一个关键字“delete”。但是在什么时候用delete呢，
这通常是很费神的活，老手也会阴沟里翻船。何况是俺呢！但在c#中有不用了。例子里就没有用“delete”。
当Node的实例不需要时，垃圾收集器（garbage collector）自动销毁它，不用俺操心喽。这点到和java挺
像的（可能是抄的）。

在一个test类里，俺用了一个循环，对stack类的实例的Push方法赋值十次。于是，Push创建了Node的十个实
例（instance）。然后用Pop把它们显示出来。其顺序正好与创建的顺序相反。
这个例子相当的好，是stack
的一个典型，也很好的表述了自动内存管理的机制。但也不好懂，好在这一节不是写给毫无基础的网友看的。
俺自个都花了几分钟看明白，各位大虾更是没问题。

其实，当显示完了“10”以后，就会有一个Node的实例符合被释放的条件，但垃圾收集器并不一定会这样做。
也就是说，它的行为并不确定（这和java一样，俺猜）。有时候，这种行为会带来一些负面影响。起码是性
能降低。自动内存管理本身也是有问题的。因为它很难管理一些特殊情况。有一些关于java的垃圾收集器的
文章也有提到。m$也不会好得了多少。所以，m$有个不安全代码的术语（unsafe code），用来为高级用户服
务。即，用户可以不采用垃圾收集器。但必须用“unsafe”关键字显式声明之。这样就避免了用户不经意以
外使用不安全代码。下面是一个例子：*/

using System;
class Test
{
unsafe static void WriteLocations(byte[] arr) {
    fixed (byte *p_arr = arr) {
      byte *p_elem = p_arr;
      for (int i = 0; i < arr.Length; i++) {
        byte value = *p_elem;
        string addr = int.Format((int) p_elem, "X");
        Console.WriteLine("arr[{0}] at 0x{1} is {2}", i, addr, value);
        p_elem++;
      }
    }
}
static void Main() {
    byte[] arr = new byte[] {1, 2, 3, 4, 5};
    WriteLocations(arr);
}
}
/*
俺对这个例子不是很满意，也让俺有点迷惑，有机会再自己写一个。很简单，只是可以用指针了！万岁！
其实，俺对这一节最没有把握了！有不少地方都不能自圆其说！所以，请各位大虾大力批评。*/

1。3 类型 
c#支持两种基本的类型：一种是值（value types），一种是引用（reference types）。值包括简单类型 
（char、int、和float），枚举（enum）和结构（struct）。引用包括类（class），界面（interface）， 
代表（delegate）和数组阵列（array）。值与引用不同之处在于：值直接存储它的数据内容；而引用存储对象 
的引用。是不是粉费解？！打个比方吧。你在某地买了套别墅（好棒噢）。却从未去过，只知道地址，怎 
么办？你可以坐出租车，司机看了地址就知道怎样走不用你操心。你手里的地址就好像对象的名字，你把 
它写在程序中，就好像把地址给了司机。司机就是你的编译器，它知道该去哪。你豪华的房子就好比那个 
NGWS SDK开发包（82mb噢，够豪华了！俺的m啊--就这样烧喽）。房子里有你想要的东东，比如你想写一句 
话（i dont like Hello world），就好像上面例子，要用到“WriteLine”。于是，你就给出“WriteLine” 
的地址，比如：“Console.WriteLine”。明白？！俺可累了。zzz...  （强打精神）不知道你想到没有， 
值和引用的区别可以引出一个重要特性。值的变量和变量存储的数据是一一对应的，唯一性。而引用则不 
然。引用中不同的变量可以引用同一个对象的实例。当其中一个变量改变实例的值时，其他引用这个实例的 
变量也会受到影响（当然，变量本身并没有改变，即，地址没变）。瞧，变量只是说明存储对象的位置（地 
址），而不是对象本身。就好像你漂亮的房子被烧了，但你的地址并没有改变，但地址对应的房子就没了。 
也许是别人也有这个地址，他去烧了你的房子！好了，在给个例子：*/ 

1: using System; 
2: class CValue 
3: { 
4: public int Value = 0; 
5: } 
6: class Test 
7: { 
8: static void Main() { 
9: int val1 = 0; 
10: int val2 = val1; 
11: val2 = 123; 
12: CValue ref1 = new CValue(); 
13: CValue ref2 = ref1; 
14: ref2.Value = 123; 
15: Console.WriteLine("Values: {0}, {1}", val1, val2); 
16: Console.WriteLine("Refs: {0}, {1}", ref1.Value, ref2.Value); 
17: } 
18: } 

/* 下面是输出的结果： 
Values: 0, 123 
Refs: 123, 123 

啊哈，应该粉清楚了吧。变量val1和变量val2互不影响,它们各自有自己的存储空间。而ref2复制 
了ref1，所以，它们引用了同一个对象的实例。当改变它们其中一个的时候，就会影响到另一个的 
值。

1。5 数组类型（Array types） 

数组可以是一维的，也可是多维的。数祖的成员可以是整齐的，也可以是变长（jagged）的。 

一维的数组是最普通，最简单的。这里值给出一个例子，就不多解释了。*/ 
using System; 
class Test 
{ 
 static void Main() { 
  int[] arr = new int[5]; 
  for (int i = 0; i < arr.Length; i++) 
   arr[i] = i * i; 
  for (int i = 0; i < arr.Length; i++) 
   Console.WriteLine("arr[{0}] = {1}", i, arr[i]); 
 } 
} 

/* 结果如下： 
arr[0] = 0 
arr[1] = 1 
arr[2] = 4 
arr[3] = 9 
arr[4] = 16 

我们还可以比较的看看多维，规则，变长的数组的定义和赋值：*/ 
class Test 
{ 
 static void Main() { 
  int[] a1 = new int[] {1, 2, 3};                     //一维 
  int[,] a2 = new int[,] {{1, 2, 3}, {4, 5, 6}};      //二维 
  int[,,] a3 = new int[10, 20, 30];                   //三维 
  int[][] j2 = new int[3][];                          //变长 
  j2[0] = new int[] {1, 2, 3}; 
  j2[1] = new int[] {1, 2, 3, 4, 5, 6}; 
  j2[2] = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9}; 
 } 
} 
/* 
上面的例子给出了各种样式的数组。变量a1、a2和a3是规则数组。j2则是变长的数组。 
规则数组很容易就可以计算出它们的长度。比如a3的长度是：10*20*30=6000。相反，变长 
数组就有点不同，它的每一个维度都必须单独定义。如j2的第一维度是3，第二个是6，第 
三个是9，所以总长度是：1*3+1*6+1*9=18。 

上面对数组的赋值是严谨的风格，在某种情况下，我们可以简化写法，但我总觉得这种简化 
应用限制太多，容易出错。在这里就不作介绍了。这里再给一个例子说明函数中的参数如何 
赋值*/ 
class Test 
{ 
 static void F(long[] arr) {} 
 static void Main() { 
  F(new longt[] {1, 2, 3}); 
 } 
}

赶出一编！请指正！ 
1。6 统一系统类型（Type system unification） 
c#独创了一种类型——统一系统类型（为了这个累刑，我头疼死了。谁有更好的名字，请务必告诉 
我）。总之，所有的其他类型，包括值和引用，都可以被当作统一系统类型来对待。从概念上说， 
所有的类型都从它派生。这样，其他的类型就可以使用统一系统类型的属性和方法。包括一些“简 
单”类型，如：int。还是给个例子吧：*/ 
using System; 
class Test 
{ 
  static void Main() { 
    Console.WriteLine(3.ToString()); 
  } 
} 
/*“3.ToString()”调用了object的“ToString()”方法。相信学过c/c++的朋友都知道要输出一个 
数字有多麻烦，现在就省事了。再看一个：*/ 
class Test 
{ 
  static void Main() { 
    int i = 123; 
    object o = i;    // boxing 
    int j = (int) o;  // unboxing 
  } 
} 
/* 这个像帽子戏法的例子中，从“int”转换成“object”，又转换回来。这样一来，在值和引用 
之间就架起了一座桥梁。这样有什么用呢。即兴举一个常见的例子...就min把。在c/c++中：*/ 
// c/c++ code 

void min(int i, int j) 
{ 
  return ((i < j) ? i : j); 
} 

/* 如果比较的不是int，或者说可能是int，也可能是float、double呢？可以这样：*/ 

template 
T min (T i, T j) 
{ 
  return ((i < j) ? i : j) 
} 

/* 用c#可以：*/ 
void swap (object a, object b) 
{ 
  return ((i < j) ? i : j); 
} 

/* 我想大家一定看出来第二个例子要比较一个int和一个float的话，还需要一些转换，而第三个 
例子就可以比较所有的变量！这个灵活度简直太大了。所以，我私以为，大家使用时一定要小心！ 
它在比较一个int和一个class的时候决不会报错的。呵呵，我发现我的翻译总是越跑越远，总是 
扣不住原文。篡改甚多，敬请原谅！

1。7 语句（Statements） 

c#借用了c/c++大多数的语句方法，不过仍然有些值得注意的地方。还有些地方是有所改动的。 
在这里，我只提一些c#特有的东东。 

1。7。10 “foreach”语句 
“foreach”语句列举一个集合内的所有元素，并对这些元素执行一系列的操作。还是看看例子吧：*/ 

using System; 
using System.Collections; 
class Test 
{ 
  static void WriteList(ArrayList list) { 
    foreach (object o in list) 
    { 
      int i = (int) o;//如果是for语句，这里一定会报错！ 
      Console.WriteLine(0); 
      Console.WriteLine(++i); 
    } 
  } 
  static void Main() { 
    ArrayList list = new ArrayList(); 
    for (int i = 0; i < 10; i++) 
      list.Add(i); 
    WriteList(list); 
  } 
} 
/*这个例子用“foreach”扫描了整个“list”，并把“list”中所有的元素打印出来。有时候还是 
挺方便的。 

1。7。15 安全检查开关（The checked and unchecked statements） 
“checked”和“unchecked”语句用来控制数学运算和完整类型转换的检查工作。“checked”检查它 
作用的域中可能出现的违例，并抛出一个异常；而“unchecked”则阻止所有的检查。举个例子：*/ 

using System; 
class Test 
{ 
   static int x = 1000000; 
   static int y = 1000000; 
   static int F() { 
      checked {return (x * y);}     // 抛出 OverflowException 
   } 
   static int G() { 
      unchecked {return (x * y);}   // 返回 -727379968 
   } 
   static int H() { 
      return x * y;              // 缺省状态。 
   } 
   static void Main() { 
     F();                        //可以注销掉此行试试。 
     Console.WriteLine(G()); 
     Console.WriteLine(H()); 
   } 
} 

/* 
在编译过程中不会有任何错误出现。因为“checked”和“unchecked”只在运行时才起作用。值得一说的是 
H()。它的缺省状态和编译器当前的缺省溢出检查的状态有关。但返回的结果肯定和F()或G()中的任一个相同。 
再看一个例子：*/ 

using System; 
class Test 
{ 
   const int x = 1000000; 
   const int y = 1000000; 
   static int F() { 
      checked {return (x * y);}    // 编译器警告（Compile warning）：溢出（overflow） 
   } 
   static int G() { 
      unchecked {return (x * y);}  // 返回 -727379968 
   } 
   static int H() { 
      return x * y;                // 编译器警告（Compile warning）：溢出（overflow） 
   } 
   static void Main() { 
     Console.WriteLine(F());       //可以注销掉此行试试。 
     Console.WriteLine(G()); 
     Console.WriteLine(H());       //可以注销掉此行试试。 
   } 
} 

/* 当F()和H()求值的时候，就会引起一个编译警告。而在G()中，因为有了“unchecked”，屏蔽了这个警 
告。要注意的是“checked”和“unchecked”都不能对函数的返回值进行操作！比如：*/ 
class Test 
{ 
   static int Multiply(int x, int y) { 
      return x * y; 
   } 
   static int F() { 
      checked{ return Multiply(1000000, 1000000); } // 与 return Multiply(1000000, 1000000); 
   }                                                // 有相同的效果。 
} 
/* 其实大家稍微想一下知道为什么m$没有这么做！对这个内容的讨论超出本文的范围和俺的能力之外哦。 

在c#中，所有的十六进制数都是uint。如果用强制类型转换会引起编译器报错。用“unchecked”则可以 
跳过这个机制，把uint的十六进制数转化为int。如：*/ 

class Test 
{ 
   public const int AllBits = unchecked((int)0xFFFFFFFF); 
   public const int HighBit = unchecked((int)0x80000000); 
} 

/* 上例所有的常数都是uint，而且超过了int的范围，没有“unchecked”，这种转换会引发一个编译器错 
误。注意：上面用的是“unchecked”操作符。不是语句。不过它们之间除了一个用“()”，另一个用 
“{}”以外，几乎一样。BTW，“checked”同样。 

1。7。16 “lock”语句（The lock statement） 
“lock”获得一个相互排斥的对象锁定。（俺查过一些资料，但都没有清晰说明，暂不介绍）

苦笑枯 2007-01-19 00:14 发表评论

文章来源:http://www.blogjava.net/kuxiaoku/articles/94806.html

苦笑枯 2007-01-19 00:14 发表评论

C#实时申请技术（作者： crystal编译出处： yesky）

苦笑枯 — Thu, 18 Jan 2007 16:13:00 GMT

Real time Application 实时申请技术在本文里是作为一个实例来演示在用户（Tcpclient）申请与服务器（TcpServer）申请之间使用Socket类的情况。该项目同样也演示在实时项目中如何使用listview控制以及如何传递XML格式信息。

　　TcpServer.exe 文件显示了在单独的thread当中（而不是在 GUI 线程之中）TCP socket的相互通讯。

　　TcpClient.exe文件同样也使用一条单独的线程从Socket中读取数据，然后对表单中的list view 控件进行更新。

　　步聚如下：

　　1．TcpServer 监听端口8002，并且发射线程等待客户端连结。

Hashtable socketHolder = new Hashtable();

Hashtable threadHolder = new Hashtable();

public Form1()

{

　// Required for Windows Form Designer support

　//

　InitializeComponent();

　tcpLsn = new TcpListener(8002);

　tcpLsn.Start();

　// tcpLsn.LocalEndpoint may have a bug, it only show 0.0.0.0:8002

　stpanel.Text = "Listen at: " + tcpLsn.LocalEndpoint. ToString ();

　Thread tcpThd = new Thread(new ThreadStart(WaitingForClient));

　threadHolder. Add (connectId, tcpThd);

　tcpThd.Start() ;

}

　2. TcpClient与TcpSrv连接上后，发送客户端信息数据包至TcpServer，然后发射线程，该线程是用来接收通过Socket传来的数据。

private void menuConn_Click(object sender, System.EventArgs e)

{
　ConnectDlg myDlg = new ConnectDlg();

　myDlg.ShowDialog(this);

　if( myDlg.DialogResult==DialogResult.OK)

　{

　　s = new Socket(AddressFamily.InterNetwork, SocketType.Stream,ProtocolType.Tcp );

　　IPAddress hostadd = IPAddress.Parse(myDlg.IpAdd);

　　int port=Int32.Parse(myDlg.PortNum);

　　IPEndPoint EPhost = new IPEndPoint(hostadd, port);

　　Try

　　{

　　　s.Connect(EPhost);

　　　if (s.Connected)

　　　{

　　　　Byte[] bBuf;

　　　　string buf;

　　　　buf = String.Format("{0}:{1}", myDlg.UserName,myDlg.PassWord);

　　　　bBuf=ASCII.GetBytes(buf);

　　　　s.Send(bBuf, 0 , bBuf.Length,0);

　　　　t = new Thread(new ThreadStart(StartRecieve));

　　　　t.Start();

　　　　sbar.Text="Ready to recieve data";

　　　}

　　}

　　catch (Exception e1)

　　{

　　　MessageBox.Show(e1.ToString());

　　}

　}

}

private void StartRecieve()

{

　miv = new MethodInvoker(this.UpdateListView);

　int cnt=0;

　string tmp=null;

　Byte[] firstb= new Byte[1];

　while (true)

　{

　　try

　　{

　　　Byte[] receive = new Byte[1];

　　　int ret = s.Receive(receive, 1, 0);

　　　if (ret > 0)

　　　{

　　　　switch(receive[0])

　　　　{

　　　　　case 11: //check start message

　　　　　　　cnt=0;

　　　　　　　break;

　　　　　case 10: // check end message

　　　　　　　cnt=0;

　　　　　　　if(firstb[0] == ':')

　　　　　　　　HandleCommand(tmp);

　　　　　　　else if(firstb[0] == '<')

　　　　　　　　HandleXml(tmp);

　　　　　　　else

　　　　　　　　HandleText(tmp);

　　　　　　　　tmp=null;

　　　　　　　　break;

　　　　　　　default:

　　　　　　　　if (cnt == 0)

　　　　　　　　　firstb[0] = receive[0];

　　　　　　　　　tmp += System.Text.Encoding

　　　　　　　　　.ASCII.GetString(receive);

　　　　　　　　　cnt++;

　　　　　　　　　break;

　　　　　　　　}

　　　　　　　}

　　　　}

　　　　catch (Exception e)

　　　　{

　　　　　if( !s.Connected )

　　　　　　{

　　　　　　　break;

　　　　　　}

　　　　　}

　　　}

　　　t.Abort();

　　}

　3.TcpServer接收来自TcpClient的连接请求，并且将socket 实例保存到Hash表中，然后发射线程以便控制socket的通讯，同时将客户端信息在listview 控件中显示出来。

public void WaitingForClient()

{

　while(true)

　{

　　// Accept will block until someone connects

　　Socket sckt = tcpLsn.AcceptSocket();

　　if (connectId < 10000)

　　　Interlocked.Increment(ref connectId);

　　Else

　　　connectId = 1;

　　　if (socketHolder.Count < MaxConnected )
　
　　　{

　　　　while (socketHolder.Contains(connectId) )

　　　　{

　　　　　Interlocked.Increment(ref connectId);

　　　　}

　　　Thread td = new Thread(new ThreadStart(ReadSocket));

　　　lock(this)

　　　{

　　　　// it is used to keep connected Sockets

　　　　socketHolder.Add(connectId, sckt);

　　　　// it is used to keep the active thread

　　　　threadHolder.Add(connectId, td);

　　　}

　　　td.Start();

　　}

　}

}

// follow function handle the communication from the clients and close the

// socket and the thread when the socket connection is down

public void ReadSocket()

{

　// the connectId is keeping changed with new connection added. it can't

　// be used to keep the real connectId, the local variable realId will

　// keep the value when the thread started.

　long realId = connectId;

　int ind=-1;

　Socket s = (Socket)socketHolder[realId];

　while (true)

　{

　　if(s.Connected)

　　{

　　　Byte[] receive = new Byte[37] ;

　　　Try

　　　{

　　　　// Receive will block until data coming

　　　　// ret is 0 or Exception happen when Socket connection

　　　　// is broken

　　　　int ret=s.Receive(receive,receive.Length,0);

　　　　if (ret > 0)

　　　　{

　　　　　string tmp = null;

　　　　　tmp=System.Text.Encoding.ASCII.GetString(receive);

　　　　　if(tmp.Length > 0)

　　　　　{

　　　　　　DateTime now1=DateTime.Now;

　　　　　　String strDate;

　　　　　　strDate = now1.ToShortDateString() + " " + now1.ToLongTimeString();

　　　　　　ListViewItem newItem = new ListViewItem();

　　　　　　string[] strArry=tmp.Split(':');

　　　　　　int code = checkUserInfo(strArry[0]);

　　　　　　if(code==2)

　　　　　　{

　　　　　　　userHolder.Add(realId, strArry[0]);

　　　　　　　newItem.SubItems.Add(strArry[0]);

　　　　　　　newItem.ImageIndex = 0;

　　　　　　　newItem.SubItems.Add(strDate);

　　　　　　　this.listView2.Items.Add(newItem);

　　　　　　　ind=this.listView2.Items.IndexOf(newItem);

　　　　　　}

　　　　　　else if( code==1)

　　　　 }

　　　}

　　　else

　　　{

　　　　this.listView2.Items[ind].ImageIndex=1;

　　　　keepUser=false;

　　　　break;

　　　}

　　}

　　catch (Exception e)

　　{

　　　if( !s.Connected )

　　　{

　　　　this.listView2.Items[ind].ImageIndex=1;

　　　　keepUser=false;

　　　　break;

　　　}

　　}

　}

　}
　
　CloseTheThread(realId);

}

private void CloseTheThread(long realId)

{

　socketHolder.Remove(realId);

　if(!keepUser) userHolder.Remove(realId);

　　lock(this)

　　{

　　　Thread thd = (Thread)threadHolder[realId];

　　　threadHolder.Remove(realId);

　　}

　　thd.Abort();

　}

4. 点击Load Data菜单，从文件中载入信息，然后把所有信息传送到每个将与TcpServer相连接的客户端，客户端会自己更新它的listview。不管是 TcpServer 还是 TcpClient ，它们都从运作中的线程之中获取数据，再在主线程中更新Listview control。下面则讲述的是通过MethodInvoker实现该功能。

public void LoadThread()

{

MethodInvoker mi = new MethodInvoker(this.UpdateListView);

string tmp = null;

StreamReader sr = File.OpenText("Issue.txt");

while((tmp = sr.ReadLine()) !=null )

{

if (tmp =="")

break;

isu.symbol= Mid(tmp, 0, 4);

isu.bid = Mid(tmp, 4, 5);

isu.offer = Mid(tmp, 9, 5);

isu.volume = Mid(tmp, 16, tmp.Length-16);

sendMsg ="\v" + tmp + "\n"; //add send message's head and end char

SendDataToAllClient(tmp);

this.BeginInvoke(mi);

JobDone.WaitOne();

}

sr.Close();

fThd.Abort();

}

private void SendDataToAllClient(string str)

{

foreach (Socket s in socketHolder.Values)

{

if(s.Connected)

{

Byte[] byteDateLine=ASCII.GetBytes(str.ToCharArray());

s.Send(byteDateLine, byteDateLine.Length, 0);

}

}

}

　　以下代码操纵XML文件，并且为客户端生成XML文件。

public void LoadXmlThread()

{

MethodInvoker miv = new MethodInvoker(this.UpdateListView);

string tmp = null;

string xmlString = null;

int recordFlg = -1;

int textCount =0;

xmlString = "\v"+"";

XmlTextReader tr = new XmlTextReader("issue.xml");

while(tr.Read())

{

switch (tr.NodeType)

{

case XmlNodeType.Element:

if (tr.Name == "Issue")

{

recordFlg++;

if(recordFlg > 0)

{

textCount=0;

xmlString += CreateXmlElement(

tr.Name, 2);

xmlString += "\n";

SendDataToAllClient(xmlString);

xmlString = "\v"+"
version='1.0'?>";

this.BeginInvoke(miv);

JobDone.WaitOne();

}

}

if (recordFlg >= 0)

{

xmlString += CreateXmlElement(

tr.Name, 1);

tmp = tr.Name;

}

break;

case XmlNodeType.Text:

switch(++textCount)

{

case 1:

isu.symbol=tr.Value;

break;

case 2:

isu.bid=tr.Value;

break;

case 3:

isu.offer=tr.Value;

break;

case 4:

isu.volume=tr.Value;

break;

}

xmlString += tr.Value;

xmlString += CreateXmlElement(tmp, 2);

break;

}

}

fThd.Abort();

}

string CreateXmlElement(string elem, int ord)

{

string tmp = null;

if (ord == 1)

tmp = String.Format("<{0}>", elem);

else

tmp = String.Format("", elem);

return tmp;

}

以下功能演示的是如何设置TcpClient中Listview控件的 BackColor和 Forecolor属性。
private void UpdateListView()

{

int ind=-1;

for (int i=0; i < this.listView1.Items.Count;i++)

{

if (this.listView1.Items[i].Text == isu.symbol.ToString())

{

ind=i;

break;

}

}

if (ind == -1)

{

ListViewItem newItem new ListViewItem(isu.symbol.ToString());

newItem.SubItems.Add(isu.bid);

newItem.SubItems.Add(isu.offer);

newItem.SubItems.Add(isu.volume);

this.listView1.Items.Add(newItem);

int i=this.listView1.Items.IndexOf(newItem);

setRowColor(i, System.Drawing.Color.FromA#ffffaf);

setColColorHL(i, 0, System.Drawing.Color.FromA#800000);

setColColorHL(i, 1, System.Drawing.Color.FromA#800000);

this.listView1.Update();

Thread.Sleep(300);

setColColor(i, 0, System.Drawing.Color.FromA#ffffaf);

setColColor(i, 1, System.Drawing.Color.FromA#ffffaf);

}

else

{

this.listView1.Items[ind].Text = isu.symbol.ToString();

this.listView1.Items[ind].SubItems[1].Text = (isu.bid);

this.listView1.Items[ind].SubItems[2].Text = (isu.offer);

this.listView1.Items[ind].SubItems[3].Text = (isu.volume);

setColColorHL(ind, 0, System.Drawing.Color.FromA#800000);

setColColorHL(ind, 1, System.Drawing.Color.FromA#800000);

this.listView1.Update();

Thread.Sleep(300);

setColColor(ind, 0, System.Drawing.Color.FromA#ffffaf);

setColColor(ind, 1, System.Drawing.Color.FromA#ffffaf);

}

JobDone.Set();

}

private void setRowColor(int rowNum, Color colr )

{

for (int i=0; i < this.listView1.Items[rowNum].SubItems.Count;i++)

if (rowNum%2 !=0)

this.listView1.Items[rowNum].SubItems[i].BackColor = colr;

}

private void setColColor(int rowNum, int colNum, Color colr )

{

if (rowNum%2 !=0)

this.listView1.Items[rowNum].SubItems[colNum].BackColor=colr;

else

this.listView1.Items[rowNum].SubItems[colNum].BackColor =

System.Drawing.Color.FromA#f8f8f8;

if (colNum==0)

{

this.listView1.Items[rowNum].SubItems[colNum].ForeColor =

System.Drawing.Color.FromA#800040;

this.listView1.Items[rowNum].SubItems[colNum].BackColor =

System.Drawing.Color.FromA#c5c5b6;

}

else

this.listView1.Items[rowNum].SubItems[colNum].ForeColor =

System.Drawing.Color.FromA#141414;

}

private void setColColorHL(int rowNum, int colNum, Color colr )

{

this.listView1.Items[rowNum].SubItems[colNum].BackColor = colr;

this.listView1.Items[rowNum].SubItems[colNum].ForeColor =

System.Drawing.Color.FromA#ffffff;

}

　　运行该例子的步骤

　　1. 在A机上运行TcpServer.exe文件。

　　2. 在A机或B机上运行一次或多次TcpClient.exe文件。

　　3. 在TcpClient端，点击菜单连接，进入TcpServer正在运行中的服务器端。在编辑栏键入用户名及口令，点击确认。

　　4. 当在TcpServer顶部的istview上瞧见客户端的提示时，则在TcpServer,上点击Load Data菜单，然后实时数据则会出现在TcpServer 和TcpClien上。

　　注意：请确认Data file, Issue.txt and Issue.xml等文件总是处于同一根目录下，正如TcpSvr.exe 和 MaskedTextBox.dll， WTcpClient.exe.是处于同一目录下一样。

　　Update at 10/20/2001.

　　当添加/删除项目时，请锁住Hash表，这样可以确保线程的安全。

　　添加功能，以便生成和处理XML格式文件。

　　在发送讯息至客户端时，请在服务器端添加发送讯息起始和结尾的字符。

　　上述方法可以增加客户端的稳定性。

苦笑枯 2007-01-19 00:13 发表评论

文章来源:http://www.blogjava.net/kuxiaoku/articles/94803.html

苦笑枯 2007-01-19 00:13 发表评论

C#：消息队列应用程序〔作者： Carl Nolan 出处： microsoft〕

苦笑枯 — Thu, 18 Jan 2007 16:13:00 GMT

　简介

Microsoft 近期推出了一种用于生成集成应用程序的新平台——Microsoft .NET 框架。.NET 框架允许开发人员使用任何编程语言迅速生成和部署 Web 服务和应用程序。Microsoft Intermediate Language (MSIL) 和实时 (JIT) 编译器使这种不依赖语言的框架得以实现。

　　与 .NET 框架同时面世的还有一种新的编程语言 C#（读作“C sharp”）。C# 是一种简单、新颖、面向对象和类型安全的编程语言。利用 .NET 框架和 C#（除 Microsoft? Visual Basic? 和 Managed C++ 之外），用户可以编写功能强大的 Microsoft Windows? 和 Web 应用程序及服务。本文提供了这样的一个解决方案，它的重点是 .NET 框架和 C# 而不是编程语言。C# 语言的介绍可以在“ C# 简介和概述（英文）”找到。

　　近期的文章“MSMQ：可伸缩、高可用性的负载平衡解决方案（英文）”介绍了一种解决方案，用于高可用性消息队列 (MSMQ) 的可伸缩负载平衡解决方案体系结构。此解决方案中涉及了一种将 Windows 服务用作智能消息路由器的开发方案。这样的解决方案以前只有 Microsoft Visual C++? 程序员才能实现，而 .NET 框架的出现改变了这种情况。从下面的解决方案中，您可以看到这一点。

　　.NET 框架应用程序

　　这里介绍的解决方案是一种用来处理若干消息队列的 Windows 服务；其中每个队列都是由多个线程进行处理（接收和处理消息）。处理程序使用循环法技术或应用程序特定值（消息 AppSpecific 属性）从目的队列列表中路由消息，并使用消息属性来调用组件方法。（示例进程也属于这种情况。）在后一种情况下，组件的要求是它能够实现给定的接口 IWebMessage。要处理错误，应用程序需要将不能处理的消息发送到错误队列中。

　　消息应用程序的结构与以前的活动模板库 (ATL) 应用程序相似，它们之间的主要不同在于用于管理服务的代码的封装和 .NET 框架组件的使用。要创建 Windows 服务，.NET 框架用户仅仅需要创建一个从 ServiceBase（来自 System.ServiceControl 程序集）继承的类。这毫不奇怪，因为 .NET 框架是面向对象的。
　应用程序结构

应用程序中主要的类是 ServiceControl，它是从 ServiceBase 继承的。因而，它必须实现 OnStart 和 OnStop 方法，以及可选的 OnPause 和 OnContinue 方法。事实上，类是在静态方法 Main 内构造的：

using System;
using System.ServiceProcess;

public class ServiceControl: ServiceBase
{
　// 创建服务对象的主入口点
　public static void Main()
　{
　　ServiceBase.Run(new ServiceControl());
　}

　// 定义服务参数的构造对象
　public ServiceControl()
　{
　　CanPauseAndContinue = true;
　　ServiceName = "MSDNMessageService";
　　AutoLog = false;
　}

　protected override void OnStart(string[] args) {...}
　protected override void OnStop() {...}
　protected override void OnPause() {...}
　protected override void OnContinue() {...}
}

ServiceControl 类创建一系列 CWorker 对象，即，为需要处理的每个消息队列创建 CWorker 类的一个实例。根据定义中处理队列所需的线程数目，CWorker 类依次创建了一系列的 CWorkerThread 对象。CWorkerThread 类创建的一个处理线程将执行实际的服务工作。

　　使用 CWorker 和 CWorkerThread 类的主要目的是确认服务控件 Start、Stop、Pause 和 Continue 命令。因为这些进程必须是无阻塞的，命令操作最终将在后台处理线程上执行。

CWorkerThread 是一个抽象类，被 CWorkerThreadAppSpecific 、CWorkerThreadRoundRobin 和 CWorkerThreadAssembly 继承。这些类以不同的方式处理消息。前两个类通过给另一队列发送消息来处理消息（其不同之处在于确定接收队列路径的方式），最后一个类则使用消息属性来调用组件方法。

　　.NET 框架内部的错误处理是以基类 Exception 为基础的。当系统引发或捕获错误时，这些错误必须是从 Exception 中导出的类。CWorkerThreadException 类就是这样一种实现，它通过附加额外属性（用于定义服务是否应继续运行）来扩展基类。

　　最后，应用程序包含两种结构。这些值类型定义了辅助进程或线程的运行时参数，以简化 CWorker 和 CWorkerThread 对象的结构。使用值类型结构（而不是引用类型类）能够确保这些运行时参数维护的是数值（而不是引用）。
　IWebMessage 接口

　　CWorkerThread 的实现之一是一个调用组件方法的类。这个名为 CWorkerThreadAssembly 的类使用 IWebMessage 接口来定义服务和组件之间的约定。

　　与当前版本的 Microsoft Visual Studio? 不同，C# 接口可以在任何语言中显式定义，而不需要创建和编译 IDL 文件。C# IWebMessage 接口的定义如下：

public interface IWebMessage
{
　WebMessageReturn Process(string sMessageLabel, string sMessageBody, int iAppSpecific);
　void Release();
}

　　ATL 代码中的 Process 方法是为处理消息而指定的。Process 方法的返回代码定义为枚举类型 WebMessageReturn：

public enum WebMessageReturn
{
　ReturnGood,
　ReturnBad,
　ReturnAbort
}

枚举的定义如下：Good 表示继续处理，Bad 表示将消息写入错误队列，Abort 表示终止处理。Release 方法为服务提供了轻松清除类实例的途径。因为仅在垃圾回收的过程中才调用类实例的析构函数，所以确保所有占用昂贵资源（例如数据库连接）的类都有一个能够在析构之前被调用的方法，用来释放这些资源，这是一种非常好的构思。

　　名称空间

在这里先简单介绍一下名称空间。名称空间允许在内部和外部表示中将应用程序组织成为逻辑元素。服务内的所有代码都包含在 MSDNMessageService.Service 名称空间内。尽管服务代码包含在若干文件中，但是由于它们包含在同一名称空间中，因此用户不需要引用其他文件。

　　由于 IWebMessage 接口包含在 MSDNMessageService.Interface 名称空间中，因此使用此接口的线程类具有一个接口名称空间。

　　服务类

　　应用程序的目的是监视和处理消息队列，每一队列在收到消息时都执行不同的进程。应用程序是作为 Windows 服务来实现的。
　ServiceBase 类

如前所述，服务的基本结构是从 ServiceBase 继承的类。重要的方法包括 OnStart、OnStop、OnPause 和 OnContinue，每一个替代方法都与一个服务控制操作直接对应。OnStart 方法的目的是创建 CWorker 对象，而 CWorker 类又创建 CWorkerThread 对象，然后在该对象中创建执行服务工作的线程。

　　服务的运行时配置（以及 CWorker 和 CWorkerThread 对象的属性）是在基于 XML 的配置文件中维护的。它的名称与创建的 .exe 文件相同，但带有一个 .cfg 后缀。配置示例如下：

＜?xml version="1.0"?＞
＜configuration＞
＜ProcessList＞
　＜ProcessDefinition
　　　　ProcessName="Worker1"
　　　　ProcessDesc="Message Worker with 2 Threads"
　　　　ProcessType="AppSpecific"
　　　　ProcessThreads="2"
　　　　InputQueue=".\private$\test_load1"
　　　　ErrorQueue=".\private$\test_error"＞
　　＜OutputList＞
　　　＜OutputDefinition OutputName=".\private$\test_out11" /＞
　　　＜OutputDefinition OutputName=".\private$\test_out12" /＞
　　＜/OutputList＞
　＜/ProcessDefinition＞
　＜ProcessDefinition
　　　　ProcessName="Worker2"
　　　　ProcessDesc="Assembly Worker with 1 Thread"
　　　　ProcessType="Assembly"
　　　　ProcessThreads="1"
　　　　InputQueue=".\private$\test_load2"
　　　　ErrorQueue=".\private$\test_error"＞
　　＜OutputList＞
　　　＜OutputDefinition OutputName="C:\MSDNMessageService\MessageExample.dll" /＞
　　　＜OutputDefinition OutputName="MSDNMessageService.MessageSample.ExampleClass"/＞
　　＜/OutputList＞
　＜/ProcessDefinition＞
＜/ProcessList＞
＜/configuration＞

对此信息的访问通过来自 System.Configuration 程序集的 ConfigManager 类来管理。静态 Get 方法返回信息的集合，这些集合将被枚举以获得单个属性。这些属性集的设置决定了辅助对象的运行时特征。除了这一配置文件，您还应该创建定义 XML 文件结构的图元文件，并在其中引用位于服务器 machine.cfg 配置文件中的图元文件：

＜?xml version ="1.0"?＞
＜MetaData xmlns="x-schema:CatMeta.xms"＞
　＜DatabaseMeta InternalName="MessageService"＞
　＜ServerWiring Interceptor="Core_XMLInterceptor"/＞
　＜Collection
　　　InternalName="Process" PublicName="ProcessList"
　　　PublicRowName="ProcessDefinition"
　　　SchemaGeneratorFlags="EMITXMLSCHEMA"＞
　　＜Property InternalName="ProcessName" Type="String" MetaFlags="PRIMARYKEY" /＞
　　＜Property InternalName="ProcessDesc" Type="String" /＞
　　＜Property InternalName="ProcessType" Type="Int32" DefaultValue="RoundRobin" ＞
　　　＜Enum InternalName="RoundRobin" Value="0"/＞
　　　＜Enum InternalName="AppSpecific" Value="1"/＞
　　　＜Enum InternalName="Assembly" Value="2"/＞
　　＜/Property＞
　　＜Property InternalName="ProcessThreads" Type="Int32" DefaultValue="1" /＞
　　＜Property InternalName="InputQueue" Type="String" /＞
　　＜Property InternalName="ErrorQueue" Type="String" /＞
　　＜Property InternalName="OutputName" Type="String" /＞
　　＜QueryMeta InternalName="All" MetaFlags="ALL" /＞
　　＜QueryMeta InternalName="QueryByFile" CellName="__FILE" Operator="EQUAL" /＞
　＜/Collection＞
　＜Collection
　　　InternalName="Output" PublicName="OutputList"
　　　PublicRowName="OutputDefinition"
　　　SchemaGeneratorFlags="EMITXMLSCHEMA"＞
　　＜Property InternalName="ProcessName" Type="String" MetaFlags="PRIMARYKEY" /＞
　　＜Property InternalName="OutputName" Type="String" MetaFlags="PRIMARYKEY" /＞
　　　＜QueryMeta InternalName="All" MetaFlags="ALL" /＞
　　　＜QueryMeta InternalName="QueryByFile" CellName="__FILE" Operator="EQUAL" /＞
　　＜/Collection＞
　＜/DatabaseMeta＞
　＜RelationMeta
　　　PrimaryTable="Process" PrimaryColumns="ProcessName"
　　　ForeignTable="Output" ForeignColumns="ProcessName"
　　　MetaFlags="USECONTAINMENT"/＞
＜/MetaData＞

由于 Service 类必须维护一个已创建辅助对象的列表，因此使用了 Hashtable 集合，用于保持类型对象的名称/数值对列表。Hashtable 不仅支持枚举，还允许通过关键字来查询值。在应用程序中，XML 进程名称是唯一的关键字：

private Hashtable htWorkers = new Hashtable();
IConfigCollection cWorkers = ConfigManager.Get("ProcessList", new AppDomainSelector());
foreach (IConfigItem ciWorker in cWorkers)
{
　WorkerFormatter sfWorker = new WorkerFormatter();
　sfWorker.ProcessName = (string)ciWorker["ProcessName"];
　sfWorker.ProcessDesc = (string)ciWorker["ProcessDesc"];
　sfWorker.NumberThreads = (int)ciWorker["ProcessThreads"];
　sfWorker.InputQueue = (string)ciWorker["InputQueue"];
　sfWorker.ErrorQueue = (string)ciWorker["ErrorQueue"];
　// 计算并定义进程类型
　switch ((int)ciWorker["ProcessType"])
　{
　　case 0:
　　　sfWorker.ProcessType = WorkerFormatter.SFProcessType.ProcessRoundRobin;
　　　break;
　　case 1:
　　　sfWorker.ProcessType = WorkerFormatter.SFProcessType.ProcessAppSpecific;
　　　break;
　　case 2:
　　　sfWorker.ProcessType = WorkerFormatter.SFProcessType.ProcessAssembly;
　　　break;
　　default:
　　throw new Exception("Unknown Processing Type");
　}
　// 执行更多的工作以读取输出信息
　string sProcessName = (string)ciWorker["ProcessName"];
　if (htWorkers.ContainsKey(sProcessName))
　　throw new ArgumentException("Process Name Must be Unique: " + sProcessName);
　　htWorkers.Add(sProcessName, new CWorker(sfWorker));
}

　　在这段代码中没有包含的主要信息是输出数据的获取。每一个进程定义中都有一组相应的输出定义项。该信息是通过如下的简单查询读取的：

string sQuery = "SELECT * FROM OutputList WHERE ProcessName=" +
sfWorker.ProcessName + " AND Selector=appdomain://";
ConfigQuery qQuery = new ConfigQuery(sQuery);
IConfigCollection cOutputs = ConfigManager.Get("OutputList", qQuery);
int iSize = cOutputs.Count, iLoop = 0;
sfWorker.OutputName = new string[iSize];
foreach (IConfigItem ciOutput in cOutputs)
sfWorker.OutputName[iLoop++] = (string)ciOutput["OutputName"];

　　CWorkerThread 和 Cworker 类都有相应的服务控制方法，根据服务控制操作进行调用。由于 Hashtable 中引用了每一个 CWorker 对象，因此需要枚举 Hashtable 的内容，以调用适当的服务控制方法：

foreach (CWorker cWorker in htWorkers.Values)
　cWorker.Start();

　　类似地，实现的 OnPause、OnContinue 和 OnStop 方法是通过调用 CWorker 对象上的相应方法来执行操作的。
　CWorker 类

CWorker 类的主要功能是创建和管理 CWorkerThread 对象。Start、Stop、Pause 和 Continue 方法调用相应的 CWorkerThread 方法。实际的 CWorkerThread 对象是在Start 方法中创建的。与使用 Hashtable 管理辅助对象引用的 Service 类相似，CWorker 使用 ArrayList（简单的动态数组）来维护线程对象的列表。

　　在这个数组内部，CWorker 类创建了 CWorkerThread 类的一个实现版本。CWorkerThread 类（将在下面讨论）是一个必须继承的抽象类。导出类定义了消息的处理方式：

aThreads = new ArrayList();
for (int idx=0; idx＜sfWorker.NumberThreads; idx++)
{
　WorkerThreadFormatter wfThread = new WorkerThreadFormatter();
　wfThread.ProcessName = sfWorker.ProcessName;
　wfThread.ProcessDesc = sfWorker.ProcessDesc;
　wfThread.ThreadNumber = idx;
　wfThread.InputQueue = sfWorker.InputQueue;
　wfThread.ErrorQueue = sfWorker.ErrorQueue;
　wfThread.OutputName = sfWorker.OutputName;
　// 定义辅助类型，并将其插入辅助线程结构
　CWorkerThread wtBase;
　switch (sfWorker.ProcessType)
　{
　　case WorkerFormatter.SFProcessType.ProcessRoundRobin:
　　　wtBase = new CWorkerThreadRoundRobin(this, wfThread);
　　　break;
　　case WorkerFormatter.SFProcessType.ProcessAppSpecific:
　　　wtBase = new CWorkerThreadAppSpecific(this, wfThread);
　　　break;
　　case WorkerFormatter.SFProcessType.ProcessAssembly:
　　　wtBase = new CWorkerThreadAssembly(this, wfThread);
　　　break;
　　default:
　　　throw new Exception("Unknown Processing Type");
　}
　// 添加对数组的调用
　aThreads.Insert(idx, wtBase);
}

　　一旦所有的对象都已创建，就可以通过调用每个线程对象的 Start 方法来启动它们：

foreach(CWorkerThread cThread in aThreads)
　cThread.Start();

　　Stop、Pause 和 Continue 方法在 foreach 循环里执行的操作类似。Stop 方法具有如下的垃圾收集操作：

GC.SuppressFinalize(this);

　　在类析构函数中将调用 Stop 方法，这样，在没有显式调用 Stop 方法的情况下也可以正确地终止对象。如果调用了 Stop 方法，将不需要析构函数。SuppressFinalize 方法能够防止调用对象的 Finalize 方法（析构函数的实际实现）。

CWorkerThread 抽象类

CWorkerThread 是一个由 CWorkerThreadAppSpecifc、CWorkerThreadRoundRobin 和 CWorkerThreadAssembly 继承的抽象类。无论如何处理消息，队列的大部分处理是相同的，所以 CWorkerThread 类提供了这一功能。这个类提供了抽象方法（必须被实际方法替代）以管理资源和处理消息。

　　类的工作再一次通过 Start、Stop、Pause 和 Continue 方法来实现。在 Start 方法中引用了输入和错误队列。在 .NET 框架中，消息由 System.Messaging 名称空间处理：

// 尝试打开队列，并设置默认的读写属性
MessageQueue mqInput = new MessageQueue(sInputQueue);
mqInput.MessageReadPropertyFilter.Body = true;
mqInput.MessageReadPropertyFilter.AppSpecific = true;
MessageQueue mqError = new MessageQueue(sErrorQueue);
// 如果使用 MSMQ COM，则将格式化程序设置为 ActiveX
mqInput.Formatter = new ActiveXMessageFormatter();
mqError.Formatter = new ActiveXMessageFormatter();

　　一旦定义了消息队列引用，即会创建一个线程用于实际的处理函数（称为 ProcessMessages）。在 .NET 框架中，使用 System.Threading 名称空间很容易实现线程处理：

procMessage = new Thread(new ThreadStart(ProcessMessages));
procMessage.Start();

　　ProcessMessages 函数是基于 Boolean 值的处理循环。当数值设为 False，处理循环将终止。因此，线程对象的 Stop 方法只设置这一 Boolean 值，然后关闭打开的消息队列，并加入带有主线程的线程：

// 加入服务线程和处理线程
bRun = false;
procMessage.Join();
// 关闭打开的消息队列
mqInput.Close();
mqError.Close();

　　Pause 方法只设置一个 Boolean 值，使处理线程休眠半秒钟：

if (bPause)
　Thread.Sleep(500);

　　最后，每一个 Start、Stop、Pause 和 Continue 方法将调用抽象的 OnStart、OnStop、OnPause 和 OnContinue 方法。这些抽象方法为实现的类提供了挂钩，以捕获和释放所需的资源。

　　ProcessMessages 循环具有如下基本结构：

　　　1、接收 Message。

　　　2、如果 Message 具有成功的 Receive，则调用抽象 ProcessMessage 方法。

　　　3、如果 Receive 或 ProcessMessage 失败，将 Message 发送至错误队列中。

Message mInput;
try
{
　// 从队列中读取，并等候 1 秒
　mInput = mqInput.Receive(new TimeSpan(0,0,0,1));
}
catch (MessageQueueException mqe)
{
　// 将消息设置为 null
　mInput = null;
　// 查看错误代码，了解是否超时
　if (mqe.ErrorCode != (-1072824293) ) //0xC00E001B
　{
　　// 如果未超时，发出一个错误并记录错误号
　　LogError("Error: " + mqe.Message);
　　throw mqe;
　}
}
if (mInput != null)
{
　// 得到一个要处理的消息，调用处理消息抽象方法
　try
　{
　　ProcessMessage(mInput);
　}
　// 捕获已知异常状态的错误
　catch (CWorkerThreadException ex)
　{
　　ProcessError(mInput, ex.Terminate);
　}
　// 捕获未知异常，并调用 Terminate
　catch
　{
　　ProcessError(mInput, true);
　}
}

　　ProcessError 方法将错误的消息发送至错误队列。另外，它也可能引发异常来终止线程。如果ProcessMessage 方法引发了终止错误或 CWorkerThreadException 类型，它将执行此操作。
CworkerThread 导出类

任何从 CWorkerThread 中继承的类都必须提供 OnStart、OnStop、OnPause、OnContinue 和 ProcessMessage 方法。OnStart 和 OnStop 方法获取并释放处理资源。OnPause 和 OnContinue 方法允许临时释放和重新获取这些资源。ProcessMessage 方法应该处理消息，并在出现失败事件时引发 CWorkerThreadException 异常。

　　由于 CWorkerThread 构造函数定义运行时参数，导出类必须调用基类构造函数：

public CWorkerThreadDerived(CWorker v_cParent, WorkerThreadFormatter v_wfThread)
: base (v_cParent, v_wfThread) {}

导出类提供了两种类型的处理：将消息发送至另一队列，或者调用组件方法。接收和发送消息的两种实现使用了循环技术或应用程序偏移（保留在消息 AppSpecific 属性中），作为使用哪一队列的决定因素。此方案中的配置文件应该包括队列路径的列表。实现的 OnStart 和 OnStop 方法应该打开和关闭对这些队列的引用：

iQueues = wfThread.OutputName.Length;
mqOutput = new MessageQueue[iQueues];
for (int idx=0; idx＜iQueues; idx++)
{
　mqOutput[idx] = new MessageQueue(wfThread.OutputName[idx]);
　mqOutput[idx].Formatter = new ActiveXMessageFormatter();
}

　　在这些方案中，消息的处理很简单：将消息发送必要的输出队列。在循环情况下，这个进程为：

try
{
　mqOutput[iNextQueue].Send(v_mInput);
}
catch (Exception ex)
{
　// 如果错误强制终止异常
　throw new CWorkerThreadException(ex.Message, true);
}
// 计算下一个队列号
iNextQueue++;
iNextQueue %= iQueues;

　　后一种调用带消息参数的组件的实现方法比较有趣。ProcessMessage 方法使用 IWebMessage 接口调入一个 .NET 组件。OnStart 和 OnStop 方法获取和释放此组件的引用。

　　此方案中的配置文件应该包含两个项目：完整的类名和类所在文件的位置。按照 IWebMessage 接口中的定义，在组件上调用 Process 方法。

　　要获取对象引用，需要使用 Activator.CreateInstance 方法。此函数需要一个程序集类型。在这里，它是从程序集文件路径和类名中导出的。一旦获取对象引用，它将被放入合适的接口：

private IWebMessage iwmSample;
private string sFilePath, sTypeName;
// 保存程序集路径和类型名称
sFilePath = wfThread.OutputName[0];
sTypeName = wfThread.OutputName[1];
// 获取对必要对象的引用
Assembly asmSample = Assembly.LoadFrom(sFilePath);
Type typSample = asmSample.GetType(sTypeName);
object objSample = Activator.CreateInstance(typSample);
// 定义给对象的必要接口
iwmSample = (IWebMessage)objSample;

获取对象引用后，ProcessMessage 方法将在 IWebMessage 接口上调用 Process 方法：

WebMessageReturn wbrSample;
try
{
　// 定义方法调用的参数
　string sLabel = v_mInput.Label;
　string sBody = (string)v_mInput.Body;
　int iAppSpecific = v_mInput.AppSpecific;
　// 调用方法并捕捉返回代码
　wbrSample = iwmSample.Process(sLabel, sBody, iAppSpecific);
}
catch (InvalidCastException ex)
{
　// 如果在消息内容中发生错误，则强制发出一个非终止异常
　throw new CWorkerThreadException(ex.Message, false);
}
catch (Exception ex)
{
　// 如果错误调用程序集，则强制发出终止异常
　throw new CWorkerThreadException(ex.Message, true);
}
// 如果没有错误，则检查对象调用的返回状态
switch (wbrSample)
{
　case WebMessageReturn.ReturnBad:
　　throw new CWorkerThreadException
　　　("Unable to process message: Message marked bad", false);
　case WebMessageReturn.ReturnAbort:
　　throw new CWorkerThreadException
　　　("Unable to process message: Process terminating", true);
　default:
　　break;
}

　　提供的示例组件将消息正文写入数据库表。如果捕获到严重数据库错误，您可能希望终止处理过程，但是在这里，仅仅将消息标记为错误的消息。

　　由于此示例中创建的类实例可能会获取并保留昂贵的数据库资源，所以用 OnPause 和 OnContinue 方法释放和重新获取对象引用。
CworkerThread 导出类

任何从 CWorkerThread 中继承的类都必须提供 OnStart、OnStop、OnPause、OnContinue 和 ProcessMessage 方法。OnStart 和 OnStop 方法获取并释放处理资源。OnPause 和 OnContinue 方法允许临时释放和重新获取这些资源。ProcessMessage 方法应该处理消息，并在出现失败事件时引发 CWorkerThreadException 异常。

　　由于 CWorkerThread 构造函数定义运行时参数，导出类必须调用基类构造函数：

public CWorkerThreadDerived(CWorker v_cParent, WorkerThreadFormatter v_wfThread)
: base (v_cParent, v_wfThread) {}

　　在这些方案中，消息的处理很简单：将消息发送必要的输出队列。在循环情况下，这个进程为：

　　提供的示例组件将消息正文写入数据库表。如果捕获到严重数据库错误，您可能希望终止处理过程，但是在这里，仅仅将消息标记为错误的消息。

　　由于此示例中创建的类实例可能会获取并保留昂贵的数据库资源，所以用 OnPause 和 OnContinue 方法释放和重新获取对象引用。

苦笑枯 2007-01-19 00:13 发表评论

文章来源:http://www.blogjava.net/kuxiaoku/articles/94804.html

苦笑枯 2007-01-19 00:13 发表评论

BlogJava-苍穹之铁十字-随笔分类-C#

DataGrid的数据过滤示例

DataGrid控件分页显示的示例

使用DataGrid控件更新删除数据示例

日历程序的使用示例

一个魔术矩阵的例子

Beginner with C#(来源csdn kamphkb 的 Blog )

C#实时申请技术（作者： crystal编译 出处： yesky）

C#：消息队列应用程序〔作者： Carl Nolan 出处： microsoft〕

C#实时申请技术（作者： crystal编译出处： yesky）