博客园_Gildor Wang

我的WCF4 REST Service及Entity Framework with POCO之旅（五）——身份验证

2011-08-21T17:15:00Z

本文将通过对2-legged OAuth的简单实现，说明如何在WCF REST Service中实现自定义的身份验证。提到验证，最显而易见的做法当然是在每个服务方法开头调用一个检查权限的方法。但这种做法显然太不好看了，如果可以在每个方法上面用一个attribute标明哪些用户(组)可以访问，那就太好了。这就是本文要介绍的AuthorizationManager方案。

首先简单提一下OAuth.

OAuth

我们一般认为OAuth的用途就是给第三方应用/网站授权，比如我有twitter账号，我授权给yfrog读/写我的twitter，通过使用OAuth，在这个授权过程中，yfrog始终不会接触到我的密码，同时，如果我改了密码，它的访问也不会受到影响，如果我要停止向它授权，只需要在twitter设置中撤销访问权就行，安全，简单。然而这其实是OAuth的一个特定版本，叫做3-legged OAuth。OAuth还有一个版本叫做2-legged OAuth，是专门用于传统的单一客户端+服务器场景的。

容易产生的疑问是，OAuth会不会太复杂？我只需要非常简单的身份验证而已，为什么要用这么麻烦的东西？其实OAuth, 尤其是2-legged Auth非常简单，而且如果你自己实现一个身份验证，当你把它实现完善时，你就会发现自己做了一个和OAuth一模一样的东西出来了，比如这个哥们，他非常兴奋地声明自己发明了一种不用OAuth的身份验证，结果人家在评论里直接指出他写的就是2-legged OAuth。

由于2-legged OAuth有一个初始条件是服务器和客户端已经获得了同样的Key/Secret对，也就是说身份验证的第一步是从服务器获得一个特定于用户的Secret Token。这个过程必须在安全的通道(如https)上完成，一般也就是一个简单的login就行了。本文为了简单起见，假定secret已经获得，而Key则是用户名。

AuthorizationManger方案

要在服务方法调用之前验证身份，就得截获请求。之前看的很多实现方法都使用了WCF 3.5 REST WCF Starter Kit中的RequestInterceptor，但是在WCF 4.0中找不到了（只有在Data Services中还有QueryInterceptor)。所以必须找到另一个地方，在调用实际的服务方法之前完成身份验证。这样一个地方就是AuthorizationManager. 添加一个继承自ServiceAuthorizationManager的类：

public class AuthorizationManager : ServiceAuthorizationManager
{
protected override bool CheckAccessCore(OperationContext operationContext)
{
}
}

这里的CheckAccessCore方法，就是我们要进行身份验证的地方，通过OperationContext参数，我们可以取到Request的URI以及Header。简单起见，先看OAuth的参数由Authorization header提供的情况。

以下是一个来自OAuth Spec的请求的例子，此处OAuth Consumer Key是dpf43f3p2l4k3l03，Consumer Secret是kd94hf93k423kf44。

http://provider.example.net/profile

Authorization: OAuth realm="http://provider.example.net/",
oauth_consumer_key="dpf43f3p2l4k3l03",
oauth_signature_method="HMAC-SHA1",
oauth_signature="IxyYZfG2BaKh8JyEGuHCOin%2F4bA%3D",
oauth_timestamp="1191242096",
oauth_token="",
oauth_nonce="kllo9940pd9333jh",
oauth_version="1.0"

服务端要做的，就是用OAuth的签名计算方法，把这个请求的签名计算出来，与上面的oauth_signature进行比较，如果符合，则身份验证通过。

首先我们将Authorization头解析为键值对。

var authParamString = operationContext.GetHttpHeader(AuthHeaderName);
if(authParamString == null || !authParamString.StartsWith(OAuthPrefix))
{
SetAnonymousContext(operationContext.RequestContext.RequestMessage);
return true;
}
var authParams = authParamString.Substring(OAuthPrefix.Length).Split(',')
.Select(p => p.Split('=')).ToDictionary(p => p[0], p => p[1].Trim('"'));

然后和method以及URI，当然还有密码的散列一起计算签名，并将计算得到的结果与客户端提交的进行比较：

简单起见，这里的GetSignature直接使用了HMAC-SHA1的签名算法，而没有按照客户端的指定：

private string GetSignature(string baseString, string key)
{
var hmac = new HMACSHA1(Encoding.UTF8.GetBytes(GetAuthSecret(key) + "&"));
return Convert.ToBase64String(hmac.ComputeHash(Encoding.UTF8.GetBytes(baseString)));
}

GetAuthScrect方法根据用户名(key)取出用户密码散列(secret)。值得注意的是，按照OAuth的标准，后面要加上一个”&”再参与计算。

SetSecurityContext方法设置当前的安全环境：

private static void SetSecurityContext(Message request, string username)
{
var policies = new List<IAuthorizationPolicy>
{ new AuthorizationPolicy(new GenericIdentity(username)) };
var securityContext = new ServiceSecurityContext(policies.AsReadOnly());

if(request.Properties.Security != null)
{
request.Properties.Security.ServiceSecurityContext = securityContext;
}
else
{
request.Properties.Security =
new SecurityMessageProperty { ServiceSecurityContext = securityContext };
}
}

这里用到了一个名为AuthorizationPolicy的类，它非常简单，只是对IAuthorizationPolicy的基本实现而已。

internal class AuthorizationPolicy : IAuthorizationPolicy
{
private readonly Guid _id = Guid.NewGuid();

private readonly IIdentity _identity;

public AuthorizationPolicy(IIdentity identity)
{
if(identity == null)
{
throw new ArgumentNullException("identity");
}
_identity = identity;
}

#region IAuthorizationPolicy Members

// this method gets called after the authentication stage
/// <summary>
/// Evaluates whether a user meets the requirements for this authorization policy.
/// </summary>
/// <param name="evaluationContext">An <see cref="T:System.IdentityModel.Policy.EvaluationContext"/> that contains the claim set that the authorization policy evaluates.</param>
/// <param name="state">A <see cref="T:System.Object"/>, passed by reference that represents the custom state for this authorization policy.</param>
/// <returns>
/// false if the <see cref="M:System.IdentityModel.Policy.IAuthorizationPolicy.Evaluate(System.IdentityModel.Policy.EvaluationContext,System.Object@)"/> method for this authorization policy must be called if additional claims are added by other authorization policies to <paramref name="evaluationContext"/>; otherwise, true to state no additional evaluation is required by this authorization policy.
/// </returns>
public bool Evaluate(EvaluationContext evaluationContext, ref object state)
{
// get the authenticated client identity
var client = _identity; //GetClientIdentity(evaluationContext);
// set the custom principal
evaluationContext.Properties["Principal"] = new CustomPrincipal(client);
HttpContext.Current.User = new CustomPrincipal(_identity);
return true;
}

public ClaimSet Issuer
{
get { return ClaimSet.System; }
}

public string Id
{
get { return _id.ToString(); }
}

#endregion
}

而CustomPrincipal则是IPrincipal的基本实现。

internal class CustomPrincipal : IPrincipal
{
private readonly IIdentity _identity;

public CustomPrincipal(IIdentity identity)
{
_identity = identity;
}

/// <summary>
/// Gets the <see cref="CustomPrincipal"/> instance for the current user.
/// It's a helper method for easy access (without casting).
/// </summary>
public static CustomPrincipal Current
{
get { return Thread.CurrentPrincipal as CustomPrincipal; }
}

public string[] Roles
{
get { return System.Web.Security.Roles.GetRolesForUser(_identity.Name); }
}

#region IPrincipal Members

public IIdentity Identity
{
get { return _identity; }
}

public bool IsInRole(string role)
{
return Roles.Contains(role);
}

#endregion
}

修改web.config

要让AuthorizationManager嵌入WCF Service工作，还需最后一步，修改web.config，在<system.serviceModel>节中添加如下内容：

这里我们定义了一个serviceBehavior来使用自定义的AuthorizationManager，然后指定MicroblogService使用这个behavior. 此处<serviceDebug includeExceptionDetailInFaults="true"/>是可选的，只是为了在出错时可以看到详细的错误信息。

定义访问策略

好了，框架都已经搭好了，现在就可以开始定义访问策略了。方法非常简单，只需要在服务方法上面加上PrincipalPermission attribute就可以了。策略的对象可以是User，也可以是Role。

比如，要限制仅允许开头示例请求中的用户”dpf43f3p2l4k3l03”获取微博列表，则可以修改GetCollection方法：

