性能问题应该从系统设计时期开始考虑，并延续到系统的生命期终止之时。

具有可伸缩性的系统是指当系统的负载增加一倍，系统需要的资源也同样增加一倍。说起来简单，但在现实环境中确难以做到。由于管理并发用户的开销的增长、锁事务的增长、一致性读负载的增加、操作系统负载的增加、低效的SQL或索引设计导致的过高的I/O等等因素，会导致系统资源的消耗的增长远大于一倍。

破坏可伸缩性的因素：

1.低效的应用程序设计、实施和配置

2.硬件部分的规模不合适

3.软件部分的限制

4.硬件部分的限制  

系统的结构可分为硬件和软件两部分：

硬件部分包括：CPU、内存、I/O子系统和网络模块。

软件部分包括：管理用户接口、实现商业逻辑、管理用户请求和资源分配、管理数据和事务。  

在设计系统时，应该考虑以下几个问题：

系统将支持多少用户？

用户的交互方式是什么？

用户所处的位置？

网络的速度怎样？

用户将访问多少数据？有多少数据是只读访问？

用户对响应时间的要求？

用户是否需要24小时服务？

是否所有的修改需要实时完成？  

应用程序设计原则：

设计简单性原则：

1.如果表的设计复杂到没有人能够完全的理解，那么表的设计可能是比较差的。

2.如果SQL语句过长以致于优化程序无法优化该语句，那么SQL语句的设计、事务和表的设计一定存在问题。

3.如果表的相同列上被重复索引，那么索引的设计可能是有问题的。

4.如果提交的查询没有限定，以致无法迅速的将结果返回给在线用户，那么用户接口或事务的设计是有问题的。

5.如果数据库的调用被许多层软件从应用逻辑中抽象出来，那么，软件开发的方法可能存在问题。

数据建模：应当注意，不要在非核心数据单元上花费过多的时间。

表和索引的设计：选择合适的列进行索引、选择索引类型、注意索引的代价、关注索引中列的顺序。

一个表上如果有3个索引，那么当进行INSERT/UPDATE/DELETE操作时，会比不带索引的表慢大约10倍。

组合索引中，选择性高的列在前查询时需要的I/O更少。选择性低的列在前，有助于代排序操作的查询。

SQL执行效率：

数据库连接管理：应避免没有必要的过多连接。

数据库游标管理：使用cursor和绑定变量，尽量避免硬分析，较少软分析。

硬分析：sql语句第一次提交，并在共享池中无法找到。

软分析：sql语句第一次提交，但是可以在共享池中找到相同的语句。  

实施新的应用程序：

切换方式包括两种：Big Bang Approach（所有用户一次性转移到新的系统上）和Trickle Approach（用户分多次转移到新的系统上）。

性能清单列表：

1.设置MAXINSTANCES, MAXDATAFILES，MAXLOGFILES，MAXLOGMEMBERS和 MAXLOGHISTORY的值高于预期值。避免系统的增长导致必须重建控制文件。

2.设置BLOCK SIZE和优化模式与开发环境中相同。如果测试环境中的所有SQL语句的执行计划都是正确的，可以测试环境中的统计信息导入到正式库中。

3.尽量少修改初始化参数。除了SGA的组成部分和归档目录的设置，其他初始化参数尽量保持默认值，可以为以后性能优化留下一定的余地。

4.通过设置数据库对象的存储参数来管理BLOCK的争用。

5.所有的sql语句应该被优化。

6.验证中间层软件和程序采用高效的方式连接数据库。

7.验证sql语句有效的利用游标。

8.确认所有方案的对象从开发环境移植到了产品数据库中。

9.一旦完成系统的切换，建立数据库和操作系统统计信息的基线。

10.发现最先出现的瓶颈。

方案一：

In web.config (StateServer mode, with a one minute timeout to make testing easier):

<sessionState mode="StateServer" stateConnectionString="tcpip=127.0.0.1:42424" sqlConnectionString="data source=127.0.0.1;user id=sa;password=letmein" cookieless="false" timeout="1" />

In Global.asax.cs:

