博客园_My Program life

【转】c# 位操作

2011-07-26T03:51:00Z

在C#中可以对整型运算对象按位进行逻辑运算。按位进行逻辑运算的意义是：依次取被运算对象的每个位，进行逻辑运算，每个位的逻辑运算结果是结果值的每个位。C#支持的位逻辑运算符如表2.9所示。

算符号	意义	运算对象类型	运算结果类型	对象数	实例
~	位逻辑非运算	整型，字符型	整型	1	~a
&	位逻辑与运算			2	a & b
\|	位逻辑或运算			2	a \| b
^	位逻辑异或运算			2	a ^ b
<<	位左移运算			2	a<<4
>>	位右移运算			2	a>>2

1、位逻辑非运算

位逻辑非运算是单目的，只有一个运算对象。位逻辑非运算按位对运算对象的值进行非运算，即：如果某一位等于0，就将其转变为1；如果某一位等于1，就将其转变为0。

比如，对二进制的10010001进行位逻辑非运算，结果等于01101110，用十进制表示就是：

~145等于110；对二进制的01010101进行位逻辑非运算，结果等于10101010。用十进制表示就是~85等于176。

2、位逻辑与运算

位逻辑与运算将两个运算对象按位进行与运算。与运算的规则：1与1等于1，1与0等于0。

比如：10010001（二进制）&11110000等于10010000（二进制）。

3、位逻辑或运算

位逻辑或运算将两个运算对象按位进行或运算。或运算的规则是：1或1等1，1或0等于1，

0或0等于0。比如10010001（二进制）| 11110000（二进制）等于11110001（二进制）。

4、位逻辑异或运算

位逻辑异或运算将两个运算对象按位进行异或运算。异或运算的规则是：1异或1等于0，

1异或0等于1，0异或0等于0。即：相同得0，相异得1。

比如：10010001（二进制）^11110000（二进制）等于01100001（二进制）。

5、位左移运算

位左移运算将整个数按位左移若干位，左移后空出的部分0。比如：8位的byte型变量

byte a=0x65(即二进制的01100101),将其左移3位：a<<3的结果是0x27(即二进制的00101000)。

6、位右移运算

位右移运算将整个数按位右移若干位，右移后空出的部分填0。比如：8位的byte型变量

Byte a=0x65(既（二进制的01100101）)将其右移3位：a>>3的结果是0x0c(二进制00001100)。

在进行位与、或、异或运算时，如果两个运算对象的类型一致，则运算结果的类型就是运算对象的类型。比如对两个int变量a和b做与运算，运算结果的类型还是int型。如果两个运算

对象的类型不一致，则C#要对不一致的类型进行类型转换，变成一致的类型，然后进行运算。

类型转换的规则同算术运算中整型量的转换则一致。

本文链接

C#中调用Windows API时的数据类型对应关系

2011-07-01T02:04:00Z

[转]C#中调用Windows API时的数据类型对应关系

BOOL=System.Int32
BOOLEAN=System.Int32
BYTE=System.UInt16
CHAR=System.Int16
COLORREF=System.UInt32
DWORD=System.UInt32
DWORD32=System.UInt32
DWORD64=System.UInt64
FLOAT=System.Float
HACCEL=System.IntPtr
HANDLE=System.IntPtr
HBITMAP=System.IntPtr
HBRUSH=System.IntPtr
HCONV=System.IntPtr
HCONVLIST=System.IntPtr
HCURSOR=System.IntPtr
HDC=System.IntPtr
HDDEDATA=System.IntPtr
HDESK=System.IntPtr
HDROP=System.IntPtr
HDWP=System.IntPtr
HENHMETAFILE=System.IntPtr
HFILE=System.IntPtr
HFONT=System.IntPtr
HGDIOBJ=System.IntPtr
HGLOBAL=System.IntPtr
HHOOK=System.IntPtr
HICON=System.IntPtr
HIMAGELIST=System.IntPtr
HIMC=System.IntPtr
HINSTANCE=System.IntPtr
HKEY=System.IntPtr
HLOCAL=System.IntPtr
HMENU=System.IntPtr
HMETAFILE=System.IntPtr
HMODULE=System.IntPtr
HMONITOR=System.IntPtr
HPALETTE=System.IntPtr
HPEN=System.IntPtr
HRGN=System.IntPtr
HRSRC=System.IntPtr HSZ=System.IntPtr
HWINSTA=System.IntPtr
HWND=System.IntPtr
INT=System.Int32
INT32=System.Int32
INT64=System.Int64
LONG=System.Int32
LONG32=System.Int32
LONG64=System.Int64
LONGLONG=System.Int64
LPARAM=System.IntPtr
LPBOOL=System.Int16[]
LPBYTE=System.UInt16[]
LPCOLORREF=System.UInt32[]
LPCSTR=System.String
LPCTSTR=System.String
LPCVOID=System.UInt32
LPCWSTR=System.String
LPDWORD=System.UInt32[]
LPHANDLE=System.UInt32
LPINT=System.Int32[]
LPLONG=System.Int32[]
LPSTR=System.String
LPTSTR=System.String
LPVOID=System.UInt32
LPWORD=System.Int32[]
LPWSTR=System.String
LRESULT=System.IntPtr
PBOOL=System.Int16[]
PBOOLEAN=System.Int16[]
PBYTE=System.UInt16[]
PCHAR=System.Char[]
PCSTR=System.String
PCTSTR=System.String
PCWCH=System.UInt32
PCWSTR=System.UInt32
PDWORD=System.Int32[]
PFLOAT=System.Float[]
PHANDLE=System.UInt32
PHKEY=System.UInt32
PINT=System.Int32[] ID=System.UInt32
PLONG=System.Int32[]
PLUID=System.UInt32
PSHORT=System.Int16[]
PSTR=System.String
PTBYTE=System.Char[]
PTCHAR=System.Char[]
PTSTR=System.String
PUCHAR=System.Char[]
PUINT=System.UInt32[]
PULONG=System.UInt32[]
PUSHORT=System.UInt16[]
PVOID=System.UInt32
PWCHAR=System.Char[]
PWORD=System.Int16[]
PWSTR=System.String
REGSAM=System.UInt32
SC_HANDLE=System.IntPtr
SC_LOCK=System.IntPtr
SHORT=System.Int16
SIZE_T=System.UInt32
SSIZE_=System.UInt32
TBYTE=System.Char
TCHAR=System.Char
UCHAR=System.Byte
UINT=System.UInt32
UINT32=System.UInt32
UINT64=System.UInt64
ULONG=System.UInt32
ULONG32=System.UInt32
ULONG64=System.UInt64
ULONGLONG=System.UInt64
USHORT=System.UInt16
WORD=System.UInt16
WPARAM=System.IntPtr

<---------补充----------->

