专栏首页大内老A深入理解C# 3.x的新特性(1): Anonymous Type

深入理解C# 3.x的新特性(1): Anonymous Type

在C#3.0中,引入了一个新的Feature:Anonymous Method,允许我们已Inline的方式来定义Delegate,为Developer在Coding的时候带来了很大的便利。在C#3.0中,我们又有了另一个相似的Feature:Anonymous Type。Anonymous Type允许我们已Inline的方式的创建一个基于未知类型、具有所需数据结构的对象。

一、Anonymous Type Overview

在传统的编程模式中,对象依赖于一个既定的Type,我们只能在Type的基础上创建相应的Instance。比如如果我们需要创建一个Employee Instance,前提是我们已经有了一个相应的Emplyee Type的定义。比如:

public class Employee
{
       private Guid _id;
       private string _name;

       public Guid ID
       {
            get { return _id; }
            set { _id = value; }
       }

       public string Name
       {
           get { return _name; }
           set { _name = value; }
       }
}

有了这样一个Employee Type,我们才可以创建相应的Employee Instance。

   1: var v = new Employee{ ID = Guid.NewGuid(), Name = "Zhang San" };

注:在上面的Code中,实际上使用到了另外两个C# 3.0的new feature: Implicitly typed local variable & Object Initializer.

这样基于一个预先定义的Type的对象创建方式的一个最大的限制就是:对于我们需要创建的每一个对象,我们必先定于该对象对应的Type。Anonymous Type有效地解决了这个问题。我认为Anonymous Type主要是基于下面的目的而设计:

一个Type是对一个现实中实体的State(Data)和Behavior(Method)的抽象。对于一些仅仅只包含State(Data)的Type(这样对象通常作为Data Package在Application各个Layer之间、以及一个分布式环境中各个Application之间进行数据的传递),我们关心的仅仅是这个由这些数据成员组成结构Type由哪些数据成员构成,它们的名称是什么,具有怎样的数据类型。换句话说,这样的Data-based Type定义了一个Data Structure,相应地,我们可以说一个固定的Data Structure对应着一个特定的Type。而C# 3.0 的Anonymous Type就提供了这样的实现:Compiler通过我们在Source Code定义的数据成员的具体结构为我们创建相应的Type

比如我们现在需要一个在上面定义的Employee对象,实际上我们不是需要的一个Type Name叫做Employee的对象,而是需要一个具有如下特征的对象:该对象具有两个数据成员: ID & Name他们的数据类型分别为GUID和string。在Source Code中,我们通过以下各结构指定这种特征:

var v = new
{ID = Guid.NewGuid(), Name= "Zhang San" };

我们仔细分析上面这段代码,实际上它包含两部分的信息的:

  • 为Compiler Type的创建定义一个数据结构。{}中的内容指明了:包含两个数据成员,第一个是名称为ID,第二个为Name(成员的顺序也是一个决定因素,也就是说{ID = Name= "Zhang San" ,Guid.NewGuid()}和{ID = Guid.NewGuid(), Name= "Zhang San" }对于的Anonymous Type将是不同的。我不太清楚这样的设计到底处于一个什么样的目的);和Implicitly typed local variable一样,成员的类型由指定的数据或者表达式计算结果的数据类型决定。
  • 为在运行时对象的创建提供数据,就像Constructor的参数一样。

二、CLR 眼中的Anonymous Type

我们说Anonymous Type仅仅是C# 3.0的新的特性,而没有说Anonymous Type是.NET Framework 3.5的新特性。这是因为Anonymous Type仅仅是.NET Programming Language和相应的Compiler的新引入的特征。而对于.NET Framework 3.5来说,它看不到这和原来有什么不同,换句话说,对于Anonymous Type和一般的Named Type,对于CLR来说他们之间没有什么本质的区别。对于下面这样的一段简单的代码:

   1: var v = new{ID = Guid.NewGuid(), Name= "Zhang San" };

