blocks|key|1269758|text|COM互操作。尤其是IUnknown。它是专门为它设计的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1269759|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

COM interop. Especially IUnknown. It was designed specially for it.

blocks|key|1269794|text|它在运行时进行计算，因此您可以像在JavaScript中那样将类型切换为您想要的任何类型。这是合法的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1269795|dynamic+i+=+12;
i+=+"text";|code-block|syntax|javascript|1269796|因此，您可以根据需要更改类型。使用它作为最后的手段；它是有益的，但我听说在幕后产生的IL方面发生了很多事情，这可能会以性能为代价。|1269797|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

It evaluates at runtime, so you can switch the type like you can in JavaScript to whatever you want. This is legit:

<pre><code>dynamic i = 12;
i = "text";
</code></pre>

And so you can change the type as you need. Use it as a last resort; it i s beneficial, but I heard a lot goes on under the scenes in terms of generated IL and that can come at a performance price.

blocks|key|1269849|text|dynamic关键字是C#+4.0中新增的关键字，用于告诉编译器变量的类型可以更改，或者直到运行时才知道。可以将其视为能够与对象交互，而不必强制转换对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1269850|dynamic+cust+=+GetCustomer();
cust.FirstName+=+"foo";+//+works+as+expected
cust.Process();+//+works+as+expected
cust.MissingMethod();+//+No+method+found!|code-block|syntax|javascript|1269851|请注意，我们不需要将cust强制转换或声明为Customer类型。因为我们声明它是动态的，所以运行库接管它，然后为我们搜索并设置FirstName属性。当然，现在当您使用动态变量时，您将放弃编译器类型检查。这意味着调用cust.MissingMethod()将会编译，直到运行时才会失败。此操作的结果是一个RuntimeBinderException，因为没有在Customer类上定义MissingMethod。|1269852|上面的例子展示了在调用方法和属性时dynamic是如何工作的。另一个强大的(也是潜在危险的)特性是能够对不同类型的数据重用变量。我相信Python、Ruby和Perl程序员可以想出一百万种方法来利用这一点，但是我使用C#太久了，以至于我觉得它是“错误的”。|1269853|dynamic+foo+=+123;
foo+=+"bar";|1269854|好的，所以你很可能不会经常写像上面这样的代码。然而，有时变量重用可能会派上用场，或者清理一段肮脏的遗留代码。我经常遇到的一个简单情况是，必须不断地在小数和双精度之间进行转换。|1269855|decimal+foo+=+GetDecimalValue();
foo+=+foo+/+2.5;+//+Does+not+compile
foo+=+Math.Sqrt(foo);+//+Does+not+compile
string+bar+=+foo.ToString("c");|1269856|第二行不能编译，因为2.5被定义为double类型，而第3行不能编译，因为Math.Sqrt需要double。显然，您所要做的就是强制转换和/或更改您的变量类型，但在某些情况下，使用dynamic可能是有意义的。|1269857|dynamic+foo+=+GetDecimalValue();+//+still+returns+a+decimal
foo+=+foo+/+2.5;+//+The+runtime+takes+care+of+this+for+us
foo+=+Math.Sqrt(foo);+//+Again,+the+DLR+works+its+magic
string+bar+=+foo.ToString("c");|1269858|阅读更多功能：http://www.codeproject.com/KB/cs/CSharp4Features.aspx|offset|length|1269859|entityMap|0|LINK|mutability|MUTABLE|url|http://www.codeproject.com/KB/cs/CSharp4Features.aspx^0|0|0|0|0|0|0|0|0|0|7|1H|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|18|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|19|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|1B|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|1D|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1E|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1F|8|@]|9|@$W|1G|X|1H|1|1I]]|A|$]]|$1|Y|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15]]]]

The dynamic keyword is new to C# 4.0, and is used to tell the compiler that a variable's type can change or that it is not known until runtime. Think of it as being able to interact with an Object without having to cast it.

<pre><code>dynamic cust = GetCustomer();
cust.FirstName = "foo"; // works as expected
cust.Process(); // works as expected
cust.MissingMethod(); // No method found!
</code></pre>

Notice we did not need to cast nor declare cust as type Customer. Because we declared it dynamic, the runtime takes over and then searches and sets the FirstName property for us. Now, of course, when you are using a dynamic variable, you are giving up compiler type checking. This means the call cust.MissingMethod() will compile and not fail until runtime. The result of this operation is a RuntimeBinderException because MissingMethod is not defined on the Customer class.

The example above shows how dynamic works when calling methods and properties. Another powerful (and potentially dangerous) feature is being able to reuse variables for different types of data. I'm sure the Python, Ruby, and Perl programmers out there can think of a million ways to take advantage of this, but I've been using C# so long that it just feels "wrong" to me.

<pre><code>dynamic foo = 123;
foo = "bar";
</code></pre>

OK, so you most likely will not be writing code like the above very often. There may be times, however, when variable reuse can come in handy or clean up a dirty piece of legacy code. One simple case I run into often is constantly having to cast between decimal and double.

<pre><code>decimal foo = GetDecimalValue();
foo = foo / 2.5; // Does not compile
foo = Math.Sqrt(foo); // Does not compile
string bar = foo.ToString("c");
</code></pre>

