例子代码：

class Program

    {

        static void Main(string[] args)

        {

            int obj = 2;

            Test<int> test = new Test<int>(obj);

            Console.WriteLine("int:" + test.obj);

            string obj2 = "hello world";

            Test<string> test1 = new Test<string>(obj2);

            Console.WriteLine("String:" + test1.obj);

            Console.Read();

        }

    }

    class Test<T>

    {

        public T obj;

        public Test(T obj)

        {

            this.obj = obj;

        }

}

    输出结果是：

    int:2

String:hello world

程序分析：

1、 Test是一个泛型类。T是要实例化的范型类型。如果T被实例化为int型，那么成员变量obj就是int型的，如果T被实例化为string型，那么obj就是string类型的。

2、 根据不同的类型，上面的程序显示出不同的值。

C#泛型机制：

C#泛型能力有CLR在运行时支持：C#泛型代码在编译为IL代码和元数据时，采用特殊的占位符来表示范型类型，并用专有的IL指令支持泛型操作。而真正的泛型实例化工作以“on-demand”的方式，发生在JIT编译时。

看看刚才的代码中Main函数的元数据

.method private hidebysig static void Main(string[] args) cil managed

{

 .entrypoint

 // Code size       79 (0x4f)

 .maxstack 2

 .locals init ([0] int32 obj,

           [1] class CSharpStudy1.Test`1<int32> test,

           [2] string obj2,

           [3] class CSharpStudy1.Test`1<string> test1)

 IL_0000: nop

 IL_0001: ldc.i4.2

 IL_0002: stloc.0

 IL_0003: ldloc.0

 IL_0004: newobj     instance void class CSharpStudy1.Test`1<int32>::.ctor(!0)

 IL_0009: stloc.1

 IL_000a: ldstr      "int:"

 IL_000f: ldloc.1

 IL_0010: ldfld      !0 class CSharpStudy1.Test`1<int32>::obj

 IL_0015: box        [mscorlib]System.Int32

 IL_001a: call       string [mscorlib]System.String::Concat(object,

                                                              object)

 IL_001f: call       void [mscorlib]System.Console::WriteLine(string)

 IL_0024: nop

 IL_0025: ldstr      "hello world"

 IL_002a: stloc.2

 IL_002b: ldloc.2

 IL_002c: newobj     instance void class CSharpStudy1.Test`1<string>::.ctor(!0)

 IL_0031: stloc.3

 IL_0032: ldstr      "String:"

 IL_0037: ldloc.3

 IL_0038: ldfld      !0 class CSharpStudy1.Test`1<string>::obj

 IL_003d: call       string [mscorlib]System.String::Concat(string,

                                                              string)

 IL_0042: call       void [mscorlib]System.Console::WriteLine(string)

 IL_0047: nop

 IL_0048: call       int32 [mscorlib]System.Console::Read()

 IL_004d: pop

 IL_004e: ret

} // end of method Program::Main

    再来看看Test类中构造函数的元数据

.method public hidebysig specialname rtspecialname

        instance void .ctor(!T obj) cil managed

{

 // Code size       17 (0x11)

 .maxstack 8

 IL_0000: ldarg.0

 IL_0001: call       instance void [mscorlib]System.Object::.ctor()

 IL_0006: nop

 IL_0007: nop

 IL_0008: ldarg.0

 IL_0009: ldarg.1

 IL_000a: stfld      !0 class ConsoleCSharpTest1.Test`1<!T>::obj

 IL_000f: nop

 IL_0010: ret

} // end of method Test`1::.ctor

1、第一轮编译时，编译器只为Test<T>类型产生“泛型版”的IL代码与元数据——并不进行泛型的实例化，T在中间只充当占位符。例如：Test类型元数据中显示的<!T>

2、JIT编译时，当JIT编译器第一次遇到Test<int>时，将用int替换“范型版”IL代码与元数据中的T——进行泛型类型的实例化。例如：Main函数中显示的<int>

3、CLR为所有类型参数为“引用类型”的泛型类型产生同一份代码；但是如果类型参数为“值类型”，对每一个不同的“值类型”，CLR将为其产生一份独立的代码。因为实例化一个引用类型的泛型，它在内存中分配的大小是一样的，但是当实例化一个值类型的时候，在内存中分配的大小是不一样的。

C#泛型特点：

1、如果实例化泛型类型的参数相同，那么JIT编辑器会重复使用该类型，因此C#的动态泛型能力避免了C++静态模板可能导致的代码膨胀的问题。

2、C#泛型类型携带有丰富的元数据，因此C#的泛型类型可以应用于强大的反射技术。

3、C#的泛型采用“基类、接口、构造器，值类型/引用类型”的约束方式来实现对类型参数的“显示约束”，提高了类型安全的同时，也丧失了C++模板基于“签名”的隐式约束所具有的高灵活性

C#泛型继承：

C#除了可以单独声明泛型类型（包括类与结构）外，也可以在基类中包含泛型类型的声明。但基类如果是泛型类，它的类型要么以实例化，要么来源于子类（同样是泛型类型）声明的类型参数，看如下类型

class C<U,V>

class D:C<string,int>

class E<U,V>:C<U,V>

class F<U,V>:C<string,int>

class G:C<U,V> //非法

E类型为C类型提供了U、V，也就是上面说的来源于子类

F类型继承于C<string,int>，个人认为可以看成F继承一个非泛型的类

G类型为非法的，因为G类型不是泛型，C是泛型，G无法给C提供泛型的实例化

泛型类型的成员：

泛型类型的成员可以使用泛型类型声明中的类型参数。但类型参数如果没有任何约束，则只能在该类型上使用从System.Object继承的公有成员。如下图：

泛型接口：

泛型接口的类型参数要么已实例化，要么来源于实现类声明的类型参数

泛型委托：

泛型委托支持在委托返回值和参数上应用参数类型，这些参数类型同样可以附带合法的约束

delegate bool MyDelegate<T>(T value);

class MyClass

{

    static bool F(int i){...}

    static bool G(string s){...}

    static void Main()

    {

        MyDelegate<string> p2 = G;

        MyDelegate<int> p1 = new MyDelegate<int>(F);

    }

}

泛型方法：

1、C#泛型机制只支持“在方法声明上包含类型参数”——即泛型方法。

2、C#泛型机制不支持在除方法外的其他成员（包括属性、事件、索引器、构造器、析构器）的声明上包含类型参数，但这些成员本身可以包含在泛型类型中，并使用泛型类型的类型参数。

3、泛型方法既可以包含在泛型类型中，也可以包含在非泛型类型中。

泛型方法声明：如下

public static int FunctionName<T>(T value){...}

泛型方法的重载：

public void Function1<T>(T a);

public void Function1<U>(U a);

这样是不能构成泛型方法的重载。因为编译器无法确定泛型类型T和U是否不同，也就无法确定这两个方法是否不同

public void Function1<T>(int x);

public void Function1(int x);

这样可以构成重载

public void Function1<T>(T t) where T:A;

public void Function1<T>(T t) where T:B;

这样不能构成泛型方法的重载。因为编译器无法确定约束条件中的A和B是否不同，也就无法确定这两个方法是否不同

泛型方法重写：

在重写的过程中，抽象类中的抽象方法的约束是被默认继承的。如下：

abstract class Base

{

    public abstract T F<T,U>(T t,U u) where U:T;

    public abstract T G<T>(T t) where T:IComparable;

}

class MyClass:Base

{

    public override X F<X,Y>(X x,Y y){...}

    public override T G<T>(T t) where T:IComparable{}

}

对于MyClass中两个重写的方法来说

F方法是合法的，约束被默认继承

G方法是非法的，指定任何约束都是多余的

泛型约束：

1、C#泛型要求对“所有泛型类型或泛型方法的类型参数”的任何假定，都要基于“显式的约束”，以维护C#所要求的类型安全。

2、“显式约束”由where子句表达，可以指定“基类约束”，“接口约束”，“构造器约束”，“值类型/引用类型约束”共四种约束。

3、“显式约束”并非必须，如果没有指定“显式约束”，范型类型参数将只能访问System.Object类型中的公有方法。例如：在开始的例子中，定义的那个obj成员变量。比如我们在开始的那个例子中加入一个Test1类，在它当中定义两个公共方法Func1、Func2，如下图：

基类约束：

class A

    {

        public void Func1()

        { }

    }

    class B

    {

        public void Func2()

        { }

    }

    class C<S, T>

        where S : A

        where T : B

    {

        public C(S s,T t)

        {

            //S的变量可以调用Func1方法

            s.Func1();

            //T的变量可以调用Func2方法

            t.Func2();

        }

    }

接口约束：

interface IA<T>

    {

        T Func1();

    }

    interface IB

    {

        void Func2();

    }

    interface IC<T>

    {

        T Func3();

    }

    class MyClass<T, V>

        where T : IA<T>

        where V : IB, IC<V>

    {

        public MyClass(T t,V v)

        {

            //T的对象可以调用Func1

            t.Func1();

            //V的对象可以调用Func2和Func3

            v.Func2();

            v.Func3();

        }

    }

构造器约束：

class A

        {

            public A()

            { }

        }

        class B

        {

            public B(int i)

            { }

        }

        class C<T> where T : new()

        {

            T t;

            public C()

            {

                t = new T();

            }

        }

        class D

        {

            public void Func()

            {

                C<A> c = new C<A>();

                C<B> d = new C<B>();

            }

        }

    d对象在编译时报错：The type B must have a public parameterless constructor in order to use it as parameter 'T' in the generic type or method C<T>

    注意：C#现在只支持无参的构造器约束

    此时由于我们为B类型写入了一个有参构造器，使得系统不会再为B自动创建一个无参的构造器，但是如果我们将B类型中加一个无参构造器，那么对象d的实例化就不会报错了。B类型定义如下：

        class B

        {

            public B()

            { }

            public B(int i)

            { }

        }

值类型/引用类型：

public struct A { }

        public class B { }

        public class C<T> where T : struct

        {

        }

        C<A> c1 = new C<A>();

        C<B> c2 = new C<B>();

    c2对象在编译时报错：The type 'B' must be a non-nullable value type in order to use it as parameter 'T' in the generic type or methor 'C<T>'

总结：

1、C#的泛型能力由CLR在运行时支持，它既不同于C++在编译时所支持的静态模板，也不同于Java在编译器层面使用“擦拭法”支持的简单的泛型。

2、C#的泛型支持包括类、结构、接口、委托四种泛型类型，以及方法成员。

3、C#的泛型采用“基类，接口，构造器，值类型/引用类型”的约束方式来实现对类型参数的“显式约束”，它不支持C++模板那样的基于签名的隐式约束。

无法显示 XML 页。

使用 XSL 样式表无法查看 XML 输入。请更正错误然后单击 刷新按钮，或以后重试。

名称以无效字符开头。处理资源 'http://localhost/likong/' 时出错。第 1 行，位置: 2

<%@ Page language="c#"  ValidateRequest="false"  Codebehind="default.aspx.cs" AutoEventWireup="false" Inherits="Socut.Cla...

删除用RowFilter筛选之后的记录集，用While循环是可以做到的，而用For循环却不行。

While(dataView.count>0)
{
  dataView.Delete(this.dataView.Count-1)
//....
}
因此，除了通过数据绑定到DataGridView,DataGrid外，可以通过循环来取经过RowFilter筛选后的记录集：
方法有很多，如：

 foreach (DataRowView row in dataView)
{
   MessageBox.Showrow.Row[4].ToString());
}