通过编译,Compiler将会创建一个名为<>f__AnonymousType0<<>j__AnonymousTypeTypeParameter1, <>j__AnonymousTypeTypeParameter2>的Class。该Class的结构如下:

   1: public sealed class <>f__AnonymousType0<<>j__AnonymousTypeTypeParameter1, <>j__AnonymousTypeTypeParameter2>
   2: {
   3:     public <>j__AnonymousTypeTypeParameter1ID{ get; set; }
   4:     public j__AnonymousTypeTypeParameter2 Name{ get; set; }
   5:     private j__AnonymousTypeTypeParameter1 <>i__AnonymousTypeField3;
   6:     private j__AnonymousTypeTypeParameter2 <>i__AnonymousTypeField4;
   7: }

<>j__AnonymousTypeTypeParameter1<>j__AnonymousTypeTypeParameter2这两个Generic Type代表我在 {} 中制定ID和Name的类型。通过这个结构,我们发现其定义和一般的Generic Type并没有什么区别。

为了进一步了解生成什么样的Anonymous Type,我们使用IL DASM在IL级别看看生成的Anonymous Type的大体结构:

为了做一个对比,下面是我们最开始定义的Named Employee Type在IL DASM中的结构:

如果想更清楚了解Anonymous Type的本质,建议读者亲自使用IL DASM看看的每个成员具体的IL。

三、Anonymous Type is Bound to Assembly

在上面一个部分中我们说了对于CLR来说,Anonymous Type和一般的Named Type并没有本质的区别。但是话不能太绝对,他们之间还是有一点小小的差异。到底是什么样差异,我在这里先卖一个关子。在具体介绍这个差异的时候,我们先来看看一个Sample:

在这个Sample中,我定义了两个Project:

  • Console Application:Artech.NewFeatureInCSharp.ConsoleApp
  • Class Libray:Artech.NewFeatureInCSharp.Library

Artech.NewFeatureInCSharp.Library中定一个Employee Type:

   1: public class Employee
   2: {
   3:     private Guid _id;
   4:     private string _name;
   5:  
   6:     public Guid ID
   7:     {
   8:         get { return _id; }
   9:         set { _id = value; }
  10:     }
  11:  
  12:     public string Name
  13:     {
  14:         get { return _name; }
  15:         set { _name = value; }
  16:     }
  17: }

和一个Static的Utility Class:

   1: public static class Utility
   2: {
   3:     public static object Anonymous_GetEmployee(Guid id, string name)
   4:     {
   5:         return new { ID = id, Name = name };
   6:     }
   7:  
   8:     public static Employee GetEmployee(Guid id, string name)
   9:     {
  10:         return new Employee { ID = id, Name = name };
  11:     }
  12: }