Wtypes.h 中的非托管类型    非托管C 语言类型    托管类名       说明
HANDLE                        void*                   System.IntPtr 32 位
BYTE                            unsigned char       System.Byte    8 位
SHORT short System.Int16 16 位
WORD                          unsigned short      System.UInt16 16 位
INT                               int                       System.Int32   32 位
UINT                             unsigned int         System.UInt32 32 位
LONG                            long                    System.Int32   32 位
BOOL                            long                    System.Int32   32 位
DWORD                        unsigned long       System.UInt32 32 位
ULONG                          unsigned long      System.UInt32 32 位
CHAR                            char                    System.Char    用 ANSI 修饰。
LPSTR                           char*                  System.String 或 System.StringBuilder 用 ANSI 修饰。
LPCSTR                         Const char*         System.String 或 System.StringBuilder 用 ANSI 修饰。
LPWSTR                        wchar_t*             System.String 或 System.StringBuilder 用 Unicode 修饰。
LPCWSTR                      Const wchar_t*    System.String 或 System.StringBuilder 用 Unicode 修饰。
FLOAT                           Float                    System.Single 32 位
DOUBLE                        Double                 System.Double 64 位

本文链接

全面理解javascript的caller,callee,call,apply概念[转载]

2011-01-26T02:07:00Z

全面理解javascript的caller,callee,call,apply概念[转载]

2006/10/23 11:31

在提到上述的概念之前，首先想说说javascript中函数的隐含参数：arguments

Arguments

该对象代表正在执行的函数和调用它的函数的参数。

[function.]arguments[n]
参数function ：选项。当前正在执行的 Function 对象的名字。 n ：选项。要传递给 Function 对象的从0开始的参数值索引。
说明

Arguments是进行函数调用时，除了指定的参数外，还另外创建的一个隐藏对象。Arguments是一个类似数组但不是数组的对象，说它类似数组是因为其具有数组一样的访问性质及方式，可以由arguments[n]来访问对应的单个参数的值，并拥有数组长度属性length。还有就是arguments对象存储的是实际传递给函数的参数，而不局限于函数声明所定义的参数列表，而且不能显式创建 arguments 对象。arguments 对象只有函数开始时才可用。下边例子详细说明了这些性质:

//arguments 对象的用法。
function ArgTest(a, b){
    var i, s = "The ArgTest function expected ";
    var numargs = arguments.length;      // 获取被传递参数的数值。
    var expargs = ArgTest.length;        // 获取期望参数的数值。
    if (expargs < 2)
       s += expargs + " argument. ";
    else
       s += expargs + " arguments. ";
    if (numargs < 2)
       s += numargs + " was passed.";
    else
       s += numargs + " were passed.";
    s += "\n\n"
    for (i =0 ; i < numargs; i++){       // 获取参数内容。
    s += "   Arg " + i + " = " + arguments[i] + "\n";
    }
    return(s);                           // 返回参数列表。
}

在此添加了一个说明arguments不是数组(Array类)的代码:

Array.prototype.selfvalue = 1;
alert(new Array().selfvalue);
function testAguments(){
alert(arguments.selfvalue);
}

运行代码你会发现第一个alert显示1，这表示数组对象拥有selfvalue属性，值为1，而当你调用函数testAguments时，你会发现显示的是“undefined”，说明了不是arguments的属性，即arguments并不是一个数组对象。

caller
   返回一个对函数的引用，该函数调用了当前函数。
   functionName.caller
   functionName 对象是所执行函数的名称。
说明
对于函数来说，caller 属性只有在函数执行时才有定义。如果函数是由顶层调用的，那么 caller 包含的就是 null 。如果在字符串上下文中使用 caller 属性，那么结果和 functionName.toString 一样，也就是说，显示的是函数的反编译文本。
下面的例子说明了 caller 属性的用法：

// caller demo {
function callerDemo() {
     if (callerDemo.caller) {
         var a= callerDemo.caller.toString();
         alert(a);
     } else {
         alert("this is a top function");
     }
}
function handleCaller() {
     callerDemo();
}

callee

返回正被执行的 Function 对象，也就是所指定的 Function 对象的正文。

[function.]arguments.callee
可选项 function 参数是当前正在执行的 Function 对象的名称。

说明

callee 属性的初始值就是正被执行的 Function 对象。

callee 属性是 arguments 对象的一个成员，它表示对函数对象本身的引用，这有利于匿名
函数的递归或者保证函数的封装性，例如下边示例的递归计算1到n的自然数之和。而该属性
仅当相关函数正在执行时才可用。还有需要注意的是callee拥有length属性，这个属性有时候
用于验证还是比较好的。arguments.length是实参长度，arguments.callee.length是
形参长度，由此可以判断调用时形参长度是否和实参长度一致。

示例

//callee可以打印其本身
function calleeDemo() {
     alert(arguments.callee);
}
//用于验证参数
function calleeLengthDemo(arg1, arg2) {
     if (arguments.length==arguments.callee.length) {
         window.alert("验证形参和实参长度正确！");
         return;
     } else {
         alert("实参长度：" +arguments.length);
         alert("形参长度： " +arguments.callee.length);
     }
}
//递归计算
var sum = function(n){
   if (n <= 0)
   return 1;
   else
     return n ＋arguments.callee(n - 1)
}
比较一般的递归函数：

var sum = function(n){
if (1==n) return 1;
else return n + sum (n-1);

调用时：alert(sum(100));
其中函数内部包含了对sum自身的引用，函数名仅仅是一个变量名，在函数内部调用sum即相当于调用
一个全局变量，不能很好的体现出是调用自身，这时使用callee会是一个比较好的方法。

apply and call

它们的作用都是将函数绑定到另外一个对象上去运行，两者仅在定义参数方式有所区别：

apply(thisArg,argArray);

call(thisArg[,arg1,arg2…] ]);

即所有函数内部的this指针都会被赋值为thisArg，这可实现将函数作为另外一个对象的方法运行的目的

apply的说明

如果 argArray 不是一个有效的数组或者不是 arguments 对象，那么将导致一个 TypeError。
如果没有提供 argArray 和 thisArg任何一个参数，那么 Global 对象将被用作 thisArg，
并且无法被传递任何参数。

call的说明

call 方法可将一个函数的对象上下文从初始的上下文改变为由 thisArg指定的新对象。
如果没有提供 thisArg参数，那么 Global 对象被用作 thisArg

发几个小的测式软件

2010-11-23T11:59:00Z

流控狗程序-下载

反ARP程序-下载

计算机急救中心-下载

本文链接

關於 IE6/7 不支援 Element 自訂方法屬性繼承的可行解決方案

2010-06-01T03:41:00Z