在"目标计算机上的注册表"下,默认有注册表的五个主键栏;
默认情况下, 在 [HKEY_CURRENT_USER] 和 [HKEY_CURRENT_MACHINE] 下会有 [Software]\[Manufacturer] 分支, 如果你的安装项目的属性中设置了 [Manufacturer]值, 安装后会用值去替代[Manufacturer], 例如 [Manufacturer] 的值 设置为 "Power Word", 则安装后会在 [Software]下创建一个[Power Word]分支;
默认情况下 [Manufacturer] 的 AlwaysCreate 属性是 false, 即:如果你的 [Manufacturer] 下没有项目,则不创建 [Manufacturer] ,如果无论如何都要创建这个键, 则可将 它的 AlwaysCreate 设置为 true;
依照上面的方法, 在你想建注册表项的主键中逐级新建分支项和项目, 在新建的注册表项目上右击后选属性, 设置注册项的 value 值;
无论是建主键分支还是项目, 都可以用 [] 的方法使用系统变量来动态指定需要添加的注册表内容. 例如:
[Manufacturer] 存放的是安装项目的公司值,
[ProductName] 存放的是安装项目属性中的 产品名称,
[TARGETDIR] 存放的是安装时用户选定的安装路径,
[COMPANYNAME] 存放的是安装时用户填入的公司名(如果没设用户信息安装界面则取操作系统中的公司名),
[USERNAME] 存放的是安装时用户填入的用户名(如果没设用户信息安装界面则取操作系统中的用户名,
如此等等

如果想要在安装时出现注册码, 要么自己做一个DLL或者EXE项目, 加入到 自定义操作中在安装时打开界面输入注册码, 要么使用VS安装项目自带的界面(在视图--用户界面中添加"用户信息"安装界面,设置showserialnumber 为 true), 不过那个注册码是用 模7 来验证的, 只要是验证位数值之和能被7整除都能通过, 就像以前安装盗板 office 97 时输入 "1111111"一样.

       Skin++是一款通用的软件换肤套件，目前支持各种版本操作系统，Windows9x、Windows2000、WindowsXP、Windows2003。支持各种开发语言，Visual C++、Visual C++.Net、Visual Basic 6 、Visual Basic.Net、C#、PowerBuilder、Delphi、C++Builder、易语言等。Skin++ 目前已经拥有数量众多的用户，并且有很多的国内外大公司客户。无论其换肤的效果还是程序本身的稳定性，都堪称一流。要做出漂亮风格的界面，使用Skin++变得非常简单，只要一行代码，就能让你的程序彻底换肤，并拥有动态换肤的功能。

       Skin++ For DotNet目前全面支持Visual C#.net 2002、Visual C#.net 2003、Visual C#.net 2005、Visual VB.net 2002、Visual VB.net 2003、Visual VB.net 2005、Visual VC.net 2002、Visual VC.net 2003、Visual VC.net 2005。

       使用Skin++之前需要做一个准备工作，注册Skin++控件。

       由于Skin++ For DotNet是以COM的形式存在的，所以在你的机器第一次使用之前应该先注册该DLL文件。注册命令：RegSvr32.exe  Skin++存在的路径\SkinPPDotNet.dll 注册后会出现下图所示：

二、Skin++如何在C#.net 2005 中使用

       1.创建C# Windows应用程序

       2.拷贝Skin++相关文件

              在Skin++的安装目录下拷贝一个Skin++皮肤文件（*.ssk或*.spp）到当前工程目录.下。

       3.添加引用

              右键单击工程目录的引用节点 ，弹出下面的菜单

              请单击“添加引用(&R)”菜单项，此时会弹出“添加引用”窗体,如下图：

切换到COM页面，请选择SkinPPDotNet 3.0 Type Library组件项，并双击该项，或点击下边的“确定”按钮。此时在引用树列表中会多出SKINPPDOTNETLib一项：

4.添加名字空间

       请在Program .cs窗体的代码开头处添加 using SKINPPDOTNETLib;

    5.声明Skin++组件变量

    请在 Program中写上：public static SKINPPDOTNETLib.SkinPPDotNetClass SkinPPObj;

       6.创建Skin++组件实例

       在Main（）中创建Skin++组件对象：

SkinPPObj = new SkinPPDotNetClass();

     SkinPPObj.LoadSkin("PixOS.spp", false);

       至此，Skin++就添加完成了！请按F5运行，效果如下图：

       7.注意事项

       1.请注意你拷贝的Skin++皮肤的路径，sppLoadSkin可以指定带路径的皮肤名称，支持绝对路径和相对路径。在2003中，工程的调试目录默认在\bin\Debug或\bin\Release中，所以在本文的例子中，请把皮肤拷贝到\bin\Debug目录中。当然你可以在sppLoadSkin中指定皮肤的路径。

       2.sppLoadSkin的第二个参数是，是否让Skin++不自动截获所有的窗口进行换肤。默认情况下请填写false.就是让Skin++对你所有的窗口进行换肤。这样以后凡是从你程序中弹出的窗口均能自动换肤，而不需要你填写任何的代码。

       3.细心的朋友也许会注意到，我们把Application.EnableVisualStyles();这句话注释掉了。原因是Skin++已经对C#所有的控件进行了彻底的换肤，所以在这个地方应该把C#默认的美化工作停止掉，这样可以提升显示效率。

然后写个类来统一验证登录
using System;
using System.Collections.Generic;
using System.Text;
using System.Configuration;

namespace BLL
{
    public class LoginCrystalReport
    {        
        public void Login( CrystalDecisions.CrystalReports.Engine.ReportDocument report)
        {
            string serverName=ConfigurationManager.AppSettings["DBServerName"];
            string userId = ConfigurationManager.AppSettings["DBUserID"];

            string passWord=ConfigurationManager.AppSettings["DBPassWord"];
           
            //Set Database Logon to main report
            foreach (CrystalDecisions.Shared.IConnectionInfo connection in report.DataSourceConnections)
            {
                if (connection.ServerName == serverName)
                {
                    connection.SetLogon(userId, passWord);
                }
            }

            //Set Database Logon to subreport
            foreach (CrystalDecisions.CrystalReports.Engine.ReportDocument subreport in report.Subreports)
            {
                foreach (CrystalDecisions.Shared.IConnectionInfo connection in subreport.DataSourceConnections)
                {
                    if (connection.ServerName == serverName)
                    {
                        connection.SetLogon(userId, passWord);
                    }
                }
            }
        }

       
    }
}

            DataGridTableStyle ts = new DataGridTableStyle();
            ts.MappingName = RealEstatePDA.Util.DataBase.DataViews.getInstance().BuildingLocationDataView.Table.TableName; //如果绑定的是Datatable,这里要变一下  
            int numCols = RealEstatePDA.Util.DataBase.DataViews.getInstance().BuildingLocationDataView.Table.Columns.Count;
            int i = 0;
            DataGridTextBoxColumn aColumnTextColumn;
            while (i < numCols)   //重绘所有的列  
            {
                aColumnTextColumn = new DataGridTextBoxColumn();
                aColumnTextColumn.MappingName = RealEstatePDA.Util.DataBase.DataViews.getInstance().BuildingLocationDataView.Table.Columns[i].ColumnName;
                ts.GridColumnStyles.Add(aColumnTextColumn);     //增加一种自定义的column风格  
                i++;
            }

            this.HousedataGrid.TableStyles.Add(ts);

            this.HousedataGrid.TableStyles[0].GridColumnStyles[0].Width = 70;   //第一列的宽度  
            this.HousedataGrid.TableStyles[0].GridColumnStyles[0].HeaderText = "房屋编号"; //第一列的标题  
            this.HousedataGrid.TableStyles[0].GridColumnStyles[1].Width = 200;   //第二列的宽度  
            this.HousedataGrid.TableStyles[0].GridColumnStyles[1].HeaderText = "YYYYY"; //第二列的标题  

            this.HousedataGrid.Refresh();    

           //




相类似的另一种样式：
private DataView dv1,dv2;
private DataGridTableStyle dgts;

private void frmChhd_Resize(object sender, System.EventArgs e)
{
//调整dataGrid1的列宽
if(dv1!=null)
{
//添加模板列
if(dataGrid1.TableStyles.Count==0)
{
dgts.MappingName=dv1.Table.TableName;
dataGrid1.TableStyles.Add(dgts);
}
int i=dataGrid1.Width/6-10;

dataGrid1.TableStyles[0].GridColumnStyles[0].Width=i*2;

dataGrid1.TableStyles[0].GridColumnStyles[1].Width
=dataGrid1.TableStyles[0].GridColumnStyles[2].Width
=dataGrid1.TableStyles[0].GridColumnStyles[3].Width
=dataGrid1.TableStyles[0].GridColumnStyles[4].Width=i;
}

}

　　.NET框架包括类和接口，在编写程序的时候，你可能知道正在用.NET的哪个类。然而，在这种情况下如果你用.NET支持的接口而不是它的类来编程时，代码会变得更加稳定、可用性会更高。请分析下面的代码：

private void LoadList (object [] items, ListBox l)
{
　for (int i = 0; i < items.Length;i++)
　　l.Items.Add (items[i].ToString ());
}

　　这个函数从一个可为任何对象的数组中加载ListBox，这段代码被限定为只能使用数组。假想过些时候你发现那些对象存在数据库中，或别的集合中。那么你需要修改程序来使用不同的集合类型。如果你用ICollection接口来写那段程序，你就不用修改那段程序了，对于任何实现ICollection接口的类型它都能很好的工作:

private void LoadList (ICollection items,ListBox l)
{
　　foreach (object o in items)
　　l.Items.Add (o.ToString ());
}

　　ICollection被数组和所有System.Collection中的集合实现。此外，多维数组也支持ICollection接口。如果那还不够的话，数据库.NET类同样支持ICollection接口。用接口写的这个函数不用需改就可以才许多中情况下使用。

　　2. 使用属性代替原始数据

　　因为属性已经成为语言本身的元素，所以声明数据元素时它的作用域等级没有必要大于private。因为代码本身会把属性看成数据元素，你并没有失去使用简单数据类型的便利性 。相反它会使你的代码更加灵活功能更加强大。属性使你的数据元素封装性更好。属性可以让你使用lazy evaluation来返回数据。lazy evaluation的意思是当用户请求时才计算它的值，而不是一直保留着它。

　　最后，属性可以是virtual也可以是abstract。你也可以在接口中定义属性。

　　这里还有维护方面的因素应当注意：尽管操作两者的方法是一样的，但是你把一个数据元素变成属性，那么原先客户端的程序便不能访问服务端的新版本程序了。实际上对于在Web service中你想实现序列化的值你可以把它们变成属性来使用：

private int TheMonth = 0;

[XmlAttribute ("Month")]
public int Month
{
　get {
　　return TheMonth;
　}
　set {
　　TheMonth = value;
　}
}

　　简单通过属性就可以使你的所有数据元素私有化。

　　3. 在Producer/Consumer 的Idiom中使用Delegate

　　当你生成一个实现producer idiom类的时候，使用deletate来通知consumer。这种方法相对于用接口更加灵活。Delegate是多点传送的，所以不用加额外的代码你就何以支持多用户。相对于用接口这样做可使类之间的耦合性降低。

　　下面的类处理键盘输入并把它传给所有的registered listeners：

public class KeyboardProcessor
{
private OnGetLine theFunc = null;

public OnGetLine OnGetLineCallback {
　get {
　　return theFunc;
　}
　set {
　　theFunc = value;
　}
}

public void Run (){
// Read input.
// If there is any listeners, publish:
string s;
do {
　s = Console.ReadLine ();
　if (s.Length == 0)
　　break;
　if (theFunc != null){
　　System.Delegate [] funcs =theFunc.GetInvocationList();
　　foreach (OnGetLine f in funcs) {
　　　try {
　　　　f (s);
　　　} catch (Exception e) {
　　　　Console.WriteLine
　　　　("Caught Exception: {0}", e.Message);
　　　}
　　}
　}
} while (true);
}

　　任何数目的listeners都可注册到producer，它们所要做的只是提供一个特定的函数：deletate。

　　4. 注意初始化顺序

　　C＃中对于一些变量声明加入了initializer的概念。它们在构造函数之前被执行，实际上变量在基类的构造函数执行前之前被初始化。

　　所以，在初始化变量的时候不要用基类中的数据，因为它们还没有被构造。

private void MyPopupEventHandler(System.Object sender, System.EventArgs e)
 {
    // Define the MenuItem objects to display for the TextBox.
    MenuItem menuItem1 = new MenuItem("&Copy");
    MenuItem menuItem2 = new MenuItem("&Find and Replace");
    // Define the MenuItem object to display for the PictureBox.
    MenuItem menuItem3 = new MenuItem("C&hange Picture");

    // Clear all previously added MenuItems.
    contextMenu1.MenuItems.Clear();
 
    if(contextMenu1.SourceControl == textBox1)
    {
       // Add MenuItems to display for the TextBox.
       contextMenu1.MenuItems.Add(menuItem1);
       contextMenu1.MenuItems.Add(menuItem2);
    }
    else if(contextMenu1.SourceControl == pictureBox1)
    {
       // Add the MenuItem to display for the PictureBox.
       contextMenu1.MenuItems.Add(menuItem3);
    }
 }

问者:7712190(25458848@163.com) 信誉:96 级别:user5 日期:2006-9-10 23:49:27

小弟一直都是做 B/S开发 
这几天心血来潮 想写一写 C/S程序 
一入门就遇到这个问题 我在 登陆窗体体 NEW了 一个新窗体吧新窗体Show了 之后 原来得窗体cLOSE。新NEW得窗体也关闭了  不知道为什么 请指点

另求 C/S程序得 设计方法。
比如如何处理 公共得变量 等应该注意得事情  希望大家不吝赐教

回复：

答者:wzq6511() 信誉:100 级别:user1 日期:2006-9-11 0:36:28 id:36659940

不要用close，用hide，原先的窗体只能隐藏起来不能关闭。

答者:bejon(阿牛[如果我懂，必坦诚相告；如果您懂，请不怜赐教。]) 信誉:93 级别:star1 日期:2006-9-11 2:00:21 id:36660132

在new form后使用this.close;来完成

在new form之前把窗体id写在注册表，然后在new form之后检查那里，如果有值就使用api关闭那个窗体，然后把注册表清空。

答者:zhgroup(王员外) 信誉:99 级别:star1 日期:2006-9-11 8:06:33 id:36660371

1、要看原窗体是那个窗体了，如果是入口的窗体，则应hide,想要显示时可用Show.
如果是登陆窗体,在主窗体的Main入口处
FormLogin frm = new FormLogin();
frm.ShowDialog();
if 登陆失败
 关闭窗体
 return
2、和B/S基本类似，只不过对于状态信息比较容易控制。

答者:qzh1119(大浪淘沙) 信誉:59 级别:user2 日期:2006-9-11 8:12:07 id:36660412

up

答者:qzh1119(大浪淘沙) 信誉:59 级别:user2 日期:2006-9-11 8:12:33 id:36660419

关注，学习中

答者:bestshl(快乐的Coder) 信誉:100 级别:user2 日期:2006-9-11 8:24:52 id:36660529

zhgroup(王员外) 正解

答者:interboy(冯东) 信誉:100 级别:user2 日期:2006-9-11 8:27:37 id:36660559

zhgroup(王员外) 说的对,如果你把main函数放在loginform里的话,那么它就是主窗体,如果你在它里面调用了this.close();你想啊,主窗体都关了,别的呢,皮之不存,毛将焉附!
建议把loginform作为子窗体,通过主窗体了掉子窗体进行判断

答者:7712190(25458848@163.com) 信誉:96 级别:user5 日期:2006-9-11 12:40:41 id:36667940

问题是我不想HIde  真的没有其他的办法了么?

答者:lovefootball(蟑螂（生活就是扯淡--做人要放低姿态）) 信誉:98 级别:star2 日期:2006-9-11 12:49:07 id:36668125

上面已经说清楚了
如果你不想hide
那你就在main里面先new这个登陆窗体
如果登陆成功在run主窗体
否则关闭

答者:zahuifan(杂烩饭) 信誉:93 级别:star1 日期:2006-9-11 12:56:33 id:36668305

up

答者:guyes123(以为喜欢这里,所以来接分) 信誉:100 级别:user1 日期:2006-9-11 13:00:06 id:36668391

一般还是用HIDE吧
其他的我就不会了

答者:naturalth(自我批判，是思想、品德、素质、技能创新的优良工具) 信誉:99 级别:user4 日期:2006-9-11 13:07:31 id:36668586

#region "Main"
public ModMain()
{
}

[STAThreadAttribute]
static void Main() 
{
//异常处理
Application.ThreadException += new ThreadExceptionEventHandler(MainUIThreadExceptionHandler);

            Common.Database.ConnectionString = Get_Info();
frmLogon frm = new frmLogon();
            frm.txtUser.Text = loginUser;
if (frm.ShowDialog()==System.Windows.Forms.DialogResult.Cancel)
{
return;
}
            
System.Windows.Forms.Application.Run(new myMenu());
}
#endregion

答者:xvting(xvting) 信誉:103 级别:user4 日期:2006-9-11 15:10:44 id:36672298

VS默认的WinForm程序模板只有一个程序消息循环，并且入口Form关闭的同时退出程序消息循环，结束程序。

开始
 |
 |
消息循环（入口Form）
 |
 |
结束

答者:xvting(xvting) 信誉:103 级别:user4 日期:2006-9-11 15:14:42 id:36672390

可以设计下面的流程

开始
 |
 |                    False
消息循环（登陆Form）---------
 |                          |
 | True                     |
 |                          |
消息循环（主Form）           |
 |                          |
 |--------------------------
退出

答者:xvting(xvting) 信誉:103 级别:user4 日期:2006-9-11 15:16:34 id:36672453

Demo

StartApp.cs文件
/////////////////////////////////////////////////////////////////
using System;
using System.Windows.Forms;
using System.Drawing;
using System.Text;

namespace WinFromDemo
{
public class StartApp
{
private static bool LoginResult = false;

[STAThread]
static void Main()
{
//First Message Loop
LoginContext loginContext = new StartApp.LoginContext();
Application.Run(loginContext);

if (LoginResult)
{
//Second Message Loop
StartApp.MainContext mainContext = new StartApp.MainContext();
Application.Run(mainContext);
}
}

public class LoginContext : ApplicationContext 
{
private LoginDialog loginDialog;

public LoginContext() 
{
loginDialog = new LoginDialog();
loginDialog.StartPosition = FormStartPosition.CenterScreen;
loginDialog.Closed += new EventHandler(OnFormClosed);            
loginDialog.Show();
}

private void OnFormClosed(object sender, EventArgs e) 
{
LoginResult = !(this.loginDialog.DialogResult == DialogResult.Cancel);

ExitThread();
}
}

public class MainContext : ApplicationContext 
{
private Form mainForm;

public MainContext() 
{
mainForm = new Form();
mainForm.StartPosition =  FormStartPosition.CenterScreen;
mainForm.Closed += new EventHandler(OnFormClosed);            
mainForm.Show();
}

private void OnFormClosed(object sender, EventArgs e) 
{
ExitThread();
}
}
}
}

答者:csLius() 信誉:100 级别:user2 日期:2006-9-11 15:17:56 id:36672496

http://blog.csdn.net/Knight94/archive/2006/08/22/1104957.aspx

答者:pegtop(再回首) 信誉:100 级别:user2 日期:2006-9-11 15:23:51 id:36672677

新窗体是在原窗体基础上建立起来的,不能关闭原窗体只能隐藏.

要想处理全局变量,建议采用Static变量

答者:pretty_soft() 信誉:100 级别:user1 日期:2006-9-11 15:36:50 id:36673096

我觉得还是
 开启---登陆画面/显示主窗体默认界面---用showdialog显示登陆---判断返回值初始权限
这样比较好
把应用程序加载放到启动画面去
这种更适合比较大的系统，不同的模块不同的用户权限

答者:Santos(快乐的GG) 信誉:100 级别:user4 日期:2006-9-11 16:15:46 id:36674473

ShowDialog();方法才是正解.

Button1_Click()
{

xxxForm frm = new xxxForm();
frm.ShowDialog();

}

答者:kissknife(侧身向南边) 信誉:100 级别:user5 日期:2006-9-11 16:20:54 id:36674652

http://www.cnblogs.com/KissKnife/archive/2006/09/10/500158.html

答者:ttgzs(一路狂奔) 信誉:100 级别:user1 日期:2006-9-11 17:01:58 id:36676000

#region "Main"
public ModMain()
{
}

[STAThreadAttribute]
static void Main() 
{
//异常处理
Application.ThreadException += new ThreadExceptionEventHandler(MainUIThreadExceptionHandler);

            Common.Database.ConnectionString = Get_Info();
frmLogon frm = new frmLogon();
            frm.txtUser.Text = loginUser;
if (frm.ShowDialog()==System.Windows.Forms.DialogResult.Cancel)
{
return;
}
            
System.Windows.Forms.Application.Run(new myMenu());
}
#endregion

答者:kubbye(小蛤蟆就是我) 信誉:100 级别:user1 日期:2006-9-11 23:15:00 id:36681363

准确的说,做为启动窗体的那个窗体是不能关的,它关了,程序就停了,其他的窗体可以关,启动窗体只能隐藏

答者:kubbye(小蛤蟆就是我) 信誉:100 级别:user1 日期:2006-9-11 23:17:29 id:36681383

接上面,你可以把主界面作为启动窗体,然后在主界面未显示出来前,先显示登录窗体,登录成功再显示主窗体,登录不成功,直接退出,直接在form的load事件中写就好了

答者:qiujb(楚留香) 信誉:100 级别:user2 日期:2006-9-12 8:12:25 id:36682515

zhgroup(王员外) 正解

答者:Samen168(让代码为你写代码) 信誉:95 级别:star1 日期:2006-9-12 8:56:52 id:36683381

逻辑问题
main()
{
   loginform lf = new loginform();
   if(lf.Showdialog() == DialogResult.OK)
   {
     mainform mf = new mainform();
     mf.show();
   }
}
这样根据不存在谁打开谁

答者:Samen168(让代码为你写代码) 信誉:95 级别:star1 日期:2006-9-12 8:57:00 id:36683386

根本

答者:sunxianyu(找工作) 信誉:100 级别:user2 日期:2006-9-12 9:05:26 id:36683679

zhgroup(王员外) ( ) 信誉：99    Blog 
正解

答者:fds2003(Hunter) 信誉:99 级别:user5 日期:2006-9-12 9:17:54 id:36684103

上面能说的都讲了！

答者:yangao(偶新手 请问门在哪里？) 信誉:100 级别:user4 日期:2006-9-12 9:41:16 id:36684775

学习

答者:henrydee1(小d) 信誉:101 级别:user2 日期:2006-9-12 10:29:21 id:36686255

if (this.ActiveMdiChild!=null)
{
this.ActiveMdiChild.Close(); //关闭已经打开的子窗体
}

InSchool child_InSchool=new InSchool();
child_InSchool.MdiParent=this;//this表示本窗体为其父窗体
child_InSchool.Show();

答者:xiaoliangwh(小亮wh) 信誉:100 级别:user2 日期:2006-9-12 23:55:03 id:36705585

xuexi

答者:sdl2005lyx() 信誉:100 级别:user4 日期:2006-9-13 8:26:41 id:36706505

lz：一个很简单的办法（刚好前几天解决的）：
     你在原来的窗体设置一个public bool bNew=false;的变量，在你要new新窗体的地方改成如下代码：
     bNew=true;
     this.Close();
     //原来窗体消失了，但它的类作用域并没有消失
   
然后在你原来定义、使用原窗体变量的地方，即frmOld.ShowDialog();之后：
    if(frmOld.bNew)
    {
        NewForm frmNew=new NewForm ();
        frmNew.ShowDialog();
    } 
问题就搞定了。。。  

答者:GXY2005(晓晨美眉好^_^) 信誉:94 级别:user5 日期:2006-9-13 8:52:21 id:36707030

jf

答者:wuhuiITren(CSDN男主角) 信誉:100 级别:user2 日期:2006-9-14 13:26:23 id:36740819

楼上的都说了，楼主自己一个个试就可以了啊，想怎么办就怎么办啊

答者:slex(蘂橤（蛋不能扯远，笑不能搞大)) 信誉:100 级别:user4 日期:2006-9-14 14:35:50 id:36743030

上面的那两个方法已经能解决lz问题了，该结了 呵呵

可以在DataGirdView的RowPostPaint事件中进行绘制。
如：添加以下方法代码

private void DrawRowIndex(object sender, DataGridViewRowPostPaintEventArgs e)
        {
            Rectangle rectangle = new Rectangle(e.RowBounds.Location.X,
               e.RowBounds.Location.Y,
               this.costomerDataGridView.RowHeadersWidth - 4,
               e.RowBounds.Height);

            TextRenderer.DrawText(e.Graphics, (e.RowIndex + 1).ToString(),
                this.costomerDataGridView.RowHeadersDefaultCellStyle.Font,
                rectangle,
                this.costomerDataGridView.RowHeadersDefaultCellStyle.ForeColor,
                TextFormatFlags.VerticalCenter | TextFormatFlags.Right);

        }
即可完成显示行号的功能。

    正则表达式（regular expression）描述了一种字符串匹配的模式，可以用来：（1）检查一个串中是否含有符合某个规则的子串，并且可以得到这个子串；（2）根据匹配规则对字符串进行灵活的替换操作。

    正则表达式学习起来其实是很简单的，不多的几个较为抽象的概念也很容易理解。之所以很多人感觉正则表达式比较复杂，一方面是因为大多数的文档没有做到由浅入深地讲解，概念上没有注意先后顺序，给读者的理解带来困难；另一方面，各种引擎自带的文档一般都要介绍它特有的功能，然而这部分特有的功能并不是我们首先要理解的。

    文章中的每一个举例，都可以点击进入到测试页面进行测试。闲话少说，开始。

1. 正则表达式规则

1.1 普通字符

    字母、数字、汉字、下划线、以及后边章节中没有特殊定义的标点符号，都是"普通字符"。表达式中的普通字符，在匹配一个字符串的时候，匹配与之相同的一个字符。

    举例1：表达式 "c"，在匹配字符串 "abcde" 时，匹配结果是：成功；匹配到的内容是："c"；匹配到的位置是：开始于2，结束于3。（注：下标从0开始还是从1开始，因当前编程语言的不同而可能不同）

    举例2：表达式 "bcd"，在匹配字符串 "abcde" 时，匹配结果是：成功；匹配到的内容是："bcd"；匹配到的位置是：开始于1，结束于4。

1.2 简单的转义字符

    一些不便书写的字符，采用在前面加 "\" 的方法。这些字符其实我们都已经熟知了。

    还有其他一些在后边章节中有特殊用处的标点符号，在前面加 "\" 后，就代表该符号本身。比如：^, $ 都有特殊意义，如果要想匹配字符串中 "^" 和 "$" 字符，则表达式就需要写成 "\^" 和 "\$"。

    这些转义字符的匹配方法与 "普通字符" 是类似的。也是匹配与之相同的一个字符。

    举例1：表达式 "\$d"，在匹配字符串 "abc$de" 时，匹配结果是：成功；匹配到的内容是："$d"；匹配到的位置是：开始于3，结束于5。

1.3 能够与 '多种字符' 匹配的表达式

    正则表达式中的一些表示方法，可以匹配 '多种字符' 其中的任意一个字符。比如，表达式 "\d" 可以匹配任意一个数字。虽然可以匹配其中任意字符，但是只能是一个，不是多个。这就好比玩扑克牌时候，大小王可以代替任意一张牌，但是只能代替一张牌。

    举例1：表达式 "\d\d"，在匹配 "abc123" 时，匹配的结果是：成功；匹配到的内容是："12"；匹配到的位置是：开始于3，结束于5。

    举例2：表达式 "a.\d"，在匹配 "aaa100" 时，匹配的结果是：成功；匹配到的内容是："aa1"；匹配到的位置是：开始于1，结束于4。

1.4 自定义能够匹配 '多种字符' 的表达式

    使用方括号 [ ] 包含一系列字符，能够匹配其中任意一个字符。用 [^ ] 包含一系列字符，则能够匹配其中字符之外的任意一个字符。同样的道理，虽然可以匹配其中任意一个，但是只能是一个，不是多个。

    举例1：表达式 "[bcd][bcd]" 匹配 "abc123" 时，匹配的结果是：成功；匹配到的内容是："bc"；匹配到的位置是：开始于1，结束于3。

    举例2：表达式 "[^abc]" 匹配 "abc123" 时，匹配的结果是：成功；匹配到的内容是："1"；匹配到的位置是：开始于3，结束于4。

1.5 修饰匹配次数的特殊符号

    前面章节中讲到的表达式，无论是只能匹配一种字符的表达式，还是可以匹配多种字符其中任意一个的表达式，都只能匹配一次。如果使用表达式再加上修饰匹配次数的特殊符号，那么不用重复书写表达式就可以重复匹配。

    使用方法是："次数修饰"放在"被修饰的表达式"后边。比如："[bcd][bcd]" 可以写成 "[bcd]{2}"。

    举例1：表达式 "\d+\.?\d*" 在匹配 "It costs $12.5" 时，匹配的结果是：成功；匹配到的内容是："12.5"；匹配到的位置是：开始于10，结束于14。

    举例2：表达式 "go{2,8}gle" 在匹配 "Ads by goooooogle" 时，匹配的结果是：成功；匹配到的内容是："goooooogle"；匹配到的位置是：开始于7，结束于17。

1.6 其他一些代表抽象意义的特殊符号

    一些符号在表达式中代表抽象的特殊意义：

    进一步的文字说明仍然比较抽象，因此，举例帮助大家理解。

    举例1：表达式 "^aaa" 在匹配 "xxx aaa xxx" 时，匹配结果是：失败。因为 "^" 要求与字符串开始的地方匹配，因此，只有当 "aaa" 位于字符串的开头的时候，"^aaa" 才能匹配，比如："aaa xxx xxx"。

    举例2：表达式 "aaa$" 在匹配 "xxx aaa xxx" 时，匹配结果是：失败。因为 "$" 要求与字符串结束的地方匹配，因此，只有当 "aaa" 位于字符串的结尾的时候，"aaa$" 才能匹配，比如："xxx xxx aaa"。

    举例3：表达式 ".\b." 在匹配 "@@@abc" 时，匹配结果是：成功；匹配到的内容是："@a"；匹配到的位置是：开始于2，结束于4。
    进一步说明："\b" 与 "^" 和 "$" 类似，本身不匹配任何字符，但是它要求它在匹配结果中所处位置的左右两边，其中一边是 "\w" 范围，另一边是 非"\w" 的范围。

    举例4：表达式 "\bend\b" 在匹配 "weekend,endfor,end" 时，匹配结果是：成功；匹配到的内容是："end"；匹配到的位置是：开始于15，结束于18。

    一些符号可以影响表达式内部的子表达式之间的关系：

    举例5：表达式 "Tom|Jack" 在匹配字符串 "I'm Tom, he is Jack" 时，匹配结果是：成功；匹配到的内容是："Tom"；匹配到的位置是：开始于4，结束于7。匹配下一个时，匹配结果是：成功；匹配到的内容是："Jack"；匹配到的位置时：开始于15，结束于19。

    举例6：表达式 "(go\s*)+" 在匹配 "Let's go go go!" 时，匹配结果是：成功；匹配到内容是："go go go"；匹配到的位置是：开始于6，结束于14。

    举例7：表达式 "￥(\d+\.?\d*)" 在匹配 "＄10.9,￥20.5" 时，匹配的结果是：成功；匹配到的内容是："￥20.5"；匹配到的位置是：开始于6，结束于10。单独获取括号范围匹配到的内容是："20.5"。

2. 正则表达式中的一些高级规则

2.1 匹配次数中的贪婪与非贪婪

    在使用修饰匹配次数的特殊符号时，有几种表示方法可以使同一个表达式能够匹配不同的次数，比如："{m,n}", "{m,}", "?", "*", "+"，具体匹配的次数随被匹配的字符串而定。这种重复匹配不定次数的表达式在匹配过程中，总是尽可能多的匹配。比如，针对文本 "dxxxdxxxd"，举例如下：

    由此可见，"\w+" 在匹配的时候，总是尽可能多的匹配符合它规则的字符。虽然第二个举例中，它没有匹配最后一个 "d"，但那也是为了让整个表达式能够匹配成功。同理，带 "*" 和 "{m,n}" 的表达式都是尽可能地多匹配，带 "?" 的表达式在可匹配可不匹配的时候，也是尽可能的 "要匹配"。这 种匹配原则就叫作 "贪婪" 模式 。

    非贪婪模式：

    在修饰匹配次数的特殊符号后再加上一个 "?" 号，则可以使匹配次数不定的表达式尽可能少的匹配，使可匹配可不匹配的表达式，尽可能的 "不匹配"。这种匹配原则叫作 "非贪婪" 模式，也叫作 "勉强" 模式。如果少匹配就会导致整个表达式匹配失败的时候，与贪婪模式类似，非贪婪模式会最小限度的再匹配一些，以使整个表达式匹配成功。举例如下，针对文本 "dxxxdxxxd" 举例：

    更多的情况，举例如下：

    举例1：表达式 "<td>(.*)</td>" 与字符串 "<td><p>aa</p></td> <td><p>bb</p></td>" 匹配时，匹配的结果是：成功；匹配到的内容是 "<td><p>aa</p></td> <td><p>bb</p></td>" 整个字符串， 表达式中的 "</td>" 将与字符串中最后一个 "</td>" 匹配。

    举例2：相比之下，表达式 "<td>(.*?)</td>" 匹配举例1中同样的字符串时，将只得到 "<td><p>aa</p></td>"， 再次匹配下一个时，可以得到第二个 "<td><p>bb</p></td>"。

2.2 反向引用 \1, \2...

    表达式在匹配时，表达式引擎会将小括号 "( )" 包含的表达式所匹配到的字符串记录下来。在获取匹配结果的时候，小括号包含的表达式所匹配到的字符串可以单独获取。这一点，在前面的举例中，已经多次展示了。在实际应用场合中，当用某种边界来查找，而所要获取的内容又不包含边界时，必须使用小括号来指定所要的范围。比如前面的 "<td>(.*?)</td>"。

    其实，"小括号包含的表达式所匹配到的字符串" 不仅是在匹配结束后才可以使用，在匹配过程中也可以使用。表达式后边的部分，可以引用前面 "括号内的子匹配已经匹配到的字符串"。引用方法是 "\" 加上一个数字。"\1" 引用第1对括号内匹配到的字符串，"\2" 引用第2对括号内匹配到的字符串……以此类推，如果一对括号内包含另一对括号，则外层的括号先排序号。换句话说，哪一对的左括号 "(" 在前，那这一对就先排序号。

    举例如下：

    举例1：表达式 "('|")(.*?)(\1)" 在匹配 " 'Hello', "World" " 时，匹配结果是：成功；匹配到的内容是：" 'Hello' "。再次匹配下一个时，可以匹配到 " "World" "。

    举例2：表达式 "(\w)\1{4,}" 在匹配 "aa bbbb abcdefg ccccc 111121111 999999999" 时，匹配结果是：成功；匹配到的内容是 "ccccc"。再次匹配下一个时，将得到 999999999。这个表达式要求 "\w" 范围的字符至少重复5次，注意与 "\w{5,}" 之间的区别。

    举例3：表达式 "<(\w+)\s*(\w+(=('|").*?\4)?\s*)*>.*?</\1>" 在匹配 "<td id='td1' style="bgcolor:white"></td>" 时，匹配结果是成功。如果 "<td>" 与 "</td>" 不配对，则会匹配失败；如果改成其他配对，也可以匹配成功。