在Utility中定义了两个GetEmployee方法,分别返回以Anonymous Type形式和Named Type形式的Employee对象。

   1: class Program
   2: {
   3:     static void Main(string[] args)
   4:     {
   5:         var v1 = new { ID = Guid.NewGuid(), Name = "Zhang San" };
   6:         var v2 = new { ID = Guid.NewGuid(), Name = "Li Si" };
   7:         var v3 = Utility.Anonymous_GetEmployee(Guid.NewGuid(), "Wang Wu");
   8:         Console.WriteLine("var v1 = new{ID = Guid.NewGuid(), Name= \"Zhang San\" };");
   9:         Console.WriteLine("var v2 = new{ID = Guid.NewGuid(), Name= \"Li Si\" };");
  10:         Console.WriteLine("var v3 = Utility.Anonymous_GetEmployee(Guid.NewGuid(), \"Wang Wu\");");
  11:  
  12:         Console.WriteLine("\nv1.GetType() = {0}", v1.GetType());
  13:         Console.WriteLine("v2.GetType() = {0}", v2.GetType());
  14:         Console.WriteLine("v3.GetType() = {0}", v3.GetType());
  15:  
  16:         Console.WriteLine("\nobject.ReferenceEquals(v1.GetType(),v2.GetType()) = {0}", object.ReferenceEquals(v1.GetType(), v2.GetType()));
  17:         Console.WriteLine("object.ReferenceEquals(v1.GetType(),v3.GetType()) = {0}", object.ReferenceEquals(v1.GetType(), v3.GetType()));
  18:  
  19:         Console.WriteLine("\n\n");
  20:  
  21:         var v4 = new Employee { ID = Guid.NewGuid(), Name = "Zhang San" };
  22:         var v5 = new Employee { ID = Guid.NewGuid(), Name = "Li Si" };
  23:         var v6 = Utility.GetEmployee(Guid.NewGuid(), "Wang Wu");
  24:         Console.WriteLine("var v4 = new Employee{ID = Guid.NewGuid(), Name= \"Zhang San\" };");
  25:         Console.WriteLine("var v5 = new Employee{ID = Guid.NewGuid(), Name= \"Li Si\" };");
  26:         Console.WriteLine("var v6 = Utility.GetEmployee(Guid.NewGuid(), \"Wang Wu\");");
  27:  
  28:         Console.WriteLine("\nv4.GetType() = {0}", v4.GetType());
  29:         Console.WriteLine("v5.GetType() = {0}", v5.GetType());
  30:         Console.WriteLine("v6.GetType() = {0}", v6.GetType());
  31:  
  32:         Console.WriteLine("\nobject.ReferenceEquals(v4.GetType(),v5.GetType()) = {0}", object.ReferenceEquals(v4.GetType(), v5.GetType()));
  33:         Console.WriteLine("object.ReferenceEquals(v4.GetType(),v6.GetType()) = {0}", object.ReferenceEquals(v4.GetType(), v6.GetType()));
  34:     }
  35: }

代码不复杂,我在这里简单介绍一下整体的结构。这个结构分两部分,第一部分是基于Anonymous Type的,另一部分是基于Named Employee Type的。在第一部分中,我首先创建了3个Anonymous Type的Instance:v1、v2和v3(v3是通过调用定义在Artech.NewFeatureInCSharp.Library中的Utility获得,其余两个则直接通过Inline的方式创建),第二部分也具有相同的代码结构。

   1: var v1 = new{ID = Guid.NewGuid(), Name= "Zhang San" };
   2: var v2 = new { ID = Guid.NewGuid(), Name = "Li Si"};
   3: var v3 = Utility.Anonymous_GetEmployee(Guid.NewGuid(), "Wang Wu");

然后现实他们对应的Type的Full name.

   1: Console.WriteLine("\nv1.GetType() = {0}", v1.GetType());
   2: Console.WriteLine("v2.GetType() = {0}", v2.GetType());
   3: Console.WriteLine("v3.GetType() = {0}", v3.GetType());

最后调用object.ReferenceEquals对这3个Type进行比较。

   1: Console.WriteLine("\nobject.ReferenceEquals(v1.GetType(),v2.GetType()) = {0}",object.ReferenceEquals(v1.GetType(),v2.GetType()));
   2: Console.WriteLine("object.ReferenceEquals(v1.GetType(),v3.GetType()) = {0}", object.ReferenceEquals(v1.GetType(), v3.GetType()));

大家先想想到底运行后将会出现什么样的结果,看看你的想法和真实的结果是否一致:

对于第二部分基于Named Type的输出,结果很明显,没有什么好说的。我们重点来看基于Anonymous Type的输出结果:

