博客园_dudu

浏览器兼容CSS代码：按钮文字垂直居中(input button text vertical align)

2012-02-03T10:14:00Z

经过测试的浏览器：IE6, IE7, IE8, IE9, Firefox, Chrome, Safiri, Maxthon

按钮的HTML代码：

<input id="btn_comment_submit" type="button" class="comment_btn" value="提交评论"/>

CSS代码：

input::-moz-focus-inner{ border: 0;padding: 0;}/*针对Firefox*/
.comment_btn{
height:26px;
line-height:22px;/*针对IE*/
width:68px;
}

显示效果：

本文链接

C#正则表达式操作中使用LINQ

2012-01-06T05:34:00Z

问题场景

在博客园闪存内容中提取Tag，Tag要放在中括号之间并且出现在闪存内容的开头。

比如：[程序员][代码]博客园 - 程序员的网上家园，代码改变世界

提取出来的Tag应该是：[程序员]、[代码]

正则表达式

Regex _regexTag = new Regex(@"^(\[[^\]]+\])+", RegexOptions.Compiled);

通过LINQ从正则表达式的捕获中提取出Tag

public IList<string> GetTags(string ingContent)
{
    return (from Capture c in _regexTag.Match(ingContent).Groups[1].Captures   
            select c.Value).ToList();
}

注：即使没有捕获到，_regexTag.Match(ingContent).Groups[1].Captures也不会引发异常。

LINQ使用感言

LINQ就像代码世界的小天使，给程序员带来了更多的轻松与快乐！

本文链接

Entity Framework - 理清关系 - 基于共享主键的单向一对一关系

2012-01-05T05:43:00Z

在上篇文章中，我们理了一下基于外键关联的单向一对一关系。在这篇文章中，我们理一理“基于共享主键的单向一对一关系”，找出Entity Framework中正确的映射关系。

一、明确需求，也就是Entity Framework正确映射之后要达到的效果

1）数据库结构要符合要求——共享主键。所下图所示，数据库中表A与表B的主键都是AID。

2）实体关系要符合要求——单向一对一关系。我们通过下面的UML类图来表达：

上图中只有A到B的关联箭头，这就是“单向”，这个箭头也表示A依赖B，在代码中的表现就是A有一个导航属性A.B。

上图中箭头两头的两个1就是“一对一”，存在一个A，必然存在一个对应的B；存在一个B，必然存在一个对应的A。

EDM中的实体关系要与UML类图中的关系一致。

实体A的定义：

public class A
{
    public int AID { get; set; }
    public string Title { get; set; }
    public B B { get; set; }
}

实体B的定义：

public class B
{
    public int AID { get; set; }
    public string Body { get; set; }
}

3）持久化操作要符合要求

只允许A与B一起进行持久化，测试代码如下：

var a = new A();
a.Title = "title test";
a.B = new B();
a.B.Body = "body test";
using (EfUnitOfWork ef = new EfUnitOfWork())
{
    ef.Set<A>().Add(a);
    ef.SaveChanges();
}

不允许A与B各自单独的持久化，测试代码如下：

//不允许的持久化操作
var a = new A();
a.Title = "title a";
using (EfUnitOfWork ef = new EfUnitOfWork())
{
    ef.Set<A>().Add(a);
    ef.SaveChanges();
}

var b = new B();
b.Body = "body b";
using (EfUnitOfWork ef = new EfUnitOfWork())
{
    ef.Set<B>().Add(b);
    ef.SaveChanges();
}

4）生成的SQL查询语句要符合要求

比如这样的查询：

using (EfUnitOfWork ef = new EfUnitOfWork())
{
    ef.Set<A>()
        .Include(a => a.B)
        .Where(a => a.AID == 1)
        .ToList();
}

生成的SQL查询语句应该是：

SELECT 
[Extent1].[AID] AS [AID], 
[Extent1].[Title] AS [Title], 
[Extent2].[AID] AS [AID1], 
[Extent2].[Body] AS [Body]
FROM  [dbo].[A] AS [Extent1]
INNER JOIN [dbo].[B] AS [Extent2] ON [Extent1].[B_AID] = [Extent2].[AID]
WHERE 1 = [Extent1].[AID]

