博客园_上善若水,润物无声

JavaScript里String.Format方法的实现

2011-06-26T08:43:00Z

在Javascript里通过原型扩展和正则表达式实现类似于C#里的String.Format方法.

方法实现:

String.prototype.format = function (args) {
       var str = this;
       return str.replace(new RegExp("{-?[0-9]+}", "g"), function(item) {
       var intVal = parseInt(item.substring(1, item.length - 1));
       var replace;
       if (intVal >= 0) {
            replace = args[intVal];
       } else if (intVal === -1) {
            replace = "{";
       } else if (intVal === -2) {
            replace = "}";
       } else {
            replace = "";
       }
       return replace;
    });
};

使用如下:

var str = "She {1} {0}{2} by the {0}{3}. {-1}^_^{-2}";
str = str.format(["sea", "sells", "shells", "shore"]);
alert(str);//out put: She sells seashells by the seashore. {^_^}

原文地址:String.Format in JavaScript

本文链接

asp.net异步页

2011-04-08T14:12:00Z

在请求一个普通的耗时Asp.net Web页面时(比较慢的数据库查询,请求一个网络资源等),asp.net从自身维护的线程池里取出一个可用的线程处理Web页(包括对象的实例化,相应的事件处理,HTML的呈现等),当线程池里没有可用的线程时(站点的请求频率很高,线程池里的线程都在处理请求)新的请求将压入一个队列,如果队列满了,asp.net则返回"服务器不可用"的503错误以拒绝新的请求.
线程池里的线程数及队列的大小受多个因素影响,包括IIS版本,.net framework版本,机器CPU数量等
在等待较慢的数据库查询或者请求一个网络资源返回结果时,当前使用的线程被挂起,这些线程没有处理其它的逻辑也没有占用CPU,但严重影响了整个网站的吞吐量,因为站点本应该处理更多的请求的.
在这种情况下可以使用asp.net异步页提高站点的吞吐量,通过asp.net异步页可以将耗时的处理代码转移到非asp.net线程里,当异步结果返回时会通知asp.net并从Asp.net线程池里取出一个可用的线程处理结束代码并呈现HTML.

在使用asp.net异步页时有几个地方需要注意:
1.异步线程的使用
尽量使用framework内建的异步支持,SqlCommand,HttpWebRequest,FileStream等对象都提供了相关的BeginXX()和EndXX()方法,这些对象的异步方法使用的都不是Asp.net线程池里的线程.
使用delegate的BeginInvoke()或者ThreadPool.QueueUserWorkItem()都是从asp.net线程池里取可以的线程,使用它们对解决问题没有什么意义.通过Tread类创建自定义的处理线程如果不能很好的管理创建出来的线程就比较危险了(如果同时有N个请求,就会有N个线程被创建,过多的创建线程会影响Asp.net的性能并且可能导致Asp.net站点不能正常处理请求).
2.异步页并不比普通页快
因为异步页会有线程切换的过程,所以异步页并不比普通页快.当然在Asp.net异步页里可以通过RegisterAsycTask()方法执行多个并发任务.
3.错误处理
使用异步页时一定要处理好异常,如果处理不好可能会让整个进程中指,在异步操作中发生的异常会在调用EndXX()方法时抛出.
如果异常发生在返回IAsyncResult对象之前发生,可以返回一个实现了IAsyncResult接口的自定义对象.
比如在调用SqlCommand类的BeginExecuteNonQuery(AsyncCallback callback, object stateObject)方法前执行
SqlConnection.Open()方法时发生异常,因为打开数据库连接时异步操作还没有开始,所以这里的异常不会在
调用EndExecuteReader(IAsyncResult asyncResult)方法时抛出,因此需要在捕捉到打开数据库连接的异常时返回一个自定义IAsyncResult对象.

本文链接

获取SQL Server数据行的物理地址信息(%%lockress%% & %%physloc%%)

2011-03-19T09:40:00Z

在SQL Server 2005里可以通过%%lockress%%得到数据行对应的物理路径信息,在SQL Server2008里还可以通过%%physloc%% 得到,用sys.fn_PhysLocFormatter 将得到的binary数据转换后就是%%lockress%% 的值,但是,这几个在MSDN里都没有介绍.

%%lockress%% 得到值包含了3部分:文件编号,页编号和位置编号,并以冒号分隔.