[转]關於 IE6/7 不支援 Element 自訂方法屬性繼承的可行解決方案来源[http://audi.tw/Blog/JavaScript/javascript.element.ie.asp] 由 prototype 談起物件導向語言，支援「繼承」的概念，也就是父物件有的方法及屬性，物件本身也一應具備。於是設計人員可以直接在上層物件定義好一堆自己專屬或改良的方法和屬性，這比設計副程式庫還...

Vs2010 配置驱动开发环境

2010-05-17T08:06:00Z

1、安装VS2010，安装WDK 7.0(DDK);

2、新建VC++->Empty Project

3、打开Configuration Manager 并新建一个名称为“ dirver ”的Solution Configuration 并将“dirver” 设为Active Solution Configuration .

4、打开View-> property Manager。

5、在"dirver" solution configuration 上点击右键，选择Add new property Sheet。取名为“dirverProperty”. 并对他进下以下设置。

5.1. C\C++ - General - Debug Information Format = Program Database (/Zi)
5.2. C\C++ - Preprocessor - Preprocessor Definitions = _X86_ [add also DBG for Debug config]
【WIN32;_DEBUG;_X86_;i386;STD_CALL;CONDITION_HANDLING;WIN32_LEAN_AND_MEAN;NT_UP;SRVDBG;DBG;_IDWBUILD;_WIN32_WINNT=0x0400;% (PreprocessorDefinitions)】
5.3. C\C++ - Code Generation - Enable C++ Exceptions = No
5.4. C\C++ - Code Generation - Basic Runtime Checks = Default
5.5. C\C++ - Code Generation - Buffer Security Check = No (/GS-)
5.6. C\C++ - Advanced - Calling Convention = __stdcall (/Gz)
5.7. C\C++ - Advanced - Compile As = Compile as C Code (/TC) [if you are going to use plain C]
5.8. Linker - General - Output File = $(OutDir)\$(ProjectName).sys
5.9. Linker - General - Enable Incremental Linking = Default
5.10. Linker - Input - Additional Dependencies = ntoskrnl.lib hal.lib $(NOINHERIT) [add here needed libs here e.g. ntoskrnl.lib hal.lib]
【不知道上面是不是笔误，应该为：ntoskrnl.lib;hal.lib;%(AdditionalDependencies)】
5.11. Linker - Input - Ignore All Default Libraries = Yes (/NODEFAULTLIB)
5.12. Linker - Manifest File - Generate Manifest = No
5.13. Linker - System - SubSystem = Native (/SUBSYSTEM:NATIVE)
5.14. Linker - System - Driver = Driver (/DRIVER)
5.15. Linker - Advanced - Entry Point = DriverEntry
5.16. Linker - Advanced - Base Address = 0x10000
5.17. Linker - Advanced - Randomized Base Address = Disable (/DYNAMICBASE:NO)
【这个也是错误的：应该置空】
5.18. Linker - Advanced - Data Execution Prevention (DEP) = Disable (/NXCOMPAT:NO)
【这个也是错误的：应该置空】

6. Config VC++ Directories
6.1 Open Open up property manager by clicking on Menu View->Property Manager.
6.2 Expand the project node and then the Configuration|Platform nodes, you will see "Microsoft.cpp.<Platform>.users" file for each Configuration|Platform. These are the files

for the global settings, similar to the old tools/Options/VC++ Directories.
6.3 Multi-Select "Microsoft.cpp.<Platform>.users", right click and bring up the property page window
6.4 In the property page window, click on "VC++ Directories" (for example) in the left pane, add new paths for the directories such as "Include Directories". separated by

semicolons
(eg:Include Directories config As:
$(ddkroot)\INC
$(ddkroot)\INC\WNET
$(ddkroot)\INC\DDK\WNET
Library Directories config As:
$(ddkroot)\LIB\WNET\I386
)
6.5 Make sure to save the settings before shutting down Visual Studio.
6.6 Re-launch Visual Studio and the new settings will be in effect.
6.7 Note: If you would like to only change the settings for one project, you can right click on the project and bring up the property page. Change the settings for “VC++

Directories”, these settings will be persisted to the project file.
七. OK. Have done. Now you can test it with simple code, e.g.:

#include "ntddk.h"

NTSTATUS
DriverEntry(PDRIVER_OBJECT DriverObject,PUNICODE_STRING RegistryPath)
{
return STATUS_UNSUCCESSFUL;
}

特别说明：
   1.
      Visual Studio 2010 在智能设备开发方面只支持Windows Phone OS 7.0。如果你要为Windows CE 5.0和Windows Mobile 6.5开发应用程序，请安装Visual Studio 2008。
   2.
      做驱动开发时，SDK的版本要和WDK的版本一致，即Win7 WDK要配Win7 SDK，否则会出现编译错误。VS2010里集成了Windows SDK 7.0A。
   3.
      如果出现类似如下编译错误，解决方法是：拷贝C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include\sal.h，然后覆盖掉C:\WinDDK\7600.16385.1\inc\api\sal.h。

C:\Program Files\Microsoft Visual Studio 10.0\VC\include\crtdefs.h(550): error C2143: syntax error : missing ')' before 'const'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\crtdefs.h(550): error C2143: syntax error : missing '{' before 'const'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\crtdefs.h(550): error C2059: syntax error : ','
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\crtdefs.h(550): error C2059: syntax error : ')'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\excpt.h(56): error C2143: syntax error : missing ')' before 'type'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\excpt.h(56): error C2085: '_ExceptionRecord' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\excpt.h(57): error C2143: syntax error : missing ';' before 'type'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\excpt.h(57): error C2085: '_EstablisherFrame' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\excpt.h(58): error C2085: '_Inout_' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\excpt.h(58): error C2143: syntax error : missing ';' before 'type'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\excpt.h(58): error C2085: '_ContextRecord' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\excpt.h(59): error C2085: '_Inout_' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\excpt.h(59): error C2143: syntax error : missing ';' before 'type'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\excpt.h(60): error C2059: syntax error : ')'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\excpt.h(60): error C2085: '_DispatcherContext' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\excpt.h(104): error C2082: redefinition of formal parameter '_exception_code'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\excpt.h(105): error C2082: redefinition of formal parameter '_exception_info'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\excpt.h(106): error C2082: redefinition of formal parameter '_abnormal_termination'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(92): error C2061: syntax error : identifier '_Check_return_'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(93): error C2054: expected '(' to follow '_Check_return_'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(93): error C2143: syntax error : missing ')' before 'type'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(93): error C2085: '_isctype_l' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(93): error C2143: syntax error : missing ';' before 'type'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(93): error C2085: '_C' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(93): error C2085: '_In_' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(93): error C2143: syntax error : missing ';' before 'type'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(93): error C2085: '_Type' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(93): error C2085: '_In_opt_' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(93): error C2146: syntax error : missing ',' before identifier '_locale_t'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(93): error C2146: syntax error : missing ',' before identifier '_Locale'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(93): error C2059: syntax error : ')'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(94): error C2061: syntax error : identifier '_Check_return_'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(95): error C2086: 'int _Check_return_' : redefinition
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(93) : see declaration of '_Check_return_'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(95): error C2054: expected '(' to follow '_Check_return_'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(95): error C2143: syntax error : missing ')' before 'type'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(95): error C2085: '_isalpha_l' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(95): error C2143: syntax error : missing ';' before 'type'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(95): error C2085: '_C' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(95): error C2085: '_In_opt_' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(95): error C2146: syntax error : missing ',' before identifier '_locale_t'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(95): error C2146: syntax error : missing ',' before identifier '_Locale'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(95): error C2059: syntax error : ')'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(96): error C2061: syntax error : identifier '_Check_return_'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(97): error C2086: 'int _Check_return_' : redefinition
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(93) : see declaration of '_Check_return_'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(97): error C2054: expected '(' to follow '_Check_return_'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(97): error C2143: syntax error : missing ')' before 'type'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(97): error C2085: '_isupper_l' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(97): error C2143: syntax error : missing ';' before 'type'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(97): error C2085: '_C' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(97): error C2085: '_In_opt_' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(97): error C2146: syntax error : missing ',' before identifier '_locale_t'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(97): error C2146: syntax error : missing ',' before identifier '_Locale'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(97): error C2059: syntax error : ')'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(98): error C2061: syntax error : identifier '_Check_return_'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(99): error C2086: 'int _Check_return_' : redefinition
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(93) : see declaration of '_Check_return_'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(99): error C2054: expected '(' to follow '_Check_return_'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(99): error C2143: syntax error : missing ')' before 'type'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(99): error C2085: '_islower_l' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(99): error C2143: syntax error : missing ';' before 'type'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(99): error C2085: '_C' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(99): error C2085: '_In_opt_' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(99): error C2146: syntax error : missing ',' before identifier '_locale_t'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(99): error C2146: syntax error : missing ',' before identifier '_Locale'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(99): error C2059: syntax error : ')'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(100): error C2061: syntax error : identifier '_Check_return_'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(101): error C2086: 'int _Check_return_' : redefinition
          C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(93) : see declaration of '_Check_return_'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(101): error C2054: expected '(' to follow '_Check_return_'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(101): error C2143: syntax error : missing ')' before 'type'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(101): error C2085: '_isdigit_l' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(101): error C2143: syntax error : missing ';' before 'type'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(101): error C2085: '_C' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(101): error C2085: '_In_opt_' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(101): error C2146: syntax error : missing ',' before identifier '_locale_t'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(101): error C2146: syntax error : missing ',' before identifier '_Locale'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(101): error C2059: syntax error : ')'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(102): error C2061: syntax error : identifier '_Check_return_'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(103): error C2086: 'int _Check_return_' : redefinition
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(93) : see declaration of '_Check_return_'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(103): error C2054: expected '(' to follow '_Check_return_'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(103): error C2143: syntax error : missing ')' before 'type'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(103): error C2085: '_isxdigit_l' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(103): error C2143: syntax error : missing ';' before 'type'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(103): error C2085: '_C' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(103): error C2085: '_In_opt_' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(103): error C2146: syntax error : missing ',' before identifier '_locale_t'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(103): error C2146: syntax error : missing ',' before identifier '_Locale'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(103): error C2059: syntax error : ')'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(104): error C2061: syntax error : identifier '_Check_return_'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(105): error C2086: 'int _Check_return_' : redefinition
          C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(93) : see declaration of '_Check_return_'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(105): error C2054: expected '(' to follow '_Check_return_'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(105): error C2143: syntax error : missing ')' before 'type'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(105): error C2085: '_isspace_l' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(105): error C2143: syntax error : missing ';' before 'type'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(105): error C2085: '_C' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(105): error C2085: '_In_opt_' : not in formal parameter list
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(105): error C2146: syntax error : missing ',' before identifier '_locale_t'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(105): error C2146: syntax error : missing ',' before identifier '_Locale'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(105): error C2059: syntax error : ')'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(106): error C2061: syntax error : identifier '_Check_return_'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(107): error C2086: 'int _Check_return_' : redefinition
          C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(93) : see declaration of '_Check_return_'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(107): error C2054: expected '(' to follow '_Check_return_'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(107): error C2143: syntax error : missing ')' before 'type'
C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ctype.h(107): fatal error C1003: error count exceeds 100; stopping compilation

本文链接

美杜杉主动防御最新版

2010-04-30T15:27:00Z

美杜杉 2010 家庭版

1、优化启动速度。

2、全新有UI界面。

3、更加智能的主动杀。

4、全新主动防强攻击行为特征库。

5、添加英文语言包。

6、更加详细的监控日记计录，让木码病毒无处藏身。

软件界面图。

详细功能请见:http://m25.mds110.com 点击立即下载

本文链接

Asp.net 异步请求 IHttpAsyncHandler

2010-04-24T19:14:00Z

Use Threads and Build Asynchronous Handlers in Your Server-Side Web Code

Fritz Onion

Code download available at: Threading.exe (121 KB)
Browse the Code Online

This article assumes you're familiar with C#, ASP.NET, and Multithreading

Level of Difficulty 1 2 3

SUMMARY

Fortunately for developers, threading in ASP.NET is a lot easier than it was in ASP. In this article, the author takes a look at threading in the ASP.NET HTTP pipeline, and explains how threads are managed efficiently without the involvement of the developer. The article considers how the common language runtime threadpool is used by ASP.NET to service requests, looks at the pooling mechanisms used for handlers, modules, and applications, and covers both IIS 5.0 and IIS 6.0 and how they differ in their approach to request processing and thread allocation. Finally, how and when to use asynchronous handlers is discussed for developers who still need to use threads in their own applications.

Contents

Threading in ASP.NET
Thread Dispatching in IIS 5.0 and 6.0
The Need for Asynchrony
Asynchronous Handlers
Asynchronous Handler with a Delegate
Asynchronous Handler with Custom Threads
Asynchronous Handler with a Custom Thread Pool
Asynchronous Pages
Conclusion

In traditional ASP, developers faced more threading issues than they knew what to do with. Because ASP was built on top of COM, there were very specific rules about the threading requirements of objects. Objects used by pages needed to be apartment threaded for maximum efficiency. Conversely, objects living in Session and Application state needed to be context-agile and able to aggregate the freethreaded marshaler, as well as have their state protected against concurrent access.

If you look at the documentation for ASP.NET, however, you will find very little information about threading requirements. Does this mean that all threading issues are solved and that ASP.NET developers can live carefree lives building .aspx pages and Microsoft® .NET Framework classes without cluttering their minds with concurrency issues? Well, yes, in most cases it does.

In this article, I will explore the details of threading in the HTTP pipeline and how it efficiently manages threads without burdening the developer. I will also take a look at how ASP.NET uses the common language runtime (CLR) thread pool to service requests, the pooling mechanisms used for handlers, modules, and applications, and some of the differences in request processing and thread allocation between Microsoft Internet Information Services (IIS) 5.0 and IIS 6.0. For those developers who just don't feel complete if they don't use threads in their applications, I will also introduce asynchronous handlers and discuss how and when to use them.

Threading in ASP.NET

To efficiently service multiple client requests, Web servers make extensive use of concurrency by launching multiple processes and/or spawning multiple threads to service requests and perform work. ASP.NET is no exception and uses multiple threads within each worker process to service requests. In spite of this fact, ASP.NET developers need not concern themselves with the multitude of issues that come with developing in a multithreaded environment. Page requests are always serviced on the same thread, and a distinct instance of the Page class is always created to service any new requests. Distinct instances of application and module objects are also used to service each request. It is important, however, to understand how threads are used to service requests so that you don't make incorrect assumptions about which objects in your applications may be accessed by concurrent threads.

To begin with, ASP.NET uses the process-wide CLR thread pool to service requests (for more background on the CLR thread pool, see the .NET column in this issue). The size of this pool is configurable in the processModel element of machine.config, and is set to a default of 25 worker threads and 25 I/O threads:

复制代码

<processModel enable="true" 
              •••
            maxWorkerThreads="25" 
            maxIoThreads="25" />

Threads are processed differently depending whether you are using IIS 5.0 or IIS 6.0, which I will discuss shortly. For each request that comes in, a new instance of the appropriate HttpApplication-derived class is created, as are the associated modules for that app. To avoid reallocating apps and modules too often, each AppDomain maintains a pool of apps and modules. The maximum size of the app pool is the same as the size of the thread pool, so by default, up to 25 requests per worker process can be processed concurrently, each with its own app and module set. Figure 1 shows a snapshot in time of the ASP.NET worker process. In this scenario, there are two active apps in the worker process, each with a dedicated AppDomain. Each app is currently processing two requests, and each is using two threads from the CLR thread pool to service those requests.

Figure 1 Threading and Pooling in the HTTP Pipeline

Several aspects of this architecture may influence the way you construct your ASP.NET applications. First, the fact that applications and modules are instantiated multiple times means that you should never rely on adding fields or other states because they will not be shared across multiple requests, as you might think. Instead, use one of the many state repositories available in the pipeline, such as the application-wide cache, the session state bag, the appliction state bag, or the per-request Items collection of the HttpContext class. Additionally you can use static data if properly synchronized.

By default, most handlers created to service requests are not pooled. You can pool handlers and even control pooling on a per-handler basis through the IsReusable property of IHttpHandler, but the only handlers that are pooled implicitly are custom handlers that you write with no designated handler factory. The PageHandlerFactory class does not perform pooling, nor does the SimpleHandlerFactory class, which instantiates .ashx-defined handlers. Typically, therefore, each request is serviced by a freshly allocated instance of the appropriate handler class, which is discarded after the request completes.

Thread Dispatching in IIS 5.0 and 6.0

Requests in IIS 5.0 are typically serviced over I/O threads, or threads performing asynchronous I/O because requests are dispatched to the worker process using asynchronous writes to a named pipe. When the request is serviced in the worker process, it will typically use the thread on which the asynchronous read was performed. The threads used to service requests in the worker process are drawn from the process-wide CLR thread pool, although thread pool threads tied to I/O completion ports incorrectly return false from the IsThreadPoolThread property of the Thread class, so don't count on that property.

Although requests are typically serviced on I/O threads in IIS 5.0, under heavy loads, some requests are passed off to normal worker threads from the pool, so both types of threads are used simultaneously. The default size of the CLR thread pool is 25, with separate limits for I/O threads and worker threads. You can change the upper number of threads allocated in the CLR thread pool by modifying the processModel element found in machine.config, as was shown earlier.

Things change dramatically with IIS 6.0 (which ships with Windows® Server 2003). To begin with, inetinfo.exe is no longer used to service HTTP requests (although it remains in place to service other protocols, like FTP). Instead, HTTP requests are queued in a kernel-mode service, http.sys, which takes care of dispatching each request to the appropriate application queue. In addition, IIS 6.0 supports application pools, which are groupings of applications that will share a single worker process, now named w3pwp.exe. Application pools give you the option of having as many distinct worker processes as you want on any given server, depending on how much you care about process isolation between your Web applications.

This paradigm changes the way requests are handled in ASP.NET. Instead of dispatching requests from inetinfo.exe to the ASP.NET worker process, http.sys directly queues each request in the appropriate process. Thus all requests are now serviced by worker threads drawn from the CLR thread pool and never on I/O threads. Contrary to comments found in machine.config on Windows Server 2003, the processModel element is still used to initialize the upper bound of the thread pool, although all other attributes are ignored as they are now stored in the IIS 6.0 metabase.

The Need for Asynchrony

Many factors influence the scalability of a Web application. In general, any time multiple concurrent operations request exclusive access to a shared resource, the scalability of the system is jeopardized. High on the list of resources that are shared on a system is the CPU itself (or CPUs on a multiprocessor box). A server running ASP.NET has its CPU shared among concurrent requests by way of a thread pool. The purpose of the thread pool is to efficiently allocate CPU time for processing requests with an upper limit on the total number of threads allocated. This is an important restriction to have in place, as creating an unbounded number of threads can easily grind a system to a halt when a large number of requests are made concurrently.

However, in cases where threads from the thread pool are used to perform work that is not CPU-intensive (like making a request to a remote database or invoking a remote Web Service), it is possible to saturate the thread pool without high CPU utilization. In this scenario, the thread pool is in fact reducing the scalability of the system because requests may be delayed (or possibly rejected) even though the server was not busy processing other requests.

As an example of swamping the thread pool, consider the following ASP.NET page, slow.aspx, that artificially delays its response by two seconds (with non-CPU-bound activity) and prints out the thread on which it was serviced:

复制代码

<!-- File: slow.aspx -->
<%@ Page Language="C#" %>
<%@ Import Namespace="System.Reflection" %>
<%@ Import Namespace="System.Threading" %>

<script runat="server">
  protected void Page_Load(object src, EventArgs e)
  {
    System.Threading.Thread.Sleep(2000);
    Response.Output.Write("SlowResponse, threadid={0}",
                    AppDomain.GetCurrentThreadId());
  }
</script>

Another ASP.NET page, fast.aspx, is nearly identical, except that it does not sleep for the two seconds that slow.aspx does:

复制代码

<!-- File: fast.aspx -->
<%@ Page Language="C#" %>
<%@ Import Namespace="System.Reflection" %>

<script runat="server">
  protected void Page_Load(object src, EventArgs e)
  {
    Response.Output.Write("FastResponse, threadid={0}",
                    AppDomain.GetCurrentThreadId());
  }
</script>

Using the Web Application Stress tool against a server hosting these two pages, you can test the average response time under heavy request traffic. An initial test issuing requests on 100 concurrent threads from a separate client machine to only the fast.aspx page results in an average response time of 0.0824 seconds, servicing 52,190 requests during a one-minute time interval. Running the client against both fast.aspx and slow.aspx, however, reduces the average response time for fast.aspx requests to 4.47 seconds (and slow.aspx is 6.54 seconds), with the total number of requests serviced in one minute reduced to 1062.

While the numbers are dramatically different across the board, the most disturbing result is that it took more than four seconds on average to serve fast.aspx, which you know takes very little time to process. Although contrived, this example shows the worst case scenario when you have pages that are relatively slow to serve fighting for the same request threads that more responsive pages contend for—a dramatic increase in response times. If the slow pages in your application are sluggish due to intensive CPU usage, there is not much you can do about it except to throw in more hardware. If, however, the slow pages in your application are slow because they are waiting on non-CPU-bound operations to complete, then the problem is not the lack of CPU power, but the fact that slow requests are saturating the thread pool so that other requests must be queued until a thread is released.

You have a few options if you discover that your system's scalability is being adversely affected by the ASP.NET thread pool. You could change the upper limit of the thread pool. As you have seen, the default upper limit is set to 25 worker threads and 25 I/O threads. Of course, increasing the upper bound in the thread pool is a somewhat coarse-grained solution to the problem. If you can find the magic number that keeps your CPU utilization high and only delays or denies requests when the server is truly too busy to process more requests, you are very fortunate. The number of threads necessary to keep the server truly busy is not static, but will fluctuate based on factors like demand and process complexity.

Another potential solution is to carefully identify the requests in your system that take longer to complete and perform non-CPU-bound operations and to allocate distinct threads to service them, freeing up the original thread pool thread to service additional requests. This brings me to asynchronous handlers.

Asynchronous Handlers

While most ASP.NET pages and handlers are serviced synchronously on threads drawn from the process-wide thread pool, it is possible to create handlers (and even pages) that service requests asynchronously. Asynchronous handlers implement the IHttpAsyncHandler interface, which derives from IHttpHandler implemented by synchronous handlers:

复制代码

public interface IHttpAsyncHandler : IHttpHandler
{
  IAsyncResult BeginProcessRequest(HttpContext ctx,
                                   AsyncCallback cb, 
                                   object obj);
  void EndProcessRequest(IAsyncResult ar);
}

Handlers that implement this interface must implement two additional methods besides the standard methods of IHttpHandler. The first, BeginProcessRequest, is called by the application class instead of directly calling the ProcessRequest. It is then up to the handler to launch a new thread to process the request and then immediately return from the BeginProcessRequest method, passing back a reference to a valid IAsyncResult instance so that the runtime knows the operation is complete. The other method, EndProcessRequest, is called when the request processing is complete and can be used to clean up any allocated resources if necessary.

Asynchronous Handler with a Delegate

If you have done any work with asynchronous execution in the .NET Framework, you know that the simplest and most often recommended way to perform work asynchronously is to use asynchronous delegate invocation. Invoking a delegate asynchronously by calling BeginInvoke implicitly uses a thread from the process-wide thread pool to execute the delegate function. Implementing an asynchronous handler using asynchronous delegate invocation is actually quite straightforward, as shown in Figure 2.

Figure 2 HTTP Handler Implementation

复制代码

<!-- File: AsyncDelegate.ashx -->
<%@ WebHandler Language="C#" 
     %>

using System;
using System.Web;
using System.Threading;
using System.Diagnostics;
using System.Reflection;

namespace EssentialAspDotNet.HttpPipeline
{
  public delegate void ProcessRequestDelegate(HttpContext ctx);

  public class AsyncHandler : IHttpAsyncHandler
  { 
    public void ProcessRequest(HttpContext ctx)
    {
       System.Threading.Thread.Sleep(2000);
       ctx.Response.Output.Write(
                    "AsyncDelegate, threaded={0}",
                    AppDomain.GetCurrentThreadId());
    }
    
    public bool IsReusable
    {
      get { return true;}
    }

    public IAsyncResult BeginProcessRequest(HttpContext ctx, 
                AsyncCallback cb, object obj)
    {
      ProcessRequestDelegate prg = 
               new ProcessRequestDelegate(ProcessRequest);
      // Fire-and-forget
      return prg.BeginInvoke(ctx, cb, obj);
    }

    public void EndProcessRequest(IAsyncResult ar)
    {
    }
  }
}

My implementation of IHttpAsyncHandler.BeginProcessRequest calls BeginInvoke on an instance of my ProcessRequestDelegate which has been initialized with a reference to my ProcessRequest method. This has the effect of executing ProcessRequest on a separate thread, distinct from the request thread.

Running the same stress test I performed earlier with my slow.aspx page, this time using my new asyncDelegate.ashx handler instead of fast.aspx, produces the following results. The average response time for fast.aspx is 4.14 seconds and 7.86 seconds for asyncDelegate.ashx, with the total number of serviced requests at 957.

Disappointingly, the response time did not really improve for requests made to fast.aspx. The reason for this is that asynchronous delegate invocation completely defeats the purpose of building an asynchronous handler because it draws from the same process-wide CLR thread pool that ASP.NET uses to service requests. While the primary request thread is indeed returned to the thread pool, another thread is taken out to perform the asynchronous delegate execution, which means that there is a net gain of zero threads for servicing additional requests, rendering the handler useless. You will run into the same problem if you use ThreadPool.QueueUserWorkItem to perform the asynchronous request processing because it also draws threads from the same process-wide CLR thread pool.

Asynchronous Handler with Custom Threads

To build a truly effective asynchronous handler, you must spawn an additional thread by hand in response to BeginProcessRequest. There are three important aspects to building a successful asynchronous handler. First, construct a class that supports IAsyncResult to return from BeginProcessRequest. Then, spawn the thread to perform your request processing asynchronously. Finally, notify ASP.NET that you are finished processing the request and are ready to return the response.

I will begin the construction of an asynchronous handler by building a class that supports IAsyncResult. This class is going to be returned from the call to BeginProcessRequest, and it will later be passed into my implementation of EndProcessRequest, so among other things, it is a useful place to store request-specific state that I may need to use during the processing of a request. The complete IAsyncResult interface to be implemented is shown here:

复制代码

public interface IAsyncResult
{
  public object     AsyncState             { get; }
  public bool       CompletedSynchronously { get; }
  public bool       IsCompleted            { get; }
  public WaitHandle AsyncWaitHandle        { get; }
}

In this example, I'll store a reference to the HttpContext object associated with the request, a reference to the AsyncCallback delegate passed into BeginProcessRequest (which I'll later invoke to complete the request), and a generic object reference for extra data that may be used by the caller of BeginProcessRequest. The other element that must be implemented in this class is a synchronization object that threads can wait on to be signaled when the operation completes. I will use the common technique of supplying a ManualResetEvent that fires when my request is complete, but allocate it only if someone requests it. Finally, my class will have a convenience method called CompleteRequest, which will trigger the ManualResetEvent if it was created, invoke the AsyncCallback delegate, and set the IsCompleted flag to true. The complete class definition for AsyncRequestState is shown in Figure 3.