2.3 预搜索，不匹配；反向预搜索，不匹配

    前面的章节中，我讲到了几个代表抽象意义的特殊符号："^"，"$"，"\b"。它们都有一个共同点，那就是：它们本身不匹配任何字符，只是对 "字符串的两头" 或者 "字符之间的缝隙" 附加了一个条件。理解到这个概念以后，本节将继续介绍另外一种对 "两头" 或者 "缝隙" 附加条件的，更加灵活的表示方法。

    正向预搜索："(?=xxxxx)"，"(?!xxxxx)"

    格式："(?=xxxxx)"，在被匹配的字符串中，它对所处的 "缝隙" 或者 "两头" 附加的条件是：所在缝隙的右侧，必须能够匹配上 xxxxx 这部分的表达式。因为它只是在此作为这个缝隙上附加的条件，所以它并不影响后边的表达式去真正匹配这个缝隙之后的字符。这就类似 "\b"，本身不匹配任何字符。"\b" 只是将所在缝隙之前、之后的字符取来进行了一下判断，不会影响后边的表达式来真正的匹配。

    举例1：表达式 "Windows (?=NT|XP)" 在匹配 "Windows 98, Windows NT, Windows 2000" 时，将只匹配 "Windows NT" 中的 "Windows "，其他的 "Windows " 字样则不被匹配。

    举例2：表达式 "(\w)((?=\1\1\1)(\1))+" 在匹配字符串 "aaa ffffff 999999999" 时，将可以匹配6个"f"的前4个，可以匹配9个"9"的前7个。这个表达式可以读解成：重复4次以上的字母数字，则匹配其剩下最后2位之前的部分。当然，这个表达式可以不这样写，在此的目的是作为演示之用。

    格式："(?!xxxxx)"，所在缝隙的右侧，必须不能匹配 xxxxx 这部分表达式。

    举例3：表达式 "((?!\bstop\b).)+" 在匹配 "fdjka ljfdl stop fjdsla fdj" 时，将从头一直匹配到 "stop" 之前的位置，如果字符串中没有 "stop"，则匹配整个字符串。

    举例4：表达式 "do(?!\w)" 在匹配字符串 "done, do, dog" 时，只能匹配 "do"。在本条举例中，"do" 后边使用 "(?!\w)" 和使用 "\b" 效果是一样的。

    反向预搜索："(?<=xxxxx)"，"(?<!xxxxx)"

    这两种格式的概念和正向预搜索是类似的，反向预搜索要求的条件是：所在缝隙的 "左侧"，两种格式分别要求必须能够匹配和必须不能够匹配指定表达式，而不是去判断右侧。与 "正向预搜索" 一样的是：它们都是对所在缝隙的一种附加条件，本身都不匹配任何字符。

    举例5：表达式 "(?<=\d{4})\d+(?=\d{4})" 在匹配 "1234567890123456" 时，将匹配除了前4个数字和后4个数字之外的中间8个数字。由于 JScript.RegExp 不支持反向预搜索，因此，本条举例不能够进行演示。很多其他的引擎可以支持反向预搜索，比如：Java 1.4 以上的 java.util.regex 包，.NET 中System.Text.RegularExpressions 命名空间，以及本站推荐的最简单易用的 DEELX 正则引擎。