select *,%%lockres%% as phys from dbTest

得到的结果是:

id          name       phys
----------- ---------- --------------------------------
1           A          1:77:0
2           B          1:77:1
3           C          1:77:2

在SQL Server2008里执行

select *,%%physloc%% as phys from dbTest

得到的结果是:

id          name       phys
----------- ---------- ------------------
1           A          0x7300000001000000
2           B          0x7300000001000100
3           C          0x7300000001000200

在SQL Server2008里执行

select *,sys.fn_PhysLocFormatter(%%physloc%%) as physfrom dbTest

得到的结果是:

id          name       phys
----------- ---------- ----------------------------
1           A          (1:115:0)
2           B          (1:115:1)
3           C          (1:115:2)

因为SQL Sever2005和SQL Server2008在不同的机器上,所以得到的物理信息是不一样的,得到的这个信息,相当于是一张表的一个隐藏的唯一键列,所以通过这个可以很方便的处理一些问题,比如删除没有主键表里的重复数据,但是MSDN里没有相关的说明,所以使用时要考虑一些风险.

本文链接

利用Spire.DataExport将数据(Database/DataTable)导成各种文件

2011-03-13T13:41:00Z

借助Spire.DataExport可以很方便的将Database或者DataTable里的数据导成XLS, PDF and MS Word, HTML, MS ,XML, PDF, DBF, SQL Script, SYLK, DIF, CSV文件或者剪切板里而且机器上并不需要安装Microsoft Excel ,Microsoft Access ,Adobe Acrobat.转换后的数据可以输出到File,HttpResponse,Stream里.

当前的免费Spire.DataExport对日期类型的数据存在一个Bug:导出的数据会丢失时间部分,这个问题在以后的版本可能会解决掉,在没修正这个Bug前需要采取别的措施,比喻将时间类型转换成字符串类型.

如果要从Database里查询数据并输出成文件,需要指定相应的导出格式对象实例的DataSource属性为ExportSource.SqlCommand,并为Columns和SQLCommand属性赋相应的值.如果直接将DataTable输出成文件,则需要指定DataSource属性为ExportSource.DataTable.DataSource的默认值为ExportSource.SqlCommand.

要用Spire.DataExport组件,项目里需要引用Spire.License.dll,Spire.DataExport.ResourceMgr.dll,Spire.DataExport.dll.

以下示例将一个DataTable输出成XLS文件:

static void ExportToXLS(DataTable dbTable, string strFileName)
{
       CellExport cellExport = new CellExport();

        cellExport.ActionAfterExport = ActionType.None;
        cellExport.AutoFitColWidth = true;
        cellExport.DataFormats.CultureName = "en-US";
        cellExport.DataFormats.Currency = "#,###,##0.00";
        cellExport.DataFormats.DateTime = "yyyyhhmm HHmmss";
        cellExport.DataFormats.Float = "#,###,##0.00";
        cellExport.DataFormats.Integer = "#,###,##0";
        cellExport.DataFormats.Time = "H:mm";
        cellExport.SheetOptions.AggregateFormat.Font.Name = "Arial";
        cellExport.SheetOptions.CustomDataFormat.Font.Name = "Arial";
        cellExport.SheetOptions.DefaultFont.Name = "Arial";
        cellExport.SheetOptions.FooterFormat.Font.Name = "Arial";
        cellExport.SheetOptions.HeaderFormat.Font.Name = "Arial";
        cellExport.SheetOptions.HyperlinkFormat.Font.Color = CellColor.Blue;
        cellExport.SheetOptions.HyperlinkFormat.Font.Name = "Arial";
        cellExport.SheetOptions.HyperlinkFormat.Font.Underline = XlsFontUnderline.Single;
        cellExport.SheetOptions.NoteFormat.Alignment.Horizontal = HorizontalAlignment.Left;
        cellExport.SheetOptions.NoteFormat.Alignment.Vertical = VerticalAlignment.Top;
        cellExport.SheetOptions.NoteFormat.Font.Bold = true;
        cellExport.SheetOptions.NoteFormat.Font.Name = "Tahoma";
        cellExport.SheetOptions.NoteFormat.Font.Size = 8F;
        cellExport.SheetOptions.TitlesFormat.Font.Bold = true;
        cellExport.SheetOptions.TitlesFormat.Font.Name = "Arial";

        cellExport.DataSource = ExportSource.DataTable;
        cellExport.DataTable = dbTable;
        cellExport.FileName = strFileName;
        cellExport.SaveToFile();
}