Figure 3 AsyncRequestState Class Definition

复制代码

// From file: AsyncThread.ashx
class AsyncRequestState : IAsyncResult
{
  public AsyncRequestState(HttpContext ctx, 
                           AsyncCallback cb, 
                           object extraData )
  {
    _ctx = ctx;
    _cb = cb;
    _extraData = extraData;
  }
        
  internal HttpContext _ctx;
  internal AsyncCallback _cb;
  internal object _extraData;
  private bool _isCompleted = false;
  private ManualResetEvent _callCompleteEvent = null;

  internal void CompleteRequest()
  {
    _isCompleted = true;
    lock (this)
    {
      if (_callCompleteEvent != null)
        _callCompleteEvent.Set();
    }
    // if a callback was registered, invoke it now
    if (_cb != null)
      _cb(this);
  }
        
  // IAsyncResult interface property implementations
  public object AsyncState           
  { get { return(_extraData);   } }
  public bool CompletedSynchronously 
  { get { return(false);        } }
  public bool IsCompleted            
  { get { return(_isCompleted); } }
  public WaitHandle AsyncWaitHandle
  {
    get
    {
      lock( this )
      {
        if( _callCompleteEvent == null )
        _callCompleteEvent = new ManualResetEvent(false);
      
        return _callCompleteEvent;
      }
    }
  }
}