二、用最笨的方法找出答案

这个最笨的方法是，对四种映射关系逐一进行测试，看哪个与我们想要的效果最一致。

下面我们分别来看看在不同的映射关系配置下Entity Framework的行为。

1）.HasRequired(a => a.B).WithMany();

FluentAPI:

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Entity<B>().HasKey(b => b.AID);
    modelBuilder.Entity<A>().HasRequired(a => a.B).WithMany();
}

a) EF生成的数据库结构：

表A多了一个字段B_AID，并通过B_AID关联至表B的主键AID。数据库结构不一致，不符合要求。

b) EF生成的EDM图：

EDM与UML中的关系定义不一致，这里是一对多关系，我要的是一对一关系，不符合要求。

c) 不允许实体A的单独持久化，但允许实体B的单独持久化，不符合要求。

d) 生成的SQL查询语句符合要求。

【小结】数据库结构不符合要求，实体关系不符合要求，持久化不符合要求，生成的SQL查询语句符合要求。

2）.HasRequired(a => a.B).WithOptional();

FluentAPI:

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Entity<B>().HasKey(b => b.AID);
    modelBuilder.Entity<A>().HasRequired(a => a.B).WithOptional();
}

a) EF生成的数据库结构：

数据库结构符合要求。

b) EF生成的EDM图：

关联的一端是0..1，也就是允许“存在一个B，不存在一个A”的情况，实体关系不符合要求。

c) 不允许实体A的单独持久化，但允许实体B的单独持久化，不符合要求。

d) 生成的SQL查询语句符合要求。

【小结】数据库结构符合要求，实体关系不符合要求，持久化不符合要求，SQL查询语句符合要求。

3）.HasRequired(a => a.B).WithRequiredDependent();

FluentAPI:

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Entity<B>().HasKey(b => b.AID);
    modelBuilder.Entity<A>().HasRequired(a => a.B).WithRequiredDependent();
}

a) 生成的数据库结构与.WithOptional();一样，符合要求。

b) EF生成的EDM图：

实体关系是“单向一对一”关系，与UML类图一致。但类的摆放位置不一致，在EDM中，B在A的前面，也就是B是Principal，我们希望A是Pricipal，有点不一致。

c) 不允许实体A的单独持久化，但允许实体B的单独持久化，不符合要求。

d) 生成的SQL查询语句符合要求。

【小结】数据库结构符合要求，实体关系有点不符合要求（Pricipal不一致），持久化不符合要求，SQL查询语句符合要求。

4）.HasRequired(a => a.B).WithRequiredPrincipal();

FluentAPI:

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Entity<B>().HasKey(b => b.AID);
    modelBuilder.Entity<A>().HasRequired(a => a.B).WithRequiredPrincipal();
}

a) 生成的数据库结构与.WithOptional();一样，符合要求。

b) EF生成的EDM图：

实体关系是“单向一对一”关系，与UML类图一致，A是Pricipal，符合要求。

c) 允许实体A的单独持久化，不允许实体B的单独持久化，不符合要求。

d) 生成的SQL查询语句：

SELECT 
[Extent1].[AID] AS [AID], 
[Extent1].[Title] AS [Title], 
[Extent3].[AID] AS [AID1], 
[Extent3].[Body] AS [Body]
FROM   [dbo].[A] AS [Extent1]
LEFT OUTER JOIN [dbo].[B] AS [Extent2] ON [Extent1].[AID] = [Extent2].[AID]
LEFT OUTER JOIN [dbo].[B] AS [Extent3] ON [Extent2].[AID] = [Extent3].[AID]
WHERE 1 = [Extent1].[AID]

我们想要的是INNER JOIN，这里却是两个LEFT OUTER JOIN，不符合要求。

等等。。。我们改一下查询的LINQ语句试试，改为：

using (EfUnitOfWork ef = new EfUnitOfWork())
{
    ef.Set<A>()
        .Include(a => a.B)
        .Where(a => a.B.AID == 1)//原来是a => a.AID == 1
        .ToList();
}

改过之后，生成的SQL查询语句符合要求：