以下示例将一个DataTable输出成PDF文件:

static void ExportToPDF(DataTable dbTable, string strFileName)
{
        PDFExport pdfExport = new PDFExport();
        pdfExport.ActionAfterExport = ActionType.OpenView;
        pdfExport.DataFormats.CultureName = "en-US";
        pdfExport.DataFormats.Currency = "#,###,##0.00000";
        pdfExport.DataFormats.DateTime = "yyyy-M-d HH:mm";
        pdfExport.DataFormats.Float = "#,###,##0.00";
        pdfExport.DataFormats.Integer = "#,###,##0";
        pdfExport.DataFormats.Time = "H:mm";
        pdfExport.PDFOptions.PageOptions.Format = PageFormat.User;
        pdfExport.PDFOptions.PageOptions.Height = 11.67;
        pdfExport.PDFOptions.PageOptions.MarginBottom = 0.78;
        pdfExport.PDFOptions.PageOptions.MarginLeft = 1.17;
        pdfExport.PDFOptions.PageOptions.MarginRight = 0.57;
        pdfExport.PDFOptions.PageOptions.MarginTop = 0.78;
        pdfExport.PDFOptions.PageOptions.Width = 8.25;

        pdfExport.DataSource = ExportSource.DataTable;
        pdfExport.DataTable = dbTable;

        pdfExport.FileName = strFileName;
        pdfExport.SaveToFile();
}

以下示例将一个DataTable输出成HTML文件:

static void ExportToHTML(DataTable dbTable, string strFileName)
        {
            HTMLExport htmlExport = new HTMLExport();
            htmlExport.ActionAfterExport = ActionType.None;
            htmlExport.DataFormats.CultureName = "en-US";
            htmlExport.DataFormats.Currency = "#,###,##0.00";
            htmlExport.DataFormats.DateTime = "yyyy-M-d H:mm";
            htmlExport.DataFormats.Float = "#,###,##0.00";
            htmlExport.DataFormats.Integer = "#,###,##0";
            //htmlExport.DataFormats.Time = "H:mm";
            htmlExport.HtmlStyle = HtmlStyle.MSMoney;
            htmlExport.HtmlTextOptions.Font = new System.Drawing.Font("Arial", 8F);

            htmlExport.DataSource = ExportSource.DataTable;
            htmlExport.DataTable = dbTable;

            htmlExport.FileName = strFileName;
            htmlExport.SaveToFile();
        }

本文链接

使用XML的value()方法将多行数据合并成一列

2011-03-04T05:15:00Z

从系统视图sys.syscomments里可以得到存储过程的项,text字段记录了存储过程定义的实际文本,如果存储过程的长度超过4000长度,将使用新行记录,colid字段记录相应的行序号.

以下语句使用XML结合value()方法将同一存储过程的多行text字段合并成一列显示:

select object_name(id)procedure_name,text+isnull(
(
(select text from sys.syscomments b where a.id=b.id and b.colid>1 for xml path(''),root('root'),type)
.value('/root[1]','nvarchar(max)')
),'') procudure_text
from sys.syscomments a where number=1 and colid=1

本文链接

获取所有的外键信息

2011-03-03T08:57:00Z

通过查询系统表,可以得到一个数据库里的所有外键信息,得到这些信息后就可以生成一些脚本,比如删除某张表的所有外键,根据现有外键信息生成新的外键.

    select fk.name fkname,constable.name constablename,conscol.name conscolname,reftable.name reftablename,refcol.name refcolname
        from sys.foreign_keys fk
        join sys.objects constable on fk.parent_object_id=constable.object_id
        join sys.objects reftable on fk.referenced_object_id=reftable.object_id
        join sys.foreign_key_columns fkc on fkc.constraint_object_id=fk.object_id
        join sys.columns conscol on fkc.parent_column_id =conscol.column_id and fkc.parent_object_id=conscol.object_id
        join sys.columns refcol on fkc.referenced_column_id=refcol.column_id and fkc.referenced_object_id=refcol.object_id

以上查询得到外键名称,外键基表,外键列,外键引用表,外键引用列.

以下语句删除数据库db里关于tblname的外键:

use db
go