3. 其他通用规则

    还有一些在各个正则表达式引擎之间比较通用的规则，在前面的讲解过程中没有提到。

3.1 表达式中，可以使用 "\xXX" 和 "\uXXXX" 表示一个字符（"X" 表示一个十六进制数）

3.2 在表达式 "\s"，"\d"，"\w"，"\b" 表示特殊意义的同时，对应的大写字母表示相反的意义

3.3 在表达式中有特殊意义，需要添加 "\" 才能匹配该字符本身的字符汇总

3.4 括号 "( )" 内的子表达式，如果希望匹配结果不进行记录供以后使用，可以使用 "(?:xxxxx)" 格式

    举例1：表达式 "(?:(\w)\1)+" 匹配 "a bbccdd efg" 时，结果是 "bbccdd"。括号 "(?:)" 范围的匹配结果不进行记录，因此 "(\w)" 使用 "\1" 来引用。

3.5 常用的表达式属性设置简介：Ignorecase，Singleline，Multiline，Global

4. 其他提示

4.1 如果想要了解高级的正则引擎还支持那些复杂的正则语法，可参见本站 DEELX 正则引擎的说明文档。

4.2 如果要要求表达式所匹配的内容是整个字符串，而不是从字符串中找一部分，那么可以在表达式的首尾使用 "^" 和 "$"，比如："^\d+$" 要求整个字符串只有数字。