The next step is to spawn a new thread to process my request. The method I call on this new thread will need access to the state I cached in the AsyncRequestState class just shown. Unfortunately, the ThreadStart delegate used to spawn new threads in the .NET Framework does not take any parameters. To get around this, I create another class with the necessary state cached as data members (in this case, simply a reference to the AsyncRequestState object for this request) and with an instance method that can be used to initialize the ThreadStart delegate. This class, called AsyncRequest, is shown in Figure 4. Note that the ProcessRequest method I define in this class is the method that will be called from the manually created thread, and when it completes, it signals that the request processing is complete by invoking CompleteRequest on the AsyncRequestState object.

Figure 4 AsyncRequest

复制代码

// From file: AsyncThread.ashx
class AsyncRequest
{
  private AsyncRequestState _asyncRequestState;

  public AsyncRequest(AsyncRequestState ars)
  {
    _asyncRequestState = ars;
  }
    
  public void ProcessRequest()
  {
    // This is where the non-cpu-bound activity would take place, such as
    // accessing a Web Service, polling a slow piece of hardware, or 
    // performing a lengthy database operation. I put the thread to sleep 
    // for two seconds to simulate a lengthy operation.
    Thread.Sleep(2000);
      
    _asyncRequestState._ctx.Response.Output.Write(
            "AsyncThread, {0}", 
            AppDomain.GetCurrentThreadId());

    // tell asp.net I am finished processing this request
    _asyncRequestState.CompleteRequest();
  }
}