declare @references_name nvarchar(100),
        @table_name nvarchar(100)

declare cursor_references cursor for
    select fk.name fkname,constable.name constable from sys.foreign_keys fk
        join sys.objects constable on fk.parent_object_id=constable.object_id
        join sys.objects reftable on fk.referenced_object_id=reftable.object_id
        join sys.foreign_key_columns fkc on fkc.constraint_object_id=fk.object_id
        join sys.columns conscol on fkc.parent_column_id =conscol.column_id and fkc.parent_object_id=conscol.object_id
        join sys.columns refcol on fkc.referenced_column_id=refcol.column_id and fkc.referenced_object_id=refcol.object_id
        where reftable.name='tblname'
open cursor_references
fetch next from cursor_references into @references_name,@table_name
while @@fetch_status = 0
begin
    exec('alter table '+@table_name+' drop constraint '+@references_name)
    fetch next from cursor_references into @references_name,@table_name
end
close cursor_references
deallocate cursor_references

本文链接

ASP.NET application and page life cycle

2010-05-11T10:19:00Z

转载自CodeProject,原文地址:http://www.codeproject.com/KB/aspnet/ASPDOTNETPageLifecycle.aspx#Introduction

Introduction
The Two step process
Creation of ASP.NET environment
Process request using MHPM events fired
In What event we should do what?
A sample code for demonstration
Zooming ASP.NET page events
References

Introduction

In this article we will try to understand what are the different events which takes place right from the time the user sends a request, until the time request is rendered on the browser. So we will first try to understand the two broader steps of an ASP.NET request and then we will move in to different events emitted from ‘HttpHandler’, ‘HttpModule’ and ASP.NET page object. As we move in this event journey we will try to understand what kind of logic should go in each every of these events.
This is a small Ebook for all my .NET friends which covers topics like WCF,WPF,WWF,Ajax,Core .NET,SQL etc you can download the same from Click here or else you can catch me on my daily free training @ Click here

The Two step process

From 30,000 feet level ASP.NET request processing is a 2 step process as shown below. User sends a request to the IIS:-
• ASP.NET creates an environment which can process the request. In other words it creates the application object, request, response and context objects to process the request.
• Once the environment is created the request is processed through series of events which is processed by using modules, handlers and page objects. To keep it short lets name this step as MHPM (Module, handler, page and Module event), we will come to details later.

in the coming sections we will understand both these main steps in more details.

Creation of ASP.NET environment

Step 1:- The user sends a request to IIS. IIS first checks which ISAPI extension can serve this request. Depending on file extension the request is processed. For instance if the page is an ‘.ASPX page’ then it will be passed to ‘aspnet_isapi.dll’ for processing.
Step 2:- If this the first request to the website then a class called as ‘ApplicationManager’ creates an application domain where the website can run. As we all know application domain creates isolation between two web applications hosted on the same IIS. So in case there is issue in one app domain it does not affect the other app domain.
Step 3:- The newly created application domain creates hosting environment i.e. the ‘HttpRuntime’ object. Once the hosting environment is created necessary core ASP.NET objects like ‘HttpContext’ , ‘HttpRequest’ and ‘HttpResponse’ objects are created.
Step 4:- Once all the core ASP.NET objects are created ‘HttpApplication’ object is created to serve the request. In case you have a ‘global.asax’ file in your system then object of the ‘global.asax’ file will be created. Please note ‘global.asax’ file inherits from ‘HttpApplication’ class.
Note: The first time an ASP.NET page is attached to an application, a new instance of ‘HttpApplication’ is created. Said and done to maximize performance, ‘HttpApplication’ instances might be reused for multiple requests.
Step 5:- The ‘HttpApplication’ object is then assigned to the core ASP.NET objects to process the page.
Step 6:- ‘HttpApplication’ then starts processing the request by http module events , handlers and page events. It fires the MHPM event for request processing.
Note: - For more details http://msdn.microsoft.com/en-us/library/ms178473.aspx

Below image explains how the internal object model looks like for an ASP.NET request. At the top level is the ASP.NET runtime which has creates an ‘Appdomain’ which in turn has ‘HttpRuntime’ with ‘request’, ‘response’ and ‘context’ objects.

Process request using MHPM events fired