[Extent1].[AID] AS [AID], 
[Extent1].[Title] AS [Title], 
[Extent2].[AID] AS [AID1], 
[Extent2].[Body] AS [Body]
FROM  [dbo].[A] AS [Extent1]
INNER JOIN [dbo].[B] AS [Extent2] ON [Extent1].[AID] = [Extent2].[AID]
WHERE 1 = [Extent2].[AID]

【小结】数据库结构符合要求，实体关系符合要求，持久化不符合要求，SQL查询语句符合要求。

三、总结与分析

	数据库结构	实体关系	持久化	SQL查询语句
WithMany()	不符合	不符合	不符合	符合
WithOptional()	符合	不符合	不符合	符合
WithRequiredDependent()	符合	不符合	不符合	符合
WithRequiredPrincipal()	符合	符合	不符合	符合

从上面的表中可以出，成绩最好的是WithRequiredPrincipal()，但它有一个地方不符合要求，就是允许实体A的单独持久化。

为什么实体B不能单独持久化？看数据库的外键关系就知道答案（A_B外键约束的功劳）：

那我们只要解决“不允许实体A的单独持久化”的问题，就能完成“基于共享主键的单向一对一关系”的完美映射。

既然数据库中不好下手，那就从实体类下手吧。给实体A的导航属性A.B加一个[Required]属性，在实体验证时就要求A.B必须有一个对应的实体B的实例。修改后的实体A的代码如下：

public class A
{
    public int AID { get; set; }
    public string Title { get; set; }
    [Required]
    public B B { get; set; }
}

经过努力，我们终于找到了最佳答案——

对于“基于共享主键的单向一对一”关系，Entity Framework中正确的映射关系定义是：

modelBuilder.Entity<A>().HasRequired(a => a.B).WithRequiredPrincipal();

本文链接

Entity Framework - 理清关系 - 基于外键关联的单向一对一关系

2012-01-04T07:03:00Z

注：本文针对的是 Entity Framework Code First 场景。

之前写过三篇文章试图理清Entity Framework中的一对一关系（单相思（单向一对一）, 两情相悦（双向一对一）, 两情相悦-续），但当时理得不够清，新的一年重新理一理。

当时“一对一”的实体关系，对应的数据库关系是外键关联（实际上是一种“一对多”关系，所以映射时用了WithMany）。而数据库中的“一对一”关系是共享主键（这是我个人的理解，不妥之处，欢迎指出），下篇文章将要理的就是这个关系。

由于双向“一对一”关系很少用到，而且不推荐使用，为了更清楚地理解，我们这里只谈单向一对一关系，也就是“基于外键关联的单向一对一关系(One-to-one Unidirectional relationships)”，对应的之前的文章是单相思（单向一对一）。

1. 类图

2. 类的定义

public class BlogSite
{
    public int BlogID { get; set; }
    public string BlogApp { get; set; }
    public bool IsActive { get; set; }
    public Guid UserID { get; set; }    
    public virtual BlogUser BlogUser { get; set; }
}

public class BlogUser
{
    public Guid UserID { get; set; }
    public string Author { get; set; }
    public int BlogID { get; set; }
}

3. 数据库结构

4. Enitity Framework映射关系定义

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Entity<BlogSite>()
        .HasRequired(b => b.BlogUser)
        .WithMany();
}

怎么理解这里的HasRequired与WithMany呢？

我的理解是：HasRequired是针对BlogSite与BlogUser的关系，WithMany是针对BlogUser与BlogSite的关系。.HasRequired(b => b.BlogUser).WithMany()表示BlogSite与BlogUser存在Required关联关系（One-To-One, 每一个BlogSite都有一个对应的BlogUser），而这个关联对BlogUser来说是One-To-Many（一个BlogUser可以有多个BlogSite）。

你也许会疑惑？明明是单向一对一的实体关系，这里怎么弄出个一对多的关系？

如果有这样的疑惑，属正常现象，我从去年7月份写那篇文章开始疑惑，一直疑惑到现在，写篇文章时才有点搞明白。

注意，“单向一对一”是什么？是实体关系；Entity Framework是什么？是O/RM，是用来映射实体关系与数据库关系；还少了什么？数据库关系。

