重学c#系列——动态类型[二十二]

前言

该系列准备继续完善，一共108篇，持续更新。

正文

为什么有动态类型呢？

是因为很多东西天生就是动态类型的。

比如xml 和 json、cvs、数据库表，这些本来就是数据类型的。

在反射系列中提及到，为什么有发送呢？是因为只有在运行的时候你才能知道他是什么类型。

同样的xml、json这些也是只有运行的时候才知道他有什么样的类型，当我们加载xml、json 映射成一个对象的时候，里面的属性也只有加载完后我们的程序才知道。

那这样就有一个问题啊，那就是加载的时候我们的程序才知道有这个属性，那么这种没法处理了吗？

这个时候人就介入了，比如json开发人员是知道有一个字段叫做fistname的，那么使用动态类型，可以是dynamicObj.fistname 这样获取就可以了。

动态获取属性的值，这似乎反射也可以做到啊。是的啊，当然反射可以做到，那有没有可能dynamic 就是反射获取字段值的语法糖呢？

这样就可以了：

static void Main(string[] args)

{

	var type = typeof(String);

	var chars = new char[] { '1','2','3','4','5','6'};

	object x = Activator.CreateInstance(type, chars);

	PropertyInfo property = type.GetProperty("Length");

	var y = property.GetValue(x);

	dynamic a = "123456";

	var b = a.Length;

	var c = "123456";

	var d = c.Length;

	Console.ReadKey();

}

我们来反编译看一下到底是怎么样的？

可以看到是这样的：

先看反射这块，反射这块好理解哈:

然后动态类型这块，其实原理还是反射了，先检查类型是否存在然后去调用。

那么看来呢，我好想也没有找到动态类型跳过检查这一块。

如果检查失败会报:runtime-binder.runtimebinderException。

反射和动态类型不同的是，反射是运行时候生成的检查，而动态类型是编译的时候生成的，这个根据上面应该好理解吧。

也就是说反射是可以跳过检查的，但是动态类型不行。

只是说一下，个人觉得其实也没什么关系。因为其实不怎么影响效率。该用动态类型就用动态类型，该用反射就用反射，两种的方向不一致。

通过上面il编译后的，我们发现根本就没有这个dynamic 这个东西，会编译成别的东西，起到了包装器的作用。

static void Main(string[] args)

{

	dynamic a = "123456";

	var t = a.GetType();

	Console.WriteLine(t);

	Console.ReadKey();

}

当我们去运行它的时候获取类型的时候:

这个a 本身还是system.string.

对il来说没有动态类型这个概念。

然后有一个值得注意的误区:

就是有些人认为使用了dynamic 认为不存在装箱和拆箱？

这是一个非常值得实验的问题。

internal class Program

{

	static void Main(string[] args)

	{

		dynamic a = 1;

		Console.WriteLine(a);

	}

}

为什么会这样呢? 因为dynamic 继承obejct，实际上可以理解为object，int 到 object 自然存在装箱。

实际上dynamic 十分简化原理是这样的:

object a = "test";

var t = typeof(x);

callSite b = factory.create(t);

var reuslt = b.invoke(a, "param")

然后动态类型是不支持调用扩展方法的，这个反射也不支持。这个后面讲到扩展方法的本质的时候，就知道为什么不支持了。

动态类型的场景:

如果不使用动态类型是这样的:

static void Main(string[] args)

{

	XElement person = XElement.Parse(@"<Person>

		<FirstName>1</FirstName><LastName>2</LastName></Person>");

	Console.WriteLine(person.Descendants("FirstName").FirstOrDefault().Value);

}

那么如果有了动态类型怎么写呢?

static void Main(string[] args)

	{

		//XElement person = XElement.Parse(@"<Person>

		//    <FirstName>1</FirstName><LastName>2</LastName></Person>");

		//Console.WriteLine(person.Descendants("FirstName").FirstOrDefault().Value);

		dynamic person = DynamicXml.Parse(@"<Person>

			<FirstName>1</FirstName><LastName>2</LastName></Person>");

		Console.WriteLine(person.FirstName);

	}

}

public class DynamicXml : DynamicObject

{

	private XElement Element { get; set; }

	public DynamicXml(

		XElement element)

	{

		Element = element;

	}

	public static DynamicXml Parse(string text)

	{

		return new DynamicXml(XElement.Parse(text));

	}

	public override bool TryGetMember(GetMemberBinder binder, out object result)

	{

		bool success = false;

		result = null;

		XElement firstDescendant = Element.Descendants(binder.Name).FirstOrDefault();

		if (firstDescendant != null)

		{

			if (firstDescendant.Descendants().Any())

			{

				result = new DynamicXml(firstDescendant);

			}

			else

			{

				result = firstDescendant.Value;

			}

			success = true;

		}

		return success;

	}

	public override bool TrySetMember(SetMemberBinder binder, object value)

	{

		bool success = false;

		XElement firstDescendant = Element.Descendants(binder.Name).FirstOrDefault();

		if (firstDescendant != null)

		{

			if (value.GetType() == typeof(XElement))

			{

				firstDescendant.ReplaceWith(value);

			}

			else

			{

				firstDescendant.Value = value.ToString();

			}

			success = true;

		}

		return success;

	}

}

如果定义了自己的动态类型那么更加方便。

因为本来我们就要传递字符串的，如果字符串传递错误本来就会报错，封装成一个动态类，从工程的角度来说就是更加优雅了。

然后又一个问题，那就是本身如果我们的 DynamicXml 就有这个属性呢？是调用TryGetMember的还是调用我们自己的呢?

事实证明会调用自己的，而不走TryGetMember。

说明先进性反射，如果反射找不到，然后判断是否继承dynamicObject，如果继承那么就调用TryGetMember获取，如果失败就抛出异常。

结

该系列持续更新。

巴特西

重学c#系列——动态类型[二十二]

前言

正文

结

最新文章

热门文章