.net “；动态”；和“；对象”；C#中的关键字？_.net_C# 4.0

.net “；动态”；和“；对象”；C#中的关键字？

.net c#-4.0

.net “；动态”；和“；对象”；C#中的关键字？,.net,c#-4.0,.net,C# 4.0,有人能简要解释一下C#中“动态”和“对象”关键字之间的区别吗？请查看Anders Hejlsberg的谈话，以便更好地理解动态请在此页上查看这些关键字指的是.NET常用类型基本上：对象类型是.NET Framework中对象的别名。在C#的统一类型系统中，所有类型，预定义的和用户定义的、引用类型和值类型（包括动态）都直接或间接地从对象继承。可以将任何类型的值指定给object类型的变量谈论动态：动态类型使发生动态类型的操作能够绕过编译时类型检查。相反，这些操作是在运行时解决的。动态类

有人能简要解释一下C#中“动态”和“对象”关键字之间的区别吗？

请查看Anders Hejlsberg的谈话，以便更好地理解动态

请在此页上查看

这些关键字指的是.NET常用类型

基本上：对象类型是.NET Framework中对象的别名。在C#的统一类型系统中，所有类型，预定义的和用户定义的、引用类型和值类型（包括动态）都直接或间接地从对象继承。可以将任何类型的值指定给object类型的变量

谈论动态：

动态类型使发生动态类型的操作能够绕过编译时类型检查。相反，这些操作是在运行时解决的。动态类型简化了对COM API（如Office Automation API）、动态API（如IronPython库）和HTML文档对象模型（DOM）的访问

在大多数情况下，类型动态的行为与类型对象类似。但是，编译器不会解析或检查包含dynamic类型表达式的操作。编译器将有关操作的信息打包在一起，这些信息稍后用于在运行时评估操作。作为过程的一部分，dynamic类型的变量被编译成object类型的变量。因此，类型dynamic只在编译时存在，而不在运行时存在

请注意，此解释摘自MSDN页面。

```
object
```
就是这样：一个简单的C#object，只有最少的方法。在.NET中，它充当所有内容的内置基类（确保所有内容至少具有
```
ToString（）
```
、
```
Equals（）
```
、和
```
GetHashCode（）
```
）
```
dynamic
```
相反，对象是完全不同的种类<代码>动态允许在其他静态类型语言中后期绑定道具和方法-引入一些功能并与动态类型语言（如Python）更好地兼容

对象

object obj = 10;
Console.WriteLine(obj.GetType());
// Prints System.Int32 because 
// this is the type of the value stored in this object.

// A compiler error, because 
// at compile time the type of obj is System.Object.
// obj = obj + 10; 

// You need to explicitly cast obj to a necessary type.
obj = (int)obj + 10;

// However, this does not mean that you are really safe. 
// You can cast to a wrong type 
// and the compiler will not detect it. 
// Here you get an exception at run time, 
// because obj is an integer, not a string.
// obj = (string)obj + 10;

// You also get a run-time exception 
// if you cast to a wrong numeric type, 
// even if there is an implicit conversion in the language.
// obj = (double)obj + 10;

object obj = 10;

// Doesn't compile.
//Print(obj);

// Compiles, but there is an exception at run time.
//Print((string)obj);

// This code works because obj is now a string, 
// but you still need a cast.
obj = "10";
Print((string)obj);

动态

dynamic dyn = 10;
Console.WriteLine(dyn.GetType());
// Same as "object". 
// Prints System.Int32 because 
// this is the type of the value stored in this object.

// No compiler error, because 
// the compiler does not try to identify 
// the type of the dynamic object at compile time.
dyn = dyn + 10;

// Also, this operation will succeed for all numeric 
// or other types that support a “+” operation.
dyn = 10.0;
dyn = dyn + 10;

dyn = "10";
dyn = dyn + 10;

public static void Print(string arg)
{
    Console.WriteLine(arg);
}
Now let’s look at how you can pass a dynamic object to it.

dynamic dyn = 10;

// You get an exception at run time here.
Print(dyn);

dynamic dyn = "10";
Print(dyn);

object obj = 10;
Console.WriteLine(obj.GetType());
// Prints System.Int32 because 
// this is the type of the value stored in this object.

// A compiler error, because 
// at compile time the type of obj is System.Object.
// obj = obj + 10; 

// You need to explicitly cast obj to a necessary type.
obj = (int)obj + 10;

// However, this does not mean that you are really safe. 
// You can cast to a wrong type 
// and the compiler will not detect it. 
// Here you get an exception at run time, 
// because obj is an integer, not a string.
// obj = (string)obj + 10;

// You also get a run-time exception 
// if you cast to a wrong numeric type, 
// even if there is an implicit conversion in the language.
// obj = (double)obj + 10;

object obj = 10;

// Doesn't compile.
//Print(obj);

// Compiles, but there is an exception at run time.
//Print((string)obj);

// This code works because obj is now a string, 
// but you still need a cast.
obj = "10";
Print((string)obj);

结论

object obj = 10;
Console.WriteLine(obj.GetType());
// Prints System.Int32 because 
// this is the type of the value stored in this object.

// A compiler error, because 
// at compile time the type of obj is System.Object.
// obj = obj + 10; 

// You need to explicitly cast obj to a necessary type.
obj = (int)obj + 10;

// However, this does not mean that you are really safe. 
// You can cast to a wrong type 
// and the compiler will not detect it. 
// Here you get an exception at run time, 
// because obj is an integer, not a string.
// obj = (string)obj + 10;

// You also get a run-time exception 
// if you cast to a wrong numeric type, 
// even if there is an implicit conversion in the language.
// obj = (double)obj + 10;

object obj = 10;

// Doesn't compile.
//Print(obj);

// Compiles, but there is an exception at run time.
//Print((string)obj);

// This code works because obj is now a string, 
// but you still need a cast.
obj = "10";
Print((string)obj);