Finally, I am ready to build the asynchronous handler class itself. This class, which I have called AsyncHandler, must implement all of the methods of the IHttpAsyncHandler interface shown earlier, which derives from IHttpHandler for a total of four methods. The ProcessRequest method is not used and will never be called because I implement BeginProcessRequest. In BeginProcessRequest, I create a new instance of the AsyncRequestState class, initializing it with the HttpContext object, the AsyncCallback delegate, and the generic object reference each passed in as parameters. I then prepare a new AsyncRequest object, initialized with the freshly created AsyncRequestState object, and launch a new thread. The implementation of EndProcessRequest will not do anything in this example, but it can be used in general to perform any cleanup or last-minute response additions. The AsyncHandler class definition is shown in Figure 5.

Figure 5 AsyncHandler Class Definition

复制代码

// From file: AsyncThread.ashx
public class AsyncHandler : IHttpAsyncHandler
{ 
  public void ProcessRequest(HttpContext ctx)
  {
    // not used
  }

  public bool IsReusable
  {
    get { return false;}
  }

  public IAsyncResult BeginProcessRequest(HttpContext ctx, 
                                          AsyncCallback cb, 
                                          object obj)
  {
    AsyncRequestState reqState = 
                      new AsyncRequestState(ctx, cb, obj);
    AsyncRequest ar = new AsyncRequest(reqState);
    ThreadStart ts = new ThreadStart(ar.ProcessRequest);
    Thread t = new Thread(ts);
    t.Start();
  