[WebGet(UriTemplate = "")]
[PrincipalPermission(SecurityAction.Demand, Name = "dpf43f3p2l4k3l03")]
public List<Microblog> GetCollection()
{
...

改好之后，直接运行一下试试：

如果把includeExceptionDetailInFaults关掉，则显示：

用Fiddler2可以看到这时返回的是一个400 Bad Request。这个效果并不好，因为这时应该返回401 Unauthorized，以后会解决这个问题。至少阻止匿名用户访问的目的是达到了。

接下来，在Fiddler2中制造一个请求，提供完整的Authorization头。由于Host URI变了，所以签名也和开头示例中的有所不同：

可以看到，请求通过了身份验证，成功获取了数据。

小结

本文介绍了：

如何使用AuthorizationManager来截获请求并完成基于OAuth的身份验证

不足之处

容易看出，本文的实现还很不完善：

设置访问策略时，尚不能使用Role。Role其实是由CustomPrincipal的IsInRole方法来提供的，现在的实现是直接调用System.Web.Security.Roles，那就需要配置RoleProvider。比较简单的做法是直接使用ASP.NET Membership那一整套东西。当然也可以直接在CustomPrincipal中实现自定义的Role逻辑。
简单起见，我对OAuth的实现很基本，存在很多问题
- 不支持在URI或者Form body中提供OAuth参数
- 不支持HMAC-SHA1以外的签名算法
- 没有检查timestamp参数和服务器时间的差距
- 没有检查nonce参数的唯一性
- 没有检查realm参数（可选的）
此外，身份验证失败的返回信息并不规范，这个将在后面解决。

毕竟，我只是想要演示如何在WCF目前的框架范围内实现这一过程，实际生产应用的话，还是推荐使用成熟的library.

我将在下一篇中完善Microblog服务的身份验证功能，为其添加一个简单的用户模块。

本文代码

参考：

我的WCF4 REST Service及Entity Framework with POCO之旅系列

本文链接

我的WCF4 Rest Service及Entity Framework with POCO之旅——写在中间

2011-08-10T11:54:00Z

距离我写这个系列的上一篇文章已经过去了3个多月，这期间我自己发生了很多变化，技术圈甚至单单是WCF领域更是往前走了一大步。上个月我听了一个关于WCF Web API的talk，发现我之前用各种方法拐着弯才能做到的事情，他们都原生实现了，当然许多解决方案要比我所探索的更加优美、易用。事实上自从前一篇文章发布以来，我都没有再写关于WCF的代码，也没有去关注它的发展情况，因此听到关于WCF Web API的介绍的时候我多少有一点惊讶，感觉自己似乎像落后了几年一样——事实上这不过是短短的几个月时间而已。当然，另一方面，由于他们的许多成果中包括了我之前做过的事情，我也感到非常高兴，因为这证明了我自己的探索思路是正确的，符合大多数开发者的需求。至于WCF新的框架到底有多大改变，它现在已经发布到Preview 4了，不妨拿下来玩一下。我自己也还没有试过，不知道他们在talk中提及的那些特性，是否都已经实现了。

因此，对于我之前打过的一些草稿，我感到很犹豫，如果新的框架发布，那么我所介绍的很多东西就没有意义了。而且很多问题，园子里的高人们也讨论得很细致了。然而新框架毕竟还未发布，发布后也未必所有人都能够在实际环境中用上，而谈技术的文章是不嫌多的。所以还是把原定计划中的剩下几篇文章发上来，争取每周一篇，希望能够对用得上的人有所帮助，也对自己有个交代。

Agenda:

我的WCF4 Rest Service及Entity Framework with POCO之旅（五）——身份验证&OAuth
我的WCF4 Rest Service及Entity Framework with POCO之旅（六）——错误处理
我的WCF4 Rest Service及Entity Framework with POCO之旅（七）——参数检查
我的WCF4 Rest Service及Entity Framework with POCO之旅（八）——自定义QueryStringConverter
我的WCF4 Rest Service及Entity Framework with POCO之旅（九）——按需返回部分Entity字段
我的WCF4 Rest Service及Entity Framework with POCO之旅（十）——测试？
我的WCF4 Rest Service及Entity Framework with POCO之旅（十一）——其他几个小问题

本文链接

导出/导入Visual Studio 2010扩展

2011-08-10T11:09:00Z

Visual Studio 2010的extensions不会像Android上的app那样，通过“云推送”安装到你的每台计算机上，甚至也没有像configuration那样提供一个导出/导入的功能。每次部署开发环境，重新安装扩展是一件费时费神的工作。事实上，绝大多数在Extension Manager中安装的扩展都在

%localappdata%\microsoft\VisualStudio\10.0\Extensions下面。只要将这个文件夹中的内容备份/还原，就可以在Visual Studio的Extension Manager中看到原来的扩展了，而且Visual Studio也会检查这些扩展的更新情况并且提示更新，就好像这些扩展一开始就装在那里一样。只不过，当这些扩展刚还原时，VS默认会Disable它们，必须手动逐个Enable才行。这我还没有发现比较好的解决办法，应该有个地方设置了每个扩展的启用情况，如果有哪位知道不妨告知。

本文链接

我的WCF4 Rest Service及Entity Framework with POCO之旅（四）——定制Entity

2011-04-20T02:44:00Z

本文将focus几个结合使用WCF REST和Entity Framework with POCO的常见问题。

Entity Type和Property名称的大小写

按照RESTful的习惯，XML或者JSON格式的数据的node名称开头字母一般使用小写，比如，下面是一段Google Buzz API的RESTful返回信息：

<entry xmlns="http://www.w3.org/2005/Atom" xmlns:activity="http://activitystrea.ms/spec/1.0">
<id>tag:google.com,2010:buzz:z12puk22ajfyzsz</id>
<author>
<name>Ted Taco</name>
<uri>http://www.google.com/profiles/ted</uri>
</author>
<published>2010-04-23T11:03:34.342Z</published>
<updated>2010-04-23T11:03:34.342Z</updated>
<activity:object>
<activity:object-type>http://activitystrea.ms/schema/1.0/note</activity:object-type>
<content type="html">Hey, this is my first Buzz Post!</content>
<activity:object>
<link rel="alternate" type="text/html" href="http://www.google.com/buzz/ted/Hey-this-is-my-first-Buzz-Post" />

</entry>

要让我们的Service返回数据node也使用小写字母开头，我们需要给Entity加上[DataContract]和[DataMember] attributes。（当然也可以修改WCF的behavior让它使用我们提供的的serializer但是现在框架既然还能满足需求，我还不想那么做。）
手动加attribute显然不是一个好主意，而且可以想见一旦模型代码重新生成，我们的修改就都没了。我们需要修改生成Entity的T4模板(Model.tt和Model.Context.tt)。
T4模板和其他的一些代码生成器的模板很相似，和现在的ASP.NET也有点相似。主要特点就是在模板内容（对于模板来说类似于纯文本）中嵌入C#代码。
由于T4模板的可读性不是很好，而VS原生又不支持T4的高亮和intellisense，开始编辑之前，最好装一个支持T4高亮的插件。我用的是Visual T4，虽然反应比较慢还有一些bug，不过是免费的，基本也够用了。

我们先看一下现在的Model.tt的全貌：

<#@ template language="C#" debug="false" hostspecific="true"#>
<#@ include file="EF.Utility.CS.ttinclude"#><#@
output extension=".cs"#><#

CodeGenerationTools code = new CodeGenerationTools(this);
MetadataLoader loader = new MetadataLoader(this);
CodeRegion region = new CodeRegion(this, 1);
MetadataTools ef = new MetadataTools(this);

string inputFile = @"WcfRestServiceDemo.edmx";
EdmItemCollection ItemCollection = loader.CreateEdmItemCollection(inputFile);
string namespaceName = code.VsNamespaceSuggestion();

EntityFrameworkTemplateFileManager fileManager = EntityFrameworkTemplateFileManager.Create(this);

// Write out support code to primary template output file
WriteHeader(fileManager);
BeginNamespace(namespaceName, code);
WriteCustomObservableCollection();
EndNamespace(namespaceName);

// Emit Entity Types
foreach (EntityType entity in ItemCollection.GetItems<EntityType>().OrderBy(e => e.Name))
{
fileManager.StartNewFile(entity.Name + ".cs");
BeginNamespace(namespaceName, code);
bool entityHasNullableFKs = entity.NavigationProperties.Any(np => np.GetDependentProperties().Any(p=>ef.IsNullable(p)));
#>
<#=Accessibility.ForType(entity)#> <#=code.SpaceAfter(code.AbstractOption(entity))#>partial class <#=code.Escape(entity)#><#=code.StringBefore(" : ", code.Escape(entity.BaseType))#>
{
<#
region.Begin("Primitive Properties");

foreach (EdmProperty edmProperty in entity.Properties.Where(p => p.TypeUsage.EdmType is PrimitiveType && p.DeclaringType == entity))
{
bool isForeignKey = entity.NavigationProperties.Any(np=>np.GetDependentProperties().Contains(edmProperty));
bool isDefaultValueDefinedInModel = (edmProperty.DefaultValue != null);
bool generateAutomaticProperty = false;

#>

<#=PropertyVirtualModifier(Accessibility.ForProperty(edmProperty))#> <#=code.Escape(edmProperty.TypeUsage)#> <#=code.Escape(edmProperty)#>
{
<#
if (isForeignKey)
{
#>
<#=code.SpaceAfter(Accessibility.ForGetter(edmProperty))#>get { return <#=code.FieldName(edmProperty)#>; }
<#=code.SpaceAfter(Accessibility.ForSetter(edmProperty))#>set
{
<#
if (entityHasNullableFKs)
{
#>
try
{
_settingFK = true;
<#
PushIndent(CodeRegion.GetIndent(1));
}
if (((PrimitiveType)edmProperty.TypeUsage.EdmType).PrimitiveTypeKind == PrimitiveTypeKind.Binary)
{
#>
if (!StructuralComparisons.StructuralEqualityComparer.Equals(<#=code.FieldName(edmProperty)#>, value))
<#
}
else
{
#>
if (<#=code.FieldName(edmProperty)#> != value)
<#
}
#>
{
<#
foreach (var np in entity.NavigationProperties.Where(np=>np.GetDependentProperties().Contains(edmProperty)))
{
EdmProperty principalProperty = ef.GetCorrespondingPrincipalProperty(np, edmProperty);
if (((PrimitiveType)principalProperty.TypeUsage.EdmType).PrimitiveTypeKind == PrimitiveTypeKind.Binary)
{
#>
if ((<#=code.Escape(np)#> != null) && !StructuralComparisons.StructuralEqualityComparer.Equals(<#=code.Escape(np)#>.<#=code.Escape(principalProperty)#>, value))
<#
}
else
{
#>
if (<#=code.Escape(np)#> != null && <#=code.Escape(np)#>.<#=code.Escape(principalProperty)#> != value)
<#
}
#>
{
<#
if (!(np.GetDependentProperties().Where(p=>ef.IsNullable(p)).Any() &&
np.GetDependentProperties().Count() > 1))
{
#>
<#=code.Escape(np)#> = null;
<#
}
else
{
#>
var previousValue = <#=code.FieldName(np)#>;
<#=code.FieldName(np)#> = null;
Fixup<#=np.Name#>(previousValue, skipKeys: true);
<#
}
#>
}
<#
}
#>
<#=code.FieldName(edmProperty)#> = value;
}
<#
if (entityHasNullableFKs)
{
PopIndent();
#>
}
finally
{
_settingFK = false;
}
<#
}
#>
}
<#
}
else if (isDefaultValueDefinedInModel)
{
#>
<#=code.SpaceAfter(Accessibility.ForGetter(edmProperty))#>get { return <#=code.FieldName(edmProperty)#>; }
<#=code.SpaceAfter(Accessibility.ForSetter(edmProperty))#>set { <#=code.FieldName(edmProperty)#> = value; }
<#
}
else
{
generateAutomaticProperty = true;
#>
<#=code.SpaceAfter(Accessibility.ForGetter(edmProperty))#>get;
<#=code.SpaceAfter(Accessibility.ForSetter(edmProperty))#>set;
<#
}
#>
}
<#
if (!generateAutomaticProperty)
{
#>
private <#=code.Escape(edmProperty.TypeUsage)#> <#=code.FieldName(edmProperty)#><#=code.StringBefore(" = ", code.CreateLiteral(edmProperty.DefaultValue))#>;
<#
}
}
region.End();

region.Begin("Complex Properties");

foreach(EdmProperty edmProperty in entity.Properties.Where(p => p.TypeUsage.EdmType is ComplexType && p.DeclaringType == entity))
{
#>

<#=PropertyVirtualModifier(Accessibility.ForProperty(edmProperty))#> <#=code.Escape(edmProperty.TypeUsage)#> <#=code.Escape(edmProperty)#>
{
<#=code.SpaceAfter(Accessibility.ForGetter(edmProperty))#>get { return <#=code.FieldName(edmProperty)#>; }
<#=code.SpaceAfter(Accessibility.ForSetter(edmProperty))#>set { <#=code.FieldName(edmProperty)#> = value; }
}
private <#=code.Escape(edmProperty.TypeUsage)#> <#=code.FieldName(edmProperty)#> = new <#=code.Escape(edmProperty.TypeUsage)#>();
<#
}

region.End();

////////
//////// Write Navigation properties -------------------------------------------------------------------------------------------
////////

region.Begin("Navigation Properties");

foreach (NavigationProperty navProperty in entity.NavigationProperties.Where(np => np.DeclaringType == entity))
{
NavigationProperty inverse = ef.Inverse(navProperty);
if (inverse != null && !IsReadWriteAccessibleProperty(inverse))
{
inverse = null;
}
#>

<#
if (navProperty.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many)
{
#>
<#=PropertyVirtualModifier(Accessibility.ForReadOnlyProperty(navProperty))#> ICollection<<#=code.Escape(navProperty.ToEndMember.GetEntityType())#>> <#=code.Escape(navProperty)#>
{
get
{
if (<#=code.FieldName(navProperty)#> == null)
{
<#
if (inverse != null || ((AssociationType)navProperty.RelationshipType).IsForeignKey)
{
#>
var newCollection = new FixupCollection<<#=code.Escape(navProperty.ToEndMember.GetEntityType())#>>();
newCollection.CollectionChanged += Fixup<#=navProperty.Name#>;
<#=code.FieldName(navProperty)#> = newCollection;
<#
}
else
{
#>
<#=code.FieldName(navProperty)#> = new FixupCollection<<#=code.Escape(navProperty.ToEndMember.GetEntityType())#>>();
<#
}
#>
}
return <#=code.FieldName(navProperty)#>;
}
set
{
<#
if (inverse != null || ((AssociationType)navProperty.RelationshipType).IsForeignKey)
{
#>
if (!ReferenceEquals(<#=code.FieldName(navProperty)#>, value))
{
var previousValue = <#=code.FieldName(navProperty)#> as FixupCollection<<#=code.Escape(navProperty.ToEndMember.GetEntityType())#>>;
if (previousValue != null)
{
previousValue.CollectionChanged -= Fixup<#=navProperty.Name#>;
}
<#=code.FieldName(navProperty)#> = value;
var newValue = value as FixupCollection<<#=code.Escape(navProperty.ToEndMember.GetEntityType())#>>;
if (newValue != null)
{
newValue.CollectionChanged += Fixup<#=navProperty.Name#>;
}
}
<#
}
else
{
#>
<#=code.FieldName(navProperty)#> = value;
<#
}
#>
}
}
private ICollection<<#=code.Escape(navProperty.ToEndMember.GetEntityType())#>> <#=code.FieldName(navProperty)#>;
<#
}
else
{
#>
<#=PropertyVirtualModifier(Accessibility.ForProperty(navProperty))#> <#=code.Escape(navProperty.ToEndMember.GetEntityType())#> <#=code.Escape(navProperty)#>
{
<#
if (inverse != null || ((AssociationType)navProperty.RelationshipType).IsForeignKey)
{
#>
<#=code.SpaceAfter(Accessibility.ForGetter(navProperty))#>get { return <#=code.FieldName(navProperty)#>; }
<#=code.SpaceAfter(Accessibility.ForSetter(navProperty))#>set
{
if (!ReferenceEquals(<#=code.FieldName(navProperty)#>, value))
{
var previousValue = <#=code.FieldName(navProperty)#>;
<#=code.FieldName(navProperty)#> = value;
Fixup<#=navProperty.Name#>(previousValue);
}
}
}
private <#=code.Escape(navProperty.ToEndMember.GetEntityType())#> <#=code.FieldName(navProperty)#>;
<#
}
else
{
#>
<#=code.SpaceAfter(Accessibility.ForGetter(navProperty))#>get;
<#=code.SpaceAfter(Accessibility.ForSetter(navProperty))#>set;
}
<#
}
}
}
region.End();

region.Begin("Association Fixup");

if (entityHasNullableFKs)
{
#>

private bool _settingFK = false;
<#
}
foreach (NavigationProperty navProperty in entity.NavigationProperties.Where(np => np.DeclaringType == entity))
{
NavigationProperty inverse = ef.Inverse(navProperty);

if (inverse != null && !IsReadWriteAccessibleProperty(inverse))
{
inverse = null;
}

if ( (inverse != null || ((AssociationType)navProperty.RelationshipType).IsForeignKey) &&
(navProperty.ToEndMember.RelationshipMultiplicity != RelationshipMultiplicity.Many) )
{
var skipKeysArgument = (navProperty.GetDependentProperties().Where(p=>ef.IsNullable(p)).Any() && navProperty.GetDependentProperties().Count() > 1)
? ", bool skipKeys = false"
: String.Empty;
#>

private void Fixup<#=navProperty.Name#>(<#=code.Escape(navProperty.ToEndMember.GetEntityType())#> previousValue<#= skipKeysArgument #>)
{
<#
if (inverse != null)
{
if (inverse.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many)
{
#>
if (previousValue != null && previousValue.<#=code.Escape(inverse)#>.Contains(this))
{
previousValue.<#=code.Escape(inverse)#>.Remove(this);
}
<#
}
else
{
#>
if (previousValue != null && ReferenceEquals(previousValue.<#=code.Escape(inverse)#>, this))
{
previousValue.<#=code.Escape(inverse)#> = null;
}
<#
}

if (inverse.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many)
{
#>

if (<#=code.Escape(navProperty)#> != null)
{
if (!<#=code.Escape(navProperty)#>.<#=code.Escape(inverse)#>.Contains(this))
{
<#=code.Escape(navProperty)#>.<#=code.Escape(inverse)#>.Add(this);
}
<#
foreach (var dependentProperty in navProperty.GetDependentProperties())
{
EdmProperty principalProperty = ef.GetCorrespondingPrincipalProperty(navProperty, dependentProperty);
if (((PrimitiveType)principalProperty.TypeUsage.EdmType).PrimitiveTypeKind == PrimitiveTypeKind.Binary)
{
#>
if (!StructuralComparisons.StructuralEqualityComparer.Equals(<#=code.Escape(dependentProperty)#>, <#=code.Escape(navProperty)#>.<#=code.Escape(principalProperty)#>))
<#
}
else
{
#>
if (<#=code.Escape(dependentProperty)#> != <#=code.Escape(navProperty)#>.<#=code.Escape(principalProperty)#>)
<#
}
#>
{
<#=code.Escape(dependentProperty)#> = <#=code.Escape(navProperty)#>.<#=code.Escape(principalProperty)#>;
}
<#
}
#>
}
<#
if (navProperty.GetDependentProperties().Where(p=>ef.IsNullable(p)).Any())
{
if (navProperty.GetDependentProperties().Count() > 1)
{
#>
else if (!_settingFK && !skipKeys)
<#
}
else
{
#>
else if (!_settingFK)
<#
}
#>
{
<#
foreach (var dependentProperty in navProperty.GetDependentProperties().Where(p => ef.IsNullable(p)))
{
#>
<#=code.Escape(dependentProperty)#> = null;
<#
}
#>
}
<#
}
}
else
{
#>

if (<#=code.Escape(navProperty)#> != null)
{
<#=code.Escape(navProperty)#>.<#=code.Escape(inverse)#> = this;
<#
foreach (var dependentProperty in navProperty.GetDependentProperties())
{
EdmProperty principalProperty = ef.GetCorrespondingPrincipalProperty(navProperty, dependentProperty);
if (((PrimitiveType)principalProperty.TypeUsage.EdmType).PrimitiveTypeKind == PrimitiveTypeKind.Binary)
{
#>
if (!StructuralComparisons.StructuralEqualityComparer.Equals(<#=code.Escape(dependentProperty)#>, <#=code.Escape(navProperty)#>.<#=code.Escape(principalProperty)#>))
<#
}
else
{
#>
if (<#=code.Escape(dependentProperty)#> != <#=code.Escape(navProperty)#>.<#=code.Escape(principalProperty)#>)
<#
}
#>
{
<#=code.Escape(dependentProperty)#> = <#=code.Escape(navProperty)#>.<#=code.Escape(principalProperty)#>;
}
<#
}
#>
}
<#
}
}
else
{
if (navProperty.GetDependentProperties().Any())
{
#>
if (<#=code.Escape(navProperty)#> != null)
{
<#
foreach (var dependentProperty in navProperty.GetDependentProperties())
{
EdmProperty principalProperty = ef.GetCorrespondingPrincipalProperty(navProperty, dependentProperty);
if (((PrimitiveType)principalProperty.TypeUsage.EdmType).PrimitiveTypeKind == PrimitiveTypeKind.Binary)
{
#>
if (!StructuralComparisons.StructuralEqualityComparer.Equals(<#=code.Escape(dependentProperty)#>, <#=code.Escape(navProperty)#>.<#=code.Escape(principalProperty)#>))
<#
}
else
{
#>
if (<#=code.Escape(dependentProperty)#> != <#=code.Escape(navProperty)#>.<#=code.Escape(principalProperty)#>)
<#
}
#>
{
<#=code.Escape(dependentProperty)#> = <#=code.Escape(navProperty)#>.<#=code.Escape(principalProperty)#>;
}
<#
}
#>
}
<#
if (navProperty.GetDependentProperties().Where(p => ef.IsNullable(p)).Any())
{
if (navProperty.GetDependentProperties().Count() > 1)
{
#>
else if (!_settingFK && !skipKeys)
<#
}
else
{
#>
else if (!_settingFK)
<#
}
#>
{
<#
foreach (var dependentProperty in navProperty.GetDependentProperties().Where(p => ef.IsNullable(p)))
{
#>
<#=code.Escape(dependentProperty)#> = null;
<#
}
#>
}
<#
}
}
else if (((AssociationType)navProperty.RelationshipType).IsForeignKey)
{
#>
if (<#=code.Escape(navProperty)#> != null)
{
<#
foreach (var fromProperty in ef.GetPrincipalProperties(navProperty))
{
#>
<#=code.Escape(navProperty)#>.<#=code.Escape(ef.GetCorrespondingDependentProperty(navProperty, fromProperty))#> = <#=code.Escape(fromProperty)#>;
<#
}
#>
}
<#
}
}
#>
}
<#
}
}

foreach (NavigationProperty navProperty in entity.NavigationProperties.Where(np => np.DeclaringType == entity))
{
NavigationProperty inverse = ef.Inverse(navProperty);

if (inverse != null && !IsReadWriteAccessibleProperty(inverse))
{
inverse = null;
}

if ( (inverse != null || ((AssociationType)navProperty.RelationshipType).IsForeignKey) &&
(navProperty.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many) )
{
#>

private void Fixup<#=navProperty.Name#>(object sender, NotifyCollectionChangedEventArgs e)
{
if (e.NewItems != null)
{
foreach (<#=code.Escape(navProperty.ToEndMember.GetEntityType())#> item in e.NewItems)
{
<#
if (inverse != null)
{
if (inverse.ToEndMember.RelationshipMultiplicity != RelationshipMultiplicity.Many)
{
#>
item.<#=code.Escape(inverse)#> = this;
<#
}
else
{
#>
if (!item.<#=code.Escape(inverse)#>.Contains(this))
{
item.<#=code.Escape(inverse)#>.Add(this);
}
<#
}
}
else if (((AssociationType)navProperty.RelationshipType).IsForeignKey)
{
foreach (var fromProperty in ef.GetPrincipalProperties(navProperty))
{
#>
item.<#=code.Escape(ef.GetCorrespondingDependentProperty(navProperty, fromProperty))#> = <#=code.Escape(fromProperty)#>;
<#
}
}
#>
}
}

if (e.OldItems != null)
{
foreach (<#=code.Escape(navProperty.ToEndMember.GetEntityType())#> item in e.OldItems)
{
<#
if (inverse != null)
{
if (inverse.ToEndMember.RelationshipMultiplicity != RelationshipMultiplicity.Many)
{
#>
if (ReferenceEquals(item.<#=code.Escape(inverse)#>, this))
{
item.<#=code.Escape(inverse)#> = null;
}
<#
}
else
{
#>
if (item.<#=code.Escape(inverse)#>.Contains(this))
{
item.<#=code.Escape(inverse)#>.Remove(this);
}
<#
}
}
else if (((AssociationType)navProperty.RelationshipType).IsForeignKey)
{
foreach (var fromProperty in ef.GetPrincipalProperties(navProperty))
{
var p = ef.GetCorrespondingDependentProperty(navProperty, fromProperty);
if (ef.IsNullable(p.TypeUsage))
{
#>
item.<#=code.Escape(p)#> = null;
<#
}
}
}
;#>
}
}
}
<#
}
}

region.End();
#>
}
<#
EndNamespace(namespaceName);
}

foreach (ComplexType complex in ItemCollection.GetItems<ComplexType>().OrderBy(e => e.Name))
{
fileManager.StartNewFile(complex.Name + ".cs");
BeginNamespace(namespaceName, code);
#>
<#=Accessibility.ForType(complex)#> partial class <#=code.Escape(complex)#>
{
<#
region.Begin("Primitive Properties");

foreach(EdmProperty edmProperty in complex.Properties.Where(p => p.TypeUsage.EdmType is PrimitiveType && p.DeclaringType == complex))
{
bool isDefaultValueDefinedInModel = (edmProperty.DefaultValue != null);
#>

<#=Accessibility.ForProperty(edmProperty)#> <#=code.Escape(edmProperty.TypeUsage)#> <#=code.Escape(edmProperty)#>
<#
if (isDefaultValueDefinedInModel)
{
#>
{
<#=code.SpaceAfter(Accessibility.ForGetter(edmProperty))#>get { return <#=code.FieldName(edmProperty)#>; }
<#=code.SpaceAfter(Accessibility.ForSetter(edmProperty))#>set { <#=code.FieldName(edmProperty)#> = value; }
}
private <#=code.Escape(edmProperty.TypeUsage)#> <#=code.FieldName(edmProperty)#><#=code.StringBefore(" = ", code.CreateLiteral(edmProperty.DefaultValue))#>;
<#
}
else
{
#>
{
<#=code.SpaceAfter(Accessibility.ForGetter(edmProperty))#>get;
<#=code.SpaceAfter(Accessibility.ForSetter(edmProperty))#>set;
}
<#
}
}

region.End();

region.Begin("Complex Properties");

foreach(EdmProperty edmProperty in complex.Properties.Where(p => p.TypeUsage.EdmType is ComplexType && p.DeclaringType == complex))
{
#>

<#=Accessibility.ForProperty(edmProperty)#> <#=code.Escape(edmProperty.TypeUsage)#> <#=code.Escape(edmProperty)#>
{
<#=code.SpaceAfter(Accessibility.ForGetter(edmProperty))#>get { return <#=code.FieldName(edmProperty)#>; }
<#=code.SpaceAfter(Accessibility.ForSetter(edmProperty))#>set { <#=code.FieldName(edmProperty)#> = value; }
}
private <#=code.Escape(edmProperty.TypeUsage)#> <#=code.FieldName(edmProperty)#> = new <#=code.Escape(edmProperty.TypeUsage)#>();
<#
}

region.End();
#>
}
<#
EndNamespace(namespaceName);
}

if (!VerifyTypesAreCaseInsensitiveUnique(ItemCollection))
{
return "";
}

fileManager.Process();

#>
<#+
void WriteHeader(EntityFrameworkTemplateFileManager fileManager, params string[] extraUsings)
{
fileManager.StartHeader();
#>
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated from a template.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
<#=String.Join(String.Empty, extraUsings.Select(u => "using " + u + ";" + Environment.NewLine).ToArray())#>
<#+
fileManager.EndBlock();
}

void BeginNamespace(string namespaceName, CodeGenerationTools code)
{
CodeRegion region = new CodeRegion(this);
if (!String.IsNullOrEmpty(namespaceName))
{
#>
namespace <#=code.EscapeNamespace(namespaceName)#>
{
<#+
PushIndent(CodeRegion.GetIndent(1));
}
}

void EndNamespace(string namespaceName)
{
if (!String.IsNullOrEmpty(namespaceName))
{
PopIndent();
#>
}
<#+
}
}

bool IsReadWriteAccessibleProperty(EdmMember member)
{
string setter = Accessibility.ForWriteOnlyProperty(member);
string getter = Accessibility.ForReadOnlyProperty(member);

return getter != "private" && getter != "protected" && setter != "private" && setter != "protected";
}

string PropertyVirtualModifier(string accessibility)
{
return accessibility + (accessibility != "private" ? " virtual" : "");
}

void WriteCustomObservableCollection()
{
#>
// An System.Collections.ObjectModel.ObservableCollection that raises
// individual item removal notifications on clear and prevents adding duplicates.
public class FixupCollection<T> : ObservableCollection<T>
{
protected override void ClearItems()
{
new List<T>(this).ForEach(t => Remove(t));
}

protected override void InsertItem(int index, T item)
{
if (!this.Contains(item))
{
base.InsertItem(index, item);
}
}
}
<#+
}

bool VerifyTypesAreCaseInsensitiveUnique(EdmItemCollection itemCollection)
{
Dictionary<string, bool> alreadySeen = new Dictionary<string, bool>(StringComparer.OrdinalIgnoreCase);
foreach(StructuralType type in itemCollection.GetItems<StructuralType>())
{
if (!(type is EntityType || type is ComplexType))
{
continue;
}

if (alreadySeen.ContainsKey(type.FullName))
{
Error(String.Format(CultureInfo.CurrentCulture, "This template does not support types that differ only by case, the types {0} are not supported", type.FullName));
return false;
}
else
{
alreadySeen.Add(type.FullName, true);
}

}

return true;
}
#>

看起来很长？其实主要内容并不复杂。我们所要关心的的Entity生成代码都在一个遍历所有entity的foreach中，对于每个entity，它依次枚举Primitive Properties - entity本身定义的基本类型字段，Complex Properties - 用户定义的复杂类型字段，以及Navigation Properties - entity的关系字段。

首先找到生成每个类定义的代码：

<#=Accessibility.ForType(entity)#> <#=code.SpaceAfter(code.AbstractOption(entity))#>partial class <#=code.Escape(entity)#><#=code.StringBefore(" : ", code.Escape(entity.BaseType))#>

在上面加一行：

[DataContract(Name = "<#=char.ToLowerInvariant(entity.Name[0]) + entity.Name.Substring(1) #>")]

然后再找到生成Primitive Property的代码（其他的类似）：

<#=PropertyVirtualModifier(Accessibility.ForProperty(edmProperty))#> <#=code.Escape(edmProperty.TypeUsage)#> <#=code.Escape(edmProperty)#>

在上面加一行：

[DataMember(Name = "<#=char.ToLowerInvariant(edmProperty.Name[0]) + edmProperty.Name.Substring(1) #>")]

由于DataContract在System.Runtime.Serialization命名空间下，我们还需要添加命名空间。在接近Model.tt末尾的地方找到有一堆命名空间定义，在末尾加上：

using System.Runtime.Serialization;

然后Save，这时代码会重新生成，我们再看一下这时的Microblog.cs:

//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated from a template.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Runtime.Serialization;

namespace WcfRestServiceDemo.Data
{
[DataContract(Name = "microblog")]
public partial class Microblog
{
#region Primitive Properties
[DataMember(Name = "id")]
public virtual int Id
{
get;
set;
}
[DataMember(Name = "content")]
public virtual string Content
{
get;
set;
}
[DataMember(Name = "publishTime")]
public virtual System.DateTime PublishTime
{
get;
set;
}

#endregion
}
}

这时如果测试一下服务，就可以看到不论是XML还是JSON的返回结果中的字段都已经变成小写字母开头了。

需要注意的是，不仅是返回，这时客户端发送请求时，对应字段也必须同样改成小写字母开头。

处理Null值属性

为了引入这个问题，我们将服务稍稍变得复杂一些。假设现在并且每条微博可以关联一张图片，用户只要在写微博同时，输入图片地址即可。那么修改Microblog模型，添加Picture属性，包含一个图片的URL。由于图片是可选的，所以还要将的Nullable设为true。

如下：

由于修改了EntityModel，需要在两个.tt模板文件上右键选择Run Custom Tools来生成新的POCO entity.

然后我们看一下服务的返回：

<ArrayOfmicroblog xmlns="http://schemas.datacontract.org/2004/07/WcfRestServiceDemo.Data" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
<microblog>
<content>Microblog with no picture.</content>
<id>1</id>
<picture i:nil="true"/>
<publishTime>2011-04-19T22:00:00</publishTime>
</microblog>
<microblog>
<content>Microblog with picture</content>
<id>2</id>
<picture>http://somepicture/somepicture</picture>
<publishTime>2011-04-19T22:00:00</publishTime>
</microblog>
</ArrayOfmicroblog>

这里有两条microblog，一条有picture，一条没有。但是没有picture的那个也把picture字段给返回了，只是用i:nil=”true”来标识这是个null值。显然这不是理想方式，想象一下一个entity可能会有很多可空的属性，尤其是当一个entity与许多其他entity产生关联，引入了许多navigation properties时，传输这些空属性将严重影响可读性（虽然大多数情况下应该不是人来读）并对性能造成影响（传输、序列化和反序列化）。（当然这不是绝对的，nil值有其应用场景，请根据实际情况决定）

幸好DataMember attribute还有一个EmitDefaultValue属性，可以指定是否要序列化默认值。用和刚才类似的方法，修改T4模板，修改Property定义上方的[DataMember]:

[DataMember(Name = "<#=char.ToLowerInvariant(edmProperty.Name[0]) + edmProperty.Name.Substring(1) #>"<#
if(edmProperty.Nullable)
{
#>, EmitDefaultValue = false<#
}
#>)]首先判断了property是否可设为null，若可以才省略空值。否则对于一个int属性，值为0时它就不会被传输了，这一般是不太合适的。（确切的讲，这里的Nullable和数据类型没有关系，指的是在数据模型中的nullable，也就是是否为可空字段。)

再次访问服务：

<ArrayOfmicroblog xmlns="http://schemas.datacontract.org/2004/07/WcfRestServiceDemo.Data" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
<microblog>
<content>Microblog with no picture.</content>
<id>1</id>
<publishTime>2011-04-19T22:00:00</publishTime>
</microblog>
<microblog>
<content>Microblog with picture</content>
<id>2</id>
<picture>http://somepicture/somepicture</picture>
<publishTime>2011-04-19T22:00:00</publishTime>
</microblog>
</ArrayOfmicroblog>

可以看到没有图片的那个microblog的picture属性已经被省略了。

JSON中的DateTime

在第二章末尾我们提到过DateTime属性在JSON表示下的奇怪格式。严格来说，这不算什么问题，因为既然微软选择了这种格式，那么全世界的人都在碰到这个问题，相应的客户端解决方案也有很多。比如：

如果一定要从服务端解决这个问题的话，最根本的方法是改用自定义的序列化器。而比较简单的方法是为entity写一个partial类，然后提供一个long格式的对应属性：

using System;
using System.Runtime.Serialization;

namespace WcfRestServiceDemo.Data
{
partial class Microblog
{
private static readonly DateTime _baseTime =
new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).ToLocalTime();

[DataMember(Name = "publishTimeSec")]
public long PublishTimeSeconds
{
get { return (long)(PublishTime - _baseTime).TotalMilliseconds; }
set { PublishTime = _baseTime.AddMilliseconds(value); }
}
}
}

这时服务的返回就是：

[
{
"content":"Microblog with no picture.",
"id":1,
"publishTime":"\/Date(1303221600000+0800)\/",
"publishTimeSec":1303221600000
},
{
"content":"Microblog with picture",
"id":2,
"picture":"http:\/\/somepicture\/somepicture",
"publishTime":"\/Date(1303221600000+0800)\/",
"publishTimeSec":1303221600000
}
]

当然更绝的做法是把这个替代属性的生成也交给T4模板来做。具体做法请参考我整理好后上传的代码。

小结

本文介绍了:

如何修改T4模板控制模型代码的生成，包括修改Type名称、属性名称的起始字母大小写和是否要序列化默认值的选项
如何用替代属性解决JSON中DateTime格式的问题。

我的WCF4 REST Service及Entity Framework with POCO之旅系列

本文链接

我的WCF4 Rest Service及Entity Framework with POCO之旅（三）——用Entity Framework和POCO Template实现数据模型及存储

2011-03-31T01:04:00Z

既然这个系列标题中都含有Entity Framework和POCO，这两者若到第三篇还不出现那就太奇怪了。本文将介绍如何使用Entity Framework和POCO来实现数据模型的创建以及数据存储。

接着上文，我们现在已经有了一个微博服务。但是，一旦网站重启或者IIS重启，我们就会丢失之前所有发布的微博，这样的服务显然不是我们所能接受的，我们接下来要构建服务的数据存储。使用Entity Framework的Model-First设计方式，可以大大简化这个过程。

使用Entity Data Model创建数据模型

我们首先创建一个类库项目WcfRestServiceDemo.Data，然后添加新项“ADO.NET Entity Data Model”：

选择数据源，如果有现成的数据源的话可以从数据库导入。我们选择Empty model, 新创建数据模型。

从工具箱中找到Entity，拖入设计器，参考之前创建的数据类型，修改得到：

到这里数据模型就创建完了。下面我们要把它同步到SQL Server。

由模型生成数据库

到目前为止，模型还只存在C#项目中，虽然我们已经可以写代码来操纵数据，但实际上是无法运行的（或者说一运行就会挂掉的）。

要将模型同步到SQL Server，对设计器视图点右键，选择Generate Database from Model…

选择一个连接，没有的话就创建一个：

然后对应的SQL脚本就自动生成好了：

打开WcfRestServiceDemo.edmx.sql，右键选择Execute SQL，成功后模型就同步到SQL Server了。

修改服务代码

现在数据模型和数据存储都做好了，我们要修改服务代码来使用新的数据模型。

删去Microblog.cs，添加对WcfRestServiceDemo.Data和System.Data.Entity的引用，并修改MicroblogService.cs代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using System.ServiceModel.Activation;
using System.ServiceModel.Web;
using WcfRestServiceDemo.Data;

namespace WcfRestServiceDemo.Service
{
[ServiceContract(Namespace = "WcfRestServiceDemo")]
[AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall)]
public class MicroblogService
{
[WebGet(UriTemplate = "")]
public List<Microblog> GetCollection()
{
using(var container = new WcfRestServiceDemoContainer())
{
return container.Microblogs.ToList();
}
}

[WebInvoke(UriTemplate = "", Method = "POST")]
public Microblog Create(Microblog microblog)
{
microblog.PublishTime = DateTime.Now;
using(var container = new WcfRestServiceDemoContainer())
{
container.Microblogs.AddObject(microblog);
container.SaveChanges();
}
return microblog;
}

[WebGet(UriTemplate = "{id}")]
public Microblog Get(string id)
{
using(var container = new WcfRestServiceDemoContainer())
{
return container.Microblogs.FirstOrDefault(m => m.Id == int.Parse(id));
}
}

[WebInvoke(UriTemplate = "{id}", Method = "DELETE")]
public void Delete(string id)
{
using(var container = new WcfRestServiceDemoContainer())
{
container.Microblogs.DeleteObject(
container.Microblogs.First(m => m.Id == int.Parse(id)));
container.SaveChanges();
}
}
}
}

要让Entity Framework正常工作，我们还需要把它生成的app.config文件中的ConnectionString复制到服务的web.config文件中：

这里附带一提，有的时候我们会遇到无法正确加载Model的情形，这时只要将上面那个连接字符串中的*替换成数据模型(*.edmx)所在的程序集名称（这里是WcfRestServiceDemo.Data)，显式指定搜索路径即可。

好，都改好了，现在测试一下服务，我先手工往数据库中插入一条记录，然后访问
http://localhost:6421/microblogs/：

怎么回事？Content, Id, PublishTime这些属性倒是一个也不少，但是也多了很多其他的东西。这是因为与POCO不同，基于EntityObject的Entity Data Model支持更改提醒、关系管理等许多其他功能，所以会包含更多的属性，只不过在我们这个应用场景中，并不需要这些支持。另一个问题是，这时默认的命名空间变成了
xmlns=http://schemas.datacontract.org/2004/07/WcfRestServiceDemo.Data
而且由于Microblog这个DataModel是自动生成的，我没有办法改它的DataContractAttribute（改了下次生成又会变回来）:

[EdmEntityTypeAttribute(NamespaceName="WcfRestServiceDemo", Name="Microblog")]
[Serializable()]
[DataContractAttribute(IsReference=true)]
public partial class Microblog : EntityObject
{
…
}

要解决上述问题，我们该请出下一位主角POCO了。

使用ADO.NET C# POCO Entity Generator生成POCO模型

POCO全称Plain-Old CLR Objects（中文不知道怎么说）。以前有很多人手写POCO模型，不过现在已经有了一个非常强大的基于T4模板的模型生成器。

打开Visual Studio 2010的Extension Manager，找到ADO.NET C# POCO Entity Generator并安装（或者在这里下载）：

然后打开WcfRestServiceDemo.edmx，右键选择Add Code Generation Item…:

找到刚才安装的模板：

创建结果：

Model.Context.tt和Model.tt分别是Container和Entity的T4模板。现在再运行一下服务，获取所有微博：

为什么会Empty Response? 调试一下服务，发现返回的类型不是Microblog, 而是System.Data.Entity.DynamicProxies.Microblog_
C60A574FC06ABEF4672858332CE687DDE70D188AD3BD73ED2731E8854D30C927，而WCF并不认识这个类型。这是因为默认的Entity Data Model启用了LazyLoading和Proxy机制的缘故。这两个特性我以后也许会详细讲，不过目前我们只要把它们关闭就好。虽然Model设计器提供了下面这个属性可以修改：

但是当我改成False然后对Model.Context.tt右键选择Run Custom Tool 重新生成Container代码，却没有任何效果，Container构造器代码依旧如下：

如果有哪位高手知道应该如何设置，请告诉我。我们现在先通过扩展Container类的方法来解决这个问题，下一篇讲如何通过修改T4模板来改变生成的Container。

在WcfRestServiceDemo.Data中创建WcfRestServiceDemoContainer.cs，代码如下：

using System;

namespace WcfRestServiceDemo.Data
{
partial class WcfRestServiceDemoContainer
{
public static void Go(Action<WcfRestServiceDemoContainer> todo,
bool isLazy = false)
{
Go<object>(entities =>
{
todo(entities);
return null;
},
isLazy);
}

public static void GoAndSave(Action<WcfRestServiceDemoContainer> todo,
bool isLazy = false)
{
Go<object>(entities =>
{
todo(entities);
entities.SaveChanges();
return null;
},
isLazy);
}

public static T Go<T>(Func<WcfRestServiceDemoContainer, T> todo,
bool isLazy = false)
{
using(var entities = new WcfRestServiceDemoContainer())
{
entities.ContextOptions.LazyLoadingEnabled = isLazy;
entities.ContextOptions.ProxyCreationEnabled = false;
return todo(entities);
}
}

public static T GoAndSave<T>(Func<WcfRestServiceDemoContainer, T> todo,
bool isLazy = false)
{
return Go(entities =>
{
var result = todo(entities);
entities.SaveChanges();
return result;
},
isLazy);
}
}
}

这里我顺便写了几个帮助方法，因为每次使用Container时写using很麻烦，关键是我经常改完数据忘记调SaveChanges().

最后修改MicroblogService.cs代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using System.ServiceModel.Activation;
using System.ServiceModel.Web;
using WcfRestServiceDemo.Data;

namespace WcfRestServiceDemo.Service
{
[ServiceContract(Namespace = "WcfRestServiceDemo")]
[AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall)]
public class MicroblogService
{
[WebGet(UriTemplate = "")]
public List<Microblog> GetCollection()
{
return WcfRestServiceDemoContainer.Go(container =>
container.Microblogs.ToList());
}

[WebInvoke(UriTemplate = "", Method = "POST")]
public Microblog Create(Microblog microblog)
{
microblog.PublishTime = DateTime.Now;
WcfRestServiceDemoContainer.GoAndSave(container =>
container.Microblogs.AddObject(microblog));
return microblog;
}

[WebGet(UriTemplate = "{id}")]
public Microblog Get(string id)
{
return WcfRestServiceDemoContainer.Go(container =>
container.Microblogs.FirstOrDefault(m => m.Id == int.Parse(id)));
}

[WebInvoke(UriTemplate = "{id}", Method = "DELETE")]
public void Delete(string id)
{
WcfRestServiceDemoContainer.GoAndSave(container =>
container.Microblogs.DeleteObject(
container.Microblogs.First(m => m.Id == int.Parse(id))));
}
}
}

再次访问http://localhost:6421/microblogs/：

啊哈，又回到最初干净的状态了。只是Namespace问题以及属性名称的大小写问题还是没有解决，但是我们已经离目标更近一步了，我将在下一章讨论这些。

小结

本文介绍了：

如何用Entity Framework的Model-First方式构建数据模型及数据存储
如何改用POCO实现数据模型
如何关闭LazyLoading和ProxyCreation
以及一点点代码的sugar

我的WCF4 REST Service及Entity Framework with POCO之旅系列

本文链接

我的WCF4 Rest Service及Entity Framework with POCO之旅（二）——选择请求/返回格式

2011-03-29T01:07:00Z

REST被推崇，一个很重要的原因就是它的数据格式可以是XML，也可以是JSON，这使得Javascript可以轻松调用RESTful服务。WCF REST内置了JSON序列化器，可以轻易实现格式的转换，甚至可以根据请求动态选择返回的格式。

先看看如何手动指定返回格式。WebGetAttribute和WebInvokeAttribute有RequesetFormat和ReponseFormat两个属性，可以指定请求/返回格式为XML或者JSON:

但相比之下，动态选择格式还是更灵活也吸引人一些。打开之前创建的项目，在自动生成的web.config中，有这么一条配置：

设定标准Endpoint为打开服务帮助，并且打开自动格式选择。

打开服务帮助就是当访问/microblogs/help时会看到如下的帮助界面：

列举了服务的接口，每个接口还说明了其详细用法、示例，以及请求/返回数据的scheme。

而自动格式选择，分为两部分：自动根据请求，选择请求内容的格式和回复内容的格式。这两者分别是通过HTTP请求头中的Content-Type和Accept这两项指定的。

在Fiddler2中把Content-Type改成application/json, 表示请求的内容格式是JSON，再次发布一条微博：

请求成功，可以看到请求内容是JSON格式，服务器成功处理了，但返回还是XML格式：

现在再修改Accept头为application/json, 表示只接受JSON的返回格式，然后获取所有的微博：

结果如下：

可以看到，返回内容已经是JSON格式了。等等，那个时间的格式好像有点怪？另外，大写的field名称似乎也不合习惯。别急，我们以后会解决这些问题。

小结

本文介绍了

如何手动指定请求/返回的数据格式
如何使用WCF的自动格式选择

和上一篇一样，有图有真相。不过也很花时间，我怀疑是不是写得太详细了？以后如非必要，估计不这么写了，毕竟我的目的不是出一套教材，而是希望能整理一些其他地方找不到的东西，否则舍本逐末，得不偿失。

我的WCF4 REST Service及Entity Framework with POCO之旅系列

本文链接

我的WCF4 Rest Service及Entity Framework with POCO之旅（一）——创建一个基本的RESTful Service

2011-03-28T01:11:00Z

很久没有玩WCF了，年前和几个朋友做一个Restful的服务，惊讶于WCF4已经能如此完美实现REST（好吧，我承认不是完全完美）。期间遇到了许多难题，但还是一一解决，或者找到了workaround. 为了让以后想做同样事情的朋友不至于像我们这般抓狂，也为了给自己整理一下所学，我准备写一个系列，讲述如何从零开始创建一个完整的支持Token验证的REST服务，其内容将涉及如何控制返回内容格式，如何处理异常并返回自定义内容，如何建立基于token的身份验证，如何使用POCO，如何做service的单元测试……总之，总之，看了就知道了。鉴于文笔拙劣，技亦不精，不敢和大牛比肩，姑且自称为《我的WCF4 Rest Service及Entity Framework with POCO之旅》吧，还请各位高手多多指教。

照理说，首先应介绍什么是REST，它是怎么出现的，有什么优势，什么历史意义。不过我不多想讲，也讲不清楚。简而言之，REST最核心的概念是“资源”，一个uri代表一个特定的资源，而客户端通过HTTP method GET, POST, PUT, DELETE来和资源交互（同时导致状态转移）。至于资源的表现形式，则以XML和JSON为主。为什么要用REST? 自己想去吧。

创建项目

闲话说完，现在开始创建项目。使用Online Templates中的WCF REST Service Template是一个比较容易的方法：

项目创建好后，我们可以看到项目中已经有下面这些文件：

Service1就是一个WCF Service，和以前的WCF Service不同，这里的Service既不是一个.svc文件，也没有专门定义一个接口作为ServiceContract。

SampleItem就是我们以往所知的DataContract，不过现在即使不加DataContract attribute，也没有关系。

比较特别的是Global.asax和Global.asax.cs。Global.asax.cs中定义了Routes：

private void RegisterRoutes()
{
// Edit the base address of Service1 by replacing the "Service1" string below
RouteTable.Routes.Add(new ServiceRoute("Service1", new WebServiceHostFactory(), typeof(Service1)));
}

表示所有访问HOST/Service1的请求都要由Service1这个类来处理。再看一下Service1的定义，其中有个方法是：

[WebGet(UriTemplate = "{id}")]
public SampleItem Get(string id)
{
// TODO: Return the instance of SampleItem with the given id
throw new NotImplementedException();
}

这表示对于HOST/Service1/123的GET请求，将会用这个Get(string)方法来处理。服务运行时，WCF根据uri中的“Service1”根据前面指定的Route找到Service1这个服务类，再根据UriTemplate，将“123”赋给名为id的参数，其结果就是Get方法以参数“123”被调用了。

现在我们修改一下这个方法，让它能够返回结果：

[WebGet(UriTemplate = "{id}")]
public SampleItem Get(string id)
{
return new SampleItem
{
Id = int.Parse(id),
StringValue = string.Format("The id is {0}.", id)
};
}

然后启动这个服务。在浏览器地址栏中输入“http://localhost:6421/Service1/123”（端口号根据实际情况而定），结果如下：

如何，是不是很简单？

不过现在的RESTful服务还只能读取资源，WebGet只支持GET方法，要支持PUT, POST和DELETE，需要使用WebInvoke attribute。而且，现在的服务看不出任何实际意义。

既然掌握了基本技术，我们来创建一个稍微有点实际意义的服务

创建一个简易微博服务

（终于不是做图书管理系统示例了）

首先，我们的微博服务真的很简单，简单到只能有一个用户自娱自乐，而且还只能发文字，是不是有点无聊？不过不要急，一步一步来。

既然如此，所谓的微博服务，也就是一个微博管理系统了(…)。它应该有这些功能：

发布微博
查看已发布的微博
删除一条微博

照此删去原先那些示例代码，重新编写代码如下：

MicroblogService.cs using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using System.ServiceModel.Activation;
using System.ServiceModel.Web;
using System.Threading;
namespace WcfRestServiceDemo.Service
{
[ServiceContract(Namespace = "WcfRestServiceDemo")]
[AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall)]
public class MicroblogService
{
private static int _currentId;
private static readonly ConcurrentDictionary<int, Microblog> _microblogs =
new ConcurrentDictionary<int, Microblog>();

[WebGet(UriTemplate = "")]
public List<Microblog> GetCollection()
{
return _microblogs.Values.ToList();
}

[WebInvoke(UriTemplate = "", Method = "POST")]
public Microblog Create(Microblog microblog)
{
microblog.Id = Interlocked.Increment(ref _currentId);
microblog.PublishTime = DateTime.Now;
_microblogs.TryAdd(microblog.Id, microblog);
return microblog;
}

[WebGet(UriTemplate = "{id}")]
public Microblog Get(string id)
{
return _microblogs[int.Parse(id)];
}

[WebInvoke(UriTemplate = "{id}", Method = "DELETE")]
public void Delete(string id)
{
Microblog microblog;
_microblogs.TryRemove(int.Parse(id), out microblog);
}
}
}

Microblog.cs using System;
using System.Runtime.Serialization;
namespace WcfRestServiceDemo.Service
{
[DataContract(Namespace = "WcfRestServiceDemo")]
public class Microblog
{
[DataMember]
public int Id { get; set; }

[DataMember]
public string Content { get; set; }

[DataMember]
public DateTime PublishTime { get; set; }
}
}

Global.asax.cs using System;
using System.ServiceModel.Activation;
using System.Web;
using System.Web.Routing;
namespace WcfRestServiceDemo.Service
{
public class Global : HttpApplication
{
private void Application_Start(object sender, EventArgs e)
{
RegisterRoutes();
}

private void RegisterRoutes()
{
RouteTable.Routes.Add(new ServiceRoute("microblogs", new WebServiceHostFactory(), typeof(MicroblogService)));
}
}
}

编译并运行。首先访问http://localhost:6421/microblogs/@all：

理所当然什么都没有，一条微博都还没发呢。为了方便的发送请求并查看结果，祭出神器Fiddler2:

在右边窗口可以看到请求返回的XML。

接下来选择右边上面的Request Builder，来构造一个POST:

（可以把左边那个请求拖入编辑窗口快速复制一个请求。）
（注意要在上面的Headers窗口添加Content-Type: application/xml这一项，同时注意XML的namespace。）

点击Execute：

服务返回HTTP 200 OK，并且可以从Response的内容中看到成功创建的Microblog的Id以及PublishTime的值。

再次获取全部：

已经可以看到刚才创建的微博了。现在再试一下其他两个功能：

获取单条微博：

删除指定微博：

再次查询全部，结果又是空空如也了。到这里，一个超级简单的“微博”服务已经搭建起来了。

小结

本文从零开始，依次介绍了

什么是REST
如何创建一个基本的WCF REST Service
（如何使用Fiddler2……）

To be continued…

下篇预告：我的WCF4 Rest Service及Entity Framework with POCO之旅（二）——选择请求/返回格式

参考：

一些基础知识： http://msdn.microsoft.com/en-us/magazine/dd315413.aspx

我的WCF4 REST Service及Entity Framework with POCO之旅系列

本文链接

再说说C#定义事件的写法

2011-01-17T22:05:00Z

public event EventHandler Started;

protected virtual void OnStarted(EventArgs e)
{
EventHandler handler = Started;
if (handler != null)
{
handler(null, e);
}
}

像上面这段代码，在很多地方都可以看到，几乎可说是创建事件的标准写法了。这段代码最主要的功能是防止调用订阅者列表为空的委托。但是其中有两处让人第一眼看上去感到疑惑的地方，至少我不是一开始就理解的。

首先是显眼的protected virtual. 相信搞过WinForm编程的都很熟悉，因为从WinForm控件继承后可以看到大量的如OnClick(EventArgs), OnKeyDown(KeyEventArgs)这样的保护虚方法。用Reflector看System.Windows.Forms.Control，可以发现OnClick(EventArgs)方法定义如下：

[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnClick(EventArgs e)
{
EventHandler handler = (EventHandler) base.Events[EventClick];
if (handler != null)
{
handler(this, e);
}
}

这和前面看到的定义是一致的，可见.NET中正是遵循了这个写法。从这个方法在WinForm中的应用，也就能看出这样写的意义了。声明为protected可以让派生类自由触发事件，而virtual则令派生类可以在改变事件触发时的行为，比如在事件触发前后进行一些操作，或者决定是否要触发事件。

其次是handler的定义，看起来handler是一个冗余变量，完全多此一举。而且违反了重构中的“尽量不使用局部变量”的原则。我一开始甚至做过手动inline这样的代码中的handler。然而，事实上在多线程环境中这一行代码是必不可少的，因为可能在handler != null 判断通过后，Started在另一个线程中被设为了null! 因此，将Started首先赋给一个局部变量，避免了外界环境的影响。

但是还没有完，上面说的都是理论，如果我说，这样的代码明显是会被编译器优化掉的，因此这样写完全没有意义，怎样呢？毕竟EventHandler作为一个委托，并没有用volatile关键字声明（事实上事件不能声明为volatile，但可以在这里用Thread.VolatileRead(ref object)方法），使用时也没有用Interlocked来访问。我其实真没有想到那么远，不过CLR Via C#上给出了解释（记不得是哪一章了）：JIT的编译器在这里会识别出这个写法并且确保不会把handler变量优化掉。真是万幸，但估计又成为了一个被学院派的诟病的特性。不过管他呢，让我们少写一些代码难道不是好事么，至少我觉得很好。

另外值得一提的是，如果只是很简单的类，并且预料到不会有什么继承形式（最好同时标记为sealed），而不想写出那一坨代码的话（tip: 输invoke插入snipplet可以稍微减轻一点负担），可以采用下面一种写法偷偷懒：

public event EventHandler Started = delegate { };

本文链接

对需要读取config文件的程序集进行单元测试

2011-01-13T19:39:00Z

其实只要在Tests项目中加入app.config就可以了，不过这往往意味着要同时维护两份config文件。有两种更加优雅的办法：

使用Add Existing File, 然后选择add as link。但是貌似对于网站类型的项目就没有办法了，因为原文件名是web.config，而测试项目中必须是app.config才行，而add as link又没办法重命名。
通过配置.testsettings, 使用Test Deployment来实现自动拷贝文件。具体可以参考这里。

本文链接

使用Entity Framework遇到MetadataException: Unable to load the specified metadata resource

2011-01-13T18:44:00Z

项目中使用了Entity Framework, 然后在一个单元测试项目中引用包含了edmx的项目，跑测试时，遇到了MetadataException: Unable to load the specified metadata resource。

Google后找到了解决办法，在Entity Framework生成的连接字符串中，包含了"metadata=res://*/Model.csdl|res://*/Model.ssdl|res://*/Model.msl;"这一段。其中的*表示将在所有程序集中查找Model.csdl, Model.ssdl, Model.msl这3个资源。然而在有些情况下似乎并不能正确的找到，而将其改为显示指定就可以解决：

metadata=res://Something.Data/Model.csdl|res://Something.Data/Model.ssdl|res://Something.Data/Model.msl;

这里一篇博客介绍了更详细的信息。

本文链接