protected void Application_PreRequestHandlerExecute(Object sender, EventArgs e) { // Let's write a message to show this got fired--- Response.Write("SessionID: " +Session.SessionID.ToString() + "User key: " +(string)Session["user"]); if(Session["user"]!=null) // e.g. this is after an initial logon { string sKey=(string)Session["user"]; // Accessing the Cache Item extends the Sliding Expiration automatically string sUser=(string) HttpContext.Current.Cache[sKey]; } }

In your Login Page "Login" button handler:

private void Button1_Click(object sender, System.EventArgs e) { //validate your user here (Forms Auth or Database, for example) // this could be a new "illegal" logon, so we need to check // if these credentials are already in the Cache string sKey=TextBox1.Text+TextBox2.Text; string sUser=Convert.ToString(Cache[sKey]); if (sUser==null || sUser==String.Empty){ // No Cache item, so sesion is either expired or user is new sign-on // Set the cache item and Session hit-test for this user--- TimeSpan SessTimeOut=new TimeSpan(0,0,HttpContext.Current.Session.Timeout,0,0); HttpContext.Current.Cache.Insert(sKey,sKey,null,DateTime.MaxValue,SessTimeOut,    System.Web.Caching.CacheItemPriority.NotRemovable,null); Session["user"]=TextBox1.Text+TextBox2.Text; // Let them in - redirect to main page, etc. Label1.Text="<Marquee><h1>Welcome!</h1></marquee>"; } else { // cache item exists, so too bad... Label1.Text="<Marquee><h1><font color=red>ILLEGAL LOGIN ATTEMPT!!!</font></h1></marquee>"; return; } }

方案二：

public virtual void Application_Start(object sender, EventArgs e) 
{ 
// reset the mailer indicator 
Application["MailerStatus"] = "All Mailings Complete"; 

// initialize a datatable for users online 
DataTable objUserTable = new DataTable(); 
objUserTable.Columns.Add("SessionID",System.Type.GetType("System.Guid")); 
objUserTable.Columns.Add("PeopleID",System.Type.GetType("System.Int32")); 
objUserTable.Columns.Add("ShowDetail",System.Type.GetType("System.Boolean")); 
DataColumn[] pk = new DataColumn[1]; 
pk[0] = objUserTable.Columns[0]; 
objUserTable.PrimaryKey = pk; 
Application["UserTable"] = objUserTable; 
} 

/**//// 
/// The Session_Start event adds user session information to 
/// Application["UserTable"]. 
/// 
public virtual void Session_Start(object sender, EventArgs e) 
{ 
Application.Lock(); 
//Application.Lock (); 
DataTable objUserTable = (DataTable)Application["UserTable"]; 
DataRow objRow = objUserTable.NewRow(); 
Guid objGuid = Guid.NewGuid(); 
objRow[0] = objGuid; 
Session["PfSessionID"] = objRow[0]; 
objRow[1] = 0; 
objRow[2] = false; 
objUserTable.Rows.Add(objRow); 
Application["UserTable"] = objUserTable; 
Application.UnLock(); 
} 

/**//// 
/// The Session_End event deletes user session information from 
/// Application["UserTable"]. 
/// 
public virtual void Session_End(object sender, EventArgs e) 
{ 
Application.Lock(); 
DataTable objUserTable = (DataTable)Application["UserTable"]; 
objUserTable.Rows.Find((Guid)Session["PfSessionID"]).Delete(); 
Application["UserTable"] = objUserTable; 
Application.UnLock(); 
}

方案三：
    protected void Login_Click(object sender, EventArgs e)
    {
        try
        {
            //用户名
            string sName = TextBox1.Text;

            //生成Key  
            string sKey = sName + "_Login";
           
            //得到Cache中的给定Key的值  
            string sUser = Convert.ToString(Cache[sKey]);

            //检查是否存在  
            if (sUser == null || sUser == String.Empty)
            {
                Session["username"] = sName;

                //Cache中没有该Key的项目，表明用户没有登录，或者已经登录超时     
                //TimeSpan 表示一个时间间隔，获取系统对session超时作的设置值
                //（如果考虑到允许用户再次登陆的时间小于session超时时间，可将此值设小） 
                //TimeSpan SessTimeOut = new TimeSpan(0, 0, System.Web.HttpContext.Current.Session.Timeout, 0, 0);
                //这里为了演示，把Cache保存时间间隔设置为了20秒
                TimeSpan SessTimeOut = new TimeSpan(0, 0, 0, 20, 0);
                HttpContext.Current.Cache.Insert(
                                                    sKey,
                                                    sKey,
                                                    null,
                                                    DateTime.MaxValue,
                                                    SessTimeOut,
                                                    System.Web.Caching.CacheItemPriority.NotRemovable,
                                                    null
                                                 );
               
                //启动Timer
                this.Timer1.Enabled = true;

Label1.Text = "你好！" + sName + "欢迎光临";
            }
            else
            {
                //在Cache中发现该用户的记录，表示已经登录过，禁止再次登录  
                Label1.Text = "对不起，你的用户身份已登陆";
                return;
            }
        }
        catch (System.Exception ex)
        {
            Label1.Text = ex.Message;
        }
    }
    protected void Logout_Click(object sender, EventArgs e)
    {
        //用户名
        string sName = TextBox1.Text;

        //生成Key  
        string sKey = sName + "_Login";

        //为了测试方便，设置了这个从Cache中移出登陆信息的方法
        HttpContext.Current.Cache.Remove(sKey);

        Label1.Text = Session["username"] + " 的用户登陆信息已从Cache清除!";
    }

    protected void TimerRunning_Tick(object sender, EventArgs e)
    {
        if (Session["username"] != null)
        {
            //用户名
            string sName = TextBox1.Text;

            //生成Key  
            string sKey = sName + "_Login";

            //得到Cache中的给定Key的值  
            string sUser = Convert.ToString(Cache[sKey]);

            TimeSpan SessTimeOut = new TimeSpan(0, 0, 0, 20, 0);
            if (sUser != null)
            {
                HttpContext.Current.Cache.Remove(sKey);
            }
            HttpContext.Current.Cache.Insert(
                                                sKey,
                                                sKey,
                                                null,
                                                DateTime.MaxValue,
                                                SessTimeOut,
                                                System.Web.Caching.CacheItemPriority.NotRemovable,
                                                null
                                             );
        }
        else
        {
            this.Timer1.Enabled = false;
        }
    }

Design Templates

Download these professionally designed Starter Kits and XHTML templates to get you started creating compelling, standards-compliant Web pages with ASP.NET 2.0. There are four Starter Kits below. These Starter Kits are complete web site solutions using ASP.NET’s latest controls (tree view control, grid view control, detail view control, login control, site map path controls and more). There are another 5 XHTML templates below. These are individual XHTML strict Web page templates (available each in two different colors) that are accompanied by design philosophy whitepapers that describe each template’s Section 508 conformance, page layout with CSS (page layouts using CSS floats or tables), Web page accessibility best practices and Web standard resources. All nine templates below are easily customizable and extendable to fit your own content.

For introduction to the ASP.NET Master Pages template set, click here.

ASP.NET Design Starter Kit Templates

Visual C# Commerce Design Visual Basic Commerce Design The "Commerce" template features three columns of content in a centered fixed/fluid layout. No layout tables, just CSS. The template showcases the new ASP.NET Treeview control for displaying hierarchical lists of items and shows how to skin it as part of a theme. The use of "Commerce" is not limited to online shop scenarios. Its three themes are well suited for other purposes as well, such as fan sites or even a personal web site. Section 508 accessibility, a dedicated print style sheet and several themed tabular controls, such as GridView and DetailsView complement its feature set. Included themes: Magnolia, Jazz, Snow. Visual C# File Download Size: 1.0 MBVisual Basic File Download Size: 1.0 MB For more information, view "Commerce" template documentation.

Visual C# Personal Design Visual Basic Personal Design Best suited for a personal or blog-style web site, this template has a hybrid fixed/fluid layout that organizes the content in two columns, with a horizontal menu at the top. It is a pure CSS layout that doesn’t rely on tables for arranging page content. Themes can be selected by the user and their preference will be restored upon the next visit by taking advantage of the new ASP.NET profile feature. The template contains a Section 508-compliant sample form, a print style sheet and a themed GridView control sample. Included themes: Green, Brown, Red. Visual C# File Download Size: 1.0 MB Visual Basic File Download Size: 1.0 MB For more information, view "Personal" template documentation.

Visual C# Corporate Design Visual Basic Corporate Design This template has been specifically designed to accommodate large amounts of content. It features a three-column, centered layout with a fixed with. Navigating the site is done though two correlated ASP.NET Menu controls and the SiteMapPath control. Using CSS, the page content is placed before the navigation in the XHTML source to improve accessibility and search-engine ranking. Placeholders and themes for including personalization features, such as the new Login control, are provided. The template is Section 508-compliant, contains a dedicated print style sheet and a themed GridView sample control. Included themes: Granite, Sand, Paper. Visual C# File Download Size: 1.7 MBVisual Basic File Download Size: 1.0 MB For more information, view "Corporate Design" template documentation.

Visual C# Small Business Design Visual Basic Small Business Design This template features two columns that are arranged in a centered, fixed-width layout. It is best suited for a small to medium-sized site. Its themes are widely different from each other, demonstrating the visual potential of ASP.NET themes and skins. Additional highlights include: table-less layout; source-ordered XHTML, placing the page content before the navigation elements; Section 508-compliant sample form; ASP.NET Menu and SiteMapPath controls; varying header images; dedicated print style sheet that formats the pages for output in a printer; themed GridView control sample. Included themes: Fruits, Forest, Literature. Visual C# File Download Size: 1.3 MBVisual Basic File Download Size: 1.3 MB For more information, view "Small Business" template documentation.

These templates illustrate high quality design principles combined with standards driven code. Each template is XHTML 1.1 Strict, Section 508/WCAG conforming and works across many browsers. The accompanying documentation describes how the template was built, the thought processes, tradeoffs, and workarounds necessary to build it. It also contains instructions on how to easily customize and change the templates for use in your site. You will find these HTML templates to be an excellent starting point when beginning to build out dynamic, data-driven Web sites with Microsoft Visual Studio and Microsoft Visual Web Developer. We hope they'll give both designers and developers deep insight into their creation process while providing you with a workable starting point.

	Basic The Basic template File Download Size: 603 KB 2 column layout Both columns are fixed width File Download Size: 603 KB For more information, view "Basic" template documentation.
	Fun The Fun template 2 column layout Both columns are stretchy This layout uses absolute positioning File Download Size: 393 KB For more information, view "Fun" template documentation.
	Grid The Grid template 3 column layout is used in the header section 2 column layout is used for the body section All the columns are "stretchy" File Download Size: 570 KB For more information, view "Grid" template documentation.
	Rounded The Rounded template 2 column layout Both columns are fixed width File Download Size: 495 KB For more information, view "Rounded" template documentation.
	Simple The Simple template 3 column layout The side columns are fixed width. The middle column is "stretchy" File Download Size: 420 KB For more information

Interface Not Registered / Class Not Registered Error in SSIS

I ran into a couple errors recently when trying to create new SQL Server Integration Services (SSIS) projects. One error stated:

Failed to save package file "C:\Documents and Settings\Administrator\Local Settings\Temp\1\tmp2B.tmp" with error 0x80040155 "Interface not registered".

The other stated:

<scrīpt language="javascrīpt">
function print()
{
    document.body.innerHTML=document.getElementById('print').innerHTML;

    window.print();
}
</scrīpt>

</head>
<body>

<form id="form1" runat="server">
<div id="print">
<table><tr><td></td></tr></table>
</div>

<asp:Button ID="butPrint" runat="server" Text="打印" OnClientClick="Print();" CssClass="cmd_print" />
</form>
</body>
</html>

使用CSS区域打印：

定义一个.noprint的class，将不打印的内容放入这个class内。

<style media=print type="text/css">  
.noprint{visibility:hidden}  
</style>  

<p class="noprint">将不打印的代码放在这里。</p>
<a href="javascrīpt:window.print()"打印</a>

Introduction

AJAX or Asynchronous JavaScript and XML is a free framework for quickly creating a new generation of more efficient, more interactive and highly-personalized Web experiences that work across all the most popular browsers. AJAX is relatively new phenomenon, based on technologies that aren’t quite new, for creating a way for businesses to interact with customers over the internet.

In this article using the current AJAX technique,(in it’s simplest way) to implement an on demand tree view. Since XML is common standard and easy to implement I am using XML in my sample application rather than any database. I have found another article here that to build a tree view using this AJAX.

History: (Skip this section if you are feeling bored)

This technology was introduced first by Microsoft (from my best knowledge) back in 1999, and had been known as “DHTML / JavaScript web application with remote calls”. The whole idea of the technology was to allow an internet browser to make an asynchronous HTTP call to remote pages/services, and update a current web page with the received results without refreshing the whole page. By creators’ opinion, this should have improved customers’ experience, making HTTP pages look and feel very similar to Windows applications.

Because the core implementation of this technology was based on internet browser functionality, the usability was very limited at that time. But several years later, the technology has been reborn with new browsers support and massive implementation by such giants as Google, Amazon.com, eBay, etc.

Today, it’s known as AJAX, and considered as a natural part of any dynamic web page with advanced user experience. Many ready made frameworks are also available on the internet like Microsoft AJAX/ATLAS , Enterprise AJAX are few of them.

Why AJAX:

This sample application provides a tree view implementation from an XML file. In real scenarios, I have noticed the processing of building the complete tree structure (with many levels-children) and rendering into the browser takes quite long time. After attempting different approaches, one of them was building the tree on demand. But I don’t like the Post Back (I am sure you too). Then I found is AJAX is the best bet. By this we could avoid a post back and flickering of the browser rather we‘re just changing the portion of the page hence reducing the traffic in the server and enhance the performance.

Working:

The idea is to build a tree structure using UL and LI tags and using a style sheet and some JavaScript all together give some real effects. On Page Load or any Pre Render event, the Root node will be loaded, from that on click of the plus/minus images you can expand or collapse the tree. You can notice that the child node is generated on the fly (off course you can cache the data source). Since AJAX is asynchronous, I am displaying an image to indicate that a request is already made to the server.

Implementation:

The Code files include

TreeSource.XML -> The source file where the tree structure is defined.

<?xml version="1.0" encoding="utf-8" ?>

<Nodes>

      <Node NodeID="0" NodeName="World" ParentID="-1"></Node>

      <Node NodeID="1" NodeName="North America" ParentID="0"></Node>

<Node NodeID="13" NodeName="United States" ParentID="1"></Node>

AJAXroutine.js -> The JavaScript file contain all the required methods to handle the asynchronous calls and standard AJAX methods. Java script is the core component in this technology as you can see. It handles the change detection, data request receipt, and placing the data on the page.

//To toggle the node image and expand collapse

function Toggle(node){

      // Unfold the branch if it isn't visible

      if (node.nextSibling.style)   {          

            if (node.childNodes.length > 0)     {

                  if (node.childNodes.item(0).nodeName == "IMG"){

         ...

The core function for the asynchronous request is

//The core function to get the xml http request object

function GetXmlHttpObject(){

      var objXMLHttp=null

      if (window.XMLHttpRequest){

        ...

The HTML will looks like the following tags.

<ul id="treeUL" class="treeUL">

<li id='10'>

<span title='World' valign='bottom' onclick="javascript:if (Toggle(this))showContentsEx('divTree0','0','');">

The client SPAN will be call the following function to invoke the server request

/***********************************************************

//Builds the query string and invoke a request to the server

//using javascript async call

/***********************************************************/

function showContentsEx(div, str, lmsg){ ...

WebForm1.aspx-> The sample .aspx file. It has the root level hard coded in this sample. I have put some styles to look nice. You can build that section also on the fly.

WebForm1.aspx.cs -> The code behind of the .aspx file.

GetTreeContents.aspx -> Empty in the design mode

GetTreeContents.aspx.cs -> All the client requests are processing this code behind and renders into the browser. When the client http request is made the following scripts will execute on the server and renders the HTML on the browser.

Introduction

This article explains how to use a certificate to connect to, for example, a web service. Do you know the floppies or USB Pens that some banks and IT Companies give to their employees or customers that permit them to connect to services via the internet using a security file and channel? Well, we will learn how to use a similar file in this article, which is divided into six parts:

1. Environment Preparation
2. Server Certificate Request
3. Generate the Certificate
4. Activate the SSL Security Channel Communication on the IIS Web Server
5. Request and Obtain a User Certificate
6. Use Certificate with Windows Form

For this article I used three different machines:

• A Windows 2000 Server with Certification Authority
• Two Windows XP Professional Edition machines, one with IIS Web Server

You can use only one Windows XP Professional machine; I use the second machine to ensure that the certification file and the software that I develop are the only two things that I must take away to connect to the web service. Good luck!

Environment Preparation

In this section we create the two projects that we will use to try our certification program. I won't explain the two projects in detail; I presume that you are expert enough to create two standard projects with Visual Studio 2005.

All right, start creating a new website project. Choose the ASP.NET Web Service template. Attention! It is important that you use a real web server and not the emulator. Therefore, if you don't have IIS Web Server or something similar installed, install it and then choose the HTTP option from the combo location of the VS Project. For the name of the application, I chose http://localhost/WebServSSL. Visual Studio takes care of most of what you need; you only have to configure the website appropriately. If you build the project you'll have just one method in the service, the classic "hello word" example. I suggest we use this for our test, but if you don't like it you can create another function that you prefer. The second project that you must now create is a Windows Application. Create it in the same solution as the Web Service; I called mine testSSLWebServ. In the new project, add a Web Reference from the solution explorer and choose your web service. I called the namespace for the service remoteWebServSSL. All right, the last pass is to add a button on the form and call the unique method of the Web Service that we have. Here 's some code:

remoteWebServSSL.Service srv = new remoteWebServSSL.Service();
MessageBox.Show("The Web Service say: " + srv.HelloWorld());

Important: Some problems can arise from the firewall settings of the machine. Be sure to turn off the firewall; you can configure it in a second time.

Now we can start.

Server certificate request

Next, to activate the secure channel on our web site, we must go to the properties of the root Web Server and set the Server Certificate. There's more than one mode to do this; you can choose ones you prefer. I chose to connect to the CA Web Server to ask for the Certificate. Therefore I must create a Certification Request and ask the CA a second time. Click on the Server Certificate button. The certificate wizard will then appear; click Next. In this dialog choose Create a New Certificate and click Next. The only option that you can choose now is "Prepare the request now, but send it later;" again click Next. In this form you must choose the name of the certificate that you will install on your web server. Leave the other parameter as it is and go on. Now write something for the organization and organization unit. Go on. This next step is important: the Common Name required is the name of your machine and is, therefore, the name of the web server that responds to your web server. For example, my machine name is WorkStatio23 and the http address that I write when I navigate on my web server is http://WorkStatio23/WebServSSL. The Common Name that I must choose is WorkStatio23. Also insert the State/province and City/locality data and then go on. As a last step, save your Certification Request; choose a location and click Next. Read the Request File Summary, click Next and Finish. The Certification Request has now been created.

Generate the certificate

Open the generated Text file on your computer from the directory where you chose to save it. Select all the text in the file and copy it. Now it's time to use Windows 2000 Server with the CA. Ensure that your CA is configured to accept the request by the Web Server and that it releases the certificate immediately, without user participation. Connect to the CA Web Server using the related address. For example, my Windows 2000 Server machine is named w2ksrw. Therefore the address to request the certification is http://w2ksrw/CertSrv. Next, choose the second option "Request a certificate" and click Next. Choose the "Advanced request" option and click Next again. Choose the second available option: "Submit a certificate request using a base64 encoded PKCS #10 file or a renewal request using a base64 encoded PKCS #7 file." Click Next. Since we already have the Text file code copied to memory, just paste it in the relevant textbox control (the first) and click Next. Now you are ready to download the certificate. Download the two certificates on the result page: "Download CA certificate" and "Download CA certification path."

Activate the SSL security channel communication on the IIS Web Server

Select the certificate file with the .p7b extension. For me, this is certnew.p7b. Double click on your file once you find it. Note that the certificate is not valid. Click the "Install certificate" button and then click Next until Finish; confirm the last message and the certificate is now installed. Now finish the activation of the SSL channel on the Web Server. Launch your IIS configuration tool, go on the root Web Server (Default Web Site), right click and select Properties. Return to the Directory Security and re-click the Server Certificate button. Click Next. Note that the options have changed. Choose the "Process the pending request and install the certificate" option and click Next. Browse for the other certificate that you obtain from the CA. Click Next two times and then Finish. Well, you are ready to use your https connection. Try your web server in https and enjoy. For this example, we must enforce the use of the SSL channel on our Web Services. Therefore, on the IIS, go to the properties of WebServSSL, choose the Directory Security tab and click the Edit button. Check the "Require secure channel (SSL)" checkbox and the "Require client certificates" option in the Client Certificates group. Close all windows and try your web services now using your browser.

Request and obtain a user certificate

This step will be fast and simple. Using your browser, go to the Web Server of the CA using the same address (http://w2ksrw/CertSrv). Choose the "Request a certificate" option and click Next. Choose the "Advanced request" option and then Next. Leave the "Submit a certificate request to this CA using a form" option selected and click Next. Fill in the Name and the E-Mail fields under Identifying Information with whatever you want and leave the other field as is. For the Intended Purpose field, choose Client Authentication Certificate. For the last setting, set the "Mark keys as exportable" option. Bypass the other field and click Submit. Answer "yes" to the question and finally install the certificate.

Note: In this step, I have encountered problems using the Certification Authority website. The "Downloading ActiveX Control" message did not disappear. If you have the same problem, you can resolve it by installing a fix for the Windows 2000 Advanced Server. Refer to KB323172 of the Microsoft site and find the relative fix q323172_W2K_SP4_X86_EN.exe.

Use certificate with Windows form

You can try more tests with your example, if you'd like, before continuing with my instructions here. After you're satisfied, launch the Internet Explorer browser. Select Tools and go to Internet Options. Select the Content tab and click on the Certificates button. You can immediately see the Personal tab selected and, in the list control, you can see your personal certificate (Andy74 for me). Select the specified certificate and click on the Export button. In the wizard panel choose Next, choose the "Yes, export the private key" option and click Next again. Here you can export only in the PFX format; leave the default option and click Next. Insert a password. For simplicity, I chose a very simple password, "password." Then click Next. Choose where to export the certificate and click Next again. Click Finish and OK in the message box. Now, return to your project in Visual Studio and add this line after the creation of the web reference instance:

srv.ClientCertificates.Add(
new System.Security.Cryptography.X509Certificates.X509Certificate2(
@"c:\Andy74cert.pfx", "password"));

Obviously, change the path of the certificate where you have saved it. Now on the machine where you have the web services, go to the administrative tools section of the control panel and launch the Server Extensions Administrator. Select File -> Add/Remove Snap-in. On the next window click the Add button, select Certificates and finally click the Add button. Select the Computer Account option and click Next. Leave the "local computer" (the computer this console is running on) option selected and click Finish. Close the active window and finally the OK button. Open the Certificates (Local Computer) node in the tree view, then Trusted Root Certification Authorities and the Certificates node. Right click on the node: All Tasks -> Imports to import another wizard. Click Next. Remember the .p7b certificate that we download from the certification authority in the fourth step. Browse to that file and select it; then click Next. Choose "Place all certificates in the following store" and then the "Trusted Root Certification Authorities" folder; click Next and then Finish. All right, you are ready to try your final application. To really test your application, you can use other machines never used up to now. Copy your application and your .pfx file (certificate) to where you want, but remember to place the certification file in the same folder where you load from the application, or use a parameter to load it from whichever you'd prefer.

Introduction

In this article, I will show you how to exchange data securely with a Web Service without HTTPS/SSL but without compromising the same protection level of HTTPS/SSL. It will also give you a real life example on the implementation and limitation of the important encryption types as well as Digital Signature that are available in .NET Framework.

Advantages

1. No Installation and configuration is required in IIS or in the Client.
2. No Deployment issue (Nothing to embed/ship) in the client.
3. No Additional Library is required.
4. Less easier to implement comparing alternates.

Requirements

If you are not familiar with Symmetric, Asymmetric Encryption and Digital Signature. I strongly suggest you read the following articles of cp before you move forward, there are also many reference available in the Web on this topic:

• Cryptography 101 for the .NET Framework
• .NET Encryption Simplified
• Implementing Digital Signing in .NET
• Using XML Digital Signatures for Application Licensing

I have created the solution in Visual Studio 2005 and .NET 2.0 but it can be easily ported to Visual Studio 2003 and .NET 1.1.

Background

Symmetric VS Asymmetric

I assume that you already know the difference between the Symmetric and Asymmetric encryption. In short, in Symmetric encryption both the parties (the server and client) use the same key to encrypt and decrypt the data. On the other hand, in Asymmetric encryption a pair of key (known as Public/Private Key) is used to encrypt/decrypt. If the data is encrypted with the Private Key the only way to decrypt it is the Public Key and the vice versa.

Digital Signature

Digital Signature is also a part of the Public/Private Key implementation. The private key is used to sign the data and public key is used to verify that data has not been tampered. However, Digital signature does not retain the secrecy of the data, which means the data always remain plain (Not encrypted).

Alternate Solutions

1. Share Common Secret Key: The easiest way to implement it to share a common secret key before the Client and Service start communicating.
2. MS WSE Library: I found it difficult to implement. Maybe it will look easier to you.

The Solution

Initial Proof of Concept

After going thorough few details of the above mentioned articles and of course, MSDN I came up with the following message exchange between the client and server, which looks pretty, rock solid to me.

	The Client	The Server	The Hacker
1.	Client creates random Public/Private Key Pair and sends the Server the Public Part	The Server in turns creates a random Public/Private Key Pair and returns Public Part to Client.	The Hacker can only view both parties Public key.
2.	The Client encrypts the target data with received Server Public Key and sends it back to Server.	The Server receives the encrypted data decrypts it with the previously generated Server Private Key. Server Process the Data. Server encrypts the process result with the previously received Client Public Key and returns back to Client.	The hacker only has the Server Public key. So it is not possible for the hacker to decrypt the data, as it requires the server private key to decrypt. Again, the Hacker only has the Client Public key and thus it is not possible for the Hacker to decrypt the process result.
3.	The Client receives the encrypted process result and decrypts it with the previously generated Client Private Key.
4.	The Client returns to regular processing	The Server Goes to sleep.	The Hacker Cries.

.NET Platform

In .NET platform, there are different algorithms available for both Symmetric and Asymmetric. I am not going to explain the details of these algorithms as it is beyond the scope of this article. The characteristics are:

Symmetric Algorithms

• DES: 64 bit encryption - Good.
• RC2: 128 bit encryption - Better.
• Rijndael: 256 bit also known as AES and the most secure algorithm – The Best.
• TripleDES: 192 bit encryption – Much better.

Asymmetric Algorithms

• DSA: Does not support Encryption/Decryption. Only allows Digital Signature (So skipping from discussing).
• RSA: Supports both Encryption/Decryption and Digital Signature. But it cannot encrypt/decrypt data more than 117 byte. If you want to encrypt more than 117 byte, it will throw you a Cryptographic Exception with a message that Key not valid for use in specified state. There are many references available in web, which explains this limitation.

Implementation

As mentioned above the only asymmetric algorithm that supports Encryption/Decryption is RSA, but it has the limitation of data length. Moreover, in Web Service it is regular case that we are exchanging data more than 117 bytes with those bulky xml tags. We can surly use other mechanism such as compression, use other medium such as JSON instead of XML to reduce the data size, but none of these ensures that the data size will be always less  than 117 byte. Here comes the Symmetric Key into the scene. Let me revise the previous proof of concept.

Revised Solution

	The Client	The Server	The Hacker
1.	Client creates random Public/Private Key Pair and sends the Server the Public Part.	The Server in turns creates a random Public/Private Key Pair and returns Public Part to client.	The Hacker can only view both parties Public Key.
2.	Client Creates a random symmetric key, encrypts it with the previously received Server Public Key, and sends it to Server.	The Server receives the client symmetric key decrypts it with the previously generated Server Private Key.   Now the Server Creates a Random Symmetric Key encrypts it with the Client Public Key and returns it back to the Client.	Same thing happens for the Hacker as in the initial proof of concept. The Hacker cannot decrypt the data, as it requires the Server Private key.   Again, the Hacker only has the Client Public Key and thus it is not possible for the Hacker to decrypt the Server Symmetric Key.
3.	Client Receives the encrypted Symmetric Key of Server. It decrypts it with previously generated Client Private Key. Client Encrypts the target data with the previously generated Client Symmetric key and sends to Server.	Server Receives the Encrypted data, Server decrypts it with the previously received Client Symmetric key. Server Process the Data. Server encrypts the process result with the previously generated Server Symmetric Key and returns back to Client.	The Hacker does not have the Client Symmetric Key and so it is not possible to decrypt the data.       Again, the Hacker does not have the Server Symmetric Key and thus it is not possible for the hacker to decrypt the process result.
4.	The Client receives the encrypted process result and decrypts it with the previously received Server Symmetric Key.
5.	The Client returns to regular processing.	Server goes to sleep.	The Dumb Hacker cries and but the intelligent hacker might be thinking, “Hey there is something to hack”.

In this revised version an extra step just been introduced -the step 2, where both the parties exchanging Symmetric key (Lets call it session key from now on) instead of the actual data like in the initial concept. Now you might be thinking does not the RSA length limitation applies when encrypting the session key. The Answer is no, it does not, even we are exchange the most secure Rijndael key(256 bit) , the data length becomes 44 byte (256/8) which we can easily encrypted/decrypted with RSA. The only weakness of the above solution is, if the intelligent hacker can somehow discover the session key of the both parties, but which I assume is very difficult to discover based upon the encrypted data.

Where is the Digital Signature?

You might be thinking this article starts with Digital Signature, but still no flavor of it. Let me tell you, although the digital signature is not required but you can implement it to make the solution more secure and ensure that even the intelligent hacker can revive both the parties session key but there will be no way the hacker can tamper the data. Here is the final solution.

The Final Solution

	The Client	The Server	The Hacker
1.	Client creates random Public/Private Key Pair and sends the Server the Public Part.	The Server in turns creates a random Public/Private Key Pair and returns Public Part to client.	The Hacker can only view both parties Public Key.
2.	Client Creates a random Session key, encrypts it with the previously received Server Public Key, Digitally Signs it with the Client Private Key and sends it to Server.	The Server receives the client session key, Checks it integrity with the Client Public Key, if the Key has not been tampered, it decrypts the Client Session Key with the previously generated Server Private Key. Now the Server Creates a Random Session Key encrypts it with the Client Public Key, Digitally Signs it with the Server Private Key and returns it back to the Client.	Same thing happens for the Hacker as in the previous two solutions. The Hacker cannot decrypt the data, as it requires the Server Private key, moreover the Hacker founds the data is now Digitally Signed. Again, the Hacker only has the Client Public Key and thus it is not possible for the Hacker to decrypt the Server Session.
3.	Client Receives the encrypted Session Key of Server. It verifies it with the Server Public Key, if not tampered, it decrypts it with previously generated Client Private Key. Client Encrypts the target data with the previously generated Client Session Key, Digitally Signs it and sends to Server.	Server Receives the Encrypted data, Server verifies it with Client Public Key, if not tampered it decrypts the data with the previously received Client Session Key. Server Process the Data. Server encrypts the process result with the previously generated Server Session Key, Digitally Signs it with the Server Private Key and returns it back to Client	The Hacker does not have the Client Session Key and thus it is not possible to decrypt the data, also founds the data is Digitally Signed. Again, the Hacker does not have the Server Session Key and so it is not possible for the hacker to decrypt the process result.
4.	The Client receives the encrypted process result, verifies it with Server Public Key and decrypts it with the previously received Server Session Key.
5.	The Client returns to regular processing.	Server goes to sleep.	Both the Hacker cries now.

In the final solution, the digital signature has been introduced to ensure the data has not been tampered between the communications.

The Source Code

The attached source contains the implementation of the final solutions, RSA’s limitation of large data encryption, a bit performance benchmarking and few numbers of handy classes which you can use in your own solution.

Disadvantages

• The Solution is not 100% secure. But its is pretty good to use in production environment.
• Much more coding, as you will not get the benefit of Strongly Typed Objects that generated web service proxy provides. You have to write some kind of wrapper (Like the ServiceWrapper.cs in the Client) to get the benefit of Strongly Typed Object.
• The Service will not be stateless, as it needs to use session, cache etc to identify the client.
• Performance will not be optimal, as it requires two more calls to initialize the secure communication also the encryption/decryption/verification has extra overhead.

About kazimanzurrashid

Introduction

Let's face it. Providing sensitive information on a web site is a risk. Many visitors will not give out that kind of data even if they see that the web site claims security. Many more will certainly not reveal their personal details if the warm-and-fuzzy closed padlock isn't visible in their browser window.

See the What's new section for the latest updates.

Background

Enter Secure Sockets Layer. SSL is a developer's tool for securing the transmission of data. Whether you are encrypting pages for the checkout area of an e-commerce site or you are protecting the personal statistics that your users supply you for marketing; SSL is ideal. A trusted certificate installed on the web server offers visitors that good feeling of a secure environment.

There are caveats when implementing a web site that makes use of the HTTPS protocol. I'm not referring to the technical nuances you, or a system administrator, must face when installing a certificate on the server. What about simply adding a link from one page to another page that should be secured?

Those of you who have experience with writing web pages that use SSL probably know where I'm going with this. You cannot switch protocols unless you provide an absolute URL. Therefore, in order to allow a visitor to click on a link that should take them to a secure web page, the reference must be absolute.

https://www.codeproject.com/secure/getsensitiveinfo.asp

To make things worse, many browsers download pages referenced by a relative URL with the same protocol as the last request. So, if you had a link in the above file to another page in the root directory, that you wanted to show with the HTTP protocol, it would also have to be absolute.

<!--
The following will actually be translated as
https://www.codeproject.com/welcome.asp;
thus, retaining the HTTPS protocol that was last used.
-->
<a href="../welcome.asp">Back to the Welcome Page.</a>

Generally, it is not a good idea to encrypt every single page request with SSL. It makes for slower page serves and more bandwidth usage. It is also more intensive on the server's CPU; something your hosting provider may not be pleased with.

A Solution

Being forced to use absolute URLs for internal links in a web site is less than appealing. The next thing you know, the web site's domain name changes (for any number of reasons) or you have a staging server, which means you have to maintain a separate copy of the site for that set of absolute URLs. It makes much more sense to mark certain files and/or entire directories as "secure". This would allow you the benefit of using relative URLs freely within your web pages. If an existing page needs to be made secure, you simply add it to the list of marked files instead of finding and replacing all links to the page with an absolute URL.

That's where SecureWebPageModule comes in. SecureWebPageModule is a class that implements the IHttpModule interface. HTTP modules give programmers a means of "attaching" to a web application to process its events. It's like descending from the System.Web.HttpApplication class and overriding the application and session events in a Global.asax file. The main difference is you don't have to worry about copying and pasting the same code into the file for every application that is to use it. HTTP modules are simply "linked in" to a web application and become part of the pipeline.

The goal of this security solution is to allow a developer to easily secure a web site without the need to hard-code absolute URLs. This is accomplished by listing the files and/or directories that should be secured by SSL. It only seems natural to have a custom configuration section for this.

Configuration

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
...
<secureWebPages
mode="RemoteOnly"
encryptedUri="secure.mysite.com"
unencryptedUri="www.mysite.com"
maintainPath="True"
warningBypassMode="AlwaysBypass"
bypassQueryParamName="BypassSecurityWarning"
ignoreHandlers="WithStandardExtensions">
...
</secureWebPages>
...
<system.web>
...
</system.web>
</configuration>

mode behaves like the customErrors mode attribute. Use it to avoid redirecting to the HTTPS protocol on your development or production machine when you don't have a secure certificate installed.

The encryptedUri and unencryptedUri attributes are perfect for those situations where your secure certificate is associated with a different site than the one needing security. I know; examples are better than just explaining it. Okay then, visit searsmastercard and notice the security alert that appears. If you are using IE, you should see a security alert window appear, warning you that something is wrong with the site's certificate. Everything is okay except the name doesn't match the name of the site. Click on the View Certificate button and note the site listed next to "Issued to". www.searscard.com is the site they purchased the certificate for. What does this mean? Well, the site should be www.searscard.com; however, the IT folks at Sears thought it would be a good idea to purchase the searsmastercard.com domain as well to allow for another point of entry. Both DNS records point to the same place on their web server. They have a few options that would prevent this alert from displaying to their users, but two are the most obvious. They can redirect to https://www.searscard.com when users visit the default page on www.searsmastercard.com, or they could upgrade their site to ASP.NET and download this module ;-). All they'd have to do then, is set the encryptedUri attribute to www.searscard.com and all would be wonderful. Likewise, unencryptedUri may be specified to send the user back to another domain or specific URI when the module removes security. An example would be to redirect secure requests to secure.mysite.com, and requests that don't need to be secure could be redirected back to www.mysite.com. maintainPath is used in conjunction with the aforementioned attributes. When the module redirects to the encryptedUri or unencryptedUri, it appends the current path before sending the user on their way. You can turn off this behavior by setting maintainPath to "False".

In certain circumstances, IE displays the message, "You are about to be redirected to a connection that is not secure". This only happens as a result of a "double redirect" to an unsecured page. That is, when a page is requested via HTTPS, the programmer's code performs a relative redirect, then the module performs an absolute redirect via the HTTP protocol. Use the warningBypassMode attribute to bypass the security warning as desired. If you choose to bypass security warnings via the default BypassWithQueryParam option, you may specify the name of the query parameter with the bypassQueryParamName attribute. Use this when you only want to run the bypass code on the rare occasions you know the security warning will appear, and request the page with the query parameter specified. An example of this is when your code will be posting back to a secure page for server-side processing and then redirecting to a page that the module will deem unsecured. Simply redirect to the page and append the bypassQueryParamName with any value like so: Response.Redirect("MyUnsecurePage.aspx?BypassSecurityWarning=True");.

I received a couple of suggestions on how to solve the above warning. There was one suggestion that involved a configuration attribute that would point the module to a "redirector page". This page would be sent a parameter containing the page that should be redirected to, and it would change the location via meta refresh and JavaScript as a backup. The idea is a good one. I just don't like making the user of this module create a page that has preset code in it. Therefore, if the module determines that it should bypass the warning, it will render the necessary page itself, complete with meta tag and JavaScript. This will cause a client-side redirect and avoid the security warning.

One power of ASP.NET is the ability to create custom HTTP handlers that act similar to this module. The handlers are invoked when a certain file, or type of file, is requested from the server. In ASP.NET 2.0, embedded resources make heavy use of the WebResource.axd virtual file to dynamically serve images and JavaScript that don't actually have a physical file. When used, these handlers may cause mixed security warnings unless the module is instructed to ignore them. The ignoreHandlers attribute lets you generally ignore these handlers quite easily. You may configure the module to ignore any standard HTTP handler with a file extension of .axd by setting the attribute to WithStandardExtensions. The default setting is BuiltIn and forces the module to just ignore the two built-in handlers; Trace.axd and WebResource.axd.

Now...on to file and directory entries.

secureWebPages for .NET 1.1

    ...
<secureWebPages>
<file path="Default.aspx" secure="Insecure" />
<file path="Admin/MoreAdminStuff.aspx" secure="Insecure" />
<file path="Legal/Copyright.aspx" secure="Ignore" />
<file path="Lib/PopupCalendar.aspx" secure="Ignore" />
<directory path="/" recurse="False" />
<directory path="Admin" />
<directory path="Admin/Info" secure="Insecure" />
<directory path="Members/Secure" recurse="True" />
</secureWebPages>
...

secureWebPages for .NET 2.0

    ...
<secureWebPages>
<files>
<add path="Default.aspx" secure="Insecure" />
<add path="Admin/MoreAdminStuff.aspx" secure="Ignore" />
<add path="Legal/Copyright.aspx" secure="Ignore" />
<add path="Lib/PopupCalendar.aspx" secure="Ignore" />
</files>
<directories>
<add path="/" recurse="False" />
<add path="Admin" />
<add path="Admin/Info" secure="Insecure" />
<add path="Members/Secure" recurse="True" />
</directories>
</secureWebPages>
...

Notice that you can now include the application root as a directory entry. There is no longer an ignore attribute for each entry. It has been replaced by the secure attribute. This attribute tells the module how to handle that particular file or directory. The default value is Secure, which simply means the module should redirect to the HTTPS protocol when that file, or a file in that directory, is requested. Setting the attribute to Insecure will force a matching request to be served without SSL. In the example above, although the application root is secured, the Default.aspx page in the application root should not be. The secure attribute may also have a value of Ignore which mimics the functionality of version 1's ignore attribute. Any request to a file with a matching file or directory entry marked with secure="Ignore" will be ignored by the module. This is good when a page should remain in the same protocol as the last request, such as pop-up windows used by both secure and unsecured pages. Another example of this is an .aspx page that is used to serve content other than HTML and is referenced from within a secure page. There are times when an .aspx page will serve an image or a style sheet and is included by a secure page with the appropriate <img> or <link> tag. In these cases, a visitor of such a page would receive a warning that there is a mixture of secure and unsecured items. That usually doesn't make users feel too good about a page. Just include an entry for the file and set secure to Ignore, and there will be no problems.

You may also provide the recurse attribute for directory entries. Setting this attribute to True will inform the module to include all files in any sub-directories when monitoring requests.

Adding the Module to Applications

There are two options for adding the module to your applications. The first is to add the module to an individual application. This requires that you edit the web.config file of the application. You will need to add a custom configuration section handler for the <secureWebPages> section and a module addition to the <httpModules> section.

configSections for .NET 1.1

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
...
<configSections>
...
<section
name="secureWebPages"
type="Ventaur.Web.Security.SecureWebPageSectionHandler,
WebPageSecurity"
allowLocation="false" />
</configSections>
...
</configuration>

configSections for .NET 2.0

<?xml version="1.0"?>
<configuration>
...
<configSections>
...
<section
name="secureWebPages"
type=
"Ventaur.Web.Security.Configuration.SecureWebPageSettings,
WebPageSecurity" />
</configSections>
...
</configuration>

httpModules for .NET 1.1 and 2.0

<?xml version="1.0" encoding="utf-8" ?>
<system.web>
...
<httpModules>
...
<add
name="WebPageSecurity"
type="Ventaur.Web.Security.SecureWebPageModule,
WebPageSecurity" />
</httpModules>
...
</system.web>
...
</configuration>

The second option is to add the module to all web applications on the server. You will need to make similar modifications to the machine.config file. Editing the machine.config file should only be performed by a knowledgeable person with "Administrator" privileges. Always make a backup of your machine.config file before editing it. If you choose to add the module and configuration section handlers to your machine.config file, you should sign the assembly with a strong name and register it in the Global Assembly Cache (GAC). The "AssemblyInfo.cs" file provided with the project source should have a line near the bottom that is commented to prevent signing the assembly. To sign the assembly during a compile, un-comment this line:

[assembly: AssemblyKeyFile("..\\..\\..\\Key.snk")]

For more information on registering an assembly in the GAC, please refer to the .NET Framework documentation.

Notes

Please, be aware that although IIS allows you to "Require a secure channel (SSL)" for a folder's "Directory Security", this module will not work properly if you do so. IIS will intercept the request before passing it along to the module and reject insecure connections. Therefore, if you want to use this module, do not require SSL from IIS.

Also, testing this module on a development machine without an installed SSL certificate will yield unexpected results. The browser may appear to "hang" or fail altogether. This is because it is being sent to a page that should be encrypted, but is not.

Version History

• Version 3.1
  • See what's new for details.
• Version 2.6
  • See what's new for details.
• Version 3.0
  • See what's new for details.
• Version 2.5
  • Bug fix: encryptedUri/unencryptedUri domain differing from the current request domain. For example, if unencryptedUri="www.mysite.com", and the user visits a page via mysite.com, 4 characters ("www.") were dropped when the path was maintained during a redirect. This bug was squashed.
  • See what's new for more details.
• Version 2.1
  • Changed the maintainApplicationPath attribute to maintainPath.
  • Improved the code that redirects to another host via the encryptedUri and unencryptedUri.
• Version 2.0
  • Current version: See what's new for details.
• Version 1.0.1
  • Added code to skip comments in the configuration file. Thanks goes to dcbrowser.
  • Minor performance changes to select areas of the code.
• Version 1.0.0
  • Initial release.

What's New

Version 3.1

• Added the ignoreHandlers attribute to generally ignore HTTP handlers. I normally do not like setting the default of a new setting to something that is different from the previous version's default functionality, but I believe it is acceptable in this case. The default setting is BuiltIn to force the module to ignore requests for Trace.axd and WebResource.axd.
• The module now accounts for cookie-less sessions when redirecting without a specified encryptedUri or unencryptedUri.
• A tiny change was made to the RequestEvaluator.Evaluate method that allows you to force an evaluation, despite the mode setting in the configuration. This should allow for better testing and simulation.

Version 3.0

• Ported to .NET 2.0.
• Configuration re-written to conform to the new configuration API.

Version 2.6

• The module now accounts for cookie-less sessions when redirecting without a specified encryptedUri or unencryptedUri.
• A tiny change was made to the RequestEvaluator.Evaluate method that allows you to force an evaluation, despite the mode setting in the configuration. This should allow for better testing and simulation.

Version 2.5

• Separated appropriate logic into static helper classes. This adds benefit for testing purposes. Now, simple testing can be achieved by simulating the processes.
• Removed the configuration restriction of "order matters" for directory elements. Now, directory elements may be included in the configuration in any order. The module processes directory matches with the attitude that the deepest match is the best match. In other words, if a request is made for a page located in Admin/Reports/ and the configuration file has a directory element for both "Admin/" and "Admin/Reports/", it no longer matters if "Admin/" is first. Before, the module would stop once it found a match, despite recursion settings. Now, it finds the most accurate (deepest) match. Thanks goes out to balazs_hideghety for getting me started with this feature update.

Version 2.0 and 2.1

• Source code provided in C# and VB.NET.
• The configuration settings loader is now called once in an application Init event handler, and if the settings indicate to not use security, a handler for the BeginRequest event is not added. This improves the overall performance of the module and any application including it. Thanks goes to Diego.
• The root directory of the virtual application can now be secured by including a directory tag with a path of "/". Thanks to Andy for pointing this one out.
• A mode attribute was added to the secureWebPages section. Possible values are "On", "RemoteOnly", "LocalOnly" or "Off". Thanks to Andy for this suggestion.
• The encryptedUri and unencryptedUri attributes were added to the secureWebPages section. Set to a specific URI to indicate where the module should redirect when it decides whether security is needed or not. Thanks to Andy for this suggestion.
• The maintainPath attribute was added to the secureWebPages section. A value of "False" will prevent the module from maintaining the current path when redirecting to any specified URIs.
• The warningBypassMode attribute was added to the secureWebPages section. Possible values are "AlwaysBypass", "NeverBypass" or "BypassWithQueryParam".
• The bypassQueryParamName attribute was added to the secureWebPages section. Set the value to the name of a query string parameter that indicates to the module to bypass any security warning if warningBypassMode is set to "BypassWithQueryParam".
• The ignore attribute was removed from the file and directory tags.
• The secure attribute was added to the file and directory tags. Possible values are "True", "False" or "Ignore".
• directory tags may include the new recurse attribute. If "True", all files in any sub-directories are included.

About Matt Sollars

EXECUTE sp_configure 'show advanced options', 1
RECONFIGURE WITH OVERRIDE
GO

EXECUTE sp_configure 'Agent XPs', 1
RECONFIGURE WITH OVERRIDE
GO

EXECUTE sp_configure 'show advanced options', 0
RECONFIGURE WITH OVERRIDE
GO

C:\Visual Studio 8\SDK\v2.0>aspnet_regsql -S dbserver -U userid -P password
sstype c -d database -ssadd

<sessionState
  mode="SQLServer"
  allowCustomSqlDatabase="true"
  sqlConnectionString="data source=dbserver;uid=database ;pwd=userid ;
                       database=password;pooling=true;"
  sqlCommandTimeout="30"
  cookieless="false"
  timeout="20"
/>

    <caching>
      <outputCacheSettings>
        <outputCacheProfiles>
          <add name="MyCache" duration="0" varyByParam="none"/>
        </outputCacheProfiles>
      </outputCacheSettings>
    </caching>

  </system.web>

  <location path="App_Themes/SkinFile">
    <system.web>
      <authorization>
        <allow users="*"/>
      </authorization>
    </system.web>
  </location>

 
</configuration>

Introduction

Instructions

1. Add a new web form to your solution, name it ChatPage.aspx, choose C# language.
2. Copy and paste the "Page html" to the source view of you web form.
3. Copy and paste the "Page code behind" code to the code behind file of your web form named ChatPage.aspx.cs.
4. Copy and paste the "Business logic" to a new class in your App_Code folder named SPilafisChatLogic.cs.
5. Add Ajax for ASP.NET 2.0 (VS2005) to your solution. (With VS2005 you just have to drag and drop the dll in your bin folder and add a couple of lines to your web.config)
6. Get some french fries and enjoy!

Page html

Collapse

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="ChatPage.aspx.cs" Inherits="ChatPage" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN""http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" >
<head id="Head1" runat="server">
    <title>Chat Ajax .NET</title>
    <style type="text/css">
    td {
        font-family: Arial;
        font-size: 8pt;
       }
    </style>
    <!--
    License and Disclaimer: All the intructions, code, html and everything presented with this solution is provided 'as is' with no warranties what so ever.
	The only condition for you to use this software is that you keep the link to http://www.spilafis.com.ar in the chat page as provided. Please support freeware keeping the link and clicking on my sponsors.
	Thank you!
    !-->
</head>
<body>

	<form id="form1" runat="server" onsubmit="return false;">
<br />
<br />
<br />
<br />
<br />
<br />
<br />
    <table align="center" width="732" border="0" cellpadding="0" cellspacing="0">
    <tr>
        <td>
        <textarea id="txtChatFrame" runat="server" rows="15" style="width:527px; border:1px solid #aaaaaa; padding:4px;" readonly="readonly"></textarea><br/>
        </td>
        <td valign="top">
            <div style="overflow: auto; height: 226px; border-top: solid 2px gray; border-bottom: solid 2px gray; border-right: solid 1px gray; border-left: solid 1px gray; ">
                <asp:GridView ID="grvUsers" runat="server" AutoGenerateColumns="False" BackColor="White"
                    BorderColor="#DEDFDE" BorderStyle="None" BorderWidth="1px" CellPadding="1" ForeColor="Black"
                    GridLines="Vertical" Height="30px">
                    <FooterStyle BackColor="#CCCC99" />
                    <Columns>
                        <asp:BoundField HeaderText="User" ReadOnly="True" DataField="ChatUsers">
                            <ItemStyle Width="110px" />
                            <HeaderStyle Height="10px" />
                        </asp:BoundField>
                        <asp:BoundField HeaderText="Last Activity" DataField="ChatLastActivity">
                            <ItemStyle Width="190px" />
                            <HeaderStyle Height="10px" />
                        </asp:BoundField>
                    </Columns>
                    <RowStyle BackColor="#F7F7DE" />
                    <SelectedRowStyle BackColor="#CE5D5A" Font-Bold="True" ForeColor="White" />
                    <PagerStyle BackColor="#F7F7DE" ForeColor="Black" HorizontalAlign="Right" />
                    <HeaderStyle BackColor="#6B696B" Font-Bold="True" ForeColor="White" />
                    <AlternatingRowStyle BackColor="White" />
                </asp:GridView>
            </div>
            <input id="btnRefresh" runat="server" type="submit" onclick="document.forms['form1'].submit();" value="Refresh" style="cursor:pointer;border:1px solid gray; height: 15px; width: 100%; font-size: 7pt;" size="20"/>
            </td>            
    </tr>
    <tr>
        <td>
        
        <table border="0" cellpadding="0" cellspacing="5" style="width:527px;">
        <tr>
            <td align="right" valign="middle">Message: </td>
            <td align="left" style="height: 45px" valign="top">
                <table border="0" cellpadding="0" cellspacing="2">
                <tr>
                    <td><textarea cols="70" rows="2" id="txtMssg" style="border:1px solid gray; width: 370px; height: 37px;" onkeyup="SendByKey(event.keyCode);"></textarea></td>
                    <td><input id="btnSend" type="button" value="Send" onclick="Send()" style="cursor:pointer;border:1px solid gray; height: 42px;"/></td>
                </tr>
                </table></td>  
        </tr>
        <tr>
            <td align="right" valign="middle" style="width:70px">User Name: </td>
            <td align="left">
                <table border="0" cellpadding="0" cellspacing="2">
                <tr>
                    <td><input id="txtName" type="text" maxlength="10" style="border:1px solid #aaaaaa; width: 145px;" onblur="ChangeUserName(this);"/ value="<%=SpilafisChatLogic.Chat.GetUserName()%>" />
                    </td>
                    <td>
                        &nbsp;&nbsp; Get source code!: <a href="http://www.spilafis.com.ar">http://www.spilafis.com.ar</a>
                    </td>
                </tr>
                </table>
            </td>  
        </tr>
        </table>

        </td>
        <td valign="middle">
            <br />
            <table border="0" cellpadding="0" cellspacing="0">
                <tr>
                    <td align="center">Users Writing: &nbsp;&nbsp; <br />(max. <%=SpilafisChatLogic.Chat.MaxLoggedInUsers.ToString()%>) </td>
                    <td align="right"><span id="spnW">0</span> <br /><br /></td>
                </tr>
                <tr>
                    <td colspan="2">&nbsp;<br /></td>
                </tr>
                <tr>
                    <td align="left">Users Reading: &nbsp;&nbsp; </td>
                    <td align="right"><span id="spnR">0</span></td>
                </tr>
            </table>
        </td>
    </tr>
    </table>

    <br />
    
    <br />


<script type="text/javascript" language="javascript">

function ChangeUserName(otxtName)
{
    var tentative_name = otxtName.value;
    if(tentative_name=="")
        alert("You must enter a user name to be able to chat.");
    else
    {
        if(tentative_name!=last_user_name)
        {
            var otxtMssg = document.getElementById("txtMssg");
            var obtnSend = document.getElementById("btnSend");

            var ret = Chat.ChangeUserName(tentative_name);
            if(ret!=null && ret.error!=null && ret.error!="")
            {
                otxtName.value = last_user_name;
                alert(new String(ret.error).replace("System.Exception ",""));
            }
            else
            {
                last_user_name = otxtName.value;
                obtnSend.disabled = false;
                otxtMssg.disabled = false;
                otxtMssg.focus();
            }
        }
    }
}

function Send()
{
    var otxtName = document.getElementById("txtName");
    if(otxtName.value!="")
    {
        var otxtMssg = document.getElementById("txtMssg");
        if(!otxtMssg.disabled)
        {
            var ret = Chat.Post(otxtMssg.value);
            if(ret!=null && ret.error!=null)
            {
                alert(new String(ret.error).replace("System.Exception ",""));
            }
            otxtMssg.value = "";
            otxtMssg.focus();
        }
    }
    else
    {
        if(!otxtName.disabled)
        {
            alert("Enter a user name");
            otxtName.focus();
        }
    }
}

function SendByKey(keycode)
{
    if (keycode == 13)
        Send();
    event.returnValue = false;
}

var cycles = 20;
var add_wait_cycles = 20;
var reload_wait = 700;
var last_user_name = "";
var max_chat_lines = <%=SpilafisChatLogic.Chat.MaxChatLines%>;
function Reload()
{
    var ret;
    cycles++;;
    if(cycles>=add_wait_cycles)
    {
        cycles = 0;

        // Get users writing
        ret = Chat.GetUsersWriting();
        if(ret!=null && (ret.error==null || ret.error=="") && ret.value!=null && ret.value!="")
            document.getElementById("spnW").innerHTML = ret.value;

        // Get users reading
        ret = Chat.GetUsersReading();
        if(ret!=null && (ret.error==null || ret.error=="") && ret.value!=null && ret.value!="")
            document.getElementById("spnR").innerHTML = ret.value;
    }

    // If not logged in to write then try to logg in the user
    var otxtMssg = document.getElementById("txtMssg");
    if(otxtMssg.disabled)
    {
        var otxtName = document.getElementById("txtName");
        if(otxtName.value=="")
        {
            ret = Chat.GetNextUserName();
            if(ret!=null && ret.error==null && ret.value!=null && ret.value!="")
            {
                    otxtName.value = ret.value;
                    LoggedIn();
                    alert("You have been logged in");
            }
        }
        else
        {
            last_user_name = otxtName.value;
            otxtMssg.disabled = false;
            var obtnSend = document.getElementById("obtnSend");
            obtnSend.disabled = false;
            otxtMssg.focus();
        }
    }

    // Read Chat
    var ret = Chat.Read();
    if(ret!=null && ret.error!=null)
    {
        alert("A critical error ocurred: " + new String(ret.error).replace("System.Exception ","") + "\nPlease reload page to try again.");
        return;
    }
    var value = ret.value;
    if(value!=null && value!="")
    {
        var otxtChatFrame = document.getElementById("<%=txtChatFrame.ClientID%>");
        var already_read = otxtChatFrame.value;
        //var all = value + already_read;
        var all = already_read + value;
        if(all!="")
        {
            var arr = all.split("\n");
            if(arr.length>max_chat_lines)
            {
                all = "";
                //for(var i=0; i<max_chat_lines; i++)
                for(var i=(arr.length-max_chat_lines); i<arr.length; i++)
                    all += arr[i] + "\n";
            }
        }    
        otxtChatFrame.value = all;
        // Scroll down to the last read line
        otxtChatFrame.scrollTop=otxtChatFrame.scrollHeight;
    }

    window.setTimeout("Reload();", reload_wait);
}

function Start()
{
    Reload();

    // Initial scroll down to the last read line (in case Refresh is hit)
    var otxtChatFrame = document.getElementById("<%=txtChatFrame.ClientID%>");
    otxtChatFrame.scrollTop=otxtChatFrame.scrollHeight;
}

function LoggedIn()
{
    var otxtName = document.getElementById("txtName");
    var obtnSend = document.getElementById("btnSend");
    var otxtMssg = document.getElementById("txtMssg");
    last_user_name = otxtName.value;
    otxtName.disabled = false;
    obtnSend.disabled = false;
    otxtMssg.disabled = false;
    otxtMssg.focus();
}

// Call to start!
Start();
</script>


	
	</form>
	
</body>
</html>

Page code behind

Collapse

using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Threading;
using System.Globalization;

/// <summary>/// License and Disclaimer: All the intructions, code, html and everything presented with this solution is provided 'as is' with no warranties what so ever./// The only condition for you to use this software is that you keep the link to http://www.spilafis.com.ar in the chat page as provided. Please support freeware keeping the link and clicking on my sponsors./// Thank you!/// </summary>
public partial class ChatPage : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        // Register AJAX
        Ajax.Utility.RegisterTypeForAjax(typeof(SpilafisChatLogic.Chat));
        
        UpdateUsersGridView();
    }

    public void UpdateUsersGridView()
    {
        // Update grid
        grvUsers.DataSource = SpilafisChatLogic.Chat.GetUsersDataSource();
        grvUsers.DataBind();
    }
    protected void btnRefresh_ServerClick(object sender, EventArgs e)
    {
        UpdateUsersGridView();
    }
}

Business logic

Collapse

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;

using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Threading;
using System.Globalization;

namespace SpilafisChatLogic
{
    /// <summary>/// License and Disclaimer: All the intructions, code, html and everything presented with this solution is provided 'as is' with no warranties what so ever./// The only condition for you to use this software is that you keep the link to http://www.spilafis.com.ar in the chat page as provided. Please support freeware keeping the link and clicking on my sponsors./// Thank you!/// </summary>
    public class Business
    {
        public Business()
        {
        }

        public static User CurrentUser
        {
            get
            {
                if (HttpContext.Current.Session["ChatCurrentUser"] == null)
                    HttpContext.Current.Session["ChatCurrentUser"] = new User();

                return (User)HttpContext.Current.Session["ChatCurrentUser"];
            }
            set
            {
                HttpContext.Current.Session["ChatCurrentUser"] = value;
            }
        }

        public static App CurrentApp
        {
            get
            {
                if (HttpContext.Current.Application["ChatCurrentApp"] == null)
                    HttpContext.Current.Application["ChatCurrentApp"] = new App();

                return (App)HttpContext.Current.Application["ChatCurrentApp"];
            }
            set
            {
                HttpContext.Current.Application["ChatCurrentApp"] = value;
            }
        }
    }

    public class User
    {
        #region Private Members

        private bool m_ajax_chat_counted;
        private string m_ajax_chat_user_name;
        private int m_ajax_chat_last_read_id;

        private bool m_code_access_enabled;

        #endregion

        public User()
        {
            m_ajax_chat_counted = false;
            m_ajax_chat_user_name = "";
            m_ajax_chat_last_read_id = -1;

            m_code_access_enabled = false;
        }

        #region Properties

        public bool AjaxChatCounted
        {
            get { return m_ajax_chat_counted; }
            set { m_ajax_chat_counted = value; }
        }

        public string AjaxChatUserName
        {
            get { return m_ajax_chat_user_name; }
            set { m_ajax_chat_user_name = value; }
        }

        public int AjaxChatLastReadId
        {
            get { return m_ajax_chat_last_read_id; }
            set { m_ajax_chat_last_read_id = value; }
        }

        #endregion

    }


    public class App
    {
        #region Private Members

        private int m_ajax_chat_users_r;
        private Hashtable m_ajax_chat_users_w;
        private Hashtable m_ajax_chat_users_w_last_activity;
        private ArrayList m_ajax_chat;

        #endregion


        public App()
        {
            m_ajax_chat_users_w = new Hashtable();
            m_ajax_chat_users_w_last_activity = new Hashtable();
            m_ajax_chat = new ArrayList();
        }


        #region Properties

        public int AjaxChatUsersR
        {
            get { return m_ajax_chat_users_r; }
            set { m_ajax_chat_users_r = value; }
        }

        public Hashtable AjaxChatUsersW
        {
            get { return m_ajax_chat_users_w; }
            set { m_ajax_chat_users_w = value; }
        }

        public Hashtable AjaxChatUsersWLastActivity
        {
            get { return m_ajax_chat_users_w_last_activity; }
            set { m_ajax_chat_users_w_last_activity = value; }
        }

        public ArrayList AjaxChat
        {
            get { return m_ajax_chat; }
            set { m_ajax_chat = value; }
        }

        #endregion
    }


    public class Chat
    {
        #region Constants

        public static int MaxMessageLength = 100;
        public static int MaxChatLines = 50;
        public static int MaxLoggedInUsers = 5;
        public static string[] BadWords = { "a**hole", "boludo"}; // Add your bad word dictionary here        #endregion

        public Chat()
        {
        }

        #region Methods

        private static void IncrementUsersReading()
        {
            Business.CurrentApp.AjaxChatUsersR = GetIntUsersReading() + 1;
        }

        private static int GetIntUsersReading()
        {
            return Business.CurrentApp.AjaxChatUsersR;
        }

        private static int GetId(string message)
        {
            return Convert.ToInt32(message.Split('-')[0]);
        }

        private static string GetMessage(string message)
        {
            return message.Split('-')[1];
        }

        private static string GetNextId(ArrayList ajax_chat_list)
        {
            int id = GetMaxId(ajax_chat_list);
            if (id < Int32.MaxValue)
                id++;
            else
                id = 0;
            return id.ToString() + "-";
        }

        private static int GetMaxId(ArrayList ajax_chat_list)
        {
            if (ajax_chat_list.Count > 0)
                return GetId(ajax_chat_list[0].ToString());
            else
                return 0;
        }

        [Ajax.AjaxMethod(Ajax.HttpSessionStateRequirement.ReadWrite)]
        public static string GetUserName()
        {
            if (Business.CurrentUser.AjaxChatUserName == "")
                Chat.GetNextUserName();
            return Business.CurrentUser.AjaxChatUserName;
        }

        [Ajax.AjaxMethod(Ajax.HttpSessionStateRequirement.ReadWrite)]
        public static string GetNextUserName()
        {
            string user_name = "";
            // Count user reading if not counted yet
            if (!Business.CurrentUser.AjaxChatCounted)
            {
                Business.CurrentUser.AjaxChatCounted = true;
                IncrementUsersReading();  // Is decremented in session end
            }
            else
            {
                if (Business.CurrentUser.AjaxChatUserName != null && Business.CurrentUser.AjaxChatUserName != "")
                    return Business.CurrentUser.AjaxChatUserName;
            }

            int user_number = Business.CurrentApp.AjaxChatUsersW.Count + 1;
            // If user may log in 
            if (user_number <= MaxLoggedInUsers)
            {
                // Get first not used guest user name
                while (Business.CurrentApp.AjaxChatUsersW["ChatGuest" + user_number.ToString()] != null)
                {
                    if (user_number < int.MaxValue)
                        user_number++;
                    else
                        return "";
                }

                // Add to writing users list
                Business.CurrentApp.AjaxChatUsersW.Add("Guest" + user_number.ToString(), 1);

                // Save user name to session
                Business.CurrentUser.AjaxChatUserName = "Guest" + user_number.ToString();

                UpdateUserLastActivityTime();
            }
            return user_name;
        }

        [Ajax.AjaxMethod(Ajax.HttpSessionStateRequirement.ReadWrite)]
        public static void ChangeUserName(string tentative_name)
        {
            if (Business.CurrentUser.AjaxChatUserName == "")
            {
                int user_number = Business.CurrentApp.AjaxChatUsersW.Count + 1;
                // If user may not log in inform
                if (user_number > MaxLoggedInUsers)
                    throw new Exception("Max. number of writing users reached. You'll be inform when someone leaves.");
            }

            tentative_name = tentative_name.Trim();
            if (tentative_name == "")
                throw new Exception("You must enter a user name to be able to chat.");
            if (tentative_name.IndexOf('-') >= 0)
                throw new Exception("Character '-' is not allowed in the user name.");
            if (tentative_name.Length > 10)
                tentative_name = tentative_name.Substring(0, 10);

            // If exists inform
            if (Business.CurrentApp.AjaxChatUsersW[tentative_name] != null)
                throw new Exception("User name already in use. Please enter another.");

            // Remove old user name from the list// Add to writing users list
            ChangeUserNameInWList(tentative_name);

            // Save user name to session
            Business.CurrentUser.AjaxChatUserName = tentative_name;

            UpdateUserLastActivityTime();
        }

        [Ajax.AjaxMethod(Ajax.HttpSessionStateRequirement.ReadWrite)]
        public static void ChangeUserNameInWList(string new_name)
        {
            // If it already had a user name then remove from writing users
            if (Business.CurrentUser.AjaxChatUserName != null && Business.CurrentUser.AjaxChatUserName != "")
            {
                Business.CurrentApp.AjaxChatUsersW.Remove(Business.CurrentUser.AjaxChatUserName);

                // If it had a saved last activity time remove it
                Business.CurrentApp.AjaxChatUsersWLastActivity.Remove(Business.CurrentUser.AjaxChatUserName);

                // Add to writing users list
                Business.CurrentApp.AjaxChatUsersW.Add(new_name, 1);
                // NOTE: It is not necessary to add it to the last activity table because it will be added after this
            }
        }

        [Ajax.AjaxMethod(Ajax.HttpSessionStateRequirement.ReadWrite)]
        public static void Post(string message)
        {
            // Cut max message length
            message = message.Trim();
            if (message.Length > MaxMessageLength)
                message = message.Substring(0, MaxMessageLength);

            if (message != "")
            {
                // Add time and nickname to identify message
                string message_head = Business.CurrentUser.AjaxChatUserName + " says: ";
                message = message_head + message;

                ValidateMessage(Business.CurrentApp.AjaxChat, message);

                // Add message id
                message = GetNextId(Business.CurrentApp.AjaxChat) + message;

                // Insert new message
                Business.CurrentApp.AjaxChat.Insert(0, message);

                // Delete lines after MaxChatLines
                while (Business.CurrentApp.AjaxChat.Count > MaxChatLines)
                    Business.CurrentApp.AjaxChat.RemoveAt(Business.CurrentApp.AjaxChat.Count - 1);

                UpdateUserLastActivityTime();
            }
        }

        [Ajax.AjaxMethod(Ajax.HttpSessionStateRequirement.ReadWrite)]
        public static void ValidateMessage(ArrayList ajax_chat_list, string message)
        {
            int index;
            // Create array list of chat without message numbers
            ArrayList ajax_chat_nonumbers = new ArrayList();

            for (index = 0; index < ajax_chat_list.Count; index++)
                ajax_chat_nonumbers.Add(ajax_chat_list[index].ToString().Split('-')[1]);

            // Check for spam
            if (ajax_chat_nonumbers.Contains(message))
                throw new Exception("Please no spam...");

            // Create message words array
            string[] m_w = message.Replace("\n", " ").Replace("\r", "").Split(' ');
            ArrayList message_words = new ArrayList();
            for (index = 0; index < m_w.Length; index++)
                message_words.Add(m_w[index]);

            // Check for bad words
            for (index = 0; index < BadWords.Length; index++)
                if (message_words.Contains(BadWords[index]))
                    throw new Exception("Please no bad words...");
        }

        [Ajax.AjaxMethod(Ajax.HttpSessionStateRequirement.ReadWrite)]
        public static void UpdateUserLastActivityTime()
        {
            if (Business.CurrentUser.AjaxChatUserName != null && Business.CurrentUser.AjaxChatUserName != "")
                UpdateUserLastActivityTime(Business.CurrentApp.AjaxChatUsersWLastActivity);
        }

        [Ajax.AjaxMethod(Ajax.HttpSessionStateRequirement.ReadWrite)]
        public static void UpdateUserLastActivityTime(Hashtable ajax_chat_users_w_last_activity)
        {
            if (ajax_chat_users_w_last_activity[Business.CurrentUser.AjaxChatUserName] == null)
                ajax_chat_users_w_last_activity.Add(Business.CurrentUser.AjaxChatUserName, DateTime.Now);
            else
                ajax_chat_users_w_last_activity[Business.CurrentUser.AjaxChatUserName] = DateTime.Now;
        }

        public static DataTable GetUsersDataSource()
        {
            // Create data source
            DataTable dtSource = new DataTable();
            dtSource.Columns.Add(new DataColumn("ChatUsers"));
            dtSource.Columns.Add(new DataColumn("ChatLastActivity"));
            DataRow drSource;
            DateTime last_activity;

            if (Business.CurrentApp.AjaxChatUsersW.Keys.Count > 0)
            {
                // Add list of users to datasource
                foreach (object key in Business.CurrentApp.AjaxChatUsersW.Keys)
                {
                    drSource = dtSource.NewRow();
                    drSource["ChatUsers"] = key.ToString();
                    // Get last activity time
                    if (Business.CurrentApp.AjaxChatUsersWLastActivity[key] != null)
                    {
                        last_activity = (DateTime)Business.CurrentApp.AjaxChatUsersWLastActivity[key];
                        // Convert to GMT time
                        Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
                        string dateFormat = CultureInfo.InvariantCulture.DateTimeFormat.RFC1123Pattern.Replace("'GMT'", "zzz");
                        string dateString = last_activity.ToString(dateFormat);
                        drSource["ChatLastActivity"] = dateString;

                    }
                    else
                        drSource["ChatLastActivity"] = "<none>";
                    dtSource.Rows.Add(drSource);
                }
            }
            else
            {
                drSource = dtSource.NewRow();
                drSource["ChatUsers"] = "<none>";
                drSource["ChatLastActivity"] = "<none>";
                dtSource.Rows.Add(drSource);
            }


            // Sort by user name
            dtSource.DefaultView.Sort = "ChatUsers";

            return dtSource;
        }

        [Ajax.AjaxMethod(Ajax.HttpSessionStateRequirement.ReadWrite)]
        public static string Read()
        {
            int id;
            int max_id = 0;
            string message;

            // Create chat list if not created
            System.Text.StringBuilder chat = new System.Text.StringBuilder();

            // Get chat from application level
            ArrayList ajax_chat_list = Business.CurrentApp.AjaxChat;

            // Get last read id from user session if already saved
            int last_read_id = Business.CurrentUser.AjaxChatLastReadId;

            // Write it to a string
            int index;
            ArrayList chat_arr = new ArrayList();
            for (index = 0; index < ajax_chat_list.Count; index++)
            {
                id = GetId(ajax_chat_list[index].ToString());
                if (index == 0)
                    max_id = id;
                message = GetMessage(ajax_chat_list[index].ToString());

                // If last read message read reached then stop reading
                if (id == last_read_id)
                    break;
                // Note: Why not "<="?//       Because "<=" may cause stop of reading// Example: If last message read is 9, and then the id 10 message was sent//          and then the id message 1 was sent, first message read would be id 1 that is < than 9//          and wouldn't be read although it should be//          (if read, comparing just equal, then id 10 would be read and in 9 it would stop)

                chat_arr.Add(System.Web.HttpUtility.HtmlEncode(message) + "\n");
                //chat.Append(Server.HtmlEncode(message) + "\n");
            }

            // Build inverted order chat string
            for (index = chat_arr.Count - 1; index >= 0; index--)
                chat.Append(chat_arr[index].ToString());

            // Set max_id as new last_read_id to user session
            Business.CurrentUser.AjaxChatLastReadId = max_id;

            UpdateUserLastActivityTime();

            // Return chat string to user with max_id to set as new last_read_id
            return chat.ToString();
        }

        [Ajax.AjaxMethod(Ajax.HttpSessionStateRequirement.ReadWrite)]
        public static string GetUsersWriting()
        {
            return Business.CurrentApp.AjaxChatUsersW.Count.ToString();
        }

        [Ajax.AjaxMethod(Ajax.HttpSessionStateRequirement.ReadWrite)]
        public static string GetUsersReading()
        {
            return GetIntUsersReading().ToString();
        }

        #endregion
    }

}

See a working example: http://spilafis.com.ar/ChatPage.aspx

Or a more complex (same code but enhanced) but better working example: http://spilafis.com.ar/ChatAjaxNet.aspx

License and Disclaimer: All the intructions, code, html and everything presented in this page is provided 'as is' with no warranties what so ever.
The only condition for you to use this software is that you keep the link to http://www.spilafis.com.ar in the chat page as provided.
Please support freeware keeping the link.

Introduction

In my previous article, I discussed the DataTableTransactionLog. This article further develops those concepts by implementing a DataTable synchronization manager. The synchronization manager is responsible for taking the transaction records and creating a list of record "packets". It also takes a list of record "packets" and reconstructs the transaction records. These transaction records can then be applied to a target DataTable, synchronizing the individual DataTables.

Refactoring

Several refactorings have been made that readers of the previous article should be aware of. Besides the change of namespace, to "Clifton.Data", the others are the following:

DataTableTransactionLog.cs:

• Moved Apply and Revert record manipulation to the DataTableTransactionLog class.
• Moved RestoreRowFields and SaveRowFields to the DataTableTransactionLog class.
• Added indexer to return the transaction record.
• Modified the Deleting event to search all the previous transactions and save the current row data in any transaction record that references the row about to be deleted.
• The logger now utilizes an internal DataView to facilitate finding records by primary key(s) during synchronization.

DataTableTransactionRecord.cs:

• TransType property renamed to TransactionType.
• TransactionType enumeration renamed to RecordType.
• Added a virtual Apply method that implements the logic that used to be in the DataTableTransactionLog class.
• Added a non-virtual Revert method that implements the logic that used to be in the DataTableTransactionLog class.
• columnValues is exposed (ColumnValues) and is settable.

Architecture

There is a specific architecture that drives the application's interface to the synchronization manager. The application requirements are:

• ensuring that each DataTable implements the same column names.
• utilizing one or more primary keys to uniquely identify each row.
• ensuring that primary key values are initialized and valid before getting the transaction packets from the synchronization manager.
• ensuring that primary key values are initialized and valid before applying transaction packets to the target DataTable.
• the primary keys are determined from the DataTable's PrimaryKey array.

The following is a UML diagram illustrating the relationships between the logger and the synchronization manager:

The classes relevant to the DataTable synchronization will be discussed next.

TransactionRecordPacket

In the previous article, the DataTableTransactionRecord tracked changes to DataRow instances. Since each DataTable will have a different DataRow instance, it is necessary to use a different mechanism to synchronize unique DataTable instances. The mechanism I chose was to utilize the primary key column(s). If your DataTable does not have a primary key column, you will have to add one, or modify your query to acquire the primary key column from the persistent store.

The TransactionRecordPacket stores the primary key values in a dictionary, mapping the primary key column name and the primary key value. If the transaction is a column change, the column name of the field being changed and the new value is also stored. The old value is not preserved, nor is the entire row's field values if the row is deleted.

Implementation

The critical part of the implementation is the call to GetGuaranteedRowValue, which gets the specified field value regardless of whether the row has been deleted:

				public TransactionRecordPacket(DataTableTransactionRecord record)
{
  pkValues = new Dictionary<string, object>();
  tranType = record.TransactionType;

  foreach (DataColumn dc in record.Row.Table.PrimaryKey)
  {
    pkValues.Add(dc.ColumnName, record.GetGuaranteedRowValue(dc.ColumnName));
  }

  // Fill in some additional information if the transaction is a ChangeField.if (tranType == DataTableTransactionRecord.RecordType.ChangeField)
  {
    columnName = record.ColumnName;
    newValue = record.NewValue;
  }
}

This means that even for deleted rows, we can acquire the primary key field values so we can find the row in the DataTable being synchronized and delete it. The internal implementation of the GetGuaranteedRowValue method is:

				public
				object GetGuaranteedRowValue(string fieldName)
{
  object ret = null;

  if (WasDeleted)
  {
    ret = columnValues[fieldName];
  }
  else
  {
    if (row.RowState == DataRowState.Deleted)
    {
      thrownew DataTableTransactionException(
          "Row has been deleted and there is no saved column values.");
    }

    ret = row[fieldName];
  }

  return ret;
}

The columnValues property is populated when the record is deleted, as mentioned above, for all transaction records that reference the row being deleted. This is the refactoring of the OnRowDeleting handler:

Collapse

				protected
				void OnRowDeleting(object sender, DataRowChangeEventArgs e)
{
  if (doLogging)
  {
    DataTableTransactionRecord record;
    record = new DataTableTransactionRecord(transactions.Count, e.Row, 
         DataTableTransactionRecord.RecordType.DeleteRow);
    record.SaveRowFields(e.Row);
    OnTransactionAdding(new TransactionEventArgs(record));
    transactions.Add(record);
    Dictionary<string, object> colVals = record.ColumnValues;

    // Tell all transaction records involving this row to save the row fields.// This allows us to access deleted row data in earlier transactions.// Alternatively, since the row is deleted, all transactions involving the // deleted row could be removed. I'm not sure about this approach though--// is it possible for transactions to affect other non-deleted data before// the row deleted?for (int i = 0; i < transactions.Count - 1; i++)
    {
      if (transactions[i].Row == e.Row)
      {
        transactions[i].ColumnValues = colVals;
      }
    }

    OnTransactionAdded(new TransactionEventArgs(record));
  }
}

I'm not particularly thrilled with this implementation simply because it requires iterating through the transaction list. Well, optimizations can be done later, right?

DataTablePKTransactionRecord

This class is derived from DataTableTransactionRecord and overrides the Apply method. As mentioned above, the primary key values of a row must be used rather than the DataRow instance.

Implementation

The Apply method is implemented as follows:

Collapse

				public
				override DataRow Apply(DataView dataView)
{
  DataTable sourceTable=dataView.Table;

  // If the transaction record contains a known DataRow, then use// the default Apply method.if (row != null)
  {
    base.Apply(dataView);
  }
  else
  {
    // We have to use the PK value information to determine the row.switch (transType)
    { 
      case RecordType.NewRow:
        row = sourceTable.NewRow();
        SetPKFieldValues();
        sourceTable.Rows.Add(row);
        break;

      case RecordType.DeleteRow:
        row = FindRow(dataView);
        row.Delete();
        break;

     case RecordType.ChangeField:
       row = FindRow(dataView);
       row[columnName] = newValue;
       break;
    }
  }

  returnnull;
}

The call to SetPKFieldValues:

				protected
				void SetPKFieldValues()
{
  foreach (KeyValuePair<string, object> kvp in pkFieldNameValues)
  {
    row[kvp.Key] = kvp.Value;
  }
}

is necessary so that a new row can be located after it has been added. This results in some redundancy in transactions that set the primary key values even though they've already been set here. A possible refactoring would be to accumulate all the field change transactions and apply them all at once when adding a new row. That would involve an implementation that has access to all the transaction records, whereas what I'm focusing on here is applying transaction records one at a time. This is an important step as it validates the implementation for the basic requirements.

The FindRow method sets up the primary key field values as determined by the packet's primary key field/value dictionary:

				protected DataRow FindRow(DataView dataView)
{
  if ((dataView.Sort == null) || (dataView.Sort == String.Empty))
  {
    thrownew DataTableSynchronizationManagerException("The transaction 
       logger's SetupSort method must be called before synchronization.");
  }

  object[] pks = newobject[pkValues.Count];
  pkValues.Values.CopyTo(pks, 0);
  int idx = dataView.Find(pks);

  if (idx < 0)
  {
    thrownew DataTableSynchronizationManagerException("Could not find row 
          to update.");
  }

  return dataView[idx].Row;
}

DataTableSynchronizationManager

The synchronization manager interfaces with the DataTableTransactionLog instance to acquire the transactions and convert them into TransactionRecordPacket instances. It also does the reverse--taking a collection of TransactionRecordPacket instances and adding them to the logger's transaction collection.

Implementation

GetTransactions returns a list of TransactionRecordPacket instances:

				public List<TransactionRecordPacket> GetTransactions()
{
  if (logger.SourceTable.PrimaryKey == null)
  {
    thrownew DataTableTransactionException(
       "GetTransactions requires at least one PK.");
  }

  List<TransactionRecordPacket> packets = new List<TransactionRecordPacket>();

  foreach (DataTableTransactionRecord record in logger.Log)
  {
    TransactionRecordPacket trp = new TransactionRecordPacket(record);
    packets.Add(trp);
  }

  return packets;
}

These can then be applied to a transaction of the logger managing the mirrored DataTable:

				public
				void AddTransactions(List<TransactionRecordPacket> transactionPackets)
{
  foreach (TransactionRecordPacket trp in transactionPackets)
  {
    logger.Log.Add(new DataTablePKTransactionRecord(trp));
  }
}

Note how the synchronization manager adds the instances of the specialized DataTablePKTransactionRecord class. This is so that the Appy method can be overridden so that primary key values are used to locate rows rather than the DataRow instance itself.

Lastly, the synchronization manager implements two methods, SetupSort and Sync, the latter of which is used to apply all transactions added to the transaction log. These are expected to be exclusively DataTablePKTransactionRecord instances:

				public
				void Sync()
{
  SetupSort();
  logger.SuspendLogging();

  foreach (DataTableTransactionRecord record in logger.Log)
  {
    if (!(record is DataTablePKTransactionRecord))
    {
      thrownew DataTableSynchronizationManagerException("Expected a record 
          of type DataTablePKTransactionRecord.");
    }

    record.Apply(logger.DataView);
  }

  logger.ResumeLogging();
}

The SetupSort method will set up the DataView.Sort property so that the DataView.Find method can be used to find rows based on their primary keys. For this to work, the DataColumn instances in the DataTable's Column collection must be initialized in the same order:

				protected
				void SetupSort()
{
  if (logger.SourceTable.PrimaryKey == null)
  { 
    thrownew DataTableTransactionException(
        "GetTransactions requires at least one PK.");
  }

  string sortBy = String.Empty;
  string comma = String.Empty;

  foreach (DataColumn dc in logger.SourceTable.PrimaryKey)
  {
    sortBy += comma + dc.ColumnName;
    comma = ", ";
  }

  logger.DataView.Sort = sortBy;
}

Unit Tests

I've created a unit test for both the core logger functionality and the synchronization manager.

Transaction Logger

The transaction logger unit tests are a sequential set of unit tests, runnable using my Advanced Unit Test engine.

Collapse

				using System;
using System.Collections.Generic;
using System.Data;

using Vts.UnitTest;

using Clifton.Data;

namespace TransactionLoggerUnitTests
{
  [TestFixture]
  [ProcessTest]
  publicclass LoggerTests
  {
    protected DataTable dt;
    protected DataTableTransactionLog dttl;
    protected DataRow row;

    [TestFixtureSetUp]
    publicvoid FixtureSetup()
    {
      dt = new DataTable();
      dt.Columns.Add(new DataColumn("LastName", typeof(string)));
      dt.Columns.Add(new DataColumn("FirstName", typeof(string)));

      dttl = new DataTableTransactionLog();
      dttl.SourceTable = dt;
    }

    [Test, Sequence(1)]
    publicvoid NewRow()
    {
      row = dt.NewRow();
      Assertion.Assert(dttl.Log.Count == 1, "Expected one entry.");
      Assertion.Assert(dttl.Log[0].TransactionType == 
          DataTableTransactionRecord.RecordType.NewRow, 
          "Expected new row transaction.");
    }

    [Test, Sequence(2)]
    publicvoid SetFields()
    {
      row["LastName"] = "Clifton";
      row["FirstName"] = "Marc";
      dt.Rows.Add(row);
      Assertion.Assert(dttl.Log.Count == 3, "Expected three entries.");
      Assertion.Assert(dttl.Log[1].TransactionType == 
           DataTableTransactionRecord.RecordType.ChangeField, 
           "Expected change field transaction.");
      Assertion.Assert(dttl.Log[2].TransactionType == 
           DataTableTransactionRecord.RecordType.ChangeField, 
           "Expected change field transaction.");
      Assertion.Assert(dttl.Log[1].NewValue.ToString()=="Clifton", 
           "Incorrect new value.");
      Assertion.Assert(dttl.Log[2].NewValue.ToString() == "Marc", 
           "Incorrect new value.");
    }

    [Test, Sequence(3)]
    publicvoid CollectNothing()
    {
      dttl.CollectUncommittedRows();    
      Assertion.Assert(dt.Rows.Count == 1, "Committed row was collected!");
    }

    [Test, Sequence(4)]
    publicvoid CollectUncommitted()
    {
      dt.NewRow();
      dttl.CollectUncommittedRows();
      Assertion.Assert(dttl.Log.Count == 3, "Expected three entries.");
    }

    [Test, Sequence(5)]
    publicvoid RevertFirstNameChange()
    {
      dttl.Revert(2);
      Assertion.Assert(dt.Rows[0]["LastName"].ToString() ==
         "Clifton", "Incorrect value.");
      Assertion.Assert(dt.Rows[0]["FirstName"]==DBNull.Value, 
         "Incorrect new value.");
    }

    [Test, Sequence(6)]
    publicvoid RevertLastNameChange()
    {
      dttl.Revert(1);
      Assertion.Assert(dt.Rows[0]["LastName"] == DBNull.Value, 
          "Incorrect value.");
      Assertion.Assert(dt.Rows[0]["FirstName"] == DBNull.Value, 
          "Incorrect new value.");
    }

    [Test, Sequence(7)]
    publicvoid RevertNewRowChange()
    {
      dttl.Revert(0);
      Assertion.Assert(dt.Rows.Count == 0, "Row should have been deleted.");
    }

    [Test, Sequence(8)]
    publicvoid ApplyNewRow()
    {
      dttl.Apply(0);
      Assertion.Assert(dt.Rows.Count == 1, "Row was not added.");
      Assertion.Assert(dt.Rows[0]["LastName"] == DBNull.Value, 
           "Incorrect value.");
      Assertion.Assert(dt.Rows[0]["FirstName"] == DBNull.Value, 
           "Incorrect new value.");
    }

    [Test, Sequence(9)]
    publicvoid ApplyLastName()
    {
      dttl.Apply(1);
      Assertion.Assert(dt.Rows.Count == 1, "Row was not added.");
      Assertion.Assert(dt.Rows[0]["LastName"].ToString() == "Clifton", 
           "Incorrect value.");
      Assertion.Assert(dt.Rows[0]["FirstName"] == DBNull.Value, 
           "Incorrect new value.");
    }

    [Test, Sequence(10)]
    publicvoid ApplyFirstName()
    {
      dttl.Apply(2);
      Assertion.Assert(dt.Rows.Count == 1, "Row was not added.");
      Assertion.Assert(dt.Rows[0]["LastName"].ToString() == "Clifton", 
           "Incorrect value.");
      Assertion.Assert(dt.Rows[0]["FirstName"].ToString() == "Marc", 
           "Incorrect new value.");
    }
  }
}

Synchronization Manager

The unit test for the synchronization manager illustrates the basic process for synchronizing two DataTable instances:

Collapse

				using System;
using System.Collections.Generic;
using System.Data;

using Vts.UnitTest;

using Clifton.Data;

namespace TransactionSyncrhonizationManagerUnitTests
{
  [TestFixture]
  [ProcessTest]
  publicclass CurrencyTests
  {
    protected DataTable dt1;
    protected DataTableTransactionLog dttl1;
    protected DataTable dt2;
    protected DataTableTransactionLog dttl2;

    [TestFixtureSetUp]
    publicvoid FixtureSetup()
    {
      dt1 = new DataTable();
      dt1.Columns.Add(new DataColumn("PK", typeof(Guid)));
      dt1.Columns.Add(new DataColumn("LastName", typeof(string)));
      dt1.Columns.Add(new DataColumn("FirstName", typeof(string)));
      dt1.PrimaryKey = new DataColumn[] { dt1.Columns["PK"] };

      dttl1 = new DataTableTransactionLog(dt1);

      dt2 = dt1.Clone();
      dttl2 = new DataTableTransactionLog(dt2);

      DataRow row=dt1.NewRow();
      row["PK"]=Guid.NewGuid();
      row["LastName"]="Clifton";
      row["FirstName"]="Marc";
      dt1.Rows.Add(row);

      row=dt1.NewRow();
      row["PK"]=Guid.NewGuid();
      row["LastName"]="Linder";
      row["FirstName"]="Karen";
      dt1.Rows.Add(row);

      row=dt1.NewRow();
      row["PK"]=Guid.NewGuid();
      row["LastName"]="Doe";
      row["FirstName"]="John";
      dt1.Rows.Add(row);

      dt1.Rows[2].Delete();
    }

    [Test, Sequence(1)]
    publicvoid UpdateMirror()
    {
      DataTableSynchronizationManager dtcm1 = 
          new DataTableSynchronizationManager(dttl1);
      List<TransactionRecordPacket> trpList = dtcm1.GetTransactions();

      DataTableSynchronizationManager dtcm2 = 
          new DataTableSynchronizationManager(dttl2);
      dtcm2.AddTransactions(trpList);
      dtcm2.Sync();

      Assertion.Assert(dt2.Rows.Count == 2, "Expected 2 rows.");
      Assertion.Assert(dt2.Rows[0]["LastName"].ToString() == "Clifton", 
          "Unexpected value");
      Assertion.Assert(dt2.Rows[0]["FirstName"].ToString() == "Marc", 
          "Unexpected value");      
      Assertion.Assert(dt2.Rows[1]["LastName"].ToString() == "Linder", 
          "Unexpected value");
      Assertion.Assert(dt2.Rows[1]["FirstName"].ToString() == "Karen", 
          "Unexpected value");
    }
  }
}

You will note how both the DataTable instances are set up with the same column structure. The transaction packet collection, acquired from the DataTableSynchronizationManager that interfaces to the first logger, is passed to a second DataTableSynchronizationManager instance that interfaces with the second logger. The packets are added and the Sync method is called. Also note that because the two tables are intended to be synchronized, both implement a primary key column now.

Conclusion

The DataTableSynchronizationManager is a useful component in synchronizing the data between two remote DataTable instances. The transaction packet list is suitable for serialization, using my RawSerialization library, which would provide for a compact format to send across a network.

    #region Constructors
    public ChatUser(string id,string userName)
    {
        this.UserID=id;
        this.IsActive=false;
        this.LastSeen=DateTime.MinValue ;
        this.UserName=userName;
        this.LastMessageReceived=0;
    }
    #endregion

    #region IDisposable Members
    public void Dispose()
    {
        this.UserID="";
        this.IsActive=false;
        this.LastSeen=DateTime.MinValue ;
        this.UserName="";
        this.LastMessageReceived=0;
    }
    #endregion
}
</PRE>
<P nd="16">This class represents the user that will join the chat room. The
properties we are interested in are <CODE nd="17">IsActive</CODE>, <CODE
nd="18">LastSeen </CODE>and <CODE nd="19">LastMessageReceived</CODE>. Note that
in your application you may be using the ASP.NET membership providers. You can
easily use this with our chat application. You will find that the <CODE
nd="20">MembershipUser</CODE> class contains two properties <CODE
nd="21">IsOnline</CODE> and <CODE nd="22">LastActivityDate</CODE> that can be
used to replace the properties <CODE nd="23">IsActive</CODE> and <CODE
nd="24">LastSeen</CODE> respectively. </P>
<P nd="25">Each message that appears in the chat room is represented by the
following class:</P>
<DIV class=precollapse id=premain1 style="WIDTH: 100%"><IMG id=preimg1
style="CURSOR: hand" height=9 src="http://www.codeproject.com/images/minus.gif"
width=9 preid="1"> Collapse</DIV><PRE lang=cs id=pre1 style="MARGIN-TOP: 0px" nd="28">//ChatMessage.cs
public class Message
{
    #region Members
    public string user;
    public string msg;
    public MsgType type;
    #endregion

    #region Constructors
    public Message(string _user, string _msg, MsgType _type)
    {
        user = _user;
        msg = _msg;
        type = _type;
    }
    public Message(string _user, MsgType _type) :
                this(_user, "", _type) { }
    public Message(MsgType _type) : this("", "", _type) { }
    #endregion

    #region Methods
    public override string ToString()
    {
        switch(this.type)
        {
            case MsgType.Msg:
            return this.user+" says: "+this.msg;
            case MsgType.Join :
            return this.user + " has joined the room";
            case MsgType.Left :
            return this.user + " has left the room";
        }
        return "";
    }
    #endregion
}

public enum MsgType { Msg, Start, Join, Left, Action}
</PRE>
<P nd="42">Each chat room contains a hashtable of users and a list of
messages.</P>
<DIV class=precollapse id=premain2 style="WIDTH: 100%"><IMG id=preimg2
style="CURSOR: hand" height=9 src="http://www.codeproject.com/images/minus.gif"
width=9 preid="2"> Collapse</DIV><PRE lang=cs id=pre2 style="MARGIN-TOP: 0px" nd="45">//ChatRoom.cs
public class ChatRoom : IDisposable
{
    #region Members
   
    public List<message /> messages = null;
    public string RoomID;
    private Dictionary<string,chatuser /> RoomUsers;
    private int userChatRoomSessionTimeout;
       
    #endregion
    #region IDisposable Members
    public void Dispose()
    {
        this.messages.Clear();
        this.RoomID="";
        foreach(object key in RoomUsers.Keys)
        {
            this.RoomUsers[key.ToString()].Dispose ();
        }
    }
    #endregion
       
    #region Constructors
    public ChatRoom(string roomID)
    {
        this.messages = new List<message />();
        this.RoomID=roomID;
    userChatRoomSessionTimeout = Int32.Parse
    (System.Configuration.ConfigurationManager.AppSettings
            ["UserChatRoomSessionTimeout"]);
        RoomUsers = new Dictionary<string,chatuser />
    (Int32.Parse(System.Configuration.ConfigurationManager.AppSettings
                    ["ChatRoomMaxUsers"]));
    }
    #endregion
    .
    .
    .
    }
</PRE>
<P nd="55">The main methods in the <CODE nd="56">ChatRoom</CODE> class are
sending a message, joining a room and leaving a room. </P>
<DIV class=precollapse id=premain3 style="WIDTH: 100%"><IMG id=preimg3
style="CURSOR: hand" height=9 src="http://www.codeproject.com/images/minus.gif"
width=9 preid="3"> Collapse</DIV><PRE lang=cs id=pre3 style="MARGIN-TOP: 0px" nd="61">//ChatRoom.cs
#region Operations Join,Send,Leave
    /// Marks the user as inactive
    public void LeaveRoom(string userID)
    {
        //deactivate user
        ChatUser user=this.GetUser(userID);
        if (user == null)
        return ;
        user.IsActive=false;
        user.LastSeen=DateTime.Now;
            this.RoomUsers.Remove(userID);

        //Add leaving message
        Message msg = new Message(user.UserName ,"",MsgType.Left);
        this.AddMsg(msg);
           
    if (IsEmpty())
    ChatEngine.DeleteRoom(this.RoomID);
    }

    /// Activates the user and adds a join message to the room
    /// <returns />All the messages sent in the room</returns />
    public string JoinRoom(string userID,string userName)
    {
        //activate user
        ChatUser user=new ChatUser(userID,userName);
        user.IsActive=true;
        user.UserName=userName;
        user.LastSeen=DateTime.Now;
        if (!this.RoomUsers.ContainsKey(userID))
        {
            //Add join message
        Message msg=new Message(user.UserName ,"",MsgType.Join);
            this.AddMsg(msg);
            //Get all the messages to the user
            int lastMsgID;
            List<message /> previousMessages=
                this.GetMessagesSince(-1,out lastMsgID);
            user.LastMessageReceived=lastMsgID;
            //return the messages to the user
            string str=GenerateMessagesString(previousMessages);
            this.RoomUsers.Add(userID,user);
            return str;
        }
        return "";
    }

    /// Adds a message in the room
    /// <returns />All the messages sent from the other user from the last time
    ///the user sent a message</returns />
    public string SendMessage(string strMsg,string senderID)
    {
        ChatUser user=this.GetUser(senderID);
        Message msg=new Message(user.UserName ,strMsg,MsgType.Msg);
        user.LastSeen=DateTime.Now;
        this.ExpireUsers(userChatRoomSessionTimeout);
        this.AddMsg(msg);
        int lastMsgID;
        List<message /> previousMsgs= this.GetMessagesSince
            ( user.LastMessageReceived,out lastMsgID);
        if (lastMsgID!=-1)
            user.LastMessageReceived=lastMsgID;
        string res=this.GenerateMessagesString(previousMsgs);
        return res;
    }

    /// Removes the users that hasn't sent any message during the
    /// last window seconds
    /// <PARAM name="window" />time in secondes</PARAM />
    public void ExpireUsers(int window)
    {
        lock(this)
        {
    foreach (object key in RoomUsers.Keys)
    {
            ChatUser usr = this.RoomUsers[key.ToString()];
                lock (usr)
                {
                  if (usr.LastSeen != System.DateTime.MinValue)
                  {
                    TimeSpan span = DateTime.Now - usr.LastSeen;
                    if (span.TotalSeconds > window && usr.IsActive != false)
                        {
                          this.LeaveRoom(usr.UserID);
                        }
                   }
                 }
                }
    }
    #endregion
 </PRE>
<P nd="80">To keep the user updated, the following function retrieves all the
messages sent in the room up to the last message that was received by the
user.</P>
<DIV class=precollapse id=premain4 style="WIDTH: 100%"><IMG id=preimg4
style="CURSOR: hand" height=9 src="http://www.codeproject.com/images/minus.gif"
width=9 preid="4"> Collapse</DIV><PRE lang=cs id=pre4 style="MARGIN-TOP: 0px" nd="83">//ChatRoom.cs
<summary />    /// Returns all the messages sent since the last message
    /// the user received
    public string UpdateUser(string userID)
    {
        ChatUser user=this.GetUser(userID);
        user.LastSeen=DateTime.Now;
        this.ExpireUsers(userChatRoomSessionTimeout);
        int lastMsgID;
        List<message /> previousMsgs= this.GetMessagesSince
            ( user.LastMessageReceived,out lastMsgID);
        if (lastMsgID!=-1)
            user.LastMessageReceived=lastMsgID;
        string res=this.GenerateMessagesString(previousMsgs);
        return res;
    }
    /// Returns a list that contains all messages sent after the
    ///             message with id=msgid
    /// <PARAM name="msgid" />The id of the message after which all
    ///            the message will be retuned </PARAM />
    /// <PARAM name="lastMsgID" />the id of the last message returned</PARAM />
    public List<message /> GetMessagesSince(int msgid,out int lastMsgID)
    {
        lock(messages)
        {
        if ((messages.Count) <= (msgid+1))
            lastMsgID=-1;
        else
            lastMsgID=messages.Count-1;
        return messages.GetRange(msgid+1 , messages.Count - (msgid+1));
        }
    }
   
</PRE>
<P nd="91">The <CODE nd="92">ChatEngine</CODE> class acts as the container of
the chat rooms.</P>
<DIV class=precollapse id=premain5 style="WIDTH: 100%"><IMG id=preimg5
style="CURSOR: hand" height=9 src="http://www.codeproject.com/images/minus.gif"
width=9 preid="5"> Collapse</DIV><PRE lang=cs id=pre5 style="MARGIN-TOP: 0px" nd="95">//ChatEngine.cs
    public static class ChatEngine
    {
        #region Members
        private static Dictionary<string, /> Rooms =
                new Dictionary<string, />
        (Int32.Parse(System.Configuration.ConfigurationManager.AppSettings
                            ["MaxChatRooms"]));
        private static int userChatRoomSessionTimeout =
        Int32.Parse(System.Configuration.ConfigurationManager.AppSettings
                    ["UserChatRoomSessionTimeout"]);
        #endregion
               
        #region Methods
    /// Cleans all the chat roomsDeletes the empty chat rooms
    public static void CleanChatRooms(object state)
        {
            lock (Rooms)
            {
                foreach (object key in Rooms.Keys)
                {
                    ChatRoom room = Rooms[key.ToString()];
                    room.ExpireUsers(userChatRoomSessionTimeout);
                    if (room.IsEmpty())
                    {
                        room.Dispose();
                        Rooms.Remove(key.ToString());
                    }
                }
            }
        }

    /// Returns the chat room for this two users or create a new one
    /// if nothing exists
    public static ChatRoom GetRoom(string roomID)
    {
        ChatRoom room=null;
            lock (Rooms)
            {
                if (Rooms.ContainsKey (roomID))
                    room = Rooms[roomID];
                else
                {
                    room = new ChatRoom(roomID);
                    Rooms.Add(roomID, room);
                }
            }
            return room;
        }

    /// Deletes the specified room
    public static void DeleteRoom(string roomID)
    {
            if (!Rooms.ContainsKey(roomID))
                return;
            lock (Rooms)
            {
                ChatRoom room = Rooms[roomID];
                room.Dispose();
                Rooms.Remove(roomID);
            }
        }
        #endregion
    }
</PRE>
<P nd="106">An application level timer is set when the application starts to
periodically clean the empty chat rooms.</P><PRE lang=cs nd="108">//Global.asax
void Application_Start(object sender, EventArgs e)
    {
        System.Threading.Timer ChatRoomsCleanerTimer =
        new System.Threading.Timer(new TimerCallback
        (ChatEngine.CleanChatRooms), null, 1200000, 1200000);
    }
</PRE>
<P nd="109">When you run the application, it will take you to the default.aspx
page, where you are prompted to enter the user name that you will use in the
chat room. After that the user chooses the chat room that he will join.</P>
<P nd="110">The chatting page consists of a text area that displays all the
messages in the chat room and a list box that shows all the online users in the
room. The user writes his message in the text box and presses enter or clicks
the send button to send the message. A text box looks like this:</P>
<P><IMG height=276 alt="Chat Room" src="ASPNetChat/chat.jpg" width=582
border=0></P>
<H2>Client Side AJAX </H2>
<P nd="111">The Chat.aspx page contains javascript that calls methods on the <A
class=iAs
style="FONT-WEIGHT: normal; FONT-SIZE: 100%; PADDING-BOTTOM: 1px; COLOR: darkgreen; BORDER-BOTTOM: darkgreen 0.07em solid; BACKGROUND-COLOR: transparent; TEXT-DECORATION: underline"
href="#" target=_blank itxtdid="3442207">server</A> using AJAX. To call a method
on the server asynchoronously in AJAX you can: </P>
<UL>
<LI nd="112">Either place this method inside a web service and apply the <CODE
nd="113">ScriptService</CODE> attribute to this web service
<LI nd="114">Or place this method in the aspx page as a static public method and
apply the <CODE nd="115">WebMethod</CODE> attribute to it </LI></UL>
<P nd="116">I used the second approach in calling the server side methods.</P>
<P nd="117">All the javascript code is placed in the scripts.js file, there are
four asynchronous requests that are made from the javascript to the server, the
first two are sent periodically using a javascript timer, the <CODE
nd="118">updateUser</CODE> request is used to get all the messages that were
sent by the other users and updates the text area with these messages. The <CODE
nd="119">updateMembers</CODE> request is used to get all the online members in
the room and updates the members list box such that the members that left are
removed from the list and the newly joined members are added to the list. The
javascript code for these two requests is shown below:</P>
<DIV class=precollapse id=premain7 style="WIDTH: 100%"><IMG id=preimg7
style="CURSOR: hand" height=9 src="http://www.codeproject.com/images/minus.gif"
width=9 preid="7"> Collapse</DIV><PRE lang=jscript id=pre7 style="MARGIN-TOP: 0px" nd="121">//scripts.js
        var msgTimer = "";
           var membersTimer = "";
       
        startTimers();
     
        function startTimers()
        {
            msgTimer = window.setInterval("updateUser()",3000);
            membersTimer = window.setInterval("updateMembers()",10000);
        }
        function updateUser()
        {
            PageMethods.UpdateUser($get("hdnRoomID").value, UpdateMessages);
        }
        function updateMembers()
        {
            PageMethods.UpdateRoomMembers($get("hdnRoomID").value,
                            UpdateMembersList);
        }
        function UpdateMessages(result)
        {
            $get("txt").value=$get("txt").value+result;
            $get("txt").doScroll();
        }
        function UpdateMembersList(result)
        {
           // alert(result);
            var users=result.split(",");
           // alert(users.length);
            var i=0;
                               
                $get("lstMembers").options.length=0;
                 var i=0;
                while (i < users.length)
                {
                    if (users[i]!="");
                    {
                        var op=new Option(users[i],users[i]);
                        $get("lstMembers").options[$get("lstMembers").
                    options.length]= op;
                    }
                    i+=1;
                }
               }
</PRE>
<P nd="136">The <CODE nd="137">PageMethods</CODE> class is generated by the AJAX
script manager control and provides a proxy for all your server methods so that
you can call the method by passing it your parameters and passing the name of
the script callback function (the function that will be called when the result
of your method arrives from the server).</P>
<P nd="138">The corresponding server side methods for these two requests are
shown below:</P>
<DIV class=precollapse id=premain8 style="WIDTH: 100%"><IMG id=preimg8
style="CURSOR: hand" height=9 src="http://www.codeproject.com/images/minus.gif"
width=9 preid="8"> Collapse</DIV><PRE lang=cs id=pre8 style="MARGIN-TOP: 0px" nd="143">//Chat.aspx.cs
 
    /// This function is called peridically called from the user to update
    /// the messages
    [WebMethod]
    static public string UpdateUser(string roomID)
    {
        try
        {
            ChatRoom room = ChatEngine.GetRoom(roomID);
            if (room != null)
            {
                string res = "";
                if (room != null)
                {
                    res = room.UpdateUser(HttpContext.Current.Session
                    ["UserName"].ToString());
                }
                return res;
            }
        }
        catch (Exception ex)
        {

        }
        return "";
    }
    /// Returns a comma separated string containing the names of the users
    /// currently online
    [WebMethod]
    static public string UpdateRoomMembers(string roomID)
    {
        try
        {
            ChatRoom room = ChatEngine.GetRoom(roomID);
            if (room != null)
            {
                IEnumerable<string /> users=room.GetRoomUsersNames ();
                string res="";

                foreach (string  s in users)
                {
                    res+=s+",";
                }
                return res;
            }
        }
        catch (Exception ex)
        {
        }
        return "";
    }
</PRE>
<P nd="152">The third request is sent when the user presses the send button.
This request sends the user message to the room.</P><PRE lang=jscript nd="153">//scripts.js
    function button_clicked()
    {
        PageMethods.SendMessage($get("txtMsg").value,$get
        ("hdnRoomID").value, UpdateMessages, errorCallback);
        $get("txtMsg").value="";
        $get("txt").scrollIntoView("true");
    }
   
    function errorCallback(result)
    {
        alert("An error occurred while invoking the remote method: "
        + result);
    }
</PRE>
<P nd="161">The corresponding server side method for this request is:</P><PRE lang=cs>//Chat.aspx.cs
<summary />    /// This function is called from the client script
    [WebMethod]
    static public string SendMessage(string msg, string roomID)
    {
        try
        {
            ChatRoom room = ChatEngine.GetRoom(roomID);
            string res = "";
            if (room != null)
            {
                res = room.SendMessage
         (msg, HttpContext.Current.Session["UserName"].ToString());
            }
            return res;
        }
        catch (Exception ex)
        {

        }
        return "";
    }
</PRE>
<P>The last request is called during the <CODE>onunload</CODE> event of the
<body> element. This method notifies the server that the user left the
room. </P><PRE lang=jscript>//scripts.js
    function Leave()
    {
        stopTimers();
        PageMethods.LeaveRoom($get("hdnRoomID").value);
    }
</PRE>
<P>The corresponding server side method for this request is:</P><PRE lang=cs>//Chat.aspx.cs
<summary />    /// This function is called from the client when the user is about to
    /// leave the room
    [WebMethod]
    static public string LeaveRoom(string roomID)
    {
        try
        {
            ChatRoom room = ChatEngine.GetRoom(roomID);
            if (room != null)
                room.LeaveRoom(HttpContext.Current.Session["UserName"].
                            ToString());
        }
        catch (Exception ex)
        {

        }
        return "";
    }
</PRE>

After we have explored how to create a rich text editor, it is time to add some new features which will extend its usability and benefits. In this article we will get to know how new features were implemented. Again, all the major functionalities are written in javascript.

In the previous article you saw how easy it was to create your own text editor. Of course, as a first version the editor contained standard features. Now, after I had sometime to add new functionalities, I can say it contains more features and it is more robust.

Below are the newly added features.

1.    Strike Through: This will strike through the text entered by the user.

2.    Decrease-Increase Indent: This will decrease or increase the text indent.

3.    Insert Images: This will open a new window giving the user the ability to upload an image to the server and insert it directly into the editor.

4.    Copy, Cut, and Paste: This will copy, cut or paste the text entered by the user into the clipboard.

5.    Print: It allows only the text to be printed by opening the Print Setup dialog.

6.    Bulleted List & Numbered List: It adds a bullet or number at the beginning of the text.

7.    Super-Sub script: It will format the text into super script or sub script.

8.    Insert Lines: It adds lines to the text.

Add HTML code to the user control

In this section we will add new HTML elements to add more features into the toolbar. We will place images for all the above mentioned actions and handle all the events to perform their functionalities.

Listing 1

														
																<
																IMG class=StrikeOut id=Strikethroughonmouseover="ChangeImg('Strikethrough','strikethrough.over.gif')"title="Strike Through" onclick="Formats('StrikeThrough','<%= this.HamEditorChildID %>' )"onmouseout="ReturnImg('Strikethrough','strikethrough.gif',imgStatusUnderLine)"src="Images/strikethrough.gif" >
 
 
												

In the above listing we added an img HTML control. The onmouseover event will call a javascript function (which I already explained in the previous article), will change the image to a selected one, the onclick event will call another function which will apply the formatting into the selected text, and onmouseout will return the image to its previous state. For the rest of the features we will use the same concept except for the Insert Images.

Please download the project to see exactly how we created all the HTML tags.

Figure 1

In this section we will add the new functions to the already created javascript file to handle the events for all the new features. They are all defined in one javascript file linked to this editor.

Listing 2

														 
function Formats(style,editorId)
{
// Save the Iframe id
var finalDivId = editorId + '_content';
                  
// Set the focus back to the text
document.frames[finalDivId].focus();
                  
// Apply the new style
document.frames[finalDivId].document.execCommand(style);
                  
// Set the focus back to the text
document.frames[finalDivId].focus();
}
												

The above function is used by almost all the new event handlers. It takes two parameters; the first is the style to be applied, for example Copy, Paste, etc; the second is the editor id. We used the same function used before (execCommand) to apply the transformation.

Listing 3

														function SetBorders(id)
{
// set the borders to the emoticons icons onmouseover
var imgBorder = document.getElementById(id);
imgBorder.style.borderStyle = "solid";
imgBorder.style.borderWidth = "thin";
imgBorder.style.borderColor = "#688B9A";
}
												

The above function is being called when the insert emoticons div layer is shown. When the mouse is over an emotion, what we do is call this function which will set the borders for the table cell. In this way, it will be obvious for the user to see that he is over a specific emoticon. Notice the x image we added, it allows the user to close the div layer if he does not want to add any emoticons.

Figure 2

Listing 4

														function ClearBorders(id)
{
// Clear the borders of the emoticons icons onmouseout event
var imgBorder = document.getElementById(id);
imgBorder.style.borderStyle = "solid";
imgBorder.style.borderWidth = "thin";
imgBorder.style.borderColor = "white";
}
												

The above function will be called when the mouse is out of a specific emotion to clear its borders.

Listing 5

														function SetImage(editorId,path,e)
{
// Get the click location
var height = e.clientY + parseInt('5');
// Get the height inside the clicked image
var offsetHeight = parseInt(e.offsetY);
height = height - offsetHeight;
                  
// Get the click location(width)
var width = e.clientX
// Get the width inside the clicked image
var offsetWidth = parseInt(e.offsetX);
width = width - offsetWidth;
                  
// Save the iframe id
var finalDivId = editorId + '_content';
path = unescape(path);
                        
// Insert an image from the users Computers. 
window.open('UploadImages.aspx?path=' + path +
 '&f=' + finalDivId,null,'width=500px,height=50px,titlebar=no,menubar=no,statusbar=no,toolbar=no,top='
 + height + 'left=' + width );             
                        
}
												

For the insert images new feature, we created a new webform called UploadImages.aspx. This form will be open when the user clicks on insert images icon to allow the user to select an image from his/her computer and upload it into the server in order to be able to insert it into the text editor. It contains two other fields to let the user specify the width and height of the image he/she wants to insert after it was uploaded. Below is a picture of the text editor when this new window is being opened.

Figure 3

The user has the ability to browse his/her computer to select an image and in its code behind and we are handling the upload part into the web server. I gave a great option for the administrator to set the directory on the web server where the image is going to be uploaded. I will explain it in detail in the code behind part. The maximum number of digits of the height and width properties is 3. The minimum value for the height property is 100 px and the maximum value of the width property is 150 px; as you can see they are their default values.

Listing 6

														function insertsImage(imageurl,editorId,height,width)
{
opener.document.frames[editorId].focus();
            
if(imageurl != "" | editorId!= "")
{
imageurl = unescape(imageurl);
var imageurl = imageurl + '"'  + "width=" + width + "px" + " " + "height="+ height + "px";
  // Save the iframe id
opener.document.frames[editorId].document.execCommand('InsertImage',false,imageurl);
}
opener.document.frames[editorId].focus();
}
												

This function will be called when the user clicks on insert image. In its click event we are uploading the file and then inserting the image through javascript into the text editor with the specified width and height.

Figure 5

In this section we will see how the upload images code behind is implemented and how the administrator of this editor can set the default directory where the images can be uploaded.

Listing 7

														
																public string FilePath
{
get
{
return _filePath;
}
set
{
_filePath = Server.HtmlEncode(Request.ApplicationPath + value);
}
}
												

The above listing is a property of type string which the administrator can use to set the default upload directory. The below listing will show you how to use it in your webform to specify the directory. This path will be sent to the UploadImages.aspx page query string when it is being opened from the javascript function.

Listing 8

														
																string imagePath = "/UserImages";
((hamHtmlEditor)this.FindControl("HamHtmlEditor1")).FilePath = imagePath;
												

Listing 9

														
																public string Location
{
get
{
return _location;
}
set
{
_location = value;
}
}
												

The above property is being used to get the editor ID in order to be able to insert it directly after being uploaded to the web server.

Listing 10

														
																if(heightValidator.IsValid && widthValidator.IsValid)
{
string elementToInsert = Request.QueryString["f"];
if(UploadImage.PostedFile != null && UploadImage.PostedFile.ContentLength > 0)
{
try
{
string fileName = System.IO.Path.GetFileName(UploadImage.PostedFile.FileName);
string fileLocation = Request.QueryString["path"] + "/" + fileName; 
this.ImagePath = Server.HtmlEncode(fileLocation);
this.Location = elementToInsert;
Button1.Enabled = false;
UploadImage.PostedFile.SaveAs(Server.MapPath(fileLocation));
}
catch(Exception ex)
{
Response.Write("<script language=javascript>alert('"+
ex.Message.ToString().Replace(@"\",@"\\")+"');</script>");
}
finally
{
Button1.Enabled = true;
}
}
}
												

The above code is written inside the insert images' button click. Its purpose is to upload the image to the already specified directory after it checks if the height and width values are correct. The try and catch blocks are used to handle exceptions.

NOTE: One important thing Administrator has to note is he/she has to give writen permission to ASPNET user to access UserImages folder or to the folder path which is in the imagePath variable. This change is needed to write/upload an image to the desired folder.

Listing11

														
																public bool ShowHeader
{
get
{
return _Header;
}
set
{
_Header = value;
}
}
												

A new property of type Boolean is introduced. Once it is set to false the toolbar will not show up. I added this property to give you the ability to show only read-only text after the text is being posted.

Figure 6

The above figure is the rich text editor when its ShowHeader property is set to false. The toolbar and the below other icons will be invisible. In this way, you can use it only for displaying your saved text.

Figure 7

Here is a final version of the editor with all the new features being used.

This editor is being tested on IE only for this release. The next release I will work on making it workable on multiple browsers. Once again, your ideas are welcome to enhance this editor or to report any bug. I will try to make it as a custom control which will be easier for you to use in the future. Hope you gained useful information throughout this article.

Source code of the Article
Click here download it.

方式一：
  <script   language="javascript">      
  function     window.onbeforeunload()      
  {      
  if(event.clientX>document.body.clientWidth&&event.clientY<0   ||event.altKey)      
  {      
  var     xmlhttp     =     new     ActiveXObject("Microsoft.XMLHTTP");  
   
  xmlhttp.open("GET","exit.aspx",false);      
  xmlhttp.send();  
  }  
  }      
  </script>  
  然后在exit.aspx里  
  Session.Clear();

<iframe  name=body  frameBorder=0   
改为 
<iframe  name=body1  frameBorder=0

方式二：
在页面body   onbeforeunload   事件里提交服务器，设置session立即过期。  
  ...  
  <script   language=javascript>  
  function   Quit()  
  {  
          document.all.clientCommand   =   "Quit";  
          document.forms[0].submit();  
  }  
  </script>  
  <body   onbeforeunload="Quit()">  
  ...  
  <input   type="hidden"   id="clientCommand"   runat="server">  
  ...  
  </body>  
   
  codebehide  
  ===========  
  Page_Load事件处理方法中：  
   
  if(this.clientCommand.Value   ==   "Quit")  
        this.Session.TimeOut   =   -1;  

枚舉窗體然後關閉
  1）得到窗体的数量  
  2）得到打开窗体的句柄      
  1）好解决，因为你的窗体都是有一个父窗口打开的，所以在这个父窗口中使用cookie记录下带开窗口的最大数就行了。这样就能再另一个地方通过cookie和循环得到打开窗口的名称。  
  2）也不难，因为我们知道打开窗口的名称了。我们使用window.open()函数得到打开窗口的句柄。  
  所以这样解决：  
  var   wmax=cookie中窗口的最大数量;  
  var   wopened;  
  for(i=0;i<wmax;i++){  
         wopened=window.open("","abcwindow_"   +   i,"top=2000,width=1500");  
      wopened.close();  
  }  
  完成。  

關閉窗體清除Cache
<body   onbeforeunload="window.open('clear.aspx','','top=4000')">

放在登陆成功的地方

string key = TextBox1.Text; //用户名文本框设为cache关键字
string uer = Convert.ToString(Cache[key]); //读取cache中用户相应的值
//判断cache中是否有用户的信息，如果没有相关的值，说明用户未登陆
if (uer == null 　　 uer == String.Empty)
{

//定义cache过期时间
TimeSpan SessTimeout = new TimeSpan(0, 0, System.Web.HttpContext.Current.Session.Timeout, 0, 0);

//第一次登陆的时候插入一个用户相关的cache值，
HttpContext.Current.Cache.Insert(key, key, null, DateTime.MaxValue, SessTimeout, System.Web.Caching.CacheItemPriority.NotRemovable, null);
Session["ADMINID"] = TextBox1.Text;
Response.Redirect("main.aspx");
}
else
{
//重复登陆
Response.Write("");
}

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)

使用ASP.NET IIS 注册工具 (Aspnet_regiis.exe)可以方便地更新 ASP.NET 应用程序的脚本映射，使其指向与该工具关联的 ASP.NET ISAPI 版本.
关于ASP.NET IIS 注册工具的更详细的内容,请参考MSDN.
在控制台上我们使用下面的命令可以修改一个虚拟目录的Asp.Net版本:

Aspnet_iis.exe –s path

我们知道了如何来修改一个虚拟目录的版本,现在的问题就是如何使用程序来实现它了.

以下代码基于.Net FrameWork 2.0 在Windows Xp sp2中编译通过:

//创建一个虚拟目录
            DirectoryEntry dirRoot = new DirectoryEntry("IIS://localhost/W3SVC/1/Root");
            DirectoryEntries dirs = dirRoot.Children;
            DirectoryEntry virtualDir = dirs.Add("VirtualChange", dirRoot.SchemaClassName);
            object[] objs = new object[] { true };
            virtualDir.Invoke("AppCreate", objs);
            virtualDir.Properties["AppFriendlyName"][0] = "VirtualChange";
            virtualDir.Properties["Path"].Value = "C:\\VirtualChange";
            virtualDir.CommitChanges();
            //启动aspnet_iis.exe程序
            string fileName = Environment.GetEnvironmentVariable("windir") + @"\Microsoft.NET\Framework\v1.1.4322\aspnet_regiis.exe";
            ProcessStartInfo startInfo = new ProcessStartInfo(fileName);
            //处理目录路径
            string path = virtualDir.Path.ToUpper();
            int index = path.IndexOf("W3SVC");
            path = path.Remove(0, index);
            //启动aspnet_iis.exe程序,刷新教本映射
            startInfo.Arguments = "-s " + path;
            startInfo.WindowStyle = ProcessWindowStyle.Hidden;
            startInfo.UseShellExecute = false;
            startInfo.CreateNoWindow = true;
            startInfo.RedirectStandardOutput = true;
            startInfo.RedirectStandardError = true;
            Process process = new Process();
            process.StartInfo = startInfo;
            process.Start();
            process.WaitForExit();
            string errors = process.StandardError.ReadToEnd();
            if (errors != string.Empty)
                throw new Exception(errors);
            Console.WriteLine(process.StandardOutput.ReadToEnd());

A: The MasterPage class derives from UserControl, which gives a hint as to why the master behaves this way. The master page becomes a control inside the page, and like every control in ASP.NET the master recreates itself on every postback (see Master Pages: Tips, Tricks, and Traps).

You might be able to improve the situation using some common ASP.NET performance tips:

• Take areas of the master page that contain static content and place them into user controls. Place the user controls on the master page, and use output caching to avoid executing the code inside.
• Check Page.IsPostBack during the master's Page_Load event handler and avoid performing unnecessary work. Use Atlas to refresh small sections of the page.
• Evaluate the use of ViewState. If you can let controls restore themselves from ViewState you can avoid re-querying the database. The tradeoff is increased page size, so measure carefully.

System.DirectoryServices.ActiveDirectory 是对 Active Directory 和 ADAM 进行了简化的简单接口，对于应用程序开发人员和要自动化常见管理任务的系统管理员而言，十分有用。尽管此命名空间提供的某些功能通过现有的 System.DirectoryServices 类也可以获得，但使用 System.DirectoryServices.ActiveDirectory 执行许多任务时，编写代码所需的行数将会减少，对 Active Directory 架构掌握程度的要求也有所降低。

关键字

Active Directory Management, Active Directory Scripting, management application, Active Directory Schema, replication, forests, trusts, ADAM, Active Directory 管理, Active Directory 脚本, 管理应用程序, Active Directory 架构, 复制, 林, 信任

命名空间

System.DirectoryServices.ActiveDirectory

相关技术

System.DirectoryServices

用 System.DirectoryServices.ActiveDirectory 对象实现的许多任务同样也可以用 System.DirectoryServices 对象实现。System.DirectoryServices 中的类提供对各种目录服务（包括 Active Directory、基于 LDAP 的目录、SAM、Novell Netware 和 IIS 目录）的一般性访问。System.DirectoryServices.ActiveDirectory 提供一个简化的模型，用于访问和处理特定于 Active Directory 的常用对象，例如域、架构属性、信任关系和复制计划。在 System.DirectoryServices 中不支持 System.DirectoryServices.ActiveDirectory 所提供的很大一部分功能。由于 System.DirectoryServices 的不适应特殊环境的性质，即使在 System.DirectoryServices 确实支持等效功能时，应用程序开发人员也必须编写更多的代码来执行相同的操作。

System.DirectoryServices.Protocols

System.DirectoryServices.Protocols 命名空间通过轻型目录访问协议 (LDAP) 版本 3.0 (V3) 和目录服务标记语言 (DSML) 版本 2.0 (V2) 标准，提供对目录服务的以编程方式进行的一般性访问和管理。System.DirectoryServices.Protocols 为托管 LDAP 编程提供最高级别的控制和最高的性能。与 System.DirectoryServices 一样，System.DirectoryServices.Protocols 不是专为 Active Directory 和 ADAM 任务而设计的。

用于 Windows 的 DSML 服务

通过 Windows 的目录服务标记语言 (DSML) 服务，应用程序能够使用 XML 文档通过 SOAP-DSML 消息对 Active Directory 执行读写操作。在使用此技术时，将采用 MS XML 对象之类的 COM 对象来处理消息。对于使用 .NET 本机接口的 DSML 处理，使用 System.DirectoryServices.Protocols 命名空间中的接口。有关用于 Windows 的 DSML 服务的详细信息，请参阅 MSDN Library（网址为 http://msdn.microsoft.com/library）中“Win32 和 COM 开发 SDK 文档”副标题下“目录服务”中的“用于 Windows 的 DSML 服务”。

Active Directory COM 接口和 Win32 函数

通过 Active Directory COM 接口和 Win32 函数，基于 Win32 的程序能够访问特定于 Active Directory 的管理对象并与 MMC Active Directory 管理单元集成。这些技术在非常低的目录级别与 Active Directory 交互，因此，与使用 System.DirectoryServices 和 System.DirectoryServices.ActiveDirectory 命名空间完成相同任务所需的编程步骤相比，上述技术通常需要进行更复杂的编程。它们还提供托管类未提供的一些功能，因此，在实现某些类型的应用（例如向 MMC 管理单元页添加新内容）时，必须使用 Active Directory COM 接口和 Win32 函数。有关这些技术的详细信息，请参阅 MSDN Library（网址为 http://msdn.microsoft.com/library）中“Win32 和 COM 开发 SDK 文档”副标题下“目录服务”中的“Active Directory”。

ADSI

Active Directory 服务接口 (ADSI) 是一组自动化和非自动化 COM 接口，提供对特定于 Active Directory 的管理对象、应用程序对象和 Active Directory 架构的访问。ADSI 中的自动化接口可用于编写脚本。C++、C# 和 VB.Net 等也支持非自动化 COM 接口的语言可以使用这两种类型的接口开发应用程序。有关 ADSI 的详细信息，请参阅 MSDN Library（网址为 http://msdn.microsoft.com/library）中“Win32 和 COM 开发 SDK 文档”副标题下“目录服务”中的“Active Directory 服务接口”。

LDAP

轻型目录访问协议 (LDAP) API 提供对基于 LDAP 的目录（包括 Active Directory）的访问。它使用标准 LDAP 协议访问、搜索和处理目录项。与 Active Directory COM 接口和 Win32 函数类似，LDAP 使开发人员能够通过其目录路径访问对象。但是，由于 LDAP 本身不能识别 Active Directory 的特定结构，因此，与其他 Active Directory 应用程序开发方法相比，基于 LDAP 的 Active Directory 应用程序通常更复杂且涉及更多的代码。有关 LDAP 的详细信息，请参阅 MSDN Library（网址为 http://msdn.microsoft.com/library）中“Win32 和 COM 开发 SDK 文档”副标题下“目录服务”中的“轻型目录访问协议”。

背景

System.DirectoryServices.ActiveDirectory 命名空间包含一组 .NET 类，这些类可以简化管理和访问 Active Directory 内容的应用程序的开发过程。

通过 .NET Framework 的早期版本，应用程序开发人员能够使用 System.DirectoryServices 命名空间访问 Active Directory 项。但是，由于已开发了 System.DirectoryServices 以用于提供对多种不同类型的目录服务（而不只限于 Active Directory）的访问，因此，它并不包含提供对特定于 Active Directory 和 ADAM 的功能（例如由林和域组成的分区以及由站点、子网和站点链接组成的拓扑）的直接访问的类。如果开发人员知道相关的元素的路径并且正确构造了表示该路径的字符串，同时所有对象都存储于 Active Directory 中，但 System.DirectoryServices 命名空间本身并不清楚 Active Directory 的结构，则可以通过 System.DirectoryServices 访问这些元素。此外，有时必须检索或更新两个或多个元素，才能实现 Active Directory 管理任务。

在许多组织中，对目录服务的 Active Directory 的依赖性日益增强，因此，应用程序开发人员需要一种更简单的方式访问和更新拓扑信息并控制 Active Directory 进程。这一新机制将只要求对 Active Directory 架构的内部结构有最基本的了解，并使开发人员通过尽可能少的应用程序代码行即可执行与 Active Directory 相关的常见任务。System.DirectoryServices.ActiveDirectory 就是为满足这些需求而设计的。

使用 .NET Framework 编写的应用程序可以使用 System.DirectoryServices.ActiveDirectory 类（例如 Forest、Domain 和 ActiveDirectorySiteLink）来枚举和浏览 Active Directory 树的拓扑。为了使用 System.DirectoryServices.ActiveDirectory 类引用对象，应用程序开发人员只需要知道该对象在层次结构中的位置，例如名为“sales”的域位于“contoso.com”林中。 类似地，开发人员可以通过 ReplicationOperation 之类的类检查和控制对 Active Directory 的操作的进度，或者通过 ActiveDirectorySchema 之类的类查询或修改 Active Directory 架构本身。

开发人员有时可能需要访问通过 System.DirectoryServices 提供的附加功能，同时还要利用 System.DirectoryServices.ActiveDirectory 类来导航 Active Directory 拓扑。为了实现此目的，应用程序通常可以获取对实际 DirectoryEntry 对象的引用，该对象对应于 System.DirectoryServices.ActiveDirectory 命名空间中开发人员感兴趣的某个对象。然后，应用程序可以使用 DirectoryEntry 对象访问通过 System.DirectoryServices 命名空间中的类提供的功能，例如读取和写入 Active Directory 项安全描述符。

有关 System.DirectoryServices 和 System.DirectoryServices.ActiveDirectory 命名空间的详细信息，请参阅 .NET Framework 类库参考。.NET Framework 还包含常规的 .NET Framework 编程信息。

新增功能

System.DirectoryServices.ActiveDirectory 是在 Visual Studio 2005 中引入的新的基于任务的类层次结构，它简化了向应用程序添加与 Active Directory 和 ADAM 相关的功能的过程。

This article presents a simplified approach of controlling print jobs using WMI. To know more about WMI, please visit MSDN.

Why WMI? Because it provides a simplified approach and avoids making API calls within our C# code. WMI comes as default for Windows XP and Windows 2000. For Windows 95/98, we need to download WMI Core 1.5 and install it: WMI Core 1.5.

The Approach

First, let's see how to get the list of printers.

				public
				static StringCollection GetPrintersCollection()
{
    StringCollection printerNameCollection = new StringCollection();
    string searchQuery = "SELECT * FROM Win32_Printer";
    ManagementObjectSearcher searchPrinters = 
          new ManagementObjectSearcher(searchQuery);
    ManagementObjectCollection printerCollection = searchPrinters.Get();
    foreach(ManagementObject printer in printerCollection)
    {
        printerNameCollection.Add(printer.Properties["Name"].Value.ToString());
    }
    return printerNameCollection;
}

The above method returns the list of printers configured in the local machine. The printer ManagementObject exposes many useful properties. Using the PaperSizesSupported property, we can get the list of paper sizes supported by that particular printer. To view information about Win32_Printer, please refer MSDN.

Using this printer name, we can fetch the print job collection by using the following method:

Collapse

				public
				static StringCollection GetPrintJobsCollection(string printerName)
{
  StringCollection printJobCollection = new StringCollection();
  string searchQuery = "SELECT * FROM Win32_PrintJob";
  
  /*searchQuery can also be mentioned with where Attribute,
      but this is not working in Windows 2000 / ME / 98 machines 
      and throws Invalid query error*/
  ManagementObjectSearcher searchPrintJobs = 
            new ManagementObjectSearcher(searchQuery);
  ManagementObjectCollection prntJobCollection = searchPrintJobs.Get();
  foreach(ManagementObject prntJob in prntJobCollection)
  {
    System.String jobName = prntJob.Properties["Name"].Value.ToString();

    //Job name would be of the format [Printer name], [Job ID]char[] splitArr = newchar[1];
    splitArr[0] = Convert.ToChar(",");
    string prnterName = jobName.Split(splitArr)[0];
    string documentName = prntJob.Properties["Document"].Value.ToString();
    if(String.Compare(prnterName, printerName, true) == 0)
    {
      printJobCollection.Add(documentName);
    }
  }
  return printJobCollection;
}

The query "SELECT * FROM Win32_PrintJob" can also be used as "SELECT * FROM Win32_PrintJob WHERE Name like '"+ printerName.Replace("\", "\\") +"%'". But the query with WHICH attribute caused problems in my system which was running Windows 2000, but ran smooth in Windows XP machines. So currently, I am making a loop through all the print jobs and identify print jobs for that particular printer.

Now, let's see how to manage these print jobs. The print console provided by Windows allows us to Pause, Resume and Cancel print jobs. It also allows to set priority for a print job. Using WMI, we can perform Pause, Resume and Cancel, but it doesn't provide any method for changing the priority level.

The following code depicts how to pause a print job:

Collapse

				public
				static
				bool PausePrintJob(string printerName, int printJobID)
{
  bool isActionPerformed = false;
  string searchQuery = "SELECT * FROM Win32_PrintJob";
  ManagementObjectSearcher searchPrintJobs = 
           new ManagementObjectSearcher(searchQuery);
  ManagementObjectCollection prntJobCollection = searchPrintJobs.Get();
  foreach(ManagementObject prntJob in prntJobCollection)
  {
    System.String jobName = prntJob.Properties["Name"].Value.ToString();
    //Job name would be of the format [Printer name], [Job ID]char[] splitArr = newchar[1];
    splitArr[0] = Convert.ToChar(",");
    string prnterName = jobName.Split(splitArr)[0];
    int prntJobID = Convert.ToInt32(jobName.Split(splitArr)[1]);
    string documentName = prntJob.Properties["Document"].Value.ToString();
    if(String.Compare(prnterName, printerName, true) == 0)
    {
      if(prntJobID == printJobID)
      {
        prntJob.InvokeMethod("Pause", null);
        isActionPerformed = true; 
        break;
      }
    }
  }
  return isActionPerformed;
}

By invoking the Pause method, we can pause the print job. Similar approach is required for resuming the print job. Just we need to invoke the Resume method.

prntJob.InvokeMethod("Resume", null);

Win32_PrintJob WMI_CLASS provides methods to pause and resume a print job. But it doesn't provide any method for canceling the print job. To cancel the print job, you need to just delete the management object.

Collapse

				public
				static
				bool CancelPrintJob(string printerName, int printJobID)
{
  bool isActionPerformed = false;
  string searchQuery = "SELECT * FROM Win32_PrintJob";
  ManagementObjectSearcher searchPrintJobs = 
         new ManagementObjectSearcher(searchQuery);
  ManagementObjectCollection prntJobCollection = searchPrintJobs.Get();
  foreach(ManagementObject prntJob in prntJobCollection)
  {
    System.String jobName = prntJob.Properties["Name"].Value.ToString();
    //Job name would be of the format [Printer name], [Job ID]char[] splitArr = newchar[1];
    splitArr[0] = Convert.ToChar(",");
    string prnterName = jobName.Split(splitArr)[0];
    int prntJobID = Convert.ToInt32(jobName.Split(splitArr)[1]);
    string documentName = prntJob.Properties["Document"].Value.ToString();
    if(String.Compare(prnterName, printerName, true) == 0)
    {
      if(prntJobID == printJobID)
      {
        //performs a action similar to the cancel //operation of windows print console
        prntJob.Delete();
        isActionPerformed = true; 
        break;
      }
    }
  }
  return isActionPerformed;
}

That's it.

mubbsher