The second line does not compile because 2.5 is typed as a double and line 3 does not compile because Math.Sqrt expects a double. Obviously, all you have to do is cast and/or change your variable type, but there may be situations where dynamic makes sense to use.

<pre><code>dynamic foo = GetDecimalValue(); // still returns a decimal
foo = foo / 2.5; // The runtime takes care of this for us
foo = Math.Sqrt(foo); // Again, the DLR works its magic
string bar = foo.ToString("c");
</code></pre>

Read more feature : <a href="http://www.codeproject.com/KB/cs/CSharp4Features.aspx" rel="noreferrer">http://www.codeproject.com/KB/cs/CSharp4Features.aspx</a>

blocks|key|1269897|text|下面是一个使用示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1269898|您使用了许多具有通用属性'CreationDate‘的类：|1269899|public+class+Contact
{
++++//+some+properties

++++public+DateTime+CreationDate+{+get;+set;+}++++++++
}

public+class+Company
{
++++//+some+properties

++++public+DateTime+CreationDate+{+get;+set;+}

}

public+class+Opportunity
{
++++//+some+properties

++++public+DateTime+CreationDate+{+get;+set;+}

}|code-block|syntax|javascript|1269900|如果你写一个通信方法来检索'CreationDate‘属性的值，你必须使用反射：|1269901|++++static+DateTime+RetrieveValueOfCreationDate(Object+item)
++++{
++++++++return+(DateTime)item.GetType().GetProperty("CreationDate").GetValue(item);
++++}|1269902|有了“动态”的概念，你的代码就更优雅了：|1269903|++++static+DateTime+RetrieveValueOfCreationDate(dynamic+item)
++++{
++++++++return+item.CreationDate;
++++}|1269904|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

An example of use :

You consume many classes that have a commun property 'CreationDate' :

<pre><code>public class Contact
{
 // some properties

 public DateTime CreationDate { get; set; } 
}

public class Company
{
 // some properties

 public DateTime CreationDate { get; set; }

}

public class Opportunity
{
 // some properties

 public DateTime CreationDate { get; set; }

}
</code></pre>

If you write a commun method that retrieves the value of the 'CreationDate' Property, you'd have to use reflection:

<pre><code> static DateTime RetrieveValueOfCreationDate(Object item)
 {
 return (DateTime)item.GetType().GetProperty("CreationDate").GetValue(item);
 }
</code></pre>

With the 'dynamic' concept, your code is much more elegant :

<pre><code> static DateTime RetrieveValueOfCreationDate(dynamic item)
 {
 return item.CreationDate;
 }
</code></pre>

blocks|key|1055142|text|dynamic类型的另一个用例是遇到协方差或逆方差问题的虚拟方法。一个这样的例子是臭名昭著的Clone方法，它返回一个与被调用的对象类型相同的对象。使用动态返回并不能完全解决这个问题，因为它绕过了静态类型检查，但至少在使用普通object时，您不需要一直使用丑陋的强制转换。否则，强制转换就会变成隐式的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1055143|public+class+A
{
++++//+attributes+and+constructor+here
++++public+virtual+dynamic+Clone()
++++{
++++++++var+clone+=+new+A();
++++++++//+Do+more+cloning+stuff+here
++++++++return+clone;
++++}
}

public+class+B+:+A
{
++++//+more+attributes+and+constructor+here
++++public+override+dynamic+Clone()
++++{
++++++++var+clone+=+new+B();++++
++++++++//+Do+more+cloning+stuff+here
++++++++return+clone;
++++}
}++++

public+class+Program
{
++++public+static+void+Main()
++++{
++++++++A+a+=+new+A().Clone();++//+No+cast+needed+here
++++++++B+b+=+new+B().Clone();++//+and+here
++++++++//+do+more+stuff+with+a+and+b
++++}
}|code-block|syntax|javascript|1055144|entityMap^0|0|7|1A|5|35|6|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|L|$]]

Another use case for <code>dynamic</code> typing is for virtual methods that experience a problem with covariance or contravariance. One such example is the infamous <code>Clone</code> method that returns an object of the same type as the object it is called on. This problem is not completely solved with a dynamic return because it bypasses static type checking, but at least you don't need to use ugly casts all the time as per when using plain <code>object</code>. Otherwise to say, the casts become implicit.

<pre><code>public class A
{
 // attributes and constructor here
 public virtual dynamic Clone()
 {
 var clone = new A();
 // Do more cloning stuff here
 return clone;
 }
}

public class B : A
{
 // more attributes and constructor here
 public override dynamic Clone()
 {
 var clone = new B(); 
 // Do more cloning stuff here
 return clone;
 }
} 

public class Program
{
 public static void Main()
 {
 A a = new A().Clone(); // No cast needed here
 B b = new B().Clone(); // and here
 // do more stuff with a and b
 }
}
</code></pre>

C# 4.0 introduced a new type called 'dynamic'. It all sounds good, but what would a programmer use it for?

Is there a situation where it can save the day?

What is the 'dynamic' type in C# 4.0 used for?

编译器

Python

Perl

C# 4.0引入了一种称为“动态”的新类型。这一切听起来都不错，但是程序员会用它做什么呢？有没有一种情况，它可以拯救世界？

问C# 4.0中的“动态”类型是做什么用的？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C# 4.0中的“动态”类型是做什么用的？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C# 4.0中的“动态”类型是做什么用的？
EN