我们通过Inline的方式创建了v1和v2,通过调用定义在另一个Assembly中定义的Utility class创建了v3。虽然我们创建对象的方式不同,但是这3个Instance的结构完全相同,我们可以想象他们对应的Type应该相似。但是,他们到底是不是就是同一个Type呢?通过输出的Type的Full Name:<>f__AnonymousType0`2[System.Guid,System.String]来看,他们“貌似”同一个Type。但是Full name相同并不意味着他们就是同一个Type。确定两个Type的同一性的方法就是确定他们具有相同的Reference。于是我们使用了object.ReferenceEquals方法。两个调用的结果完全不同:v1和v2对应的Type是一样的,而v1和v3则不是同一个。关于Type在Managed Heap的体现,请参阅我的文章: 《[原创]What is "Type" in managed heap?》。

我们来讨论问什么会出现上面的运行结果。原因很简单:Compiler在生成Anonymous Type的时候,并不是为每个形如这样{M1=?, M2 =? , …}的结构生成一个不同的Type,它只会为不同的参数列表的结构:参数的名称,参数的数据类型,参数的相互顺序定义不同的Type。而具有相同的参数列表的{M1=?, M2 =? ,  …}会共享同一个Type。但是这种机制仅限于在同一个Assembly中。也就是在一个Assembly创建的Anonymous Type仅仅限于在本Assembly中使用,不同被另一个Assembly共享。所以我们通过Inline的方式创建了v1和v2是同一个Type的两个Instance,而我们通过跨Assembly创建的v3却属于不同的Type,尽管他们的Type定义可能完全一样。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 为ASP.NET MVC创建一个基于Unity的ControllerFactory

    谈到IoC和ASP.NET的集成,很多人会先后想到Ninject,不过我们个人还是倾向于Unity。这篇文章简单地介绍如果创建基于Unity的Controlle...

    蒋金楠
  • WCF并发(Concurrency)的本质:同一个服务实例上下文(InstanceContext)同时处理多个服务调用请求

    引言 服务(Service)的本质就是提供服务消费者期望的某种功能,服务的价值体现在两个方面:服务本身的质量和寄宿服务的平台应付消费者的数量,并发(Concur...

    蒋金楠
  • WCF传输安全(Transfer Security)的基本概念和原理:认证(Authentication)[上篇]

    对于任何一个企业级应用来说,安全(Security)都是一个不可回避的话题。如何识别用户的身份?如何将用户可执行的操作和可访问的资源限制在其允许的权限范围之内?...

    蒋金楠
  • SpringMVC统一异常处理

    (1)使用Spring MVC提供的简单异常处理器SimpleMappingExceptionResolver;

    黑白格
  • 如何在CDH中为Kafka设置流量配额

    Fayson
  • Android 进阶解密笔记-DVM与JVM

    jvm基于栈则需要从栈中读写数据,所需的指令会更多,这样导致运行速度慢,这对于性能有限的移动设备不合适。DVM是基于寄存器的,它没有基于栈的虚拟机在复制数据时而...

    Yif
  • Mysql锁

    锁的应用最终导致不同事务的隔离级别、而MVCC多版本并发控制,通过增加版本的形式实现两种隔离级别(不使用到锁),MVCC读写不阻塞,是行级锁的升级

    晚上没宵夜
  • Java中的语法糖

    语法糖方便了程序员的开发,提高了开发效率,提升了语法的严谨也减少了编码出错误的几率。我们不仅仅在平时的编码中依赖语法糖,更要看清语法糖背后程序代码的真实结构,这...

    哲洛不闹
  • 联盟:互联网时代的人才变革

    本书提供了一种使雇主与员工之间从商业交易转变为互惠关系的框架,创建了一种鼓励公司和个人相互投资的工作模式。打造任期制,将非终身雇用的员工变为公司的长期人脉,并吸...

    用户1908973
  • 读书笔记:软件测试的分类及原则

    黑盒测试是一种重要的测试策略,又称为数据驱动的测试或输入/输出驱动的测试。使用这种测试方法时,将程序视为一个黑盒子。测试目标与程序的内部机制和结构完全无关,而是...

    乐大爷

扫码关注云+社区

领取腾讯云代金券