Once ‘HttpApplication’ is created it starts processing request it goes through 3 different sections ‘HttpModule’ , ‘Page’ and ‘HttpHandler’. As it moves through these sections it invokes different events which the developer can extend and add customize logic to the same.
Before we move ahead lets understand what are ‘HttpModule’ and ‘HttpHandlers’. They help us to inject custom logic before and after the ASP.NET page is processed. The main differences between both of them are:-
• If you want to inject logic based in file extensions like ‘.ASPX’ , ‘.HTML’ then you use ‘HttpHandler’. In other words ‘HttpHandler’ is an extension based processor.

• If you want to inject logic in the events of ASP.NET pipleline then you use ‘HttpModule’. ASP.NET . In other word ‘HttpModule’ is an event based processor.

You can read more about the differences from http://computerauthor.blogspot.com/2009/09/two-interceptors-httpmodule-and.html
Below is the logical flow of how the request is processed. There are 4 important steps MHPM as explained below :-

Step 1(M  HttpModule):- Client request processing starts. Before the ASP.NET engine goes and creates the ASP.NET ‘HttpModule’ emits events which can be used to inject customized logic. There are 6 important events which you can utilize before your page object is created ‘BeginRequest’,’AuthenticateRequest’,’AuthorizeRequest’,’ResolveRequestCache’,’AcquireRequestState’ and ‘PreRequestHandlerExecute’.
Step 2 (H  ‘HttpHandler’ ) :- Once the above 6 events are fired , ASP.NET engine will invoke ‘ProcessRequest’ event if you have implemented ‘HttpHandler’ in your project.
Step 3 (P – ASP.NET page):- Once the ‘HttpHandler’ logic executes the ASP.NET page object is created. While the ASP.NET page object is created many events are fired which can help us to write our custom logic inside those page events. There are 6 important events which provides us placeholder to write logic inside ASP.NET pages ‘Init’ , ‘Load’ , ‘validate’ , ‘event’ , ‘render’ and ‘unload’. You can remember the word ‘SILVER’ to remember the events S – Start ( does not signify anything as such just forms the word ) , I – (Init) , L ( Load) , V ( Validate) , E ( Event) and R ( Render).
Step4 (M  HttpModule):- Once the page object is executed and unloaded from memory ‘HttpModule’ provides post page execution events which can be used to inject custom post-processing logic. There are 4 important post-processing events ‘PostRequestHandlerExecute’, ‘ReleaserequestState’, ‘UpdateRequestCache’ and ‘EndRequest’.

Below figure shows the same in a pictorial format.

In What event we should do what?

The million dollar question is in which events we should do what? . Below is the table which shows in which event what kind of logic or code can go.

Section	Event	Description
HttpModule	BeginRequest	This event signals a new request; it is guaranteed to be raised on each request.
HttpModule	AuthenticateRequest	This event signals that ASP.NET runtime is ready to authenticate the user. Any authentication code can be injected here.
HttpModule	AuthorizeRequest	This event signals that ASP.NET runtime is ready to authorize the user. Any authorization code can be injected here.
HttpModule	ResolveRequestCache	In ASP.NET we normally use outputcache directive to do caching. In this event ASP.NET runtime determines if the page can be served from the cache rather than loading the patch from scratch. Any caching specific activity can be injected here.
HttpModule	AcquireRequestState	This event signals that ASP.NET runtime is ready to acquire session variables. Any processing you would like to do on session variables.
HttpModule	PreRequestHandlerExecute	This event is raised just prior to handling control to the HttpHandler. Before you want the control to be handed over to the handler any pre-processing you would like to do.
HttpHandler	ProcessRequest	Httphandler logic is executed. In this section we will write logic which needs to be executed as per page extensions.
Page	Init	This event happens in the ASP.NET page and can be used for :- · Creating controls dynamically, in case you have controls to be created on runtime. · Any setting initialization. · Master pages and them settings. In this section we do not have access to viewstate , postedvalues and neither the controls are initialized.
Page	Load	In this section the ASP.NET controls are fully loaded and you write UI manipulation logic or any other logic over here.
Page	Validate	If you have valuators on your page, you would like to check the same here.
	Render	It’s now time to send the output to the browser. If you would like to make some changes to the final HTML which is going out to the browser you can enter your HTML logic here.
