c# - 向下转换列表反对对象实际上是什么

Question

我有一个ParentClass. 两个类都继承自它，FirstChildClass并且SecondChildClass. 一个类MultipleValueTypes包含一个Dictionary和一个为其添加值的方法。我的目的是能够将继承自同一个抽象类的不同类的值传递给Dictionary. 因此，我使用该值初始化字典，List<ParentClass>以便能够将使用子类创建的对象添加到字典中。我可以这样做，但我无法访问它们，因此在抽象类中我创建了一种将它们区分开来的方法，这是两个子类都覆盖以返回它们自己的类类型的虚拟方法。

我根据枚举本身测试它们返回的值，并根据条件是否满足，对象将被强制转换为它是什么而不是 a List<ParentClass>。这是错误的方法吗？这是不可能的吗？

我认为它应该可以工作，因为在我看来FirstObjectandSecondObject仍然是它们各自类的对象，所以强制转换应该可以工作并且我应该能够访问被覆盖的方法。

什么不起作用：我无法访问返回它是什么类型的类的方法，因为它只从List<ParentClass>.

到目前为止我已经尝试过：寻找一种访问该方法的方法，但我没有找到任何方法。

我仍然需要帮助：上面提到的一切。

public abstract class ParentClass
    {
        public string Name { get; set; }
        public ParentClass(string Name)
        {
            this.Name = Name;
        }

        public enum ChildClasses
        {
            NoChildClass = 0,
            FirstChildClass = 1,
            SecondChildClass = 2
        }
        public virtual ChildClasses TypeOfClass()
        {
            return ChildClasses.NoChildClass;
        }
    }

public class FirstChildClass : ParentClass
    {
        private string _randomvalue;
        public string RandomValue { get => _randomvalue; set => _randomvalue = value; }
        public FirstChildClass(string Name) : base(Name)
        {

        }

        public void ReturnMessage()
        {
            Console.WriteLine("This is the FirstChildClass");
        }
        public override ChildClasses TypeOfClass()
        {
            return ChildClasses.FirstChildClass;
        }
    }

public class SecondChildClass : ParentClass
    {
        private string _randomvalue;
        public string RandomValue { get => _randomvalue; set => _randomvalue = value; }
        public SecondChildClass(string Name) : base(Name)
        {

        }
        public void ReturnMessage()
        {
            Console.WriteLine("This is the SecondChildClass");
        }

        public override ChildClasses TypeOfClass()
        {
            return ChildClasses.SecondChildClass;
        }
    }

class MultipleValueTypes
    {
        public Dictionary<string, List<ParentClass>> ADictionary = new Dictionary<string, List<ParentClass>>();

        public void AddObject(string Name, ParentClass variable)
        {
            if (!ADictionary.ContainsKey(Name))
            {
                ADictionary.Add(Name, new List<ParentClass>());
            }
            ADictionary[Name].Add(variable);
        }
    }

class Program
    {
        static void Main(string[] args)
        {
            FirstChildClass FirstObject = new FirstChildClass("FirstObject");
            SecondChildClass SecondObject = new SecondChildClass("SecondObject");
            MultipleValueTypes TestDictionary = new MultipleValueTypes();
            TestDictionary.AddObject("FirstObject", FirstObject);
            TestDictionary.AddObject("SecondObject", SecondObject);
            if(TestDictionary.ADictionary["FirstObject"].TypeOfClass() == ParentClass.ChildClasses.FirstChildClass) ///List<ParentClass>' does not contain a definition for 'TypeOfClass' and no accessible extension method 'TypeOfClass' accepting a first argument of type 'List<ParentClass>' could be found (are you missing a using directive or an assembly reference?)
            {
                TestDictionary.ADictionary["FirstObject"] = (FirstChildClass)TestDictionary.ADictionary["FirstObject"]; ///Cannot convert type 'System.Collections.Generic.List<Dictionary.ParentClass>' to 'Dictionary.FirstChildClass
            }
        }
    }

标签： c#dictionary

Answer 1

您忘记在此处使用字典键的列表值的索引器：

==> TestDictionary.ADictionary["FirstObject"][0]

这是您的代码现在也重构了：

class Program
{
  static void Main(string[] args)
  {
    var FirstObject = new FirstChildClass("FirstObject");
    var SecondObject = new SecondChildClass("SecondObject");
    FirstObject.ReturnMessage();
    SecondObject.ReturnMessage();
    MultipleValueTypes TestDictionary = new MultipleValueTypes();
    TestDictionary.AddObject("FirstObject", FirstObject);
    TestDictionary.AddObject("SecondObject", SecondObject);
    if ( TestDictionary.ADictionary["FirstObject"][0].TypeOfClass()
         == ParentClass.ChildClasses.FirstChildClass )
    {
      TestDictionary.ADictionary["FirstObject"][0]
        = (FirstChildClass)TestDictionary.ADictionary["FirstObject"][0];
    }
    Console.ReadKey();
  }
}

public abstract class ParentClass
{
  public string Name { get; set; }
  public string RandomValue { get; set; }
  public ParentClass(string Name)
  {
    this.Name = Name;
  }
  public virtual void ReturnMessage()
  {
    Console.WriteLine($"This is the {this.GetType().Name} instance");
  }
  public virtual ChildClasses TypeOfClass()
  {
    return ChildClasses.NoChildClass;
  }
  public enum ChildClasses
  {
    NoChildClass = 0,
    FirstChildClass = 1,
    SecondChildClass = 2
  }
}

public class FirstChildClass : ParentClass
{
  public FirstChildClass(string Name)
    : base(Name)
  {

  }
  public override ChildClasses TypeOfClass()
  {
    return ChildClasses.FirstChildClass;
  }
}

public class SecondChildClass : ParentClass
{
  public SecondChildClass(string Name)
    : base(Name)
  {
  }
  public override ChildClasses TypeOfClass()
  {
    return ChildClasses.SecondChildClass;
  }
}

class MultipleValueTypes
{
  public readonly Dictionary<string, List<ParentClass>> ADictionary
    = new Dictionary<string, List<ParentClass>>();
  public void AddObject(string Name, ParentClass variable)
  {
    if ( !ADictionary.ContainsKey(Name) )
    {
      ADictionary.Add(Name, new List<ParentClass>());
    }
    ADictionary[Name].Add(variable);
  }
}