Fatal编程技术网
  • csharp/
  • C# 向下播放列表<；抽象类>；对象实际是什么

C# 向下播放列表<；抽象类>；对象实际是什么

c# dictionary

C# 向下播放列表<；抽象类>；对象实际是什么,c#,dictionary,C#,Dictionary,我有一个父类。两个类继承自它，FirstChildClass和SecondChildClass。类MultipleValueTypes包含一个字典和一个向其添加值的方法。我的目的是能够将继承自同一抽象类的不同类的值传递给字典的value参数。因此，我使用值List初始化字典，以便能够将使用子类创建的对象添加到字典中。我可以这样做，但我不能访问它们，因此在抽象类中我创建了一种区分它们的方法，一个虚拟方法，两个子类都重写它以返回它们自己的类类型 我根据枚举本身测试它们返回的值，并根据条件是否满足，对

我有一个
父类
。两个类继承自它，
FirstChildClass
和
SecondChildClass
。类
MultipleValueTypes
包含一个
字典
和一个向其添加值的方法。我的目的是能够将继承自同一抽象类的不同类的值传递给
字典
的value参数。因此，我使用值
List
初始化字典，以便能够将使用子类创建的对象添加到字典中。我可以这样做，但我不能访问它们，因此在抽象类中我创建了一种区分它们的方法，一个虚拟方法，两个子类都重写它以返回它们自己的类类型

我根据枚举本身测试它们返回的值，并根据条件是否满足，对象将按原样而不是按
列表来强制转换。这是错误的方法吗？这不可能吗

我认为它应该有效，因为在我看来，
FirstObject
和
SecondObject
仍然是各自类的对象，所以强制转换应该有效，我应该能够访问重写的方法

什么不起作用：我无法访问返回它是什么类型的类的方法，因为它只从
列表中获取方法

到目前为止，我一直在尝试：寻找访问该方法的方法，但我没有找到任何方法

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


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;
        }
    }



类多值类型
{
公共字典ADictionary=新字典（）；
public void AddObject（字符串名称，ParentClass变量）
{
如果（！ADictionary.ContainsKey（名称））
{
Add（Name，newlist（））；
}
a字典[名称]。添加（变量）；
}
}



类程序
{
静态void Main（字符串[]参数）
{
FirstChildClass FirstObject=新的FirstChildClass（“FirstObject”）；
SecondChildClass SecondObject=新的SecondChildClass（“SecondObject”）；
MultipleValueTypes TestDictionary=新的MultipleValueTypes（）；
AddObject（“FirstObject”，FirstObject）；
AddObject（“SecondObject”，SecondObject）；
如果（TestDictionary.ADictionary[“FirstObject”].TypeOfClass（）==ParentClass.ChildClasses.FirstChildClass）///List”不包含“TypeOfClass”的定义，并且找不到接受“List”类型的第一个参数的可访问扩展方法“TypeOfClass”（是否缺少using指令或程序集引用？）
{
TestDictionary.ADictionary[“FirstObject”]=（FirstChildClass）TestDictionary.ADictionary[“FirstObject”]；///无法将类型“System.Collections.Generic.List”转换为“Dictionary.FirstChildClass”
}
}
}

如果打算将整个列表从
列表
转换为
列表
和
列表
，那么Linq就是您的朋友，只需使用
转换
功能：


List<FirstChildClass> firstChildClasses = TestDictionary.ADictionary["FirstObject"]
    .Cast<FirstChildClass>().ToList();
List<SecondChildClass> secondChildClasses = TestDictionary.ADictionary["SecondObject"]
   .Cast<SecondChildClass>().ToList();



List firstChildClasses=TestDictionary.ADictionary[“FirstObject”]
.Cast（）.ToList（）；
List SecondChildClass=TestDictionary.adDictionary[“SecondObject”]
.Cast（）.ToList（）；

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


==> 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);
  }
}



类程序
{
静态void Main（字符串[]参数）
{
var FirstObject=新的FirstChildClass（“FirstObject”）；
var SecondObject=新的SecondChildClass（“SecondObject”）；
FirstObject.ReturnMessage（）；
SecondObject.ReturnMessage（）；
MultipleValueTypes TestDictionary=新的MultipleValueTypes（）；
AddObject（“FirstObject”，FirstObject）；
AddObject（“SecondObject”，SecondObject）；
if（TestDictionary.adDictionary[“FirstObject”][0].TypeOfClass（）
==ParentClass.ChildClasses.FirstChildClass）
{
TestDictionary.ADictionary[“FirstObject”][0]
=（FirstChildClass）TestDictionary.ADictionary[“FirstObject”][0]；
}
Console.ReadKey（）；
}
}
公共抽象类父类
{
公共字符串名称{get；set；}
公共字符串随机值{get；set；}
公共父类（字符串名称）
{
this.Name=Name；
}
公共虚拟空返回消息（）
{
WriteLine（$“这是{This.GetType（）.Name}实例”）；
}
公共虚拟子类TypeOfClass（）
{
返回ChildClasses.NoChildClass；
}
公共枚举子类
{
NoChildClass=0，
FirstChildClass=1，
SecondChildClass=2
}
}
公共类FirstChildClass:ParentClass
{
公共FirstChildClass（字符串名称）
：base（名称）
{
}
公共重写子类TypeOfClass（）
{
返回ChildClasses.FirstChildClass；
}
}
公共类SecondChildClass:父类
{
公共SecondChildClass（字符串名称）
：base（名称）
{
}
公共重写子类TypeOfClass（）
{
返回ChildClasses.SecondChildClass；
}
}
类多值类型
{
公共只读词典
=新字典（）；
public void AddObject（字符串名称，ParentClass变量）
{
如果（！ADictionary.ContainsKey（名称））
{
Add（Name，newlist（））；
}
a字典[名称]。添加（变量）；
}
}

///无法将类型“System.Collections.Generic.List”转换为“TextGame.Items.InventoryItems.Wallet”
是一个存储桶，可以包含许多不同类型的项目（以及多个项目），就像单个钱包一样？@mjwills否，但这是将不同类型的项目添加到单个词典中的唯一方法。钱包在
itemsinializers
中初始化，并添加到通用容器保护伞下的字典中。在这种情况下，向下转换在理论上不是有效的吗？“列表对象应该是

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
            }
        }
    }



List<FirstChildClass> firstChildClasses = TestDictionary.ADictionary["FirstObject"]
    .Cast<FirstChildClass>().ToList();
List<SecondChildClass> secondChildClasses = TestDictionary.ADictionary["SecondObject"]
   .Cast<SecondChildClass>().ToList();



==> 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);
  }
}