4.3 如果要求匹配的内容是一个完整的单词，而不会是单词的一部分，那么在表达式首尾使用 "\b"，比如：使用 "\b(if|while|else|void|int……)\b" 来匹配程序中的关键字。

4.4 表达式不要匹配空字符串。否则会一直得到匹配成功，而结果什么都没有匹配到。比如：准备写一个匹配 "123"、"123."、"123.5"、".5" 这几种形式的表达式时，整数、小数点、小数数字都可以省略，但是不要将表达式写成："\d*\.?\d*"，因为如果什么都没有，这个表达式也可以匹配成功。更好的写法是："\d+\.?\d*|\.\d+"。

4.5 能匹配空字符串的子匹配不要循环无限次。如果括号内的子表达式中的每一部分都可以匹配 0 次，而这个括号整体又可以匹配无限次，那么情况可能比上一条所说的更严重，匹配过程中可能死循环。虽然现在有些正则表达式引擎已经通过办法避免了这种情况出现死循环了，比如 .NET 的正则表达式，但是我们仍然应该尽量避免出现这种情况。如果我们在写表达式时遇到了死循环，也可以从这一点入手，查找一下是否是本条所说的原因。

4.6 合理选择贪婪模式与非贪婪模式，参见话题讨论。

4.7 或 "|" 的左右两边，对某个字符最好只有一边可以匹配，这样，不会因为 "|" 两边的表达式因为交换位置而有所不同。