从上面的图中的数据库结构可以看出，BlogSite与BlogUser之间是外键关联关系，下面的图可以更清楚地看出这一点。

这个外键关联表示的就是BlogUser与BlogSite之间是一对多的数据库关系。

总结一下：

实体关系 —— BlogSite与BlogUser之间的单向一对一

数据库关系 —— BlogUser与BlogSite之间的一对多

是不是这样呢？Entity Framework是不是也是这样认为的呢？我们来验证一下。

怎么知道Entity Framework的想法呢？

通过EDM。

可这里是Code First？

不管什么First，都有EDM，因为这是Entity Framework的地图，没有它，Entity Framework就会晕头转向。Code First的EDM是在EF运行时生成的，不是没有地图，只是在Entity Framework的心中，我们看不到而已。

怎么让Entity Framework说出心里话呢？

从Morteza Manavi大师那学到一招，代码如下：

using (var context = new Context())
{
    XmlWriterSettings settings = new XmlWriterSettings();
    settings.Indent = true;
 
    using (XmlWriter writer = XmlWriter.Create(@"Model.edmx", settings))
    {
        EdmxWriter.WriteEdmx(context, writer);
    }                            
}

通过上面的代码，你就可以拿到EF心中的地图 —— edmx文件。请看地图：

果然，EF心中的地图就是BlogUser与BlogSite的一对多关系。地图的作用是什么？是让EF通过地图在数据库找到对应的数据。地图是如何产生的？是我们通过FluentAPI告诉Entity Framework：.HasRequired(b => b.BlogUser).WithMany()。

我们再来剖析一下.HasRequired(b => b.BlogUser).WithMany()。

之前，我一直被困扰，是因为总是把这里的定义当作实体的关系的定义。错！这里虽然用的是实体进行定义，但定义的是实体与数据库中的数据之间的映射关系（这本来就是常识，竟然被忽略了），更多的是告诉EF这些实体在数据库中的数据关系。EF最终是根据这个定义生成相应的SQL。

那我们从生成查询SQL的角度来理解一下：

.HasRequired(b => b.BlogUser)告诉EF，这是一个INNER JOIN查询（BlogSite INNER JOIN BlogUser）；但INNER JOIN还需要条件，WithMany()告诉EF这是一个外键关联，EF据此进行推断，从BlogUser中找到主键UserID，并检查BlogSite中是否存在名为UserID的属性，如果存在，就以此为外键进行查询。而我们的BlogSite中有UserID，于是生成下面的SQL：

SELECT 
[Extent1].[BlogID] AS [BlogID], 
[Extent1].[BlogApp] AS [BlogApp], 
[Extent1].[IsActive] AS [IsActive], 
[Extent1].[UserID] AS [UserID], 
[Extent2].[UserID] AS [UserID1], 
[Extent2].[Author] AS [Author]
FROM  [dbo].[BlogSite] AS [Extent1]
INNER JOIN [dbo].[BlogUser] AS [Extent2] ON [Extent1].[UserID] = [Extent2].[UserID]
WHERE 1 = [Extent1].[IsActive]

小结

理清“基于外键关联的单向一对一关系”，关键在于对modelBuilder.Entity<A>().HasRequired(A => A.B).WithMany()的理解。

我再来理解一次：

.HasRequired(A => A.B) 表示：1）实体A与实体B是一对一关系，实体A有一个导航属性A.B；2）在数据库中表A与表B存在一对一关联（INNER JOIN）。

.WithMany() 表示：1）实体B与实体A可以没有关系，也可以是一对多关系；2）在数据库中表A与表B存在外键关联。

上面全是我的个人理解，真正理清Entity Framework中的关系需要大家的力量，我只是抛个砖。

除了“基于外键关联的单向一对一关系”，还有“基于共享主键的单向一对一关系”，这也是我们开发中经常碰到的一种关系，比如博客文章(BlogPost)与文章内容(PostBody)，新闻(NewsItem)与新闻内容(NewsBody)。下一篇文章将会理理这个关系。

本文链接

享受无止境 - 改进版WCF Client

2011-12-31T08:46:00Z

在之前的文章“让WCF客户端的“调用”成为一种‘享受’”中，分别用Func与Action实现了WCF客户端调用接口。