    return reqState;
  }

  public void EndProcessRequest(IAsyncResult ar)
  {
    // This will be called on the manually created thread in response to 
    // calling the ASP.NET AsyncCallback delegate once the request has
    // completed processing. The incoming IAsyncResult parameter will be 
    // a reference to the AsyncRequestState class, so the Context can be
    // accessed through that class. Note - you *cannot* access the 
    // current context using the HttpContext.Current property, as you are 
    // running on your own thread which has not been initialized with a 
    // context reference.
    AsyncRequestState ars = ar as AsyncRequestState;
    if (ars != null)
    {
     // here you could perform some cleanup, write something else to the
     // Response, or whatever else you need to do
    }
  }
}

When I build this handler and register it as an endpoint, as I did with the earlier handlers, it will successfully process requests asynchronously from the calling request thread of ASP.NET. Figure 6 shows the sequence of events that will take place when a request mapped onto the asynchronous handler is made. First the application class sees that my handler implements IHttpAsyncHandler, so instead of calling the synchronous ProcessRequest method, it invokes BeginProcessRequest on the handler, passing in the current context and an asynchronous callback delegate for completion call back. The handler then creates a new AsyncRequestState object, initialized with the parameters passed into BeginProcessRequest. Next, the handler creates a new AsyncRequest object, initialized with the AsyncRequestState object, and launches a new thread using the AsyncRequest.ProcessRequest method as the entry point. The handler then returns the AsyncRequestState object back to the application object and the calling thread is returned to the thread pool while the hand-created thread continues processing the request.

Figure 6 Async Handler Operation Phase 1

Once the ProcessRequest method of the AsyncRequest object is finished performing its lengthy tasks, it calls the CompleteRequest method of the AsyncRequestState class. This in turn will fire the AsyncCallback delegate originally passed into the BeginProcessRequest method, signaling that the response is prepared and ready for return. The first thing the AsyncCallback delegate will do is call the EndProcessRequest method on the asynchronous handler class. Once that returns, it will trigger the completion of the request by sending back the prepared response. All of this processing happens on the secondary thread that I created in the handler, not on a thread pool thread. Figure 7 shows the steps involved in completing the request to the asynchronous handler.

Figure 7 Async Handler Operation Phase 2

When I ran the same stress test I performed earlier with the slow.aspx page, this time using the new AsyncThread.ashx handler instead of AsyncDelegate.aspx, the following results are produced. The average response time for fast.aspx is .012 seconds and 2.014 seconds for AsyncThread.ashx, with the total number of serviced requests at 6132.

The average response time for requests made to fast.aspx is much improved because the thread pool is not tied up servicing requests to the slow handler.

Asynchronous Handler with a Custom Thread Pool

There is one remaining problem with this asynchronous handler implementation—it has the potential to create an unbounded number of threads. If a large number of requests are made to the asynchronous handler, all of which take a significant amount of time to service, then you could easily end up creating more threads than the underlying operating system can handle. To deal with this, I need to provide a secondary thread pool to service the requests in a bounded fashion. Details of creating custom thread pools are beyond the scope of this article, but a full example written in C# by Mike Woodring is available for download at http://www.bearcanyon.com/dotnet/threadpool.zip. This custom thread pool also supports propagation of call context and HttpContext, which means that you can access HttpContext.Current in the asynchronous method, unlike the previous example. The class implementing the thread pool is called DevelopMentor.ThreadPool, and its constructor takes an initial thread count, a maximum thread count, and a string to give the pool a name. To issue asynchronous requests with this pool, call PostRequest and pass in a reference to a WorkRequestDelegate.

To rewrite the asynchronous handler to use this custom thread pool there will be two major changes that just spawned new threads. First, add a static member of type DevelopMentor.ThreadPool to the handler class and a static constructor to initialize the thread pool once per AppDomain. Then change the implementation of BeginProcessRequest to call PostRequest on the thread pool with a new instance of WorkRequestDelegate (see Figure 8). If you run the same stress test performed earlier with the slow.aspx page, this time using the new AsyncPool.ashx handler instead of AsyncThread.aspx, you get the following results. The average response time for fast.aspx is .055 seconds and 12.24 seconds for AsyncThread.ashx with the total number of serviced requests at 1042.

Figure 8 Calling PostRequest

复制代码

<!-- File: AsyncPool.ashx -->
<%@ WebHandler Language="C#" 
     %>

namespace EssentialAspDotNet.HttpPipeline
{
  // AsyncRequestState and AsyncRequest remain the same 
  // as in the previous example
  
  public class AsyncHandler : IHttpAsyncHandler
  { 
    static DevelopMentor.ThreadPool _threadPool;

    static AsyncHandler()
    {
      _threadPool = 
        new DevelopMentor.ThreadPool(2, 25, "AsyncPool");
      _threadPool.PropogateCallContext = true;
      _threadPool.PropogateThreadPrincipal = true;
      _threadPool.PropogateHttpContext = true;
      _threadPool.Start();
    }

    public void ProcessRequest(HttpContext ctx)
    {
     // not used
    }

    public bool IsReusable
    {
      get { return false;}
    }