的确省写了很多代码，呵呵。但是，如果你想把变量声明和初始化分开，那var关键字就无能为力了。

（2）直接构建对象
js里创建对象的快捷途径一直令我很happy，例如：

现在C#3.0竟也有类似的语法了：

其实也是由编译器做了更多的工作，在背后自己定义了一个类，更多的原理解释大家自己google吧。

（3）扩展方法
js里给一个类扩展方法也就是给prototype原型对象添加一个方法，非常方便。
现在C#3.0也提供了类似的功能，虽然偶觉得这个新特性可能太灵活了以至影响C#的严谨性甚至软件架构方面的问题，但是无疑这还是很吸引人的：

在任意一个类中定义上述静态方法，那么你的string对象就有直接的ToInt32方法了，是不是很方便？

（4）创建对象时同时进行初始化
同样是提供了一种简洁的语法来初始化一个对象，例如：

可以这样实例化：

这样可以少些多少构造函数啊，呵呵

（5）方便声明集合对象
以前对于数组可以直接声明时初始化：

而对于ArrayList这样的集合类型却没有简洁的语法，只能通过Add之类的方法逐一添加，
而在C#3.0中，所有实现ICollection接口的类都有了简洁的初始化语法：

（6）Lambda表达式
尽管委托作为C#最新引入的一个概念非常优秀，它也是事件机制的基础。但用起来却很麻烦，相信每个写过的人都有体会，现在C#3.0通过Lambda表达式简化了这个过程。
Lambda表达式的关键特征是将表达式或者语句块作为参数，通过=>来直接定义一个委托，这个委托的类型会根据一系列的转换规则，由编译器决定，例如：

