C# 何时将动态类型与泛型类型一起使用？

我有一个关于使用dynamic关键字的良好实践的问题。假设我们有一个特定的情况：

public class MyObject
{
    public string Id { get; set; }
    public void DoSth() { /* ... */ }
}

public class Object1 : MyObject { /* ... */ }
public class Object2 : MyObject { /* ... */ }
public class Object3 : MyObject { /* ... */ }

public abstract class MyContainer
{
    public abstract dynamic Get(string id);
}

public class MyContainer<T>: MyContainer where T : MyObject
{
    private Dictionary<string, T> _container;
    public override dynamic Get(string id)
    {
        T result;
        _container.TryGetValue(id, out result);
        return result;
    }
}

public class MyStorage
{
    private MyContainer<Object1> _objects1;
    private MyContainer<Object1> _objects2;
    private MyContainer<Object1> _objects3;

    public Dictionary<Type, MyContainer> GetContainer;

    public MyStorage()
    {
        GetContainer = new Dictionary<Type, MyContainer>() 
        {
            { typeof(Object1), _objects1 },
            { typeof(Object2), _objects2 },
            { typeof(Object3), _objects3 }
        }
    }
}

public static class Program
{
    public static void Main()
    {
        MyStorage storage = new MyStorage();
        // defining a sotrage ...

        Type objectType = //let's say we have it
        string objectId = //let's say we have it

        (storage.GetContainer[objectType].Get(objectId) as MyObject).DoSth();
    }
}

公共类MyObject
{
公共字符串Id{get；set；}
public void DoSth（）{/*…*/}
}
公共类Object1:MyObject{/*…*/}
公共类Object2:MyObject{/*…*/}
公共类Object3:MyObject{/*…*/}
公共抽象类MyContainer
{
公共抽象动态Get（字符串id）；
}
公共类MyContainer:MyContainer，其中T:MyObject
{
专用字典容器；
公共覆盖动态获取（字符串id）
{
T结果；
_container.TryGetValue（id，out结果）；
返回结果；
}
}
公共类MyStorage
{
私人MyContainer_objects1；
私人MyContainer_objects2；
私人MyContainer_对象3；
公共容器；
公共MyStorage（）
{
GetContainer=newdictionary（）
{
{typeof（Object1），_objects1}，
{typeof（Object2），_objects2}，
{typeof（Object3），_objects3}
}
}
}
公共静态类程序
{
公共静态void Main（）
{
MyStorage storage=新MyStorage（）；
//定义一个拍卖场。。。
Type objectType=//假设我们拥有它
string objectId=//假设我们拥有它
（storage.GetContainer[objectType].Get（objectId）作为MyObject.DoSth（）；
}
}

---

我在“Get”方法中返回一个动态值并将其转换为MyObject，看起来还好吗？或者dynamic关键字可能没有问题，但在整个概念中，创建这样的存储（保留按类型和标识符获取对象的功能）？

这里不需要使用

dynamic

。您可以简化MyContainer，使其成为一个不受约束的泛型，并让

Get

返回一个

T

：

  public class MyContainer<T>
  {
    private Dictionary<string, T> _container;
    public T Get(string id)
    {
      T result;
      _container.TryGetValue(id, out result);
      return result;
    }
  }

---

但是，这样做会浪费拥有泛型类的全部目的。您还可以将

MyContainer

设置为非泛型，并将对

T

的任何引用替换为

MyObject

似乎没有必要使用动态，因为约束是MyObject。动态用于在运行时不知道类型的情况OK，那么如果我只是替换MyObject类型而不是Dynamic，那么代码是好的？我不会说永不、永不、永不使用

Dynamic

。几乎从来没有，从来没有。“那么代码是好的”我不敢评估：）但是用

MyObject

替换它肯定会使它更健壮。但是如果我在这里使用MyObject而不是“T”，那么每次我想要获得自己的属性/方法/等等，我都必须转换到Object1、Object2、Object3。

public class MyContainer<T> where T: MyObject