There are 3 "general" types (although not all are real types) in C#: object, var and dynamic.

Object

An actual type, like any other type, with one special rule: if a type doesn't inherit, it inherits from object. From this, it follows that all types inherit from object, directly or indirectly.

Emphasis: object is a type. An object can be of type object, and the type has its methods, like ToString(). Since everything inherits from object, everything can be upcast into object. When you assign an object to an object reference, you are doing upcasting just like when you assign an Elephant type object to an Animal reference where Elephant inherits from Animal.

SomeType x = new SomeType();
object obj = x;
obj.DoSomething();

• obj is treated as being of type object at compile time, and will be of type object at runtime (which is logical, since it is an actual type - obj is declared as object so can only be of that type)
• obj.DoSomething() will cause a compile-time error, as object does not have this method, regardless of whether SomeType has it.

Var

This is not an actual type, it is merely shorthand for "compiler, figure out the type for me based on the right side of the assignment".

SomeType x = new SomeType();
var obj = x;
obj.DoSomething();

• obj is treated as being of type SomeType at compile time, and will be of type SomeType at runtime, just as if you had written "SomeType" instead of "var".
• if SomeType has a method DoSomething(), this code will work
• if SomeType doesn't have the method, the code will cause a compile-time error

Dynamic

This is a type that tells the compiler to disable compile-time type checking on the variable. An object is treated as having the type dynamic at compile-time and run-time.

SomeType x = new SomeType();
dynamic obj = x;
obj.DoSomething();

• obj is of type dynamic at compile and run time
• if SomeType has a method DoSomething(), this code will work
• if SomeType doesn't have the method, the code will compile, but throw an exception at run-time

• note that dynamic can cause exceptions very easily if used carelessly:

  public void f(dynamic x)
  { 
      x.DoSomething();
  }
  

This will throw an exception if x is of a type that doesn't have the DoSomething method, but it will still be possible to call it and pass any object as the parameter without a compile-time error, causing an error that only shows itself at run-time, and possibly only in specific circumstances - a potential bug. So if you use dynamic in any kind of public interface of a class, you should always manually type-check at runtime using reflection, carefully deal with exceptions, or not do it in the first place.

Note: the object being referred to never changes its type, of course. While obj may be object, the x that it refers to is still SomeType.

不同之处在于，如果您使用 object 并尝试访问 object 的某些成员，这将是编译时错误（因为 object 没有此成员）。为了工作，您需要知道类型是什么并进行转换。

使用动态您可以访问任何成员 - 没有编译时错误。如果该成员在运行时不存在，则将是运行时错误。例如，如果您知道您的异质对象都具有相同的成员，那么这就是要走的路。

但是，如果是这种情况，还有另一个更清晰的解决方案：您可以使用此成员定义一个接口，然后使您的所有异类对象都实现它，并且您的列表可以是List<IYourInterface>.

请记住，动态的性能可能会稍差，因为动态类型解析。