这里的()表示一个空参数的函数，后面的Console.WriteLine("Hiya!!");是函数体。这样就很方便的实现了委托的定义，大家不妨回忆一下在C#1.1和C#2.0中是如何的麻烦，呵呵。
Lambda表达式不是那么容易理解，更多信息可以参见C#3.0的语言规范：
http://news.csdn.net/news/newstopic/26/26742.shtml

（7）查询表达式
虽然我对Ruby了解不多，但总感觉针对集合的查询，直接在语言中体现，这种灵感来源于Ruby。
于是C#3.0又多了一项诱人的特性，可以通过类似Sql语句的方式来获得需要的数据，结果可能存储于一个集合对象中或其他。
同样，没有能力三言两语将其说清楚，参见规范：
http://news.csdn.net/news/newstopic/26/26747.shtml

背景

随着Internet的普及，网络信息正以极高的速度增长，在这么多数据中找到自己需要的信息是一件很繁琐的事情，找到需要的信息后如何获取也是件麻烦的事。这就需要Internet信息抓取程序来代替人工的操作。

所谓Internet信息抓取程序，就是程序会按照用户的关键词或关键网站来收集相应的信息，并提供给用户想要的信息格式。

信息量的增加会带来信息网站发布人员工作量的剧增，为实现信息发布系统实现信息自