    public IAsyncResult BeginProcessRequest(HttpContext ctx, 
                     AsyncCallback cb, object obj)
    {
      AsyncRequestState reqState = 
                     new AsyncRequestState(ctx, cb, obj);
      _threadPool.PostRequest(
                     new DevelopMentor.WorkRequestDelegate(ProcessRequest),
                     reqState);

      return reqState;
    }

    public void EndProcessRequest(IAsyncResult ar)
    {
    }

    void ProcessRequest(object state, DateTime requestTime)
    {
      AsyncRequestState reqState = state as AsyncRequestState;

      // Take some time to do it
      Thread.Sleep(2000);
      
      reqState._ctx.Response.Output.Write(
                   "AsyncThreadPool, {0}",
                    AppDomain.GetCurrentThreadId);

      // tell asp.net you are finished processing this request
      reqState.CompleteRequest();
    }

  }
}

Note that the average response time for requests made to fast.aspx is still minimal, and there is no longer the danger of creating an unbounded number of threads. There is some additional management involved with maintaining a second thread pool, which results in the extended request times for the slow handler.

Asynchronous Pages

So far, all of the examples of asynchronous request handling have involved building custom handlers (in this case, using .ashx files). There will be many cases where you can identify normal pages (.aspx) in your ASP.NET applications that are also good candidates for asynchronous execution because they perform non-CPU-bound tasks that take significant amounts of time. Such pages are also potential bottlenecks for the ASP.NET thread pool. The Page class itself implements the IHttpHandler interface, and thus services requests synchronously. To change a given .aspx page to service requests asynchronously, it is necessary to implement IHttpAsyncHandler in the Page-derived class and then use the techniques described in this article to invoke the ProcessRequest method of the Page class on an alternate thread.

One convenient way to make any page asynchronous is to create an alternate base class from which the primary page can derive and then specify this alternate base class as the base class from which the page should derive using the Inherits attribute of the @Page directive. The AsyncPage class definition shown in Figure 9 defines such a base class. Note that this implementation uses the custom thread pool shown earlier to service requests to the page asynchronously. This implementation of BeginProcessRequest invokes the PostRequest method of the thread pool with a new WorkRequestDelegate initialized with a reference to my overload of ProcessRequest. In the overload, I invoke the base class scope of ProcessRequest (with the original signature as defined in the IHttpHandler interface), which performs the standard request processing of a page, only this time it will be performed on the thread pool thread instead of the primary request thread (see Figure 9).

Figure 9 AsyncPage

复制代码

namespace EssentialAspDotNet.HttpPipeline
{
 public class AsyncPage : Page, IHttpAsyncHandler
  { 
    static protected DevelopMentor.ThreadPool _threadPool;

    static AsyncPage()
    {
      _threadPool = 
       new DevelopMentor.ThreadPool(2, 25, "AsyncPool");
      _threadPool.PropogateCallContext = true;
      _threadPool.PropogateThreadPrincipal = true;
      _threadPool.PropogateHttpContext = true;
      _threadPool.Start();
    }

    public new void ProcessRequest(HttpContext ctx)
    {
      // not used
    }

    public new bool IsReusable
    {
      get { return false;}
    }

    public IAsyncResult BeginProcessRequest(HttpContext ctx, 
                                            AsyncCallback cb, object obj)
    {
      AsyncRequestState reqState = 
             new AsyncRequestState(ctx, cb, obj);
      _threadPool.PostRequest(
             new DevelopMentor.WorkRequestDelegate(ProcessRequest),
             reqState);

      return reqState;
    }

    public void EndProcessRequest(IAsyncResult ar)
    {
    }

    void ProcessRequest(object state, DateTime requestTime)
    {
      AsyncRequestState reqState = state as AsyncRequestState;

      // Synchronously call base class Page.ProcessRequest
      // as you are now on a thread pool thread. 
      base.ProcessRequest(reqState._ctx);

      // Once complete, call CompleteRequest to finish
      reqState.CompleteRequest();
    }
  }
}

As an example of using this new asynchronous page base class, consider the following ASPX page that inherits from the AsyncPage class. This base class could be applied to any ASPX page in a similar fashion to turn it into an asynchronously executed page:

复制代码

<!-- AsyncPage.aspx -->
<%@ Page Language="C#" 
    Inherits="EssentialAspDotNet.HttpPipeline.AsyncPage" %>
<%@ import Namespace="System.Reflection" %>
<%@ import Namespace="System.Threading" %>

<script runat="server">
protected void Page_Load(object src, EventArgs e)
{
   System.Threading.Thread.Sleep(2000);
   Response.Output.Write("AsyncPage, {0}",
                         AppDomain.GetCurrentThreadId);
}
</script>

The results of performing the stress test with fast.aspx and the asynchronous page, AsyncPage.aspx, are as follows with results matching those of the asynchronous custom handler using a custom thread pool. The average response time for fast.aspx is .054 seconds and 11.92 seconds for AsyncPage.aspx, with the total number of serviced requests at 965.

Conclusion

Building asynchronous handlers instead of synchronous ones actually adds additional overhead to request processing, so you should take the time to determine if the asynchronous capability of these types of handlers is really what you need. The purpose of an asynchronous handler is to free up an ASP.NET thread pool thread to service additional requests while the handler is processing the original request. This only makes sense if the work of servicing the request requires a significant amount of non-CPU-bound time to complete. For example, if the completion of a request depends on the completion of a number of remote procedure calls, or perhaps Web Service invocations, that would be a candidate to implement an asynchronous handler. Building asynchronous handlers to service CPU-intensive requests only adds threads to compete with the ASP.NET thread pool threads and may actually slow down the overall processing time for the request.

本文链接

[转]COM线程模型-套间

2010-01-29T06:17:00Z

首先，只要遵守COM规范，不用COM库也能编写COM程序，那相当于自己实现用到的COM库函数。本篇COM如果单独出现，指COM库。

[转]VC使用CRT调试功能来检测内存泄漏

2009-12-16T01:23:00Z

C/C++ 编程语言的最强大功能之一便是其动态分配和释放内存，但是中国有句古话：“最大的长处也可能成为最大的弱点”，那么 C/C++ 应用程序正好印证了这句话。在 C/C++ 应用程序开发过程中，动态分配的内存处理不当是最常见的问题。其中，最难捉摸也最难检测的错误之一就是内存泄漏，即未能正确释放以前分配的内存的错误。偶尔发生的少量内存泄漏可能不会引起我们的注意，但泄漏大量内存的程序或泄漏日益增多的程序可能会表现出各种各样的征兆：从性能不良（并且逐渐降低）到内存完全耗尽。更糟的是，泄漏的程序可能会用掉太多内存，导致另外一个程序垮掉，而使用户无从查找问题的真正根源。此外，即使无害的内存泄漏也可能殃及池鱼。

博客园_My Program life

【转】c# 位操作

C#中调用Windows API时的数据类型对应关系

全面理解javascript的caller,callee,call,apply概念[转载]

发几个小的测式软件

關於 IE6/7 不支援 Element 自訂方法屬性繼承的可行解決方案

Vs2010 配置驱动开发环境

美杜杉 主动防御最新版

Asp.net 异步请求 IHttpAsyncHandler

[转]COM线程模型-套间

[转]VC使用CRT调试功能来检测内存泄漏

美杜杉主动防御最新版