博客园_片言程序

自定义集合类型

2011-04-04T02:14:00Z

很多时候我们去自定义一些类型，更有些时候我们会把这些自定义类型封装成集合，比如说现在有一个自定义类型User

/// <summary>

/// 用户

/// </summary>

class User

{

/// <summary>

/// 用户ID

/// </summary>

public int ID

{

get;

set;

}

/// <summary>

/// 用户名

/// </summary>

public string UserName

{

get;

set;

}

/// <summary>

/// 用户这密码

/// </summary>

public string PassWord

{

get;

set;

}

一般情况下，我们封装集合时，是用泛型的List<>去封装，比如

List<User> users = new List<User>();

如果从技术角度考虑，这样的封装没有什么问题，如果是从业务和面向对象的角度考虑，现在的users不是纯粹一组用户，确切的理解是把用户放到了一个List的集合中，List的很多方法，对于这组用户来说是没有业务含意的，如果我们想得到纯粹的一组用户，那就得定义一个用户组类了。定义如下：

/// <summary>

/// 用户组

/// </summary>

class Users

{

/// <summary>

/// 用户集合

/// </summary>

List<User> users = new List<User>();

}

在内部，还是用List<User>来存放多个用户，但这个集合是私有的，被Users类型封装了起来。现在的Users就代表一个用户的集合了，当然，还要实现这个集合的添加用户，删除用户，包括获取用户的总数，代码如下：

/// <summary>

/// 添加用户

/// </summary>

/// <param name="user">用户</param>

public void AddUser(User user)

{

users.Add(user);

}

/// <summary>

/// 移除用户

/// </summary>

/// <param name="user">用户</param>

public void RemoveUser(User user)

{

users.Remove(user);

}

/// <summary>

/// 获得用户数量

/// </summary>

public int Count

{

get

{

return users.Count;

}

不但有添加，删除用户，还要对用户组中的用户进行修改和查询，当然我们去构建方法是没有问题的，

/// <summary>

/// 修改用户

/// </summary>

/// <param name="user">用户</param>

public void ModifyUser(User user)

{

for (int i = 0; i < users.Count;i++ )

{

if (users[i].ID == user.ID)

{

users[i] = user;

}

/// <summary>

/// 查询用户

/// </summary>

/// <param name="ID">用户ID</param>

/// <returns></returns>

public User QueryUser(int ID)

{

foreach (User user in users)

{

if (user.ID == ID)

{

return user;

}

return null;

}

这样可能实现修改和查询，但有修改和查询我们可以根据List<User>集合的特点（主要是引用类型的特点）来达到修改和查询，不防用索引器来试一下：

/// <summary>

/// 用户

/// </summary>

/// <param name="i">用户ID</param>

/// <returns></returns>

public User this[int ID]

{

get

{

foreach (User user in users)

{

if (user.ID == ID)

{

return user;

}

return null;

}

set

{

for (int i = 0; i < users.Count; i++)

{

if (users[i].ID == value.ID)

{

users[i] = value;

}

用索引器的好处是把用户组对象当集合来使用，用户ID当索引值：

Users users = new Users();

User user = users[1];

users[0].UserName = "张三";

既然Users代表一个集合，那应该能对它进行遍历，为了实现对Users的foreach遍历，必须实现IEnumerable接口的实现，代码如下：

class Users : IListSource, IEnumerable

{

……

/// <summary>

/// 实现对users的foreach遍历

/// </summary>

/// <returns></returns>

public IEnumerator GetEnumerator()

{

for (int i = 0; i < users.Count; i++)

{

yield return users[i];

}

……

}

在WinForm中或在ASP.NET中，框架中提供了一些数据库的绑定控制，如果使我们的用户组具有绑定能力，就更加完美了。

通常状况下，为了绑定到控件的DataSource的属性下，要实现以下接口，

IList 接口，包括一维数组。

IListSource 接口

IBindingList 接口

IBindingListView 接口

我们来实现IListSource接口，这个接口需要实现两个成员，一个是ContainsListCollection属性，一个是GetList方法

class Users : IListSource, IEnumerable

{

……

/// <summary>

/// 是否包含List

/// </summary>

public bool ContainsListCollection

{

get { return true; }

}

/// <summary>

/// 返回集合

/// </summary>

/// <returns></returns>

public System.Collections.IList GetList()

{

return users;

}

……

}

下面是整体类图：

本文链接

西亚斯vs2010敏捷开发分享

2010-04-30T02:42:00Z

4月24日，很有幸同西亚斯的励志工作室的的同学见面，他们是专门研究开发.net的一个工作室，大家一起学习，一起进步，是一个不错的团队。

在这里，我和大家一起分享了关于vs2010的敏捷开发，主要内容从UML架构设计，数据库设计，代码开发，代码测试等方面介绍了vs2010的开发模式。

西亚斯是个美丽的地方，不但环境优美，学生们的思想也很活跃，应该是个出人才的地方。

本文链接

3月28日 vs2010太原ReView

2010-04-29T12:26:00Z

今天，活动的形式比较特别，活动是在公园里举行，到场有近30位朋友，活动的内容谈及vs2010的新特性，vs2010的敏捷开发，C#4.0等方面的内容。

会后，大家抽取微软提供的礼品。

因为在公园，还是周末，我们的宣传广告有很多人看，还有很多人驻足观看，有的朋友还能听上半个小时，看来喜欢 IT的人越来越多了。

现场

交流

本文链接

WPF中的依赖项属性

2010-04-25T06:28:00Z

随着WPF的推广，不得不重新拾起WPF来，因为这块的产品越来越多。

只能跟着MSDN来学了，所以想是在这里记录下学习的过程和对知识的理解。

先从最基本的吧，依赖项属性是WPF中不同的地方，先了解一下它吧。

“依赖项属性的用途在于提供一种方法来基于其他输入的值计算属性值”，这是官方的一句话，理解起来有点费劲。属性本身其实很简单，就是用来封装了字段的，本质上是两个访问器，来达到对字段值的读与写，以及从业务角度保护字段的业务有效性（因为大部分字段都有一定的业务含义，即有业务含义，就有一定范围，比如工资，是个小数的类型，但工资不可能是负数，所以在封装工资字段时，要在set访问器中作限制）。但依赖项属性不只这么简单了，属性的值不是简单的封装字段，而是根据其他的输入值来决定本属性的值。为什么要这样做？因为在WPF体系中，只有定义属性为依赖项属性，这个属性才支持样式设置，数据绑定，继承，动画和默认值。也就是这个属性才能具有WPF中的一些特点。

怎么样才能使一个属性成为依赖项属性呢？

首先，属性所在的类要直接或间接继承DependencyObject。这个类生成的对象表示一个具有依赖项属性的对象，这些对象，都能享用WPF的属性系统（属性系统主要是计算属性的值，并提供有关值已更改的系统通知）方面的服务。

这个类有两个比较重要的方法，GetValue（返回当前对象依赖项属性的当前有效值）和SetValue（设置依赖项属性的本地值）。

其实，属性对应的字段必需是公有，静态，只读的，类型为DependencyProperty。即public static readonly DependencyProperty 字段名，同时字段的命名也有规范，属性名+Property，字段在定义时，通过DependencyProperty.Register来实注册属性（只有注册了，才能使用WPF属性系统的服务）。

Register方法有三种重载，如下：

名称	说明
Register(String, Type, Type)	使用指定的属性名称、属性类型和属性所在对象的类型。
Register(String, Type, Type, PropertyMetadata)	使用指定的属性名称、属性类型、属性所在对象的类型和属性元数据注册依赖项属性。
Register(String, Type, Type, PropertyMetadata, ValidateValueCallback)	使用指定的属性名称、属性类型、属性所在对象的类型、属性元数据和属性的值验证回调来注册依赖项属性。

在Register中，各个参数解释如下：

String：依赖属性的名字（不加Property，即字段的名字）；

Type：属性的类型；

Type：属性所属对象的类型；

PropertyMetadata：依赖项对象的属性元数据，是一个PropertyMetadata类型，可能赋初始值。PropertyMetadata有一个object的构造函数；

ValidateValueCallback：表示用作回调的方法，这个类型是一个委托，用于验证依赖项属性的值的有效性，因为是委托，故它的构造参数为一个方法名。

最后，来构造依赖属性，与普通的属性有所区别：

Public 属性类型属性名

{

Get

{

return (属性类型)this.GetValue(字段名);

}

Set

{

this.SetValue(字段名, value);

}

其中的GetValue和SetValue都是调用父类DependencyObject的方法。

完整的代码如下：

1 class MyClass : DependencyObject
2     {
3         public static readonly DependencyProperty MyfieldProperty = DependencyProperty.Register("Myfield", typeof(int), typeof(MyClass), new PropertyMetadata(0), new ValidateValueCallback(new MyClass().MyValidateMethod));
4         public int Myfield
5         {
6             get { return (int)GetValue(MyfieldProperty); }
7             set { SetValue(MyfieldProperty, value); }
8         }
9         public bool MyValidateMethod(object value)
10         {
11             return true;//这里实现验证
12         }
13     }
14

WPF中，大部分对象的属性都是依赖项属性，用Button来举例，Button类的继承关系如下：

可以很明显的看到，Button是间接继承DependencyObject的。再看看他的属性：

拿ISDefault属性来看，它有一个IsDefalutProperty的字段，类型为DependencyProperty，IsDefault的代码如下：

完全与我们定义的依赖项属性一样。因为只有这样，这些属性才能使用WPF属性系统服务。

本文链接

控制台输入验证

2010-04-19T18:35:00Z

VS提供了一个模版“控制台应用程序”，这种应用程序主要不是用来与用户交互的，或做一些后台程序运行的展示，或用来练习C#语法，如果当做C#语法学习的平台，在这里就说一下在控制台下的输入验证吧。

控制台状态下，程序的输入输出是流的方式进行的，也就是光标是向前的（如果不做特殊处理的话），输入的验证，只能等用户输入完后，系统从缓冲区中把数据读出来进行验证（因为在这里没有按键事件）。举个例子吧，比如，我们提示用户从控制台上输入一个数字类型（如果是字符或字符串类型，问题就会少一点，因为Console.ReadLine或 Console.Read方法，是返回字符串和字符的），拿年龄来说明问题吧。

最直接的验证是这样的：

Console.WriteLine("请输入年龄：");

string agestr = Console.ReadLine();

int age;

if (int.TryParse(agestr, out age))

{

Console.WriteLine("你输入的年龄：", age);

}

else

{

Console.WriteLine("你输入的年龄有误！");

}

我们利用类型.TryParse方法，来试图去转换一个类型，int.TryParse是试图把字符串转换成整型，当然，这个字符串必需是数字的字符串，这样才能转换成功，否则是不成功的，返回值是为false的，所以利用这点，就可以验证用户输入的年龄类型正确与否。其实上面写法还是复杂一点，于是就要简化一下，如下代码：

Console.WriteLine("请输入年龄：");

string agestr = Console.ReadLine();

int age = int.TryParse(agestr, out age) ? age : 1;

Console.WriteLine("年龄为：{0}", age);

用三元运算符可以在一定程度减少了代码量，但与之前不一样的是，在这里如果用户输入年龄有误，就会给一个默认值。

上面这两种做法都还行，能起一定的效果，但最大的依赖是TryParse，这样在业务逻辑上有一点别扭，是通过一个方法来验证类型的。

其实用更好的办法，如下：

Regex reg = new Regex(@"^\d+$");//重复一次或多次

Console.WriteLine("请输入年龄：");

string agestr = Console.ReadLine();

if (reg.Match(agestr).Success)

{

Console.WriteLine("年龄是：{0}", agestr);

}

else

{

Console.WriteLine("输入的年龄有误");

}

正则表达式，它能很好解决这个问题，这里不是在讨论正则表达式，关于它的学习，请参考相关文档，在这里主要说明，在语言中引用这个技术，在很大程度上解决了数据的安全性，有效性。

比如，我们都知道，年龄，特别是人的年龄，是在0到150，没有负数，也没有见过超过150岁的人，如果前两段代码做的话，那就是分段验证，前面验证是否为整型，后面验证是否在0到150岁之间，如果用正则，只需要如下变化：

Regex reg = new Regex(@"^\d$|^\d{2}$|^1[0-4]\d$|^150$");

只要一次的验证，改正则表达式，就能答到数据的验证。

提倡用正则，但正则一般学习和理解起来有一点难度，这就是双刃剑。

本文链接

关于DataGridView的索引

2010-03-29T02:11:00Z

最近在做一个课堂练习是被郁闷了一把。现成的事成了想当然的事。案例如下。

是一个WinForm程序，在DataGridView绑定控件后，选择一行，进行操作，代码如下：

数据绑定代码：

SqlDataAdapter da = new SqlDataAdapter("select id from shuji","server=.;database=tushudb;uid=sa;pwd=sa;");

DataTable dt = new DataTable();

da.Fill(dt);

My_DGV.DataSource = dt;

这是选择一行后的操作

label1 .Text = My_DGV.Rows[e.RowIndex].Cells[0].Value.ToString();

对于DataGridView来说，有两个例，代码如下：

// Column1

this.Column1.DataPropertyName = "id";

this.Column1.HeaderText = "ID";

this.Column1.Name = "Column1";

// Column2

this.Column2.DataPropertyName = "ISBN";

this.Column2.HeaderText = "ISBN";

this.Column2.Name = "Column2";

上面的两行，我是先添加Column2，后添加Conlumn1的，然后把name属性换掉的。

如果数据库中有数据，运行后，在DataGridView中就会有数据记录：

当我们选一行时，会报一个“未将对象引用设置到对象的实例”。当出现这个问题，我很是纳闷，因为我查询出一行，并且已经在ID这列中显示出来了，当我取这某一行的列索引为0时，出问题了，没有实例，也就是为null。不应该呀，于是就找根源。

先看局部变量窗口中的My_DGV对象，数据都在这个对象的Rows集合下，并且在非公共成员List集合中，这个集合存着所有Grid的行，在这个集合中的某个元素中，有一个Cells的属性，这个属性是这一行所有列的集合，展开这个属性的List属性，因为我们取的是第0列索引，所以展开下标为0的，再展开base，其中有一个value值，不难看到，这个值是null，也就是这列上没有值，为什么呢？如果仔细看，有一个OwningColum的属性，这个属性中明确的看到，Name=Column2，Index=0，也就是告诉我们，即使是我们改了每个列的name属性，但一开始我们在DataGridView的Columns集合中添加列的顺序是没有变的，即在集合中的位置是不变的。所以上图中的ID列，是和ISBN列换了一下位置的，所以在找下标为0的列是，其实找的是ISBN，是没有数据的。所以最好不要用下标来取值。

当然，我们可以取行某列时，改成如下

label1 .Text = My_DGV.Rows[e.RowIndex].Cells["Column1"].Value.ToString();

这样就会显示的告我们选的是那一行的数据。

本文链接

LINQ表间关联执行分析

2010-03-09T09:38:00Z

在数据库中，经验有两个表关联的情况，也就是一个表中的主键为另一个表的外键，在ADO.NET时，如果向两个表中同时添中数据，我们通常做三步SQL操作，第一步：添加主表数据，第二步：得到主表中的主键，第三步：添加子表数据，在通常状况下，这些都是在事务中。

先看一下数据库表结构。一个表为父表（这里为了说明技术，表没有具体意义），名字为FatherTable如下：

还有一个子表，名字为SonTable如下：

两个表之间有下图这样一个关系：

先看一下ADO.NET如何实现：

class TestDemo

{

string constr = "Data Source=.;Initial Catalog=MyTestDB;Persist Security Info=True;User ID=sa;Password=sa";

public static void Main()

{

TestDemo TD = new TestDemo();

SqlConnection con = new SqlConnection(TD.constr);

SqlCommand cmd = new SqlCommand();

cmd.Connection = con;

SqlTransaction tran = null;

try

{

con.Open();

tran = con.BeginTransaction();

cmd.Transaction = tran;

cmd.CommandText = "insert into fathertable([name]) values(@name)";

cmd.Parameters.Clear();

cmd.Parameters.Add("@name", SqlDbType.VarChar).Value = "李四";

cmd.ExecuteNonQuery();

cmd.CommandText = "select @@identity";

int id = Convert.ToInt32(cmd.ExecuteScalar());

cmd.CommandText = "insert into sontable(fid,names) values(@id,@names)";

cmd.Parameters.Clear();

cmd.Parameters.Add("@id", SqlDbType.Int).Value = id;

cmd.Parameters.Add("@names", SqlDbType.VarChar).Value = "李四A";

cmd.ExecuteNonQuery();

tran.Commit();

}

catch (Exception exc)

{

Console.WriteLine(exc.Message);

tran.Rollback();

}

finally

{

con.Close();

}

ADO.NET的事务没有什么好说的，现在来看看用Linq怎么实现，首先添加一个“LINQ to SQL类”，在“服务器资源管理器”中连接数据库，然后选中FatherTable和SonTable表，如下图

接下来，编程来实现添加操作，代码如下：

class TestDemo

{

string constr = "Data Source=.;Initial Catalog=MyTestDB;Persist Security Info=True;User ID=sa;Password=sa";

public static void Main()

{

TestDemo td=new TestDemo ();

DataClasses1DataContext DCDC = new DataClasses1DataContext(td.constr);

FatherTable ft = new FatherTable();

ft.name = "王五";

SonTable st1 = new SonTable();

st1.names = "王五A";

ft.SonTable.Add(st1);

SonTable st2 = new SonTable();

st2.names = "王五B";

ft.SonTable.Add(st2);

DCDC.FatherTable.InsertOnSubmit(ft);

DCDC.SubmitChanges();

}

运后的结果是一样的。用ADO.NET，我们自己写的SQL语句，清楚我们对数据执行了什么操作，上面的用Linq to Sql做的话，就不知道系统执行了什么操作。我们看见系统调用了DataClasses1DataContext类的SubmitChanges，这个方法在DataClasses1DataContext找不到，它是从DataContext继承下来的。我们用工具Reflector查看，SubmitChanges是调用有参的SubmitChanges(ConflictMode)，这个方法代码如下:

public virtual void SubmitChanges(ConflictMode failureMode)

{

this.CheckDispose();

this.CheckNotInSubmitChanges();

this.VerifyTrackingEnabled();

this.conflicts.Clear();

try

{

this.isInSubmitChanges = true;

if ((Transaction.Current == null) && (this.provider.Transaction == null))

{

bool flag = false;

DbTransaction transaction = null;

try

{

try

{

if (this.provider.Connection.State == ConnectionState.Open)

{

this.provider.ClearConnection();

}

if (this.provider.Connection.State == ConnectionState.Closed)

{

this.provider.Connection.Open();

flag = true;

}

transaction = this.provider.Connection.BeginTransaction(IsolationLevel.ReadCommitted);

this.provider.Transaction = transaction;

new ChangeProcessor(this.services, this).SubmitChanges(failureMode);

this.AcceptChanges();

this.provider.ClearConnection();

transaction.Commit();

}

catch

{

if (transaction != null)

{

try

{

transaction.Rollback();

}

catch

{

}

throw;

}

return;

}

finally

{

this.provider.Transaction = null;

if (flag)

{

this.provider.Connection.Close();

}

new ChangeProcessor(this.services, this).SubmitChanges(failureMode);

this.AcceptChanges();

}

finally

{

this.isInSubmitChanges = false;

}

我们清楚的看到，这里面启用了事务，与我们ADO.NET的做法是一样的。事务有了，SQL语句怎么样？继续查找SubmitChanges方法，代码如下：

internal void SubmitChanges(ConflictMode failureMode)

{

this.TrackUntrackedObjects();

this.ApplyInferredDeletions();

this.BuildEdgeMaps();

List<TrackedObject> orderedList = this.GetOrderedList();

ValidateAll(orderedList);

int totalUpdatesAttempted = 0;

ChangeConflictSession session = new ChangeConflictSession(this.context);

List<ObjectChangeConflict> conflictList = new List<ObjectChangeConflict>();

List<TrackedObject> deletedItems = new List<TrackedObject>();

List<TrackedObject> insertedItems = new List<TrackedObject>();

foreach (TrackedObject obj2 in orderedList)

{

try

{

if (obj2.IsNew)

{

obj2.SynchDependentData();

this.changeDirector.Insert(obj2);

insertedItems.Add(obj2);

}

else if (obj2.IsDeleted)

{

totalUpdatesAttempted++;

if (this.changeDirector.Delete(obj2) == 0)

{

conflictList.Add(new ObjectChangeConflict(session, obj2, false));

}

else

{

deletedItems.Add(obj2);

}

else if (obj2.IsPossiblyModified)

{

obj2.SynchDependentData();

if (obj2.IsModified)

{

CheckForInvalidChanges(obj2);

totalUpdatesAttempted++;

if (this.changeDirector.Update(obj2) <= 0)

{

conflictList.Add(new ObjectChangeConflict(session, obj2));

}

catch (ChangeConflictException)

{

conflictList.Add(new ObjectChangeConflict(session, obj2));

}

if ((conflictList.Count > 0) && (failureMode == ConflictMode.FailOnFirstConflict))

{

break;

}

if (conflictList.Count > 0)

{

this.context.ChangeConflicts.Fill(conflictList);

throw CreateChangeConflictException(totalUpdatesAttempted, conflictList.Count);

}

this.PostProcessUpdates(insertedItems, deletedItems);

}

如果继续下付出，会发现查找许多类，能隐约看出系统在组织sql语句。

与其在这里找，不如到SQL里等它生成的SQL语句看看。

打开SQL的跟踪工具，运行结果如下图：

起作用的是ApplicationName为.NET SqlClient Data Provider的四五列，第一列为登录数连库，最后注销数据库，语句为中间三列，先看第一列，语句如下：

exec sp_executesql N'INSERT INTO [dbo].[FatherTable]([name])

VALUES (@p0)

SELECT CONVERT(Int,SCOPE_IDENTITY()) AS [value]',N'@p0 varchar(4)',@p0='王五'

执行了两个操作，一个添中，一个查询，查询的是添加后自动生成的ID值，另外两个语句如出一辙，单从SQL语句的角度看，多了两个查询，这在一定程度上没有我们自己写的SQL语句简单，多了子表中的一个查询。

本文链接

ado.net连接池

2010-02-24T16:46:00Z

ado.NET中提供了连接池的功能，多数开发人员很少设置它，因为它是默认的。

界面设置如下图：

关闭连接池也很简单，在连接字符串如下：

Data Source=(local);Initial Catalog=AdventureWorks;Integrated Security=SSPI;Pooling=False;

但连接池的本质是什么样的呢？

用Reflector，打开System.Data.SqlClient.SqlConnection的ConnectionString属性的设置值的方法，如下：

private void ConnectionString_Set(string value)

{

DbConnectionOptions userConnectionOptions = null;

DbConnectionPoolGroup group = this.ConnectionFactory.GetConnectionPoolGroup(value, null, ref userConnectionOptions);

DbConnectionInternal innerConnection = this.InnerConnection;

bool allowSetConnectionString = innerConnection.AllowSetConnectionString;

if (allowSetConnectionString)

{

allowSetConnectionString= this.SetInnerConnectionFrom(DbConnectionClosedBusy.SingletonInstance, innerConnection);

if (allowSetConnectionString)

{

this._userConnectionOptions = userConnectionOptions;

this._poolGroup = group;

this._innerConnection = DbConnectionClosedNeverOpened.SingletonInstance;

}

if (!allowSetConnectionString)

{

throw ADP.OpenConnectionPropertySet("ConnectionString", innerConnection.State);

}

if (Bid.TraceOn)

{

string str = (userConnectionOptions != null) ? userConnectionOptions.UsersConnectionStringForTrace() : "";

Bid.Trace("<prov.DbConnectionHelper.ConnectionString_Set|API> %d#, '%ls'\n", this.ObjectID, str);

}

再连接到红色的GetConnectionPoolGroup方法，如下代码

internal DbConnectionPoolGroup GetConnectionPoolGroup(string connectionString, DbConnectionPoolGroupOptions poolOptions, ref DbConnectionOptions userConnectionOptions)

{

DbConnectionPoolGroup group;

if (ADP.IsEmpty(connectionString))

{

return null;

}

if (!this._connectionPoolGroups.TryGetValue(connectionString, out group) || (group.IsDisabled && (group.PoolGroupOptions != null)))

{

DbConnectionOptions options = this.CreateConnectionOptions(connectionString, userConnectionOptions);

if (options == null)

{

throw ADP.InternalConnectionError(ADP.ConnectionError.ConnectionOptionsMissing);

}

string str = connectionString;

if (userConnectionOptions == null)

{

userConnectionOptions = options;

str = options.Expand();

if (str != connectionString)

{

return this.GetConnectionPoolGroup(str, null, ref userConnectionOptions);

}

if ((poolOptions == null) && ADP.IsWindowsNT)

{

if (group != null)

{

poolOptions = group.PoolGroupOptions;

}

else

{

poolOptions = this.CreateConnectionPoolGroupOptions(options);

}

DbConnectionPoolGroup group2 = new DbConnectionPoolGroup(options, poolOptions) {

ProviderInfo = this.CreateConnectionPoolGroupProviderInfo(options)

};

lock (this)

{

Dictionary<string, DbConnectionPoolGroup> dictionary = this._connectionPoolGroups;

if (!dictionary.TryGetValue(str, out group))

{

Dictionary<string, DbConnectionPoolGroup> dictionary2 = new Dictionary<string, DbConnectionPoolGroup>(1 + dictionary.Count);

foreach (KeyValuePair<string, DbConnectionPoolGroup> pair in dictionary)

{

dictionary2.Add(pair.Key, pair.Value);

}

dictionary2.Add(str, group2);

this.PerformanceCounters.NumberOfActiveConnectionPoolGroups.Increment();

group = group2;

this._connectionPoolGroups = dictionary2;

}

return group;

}

if (userConnectionOptions == null)

{

userConnectionOptions = group.ConnectionOptions;

}

return group;

}

TryGetValue是判断是否存在连接字符串为connectionString的连接，存在返回到group，不存在就调用CreateConnectionOptions创建一个DbConnectionOptions，最后用

lock (this)

{

Dictionary<string, DbConnectionPoolGroup> dictionary = this._connectionPoolGroups;

if (!dictionary.TryGetValue(str, out group))

{

Dictionary<string, DbConnectionPoolGroup> dictionary2 = new Dictionary<string, DbConnectionPoolGroup>(1 + dictionary.Count);

foreach (KeyValuePair<string, DbConnectionPoolGroup> pair in dictionary)

{

dictionary2.Add(pair.Key, pair.Value);

}

dictionary2.Add(str, group2);

this.PerformanceCounters.NumberOfActiveConnectionPoolGroups.Increment();

group = group2;

this._connectionPoolGroups = dictionary2;

}

return group;

}

这段代码放到连接池中，在这里，可能显示的看到，ado.NET的连接池实质上是一个Dictionary<string, DbConnectionPoolGroup>泛型集合。

所谓的连接池，就是一个与连接对象Connection相关的集合，这不只是简单的集合，而是有一定的机制在内部。我们做开发时，可能建立Connection连接对象，关闭连接对象，有时候还调用Dispose来释放连接。下次再用时，便重新实例化一个连接。但在池中的连接不随连接对象的Close或Dispose而释放。如果下次重新建立连接，连接字符串与前一次完全一模一样，则连接池就会把上次可用的连接对象赋给连接去用。如果两个连接字符串有一点不一样，即使在某一个地方多一个空格，连接池也不会以为是相同的连接，这点微软可能在内部只直接去比较两个字符串了，而不是比较连接数据库字符串的键值互相匹配。

连接池的好处就是保留连接对象，防止下次重头再来实例化一个连接对象。

（说明：可能找到结果后觉得非常简单，但怎么找到结果的，却是费了很大劲，几乎是5个小时，所以相把找到结果的过程简单说一下：

一开始用Reflector发现SqlConnection中有一个PoolGroup的属性，于是就想在运行时候比较两个SqlConnection对象的这个属性，但由于这个属性是的访问修饰符是internal的，不能直接访问，只有用反射，代码（是经过优化的）如下：

string constr1 = "Data Source=(local);Initial Catalog=AdventureWorks;Integrated Security=SSPI;";

string constr2 = "Data Source=(local);Initial Catalog=Pubs;Integrated Security=SSPI;";

string AssMark = "System.Data,Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";

Assembly ass = Assembly.Load(AssMark);

Type SqlConType = null;

foreach (Type conType in ass.GetExportedTypes())

{

Console.WriteLine(conType .ToString ());

if ("System.Data.SqlClient.SqlConnection" == conType.ToString())

{

SqlConType = conType;

}

if (SqlConType != null)

{

Type[] types1 = new Type[0];

ConstructorInfo constructorInfoObj1 = SqlConType.GetConstructor(

BindingFlags.Instance | BindingFlags.Public, null,

CallingConventions.HasThis, types1, null);

SqlConnection con1 = (SqlConnection)constructorInfoObj1.Invoke(null);

con1.ConnectionString = constr1;

SqlConnection con2 = (SqlConnection)constructorInfoObj1.Invoke(null);

con2.ConnectionString = constr2;

PropertyInfo PI = SqlConType.GetProperty("PoolGroup", BindingFlags.Instance | BindingFlags.NonPublic);

object poolGroup1 = PI.GetValue(con1, null);

object poolGroup2 = PI.GetValue(con2, null);

}

然后在倒数第一行设置断点，为比较poolGroup1和poolGroup2的不同，结果发现，当连接字符串一样时，这两个对象的_objectID相同，字符串有一点不同就会不同，这点说明连接池中是用字符串本身比较的，而不是字符串中键值对进行比较。同还发现当con1和con2的ConnectionString不赋值时这两个对象都是null，由此说明关键是ConnectionString赋值上，所以才开始用Reflector查看这个属性的赋值方法，才有上面的代码。）

本文链接

有感微软中文论坛2010party

2010-02-03T13:59:00Z

1月31号，是周末，很荣幸收到邀请参加微软中文技术论坛2010 party，这是我第一次参加论坛的party，因为2009年的那次我不在北京，没有能参加，所以这次就带了更多的好奇。虽然坐车出了点小插曲（比起冯瑞涛同志，我还算幸运，因为他在来的路上把钱包丢了），但还是如期到达微软大厦。我到时已经来了很多论坛的朋友，很多都不认识，因为都是线上论坛交流，但也不乏老朋友，比如MVP葛涵涛，陈广琛等。当到了...

.net中的TDD

2010-01-18T08:19:00Z

TDD(Test-Driven Development)测试驱动开发，就是以测试用例来带动开发，也就是先做测试用例，然后根据测试用例做开发。TDD的好外使是开发人员可以针对性的做开发，目标就是通过测试用例，当然，TDD更适合做逻辑的程序员，不适合更多的与UI开发相关的程序员。不管是TDD也好，传统的开发也好，肯定要先做设计，设计展开后如果采用普通方法做开发，那就是开始写代码，然后单元测试，集成测试...