Func实现的调用方式：

WcfClient.UseService((IUserService userService) => (userService.GetUser(userId)));

缺点：

1. 需要用匿名方法传递参数，写起来比较麻烦。

2. 不支持无返回值的ServiceContract。

Action实现的调用方式：

List<ZzkDocument> docs = null;
WcfClient.UseService<IZzkDocumentService>(
    s =>
    {
        docs = s.GetZzkDocuments("0", 30).ToList(); 
    });

缺点：

虽然支持了无返回值的ServiceContract，但需要在Lambda表达式中获取返回值。这样还造成了无法使用类型判断，也就是不能使用var docs。

用Action“享受”了很多次的过程中，总是有那么一点点“不爽”萦绕在心头，挥之不去。。。

2011即将过去，2012即将到来，在这辞旧换新之际，也把那一点点“不爽”辞去吧。

今天下午，借助.NET世界中一个强大的武器完成了这个小小的心愿，它就是表达式树 —— Expression<Func<TService, TReturn>> operation

先一睹调用改进版WCF Client的风采：

var client = new WcfClient<IZzkDocumentService>();
var docs = client.UseService(s => s.GetZzkDocuments("0", 10));

然后看看WcfClient的实现代码：

public class WcfClient<TService> where TService : class
{
    public TReturn UseService<TReturn>(Expression<Func<TService, TReturn>> operation)
    {
        var channelFactory = new ChannelFactory<TService>("*");
        TService channel = channelFactory.CreateChannel();
        var client = (IClientChannel)channel;
        client.Open();
        TReturn result = operation.Compile().Invoke(channel);
        try
        {
            if (client.State != CommunicationState.Faulted)
            {
                client.Close();
            }
        }
        catch
        {
            client.Abort();
        }
        return result;
    }
}

对于Expression<Func<TService, TReturn>> operation，我的理解是：请你告诉我，如果给你一段代码（TService），你如何给我一个改变了的世界（TReturn）。我不关心给你的是什么代码，也不关心改变后的世界是什么样子，我只关心你如何改变世界。

享受无止境，但真正让人成长与快乐的不是得到那个享受，而是这个追求享受的过程。现实世界如此，代码世界也是如此。

祝大家2012年在代码世界享受更多快乐！

参考文章：

Explaining Expression

本文链接

2011年的那个“一”

2011-12-30T00:28:00Z

一本书：《.NET软件架构之美 Microsoft .NET: Architecting Applications for the Enterprise》（链接）

一首歌：孙燕姿《追》（链接）

一部电影：《源代码 Sourec Code》（链接）

一个问题：ISAPI_Rewrite引起的IIS应用程序池崩溃(fatal communication error)（链接）

一个桌面：《欧洲城堡》（链接）

一行代码：

string.Join("','", userIDs); //List<Guid> userIDs

一句话：“你在找的根本不是「成功」，你在找的是「进步」。” （链接）

...

本文链接

让Entity Framework不再私闯sys.databases

2011-12-27T08:52:00Z

这里的“私闯sys.databases”是指Entity Framework默认发起的查询：SELECT Count(*) FROM sys.databases WHERE [name]=N'数据库名'

注：本文针对的是Entity Framework Code First场景，Entity Framework的版本是4.1与4.2。

3月份的时候在揭开Entity Framework LINQ查询的一点面纱一文中发现了Entity Framework的两个幕后交易。

第一个交易（私闯sys.databases）：

SELECT Count(*) FROM sys.databases WHERE [name] = N'CNBlogsData'

第二个交易（私自打探数据库的信息）：

SELECT TOP (1)
[Extent1].[Id] AS [Id],
[Extent1].[ModelHash] AS [ModelHash]
FROM [dbo].[EdmMetadata] AS [Extent1]
ORDER BY [Extent1].[Id] DESC

当时通过modelBuilder.Conventions.Remove<IncludeMetadataConvention>();阻止了第二个交易，但未能找到方法阻止第一个交易。

记得当时用的是Entity Framework 4.0，后来微软发布了EF4.1和EF4.2。那我们来看看Entity Framework有没有改邪归正。

结果发现，只改了一半，第二个交易“浪子回头”，而第一个交易“贼心不改”。