Page	Unload	Page object is unloaded from the memory.
HttpModule	PostRequestHandlerExecute	Any logic you would like to inject after the handlers are executed.
HttpModule	ReleaserequestState	If you would like to save update some state variables like session variables.
HttpModule	UpdateRequestCache	Before you end if you want to update your cache.
HttpModule	EndRequest	This is the last stage before your output is sent to the client browser.

A sample code for demonstration

With this article we have attached a sample code which shows how the events actually fire. In this code we have created a ‘HttpModule’ and ‘Httphandler’ in this project and we have displayed a simple response write in all events , below is how the output looks like.
Below is the class for ‘HttpModule’ which tracks all event s and adds it to a global collection.

public class clsHttpModule :IHttpModule
{
    ......
    void OnUpdateRequestCache(object sender, EventArgs a)
    {
        objArrayList.Add("httpModule:OnUpdateRequestCache");
    }
    void OnReleaseRequestState(object sender, EventArgs a)
    {
        objArrayList.Add("httpModule:OnReleaseRequestState");
    }
    void OnPostRequestHandlerExecute(object sender, EventArgs a)
    {
        objArrayList.Add("httpModule:OnPostRequestHandlerExecute");
    }
    void OnPreRequestHandlerExecute(object sender, EventArgs a)
    {
        objArrayList.Add("httpModule:OnPreRequestHandlerExecute");
    }
    void OnAcquireRequestState(object sender, EventArgs a)
    {
        objArrayList.Add("httpModule:OnAcquireRequestState");
    }
    void OnResolveRequestCache(object sender, EventArgs a)
    {
        objArrayList.Add("httpModule:OnResolveRequestCache");
    }
    void OnAuthorization(object sender, EventArgs a)
    {
        objArrayList.Add("httpModule:OnAuthorization");
    }
    void OnAuthentication(object sender, EventArgs a)
    {

        objArrayList.Add("httpModule:AuthenticateRequest");
    }
    void OnBeginrequest(object sender, EventArgs a)
    {

        objArrayList.Add("httpModule:BeginRequest");
    }
    void OnEndRequest(object sender, EventArgs a)
    {
        objArrayList.Add("httpModule:EndRequest");
        objArrayList.Add("<hr>");
        foreach(string str in objArrayList)
        {
            httpApp.Context.Response.Write(str + "<br>");
        }
    }
}

Below is the code snippet for ‘HttpHandler’ which tracks ‘ProcessRequest’ event.

public class clsHttpHandler :IHttpHandler
{
    public void ProcessRequest(HttpContext context)
    {
        clsHttpModule.objArrayList.Add("HttpHandler:ProcessRequest");
        context.Response.Redirect("Default.aspx");
    }
}

We are also tracking all the events from the ASP.NET page.

public partial class _Default :System.Web.UI.Page
{
    protected void Page_init(object sender, EventArgs e)
    {

        clsHttpModule.objArrayList.Add("Page:Init");
    }
    protected void Page_Load(object sender, EventArgs e)
    {
        clsHttpModule.objArrayList.Add("Page:Load");
    }
    public override void Validate()
    {
        clsHttpModule.objArrayList.Add("Page:Validate");
    }
    protected void Button1_Click(object sender, EventArgs e)
    {
        clsHttpModule.objArrayList.Add("Page:Event");
    }
    protected override void Render(HtmlTextWriter output)
    {
        clsHttpModule.objArrayList.Add("Page:Render");
        base.Render(output);
    }
    protected void Page_Unload(object sender, EventArgs e)
    {
        clsHttpModule.objArrayList.Add("Page:UnLoad");
    }
}

Below is how the display looks like with all events as per the sequence discussed in the previous section.

Zooming ASP.NET page events
In the above section we have seen the overall flow of events for an ASP.NET page request. One of the most important section is the ASP.NET page, we have not discussed the same in detail. So let’s take some luxury to describe the ASP.NET page events in more detail in this section.
Any ASP.NET page has 2 parts one is the page which is displayed on the browser which has HTML tags , hidden values in form of viewstate and data on the HTML inputs. When the page is posted these HTML tags are created in to ASP.NET controls with viewstate and form data tied up together on the server. Once you get these full server controls on the behind code you can execute and write your own login on the same and render the page back to the browser.