动发布、减少工作人员工作量、即时跟踪最新信息，就需要自动信息提供程序，因此Internet信息抓取程序应运而生。

目标

实现自定义网站信息分类抓取，存入本地数据库、生成静态页面或其它用户定义的信息结构，并下载与信息相关的多媒体文件。

开发

l         目标站点结构分析

本步骤是准确抓取信息个关键。

首先要选择更新频率高的页面做为抓取地址，然后分析要抓取内容页面url特点。

然后分析要抓取信息页面的元素特性，比如标题位置，内容位置 等，得到定位标记点。

将以上信息写成自己的配置文件或存到数据库中。

每个网站都需要分析，写出单独的配置文件，供抓取程序使用。

l         信息提取

根据配置文件取得要抓取页面url，使用HttpWebRequest类获取内容：

//获取http页面函数

        public string Get_Http(string a_strUrl,int timeout)

        {

            string strResult ;        

            try

            {

HttpWebRequest myReq = (HttpWebRequest)HttpWebRequest.Create(a_strUrl) ;

                myReq.Timeout = timeout;

                HttpWebResponse HttpWResp = (HttpWebResponse)myReq.GetResponse();

                Stream myStream = HttpWResp.GetResponseStream () ;

                StreamReader sr = new StreamReader(myStream , Encoding.Default);

                StringBuilder strBuilder = new StringBuilder();

                while (-1 != sr.Peek())

                {

                    strBuilder.Append(sr.ReadLine()+"\r\n");

                }

                strResult = strBuilder.ToString();

            }

            catch(Exception exp)

            {

                strResult = "错误：" + exp.Message ;

            }

            return strResult ;

        }

获取页面内容后，分析页面中连接地址取到要抓取的url：

//处理页面标题和链接

        public string SniffWebUrl( string urlStr,string blockB,string blockE )

        {      

            string urlch1 = "";

            string urlch2 = "";                   

            int end_n1 = 0;

            int end_nums = 0;

            int end_nums1 = 0;

            int end_nums2 = 0;

            int end_nums3     = 0;           

            string reUTStr = "";

            string reTitle = "";

            string ret = "";          

            try

            {

                int pos01 = urlStr.IndexOf( "." );

                int pos02 = urlStr.LastIndexOf( "/" );

                if( pos01 < 0 )

                {

                    return "";

                }

                if( pos02 < 0 )

                {

                    return "";

                }

                int pos03 = urlStr.IndexOf( "/",pos01 );

                if ( pos03 < 0 )

                {

                    urlch1 = urlStr;

                    urlch2 = urlStr;

                }

                else

                {

                    urlch1 = urlStr.Substring( 0,pos03 );

                    urlch2 = urlStr.Substring( 0,pos02 );

                }

                string tmpAllStr = new PublicFun().Get_Http( urlStr ,time1);

                int pos1 = tmpAllStr.IndexOf( blockB );

                int pos2 = tmpAllStr.IndexOf( blockE,pos1 + blockB.Length );

                if ( pos1>0 && pos2>0 && pos2>pos1 )

                {

                    ret = tmpAllStr.Substring( pos1 + blockB.Length,pos2 - pos1 - blockB.Length );

                    ret = ret.Substring( ret.IndexOf( "<" ));

                    while( ret.IndexOf( "<A" ) >= 0 )

                    {

                        ret = ret.Substring( 0,ret.IndexOf( "<A" ) ) + "<a" + ret.Substring( ret.IndexOf( "<A" ) + 2 );

                    }

                    while( ret.IndexOf( "</A" ) >=0 )

                    {

                        ret = ret.Substring( 0,ret.IndexOf( "</A" ) ) + "</a" + ret.Substring( ret.IndexOf( "</A" ) + 3 );

                    }

                    while( ret.IndexOf( "Href=" ) >=0 )

                    {

                        ret = ret.Substring( 0,ret.IndexOf( "Href=" )) + "href=" + ret.Substring( ret.IndexOf( "Href=" ) + 5 );

                    }

                    while( ret.IndexOf( "HREF=" ) >=0 )

                    {

                        ret = ret.Substring( 0,ret.IndexOf( "HREF=" )) + "href=" + ret.Substring( ret.IndexOf( "HREF=" ) + 5 );

                    }

                    while( ret.IndexOf( "href='" ) >=0 )

                    {

                        ret = ret.Substring( 0,ret.IndexOf( "href='" )) + "href=\"" + ret.Substring( ret.IndexOf( "href='" ) + 6 ); 

单态模式Singleton, 目的是保在调用期间, 一个类只有一个实例存在.
最典型的例子为数据库连接, 数据库连接只需要一个, 所以可以使用单态模式.
使用单态模式时, 创建数据库连接的方法, 只能为静态, 并且要保证方法的同步, 否则在多线程操作中, 有可能会创建多个实例.
示例代码如下:

using System;
using System.Data.OleDb;
using System.Runtime.Remoting.Contexts;

[Synchronization()]
public class ConnectionClass
{
 private static OleDbConnection instance = null;
 private static string constring = "Provider=Microsoft.Jet.OLEDB.4.0;User ID=Admin;Data Source=singleton.mdb;Mode=Share Deny None;Jet OLEDB:Engine Type=5;Jet OLEDB:Database Locking Mode=1;Jet OLEDB:Global Partial Bulk Ops=2;Jet OLEDB:Global Bulk Transactions=1;Jet OLEDB:Create System Database=False;Jet OLEDB:Encrypt Database=False;Jet OLEDB:Don't Copy Locale on Compact=False;Jet OLEDB:Compact Without Replica Repair=False;Jet OLEDB:SFP=False";

 public static OleDbConnection GetInstance()
 {
  if (instance == null)
  {
   Console.WriteLine("Create new connection");
   instance = new OleDbConnection(constring);
  }
  return instance;
 }
}
public class Client
{
 public static void Main()
 {
  OleDbConnection cn = ConnectionClass.GetInstance();
  cn.Open();
  cn = ConnectionClass.GetInstance();
  cn.Close();
 }
}

DataGrid资料

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1444169