代码世界是完美世界，决不允许这样的行为，一定要将之绳之以法。

经过今天下午的努力，终于找到了这根“绳子”：

Database.SetInitializer<DbContextTypeName>(null);

示例代码如下：

public class EfUnitOfWork : DbContext, IUnitOfWork
{
    public EfUnitOfWork()
    {
        Database.SetInitializer<EfUnitOfWork>(null);
    }       

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {       
    }
}

可以看出，Entity Framework“私闯sys.databases”的目的是为了在根据实体生成数据库时，检查是否存在同名的数据库。

而我们的应用场景根本不需要Entity Framework生成数据库，所以将之绳之以法是“名正言顺”。

本文链接

C# string Array to int Array

2011-12-18T09:41:00Z

在C#中，目前发现的将“字符串型数组string[]”转换为“整型数组int[]”的最简单方法：

string[] ids = new string[5] { "5", "6", "7", "8", "9" };
int[] ids2 = Array.ConvertAll(ids, id => Convert.ToInt32(id));

使用的是Array的静态方法Array.ConvertAll<TInput, TOutput>。

本文链接

AutoMapper使用笔记

2011-12-16T06:34:00Z

AutoMapper是一个.NET的对象映射工具。

项目地址：https://github.com/AutoMapper/AutoMapper。

帮助文档：https://github.com/AutoMapper/AutoMapper/wiki

主要用途

领域对象与DTO之间的转换、数据库查询结果映射至实体对象。

使用笔记

场景1：源类型BlogEntry，目标类型BlogPostDto，指定属性进行映射（BlogEntry.ID对应于BlogPostDto.PostId）。

代码：

AutoMapper.Mapper.CreateMap<BlogEntry, BlogPostDto>()
                .ForMember(dto => dto.PostId, opt => opt.MapFrom(entity => entity.ID));

场景2：IDataReader映射至实体类

代码：

using (IDataReader reader = _db.ExecuteReader(command))
{
    if (reader.Read())
    {
        return AutoMapper.Mapper.DynamicMap<BlogConfig>(reader);
    }
}

场景3：列表类型之间的映射，比如：源类型List<BlogSite>，目标类型List<BlogSiteDto>

代码如下：

AutoMapper.Mapper.CreateMap<BlogSite, BlogSiteDto>();
var blogSiteDto = AutoMapper.Mapper.Map<List<BlogSite>, List<BlogSiteDto>>(blogSite);

注：必须要先通过CreateMap建立BlogSite与BlogSiteDto的映射关系。

场景4：在映射时为目标实例的属性指定值

代码如下：

var blogSiteDto = new BlogSiteDto();
AutoMapper.Mapper.CreateMap<BlogEntry, BlogPostDto>()
                .ForMember(dto => dto.BlogSiteDto, opt => opt.UseValue(blogSiteDto));

注：BlogSiteDto是BlogPostDto的一个属性。

补充：

AutoMapper的配置（比如AutoMapper.Mapper.CreateMap<BlogSite, BlogSiteDto>();）建议放在程序启动时，比如Global.asax的Application_Start, BootStrapper。

本文链接

遭遇IE8下的JavaScript兼容问题

2011-12-14T08:40:00Z

博客园闪存分页是用JavaScript生成的，今天发现在IE8下点击页码不能翻页，翻页操作是在当前页码的onclick事件中进行的。

开始代码是这么写的：

var a = document.createElement("a");
a.setAttribute("onclick", this.ClickFunctionName + "(" + pageIndex + ");Pager.SetCurrent(" + pageIndex + ");");

由于IE8不支持setAttribute方法，这里添加的onclick事件处理程序并未添加上。

后来改为jQuery的attr方法：

$(a).attr("onclick", this.ClickFunctionName + "(" + pageIndex + ");Pager.SetCurrent(" + pageIndex + ");");

这样虽然添加上去了，但不管怎么点击，onclick事件处理程序就是不执行，Chrome与Firefox都没这个问题。

最终通过下面的代码解决了问题：

var js = this.ClickFunctionName + "(" + pageIndex + ");Pager.SetCurrent(" + pageIndex + ");";
a.onclick = function() { eval(js); }

本文链接