Now between these HTML controls coming live on the server as ASP.NET controls, the ASP.NET page emits out lot of events which can be consumed to inject logic. Depending on what task / logic you want to perform we need to put these logics appropriately in those events.
Note: - Most of the developers directly use the ‘page_load’ method for everything, which is not a good thought. So it’s either populating the controls, setting view state, applying themes etc everything happens on the page load. So if we can put logic in proper events as per the nature of the logic that would really make your code clean.

Seq	Events	Controls Initialized	View state Available	Form data Available	What Logic can be written here?
1	Init	No	No	No	Note: - You can access form data etc by using ASP.NET request objects but not by Server controls.Creating controls dynamically, in case you have controls to be created on runtime. Any setting initialization.Master pages and them settings.In this section we do not have access to viewstate , posted values and neither the controls are initialized.
2	Load view state	Not guaranteed	Yes	Not guaranteed	You can access view state and any synch logic where you want viewstate to be pushed to behind code variables can be done here.
3	PostBackdata	Not guaranteed	Yes	Yes	You can access form data. Any logic where you want the form data to be pushed to behind code variables can be done here.
4	Load	Yes	Yes	Yes	This is the place where you will put any logic you want to operate on the controls. Like flourishing a combox box from the database , sorting data on a grid etc. In this event we get access to all controls , viewstate and their posted values.
5	Validate	Yes	Yes	Yes	If your page has validators or you want execute validation for your page this is the right place to the same.
6	Event	Yes	Yes	Yes	If this is a post back by a button click or a dropdown change then the relative events will be fired. Any kind of logic which is related to that event can be executed here.
7	Pre-render	Yes	Yes	Yes	If you want to make final changes to the UI objects like changing tree structure or property values, before these controls are saved in to view state.
8	Save view state	Yes	Yes	Yes	Once all changes to server controls are done this event can be an opportunity to save control data in to view state.
9	Render	Yes	Yes	Yes	If you want to add some custom HTML to the output this is the place you can.
10	Unload	Yes	Yes	Yes	Any kind of clean up you would like to do here.

References

I am not so smart to write this article by myself ;-) , lot of things I have plugged from the below articles.
Read more about IIS 7.0 life cycle http://msdn.microsoft.com/en-us/library/bb470252.aspx
Intercepting filters http://msdn.microsoft.com/en-us/library/ms998536.aspx
Explains how to implement Httphandlers and modules http://msdn.microsoft.com/en-us/library/system.web.httpapplication.aspx
Httphandlers and Httpmodules :- http://www.15seconds.com/Issue/020417.htm
Implementing security using modules and handlers http://joel.net/articles/asp.net2_security.aspx
Difference between Httpapplication and global.asax http://codebetter.com/blogs/karlseguin/archive/2006/06/12/146356.aspx

本文链接

SQL Server 2005 CLR 调用Web Service需要注意的几个问题

2009-10-16T07:50:00Z

用Visual Studio 2005创建SQL Server项目,然后编写调用Web Service的过程是很简单的,在项目里添加引用Web Service,然后编写处理代码.在部署前有几个问题需要注意:1.目标数据库实例需要启用CLR集成.如果没启用,可以在 SQL Server 外围应用配置器里去启用或者使用以下语句:[代码]2.目标数据库的可信任属性需要设为FALSE,可以使用以下语句启...

SQL SERVRE 2005 CLR TVF错误:从用户定义的表值函数获取新行时出错:Data access is not allowed in this context.

2009-06-14T07:05:00Z

消息 6260，级别 16，状态 1，第 1 行从用户定义的表值函数获取新行时出错: System.InvalidOperationException: Data access is not allowed in this context. Either the context is a function or method not marked with DataAccessKind.Read or SystemDataAccessKind.Read, is a callback to obtain data from FillRow method of a Table Valued Function, or is a UDT validation method.System.InvalidOperationException: at System.Data.SqlServer.Internal.ClrLevelContext.CheckSqlAccessReturnCode(SqlAccessApiReturnCode eRc) at System.

PHP执行MYSQL存储过程报错:Commands out of sync; you can't run this command now

2009-04-29T08:22:00Z

在PHP同一事物里调用MYSQL的存储过程后再次执行另外的一个或多个命令(或者在同一事物里执行多个存储过程)，如果使用mysqli的query方法获得结果,将获得一个错误:Commands out of sync; you can't run this command now sss 先给出代码:存储过程:[代码]PHP代码:[代码]执行上面的代码后就会出现上面的错误，消息说明MYSQL数据库认为...