概念性帮助单个列表中的不同类别<>?

罗丹

活跃的成员
加入
2015年4月7日
消息
41
编程经验
10+
我正在使用Beaglebone / Mono的项目在一个项目上工作,我想在单个DataGridView上显示所有输入,输出,警报等。问题是这些的类是完全不同的。我可以只使用单独的课程并手动填补DGV,但我认为应该有一种方法可以使用"info"类包含所有其他类,然后使用"Info"填充控制的课程。

关于我能想到的唯一方法是使用类型的成员"Object"要指向实际类,以便信息类条目均可与列表相同<>并控制着。然后我必须弄清楚哪个课程"Object"是并在需要时提取适当的信息。

这是一种很好的方法,还是有人可以建议更优雅的东西。不一定需要代码,只是朝着正确的方向轻推。

谢谢!

P.S.使用VS2013或2015
 

jmplhinney.

C#论坛主持人
工作人员
加入
2011年4月23日
消息
3,717
地点
悉尼,澳大利亚
编程经验
10+
如果您真的想下轨道,那么您可以定义一个包装类,了解所有其他类型,并可以通过一组公共属性提取数据并公开它。然后,您可以创建一个包含一个原始类别的实例的每个项目的该类型的列表。然后,您可以简单地将列表绑定到网格中。你的班级可能看起来像这样:
    internal class FirstItemType
    {
        public string SomeText { get; set; }
        public int SomeNumber { get; set; }
    }

    internal class SecondItemType
    {
        public string MyText { get; set; }
        public int MyNumber { get; set; }
    }

    internal class ItemWrapper
    {
        private FirstItemType firstInstance;
        private SecondItemType secondInstance;

        public ItemWrapper(FirstItemType firstInstance)
        {
            this.firstInstance = firstInstance;
        }

        public ItemWrapper(SecondItemType secondInstance)
        {
            this.secondInstance = secondInstance;
        }

        public string Text
        {
            get
            {
                string value = null;

                if (firstInstance != null)
                {
                    value = firstInstance.SomeText;
                }
                else if (secondInstance != null)
                {
                    value = secondInstance.MyText;
                }

                return value;
            }
            set
            {
                if (firstInstance != null)
                {
                    firstInstance.SomeText = value;
                }
                else if (secondInstance != null)
                {
                    secondInstance.MyText = value;
                }
            }
        }

        public int Number
        {
            get
            {
                int value = 0;

                if (firstInstance != null)
                {
                    value = firstInstance.SomeNumber;
                }
                else if (secondInstance != null)
                {
                    value = secondInstance.MyNumber;
                }

                return value;
            }
            set
            {
                if (firstInstance != null)
                {
                    firstInstance.SomeNumber = value;
                }
                else if (secondInstance != null)
                {
                    secondInstance.MyNumber = value;
                }
            }
        }
    }
写作有点费力但是,一旦你拥有,它会使用不同的类型很容易。
 

罗丹

活跃的成员
加入
2015年4月7日
消息
41
编程经验
10+
这不是我想要描述的(我认为的)。包装类实例只有一次分配给它的包装类实例,我认为您在示例中瞄准两个(?)。

哦等等......现在我看到了它。通过分配给它的类类型调用公共方法(我还没有通过这种方式玩多种公共方法)。

我想知道我是否可以基于包装的类类型而不是大量的if-chen使用交换块。

非常感谢解释。它真的有助于!
 

约翰

C#论坛主持人
工作人员
加入
2011年4月23日
消息
1,158
地点
挪威
编程经验
10+
如果可以修改不同类型,可以定义接口并在类型中实现该类型,然后使用列表<Interfacetype>作为数据源。您可以添加实现此列表的任何对象。 DataGridView将使用接口属性从不同对象中显示数据。
 

jmplhinney.

C#论坛主持人
工作人员
加入
2011年4月23日
消息
3,717
地点
悉尼,澳大利亚
编程经验
10+
我想知道我是否可以基于包装的类类型而不是大量的if-chen使用交换块。

不,你不能。与在VB.NET中的选择案例不同,“开关”中的“C”中的“开关”中是否需要每个“案例”中的常量值。基本上意味着价值类型或字符串。
 

Stonecodemonkey.

新成员
加入
2016年7月7日
消息
3
编程经验
10+
抽象的

定义一个抽象类,其中包含以一致方式发布数据。然后在每个现有类中实现抽象类。

C#:
    [COLOR=#569cd6][B]abstract[/B][/COLOR] [COLOR=#569cd6][B]class[/B][/COLOR] [COLOR=#4ec9b0]AbstractPublisher[/COLOR]
    {
        [COLOR=#569cd6][B]public[/B][/COLOR] [COLOR=#569cd6][B]abstract[/B][/COLOR] [COLOR=#569cd6][B]string[/B][/COLOR] [COLOR=white]MyData[/COLOR] { [COLOR=#569cd6][B]get[/B][/COLOR]; [COLOR=#569cd6][B]set[/B][/COLOR]; }    
    }
 
    [COLOR=#569cd6][B]class[/B][/COLOR] [COLOR=#4ec9b0]MyClass[/COLOR]:[COLOR=#4ec9b0]AbstractPublisher[/COLOR]
    {
 
        [COLOR=#569cd6][B]public[/B][/COLOR] [COLOR=#569cd6][B]override[/B][/COLOR] [COLOR=#569cd6][B]string[/B][/COLOR] [COLOR=white]MyData[/COLOR]
        {
            [COLOR=#569cd6][B]get[/B][/COLOR]
            {
                [COLOR=#569cd6][B]throw[/B][/COLOR] [COLOR=#569cd6][B]new[/B][/COLOR] [COLOR=#4ec9b0]NotImplementedException[/COLOR]();
            }
            [COLOR=#569cd6][B]set[/B][/COLOR]
            {
                [COLOR=#569cd6][B]throw[/B][/COLOR] [COLOR=#569cd6][B]new[/B][/COLOR] [COLOR=#4ec9b0]NotImplementedException[/COLOR]();
            }
        }
    }

覆盖抽象属性并使用它们发布数据。
 

jmplhinney.

C#论坛主持人
工作人员
加入
2011年4月23日
消息
3,717
地点
悉尼,澳大利亚
编程经验
10+
定义一个抽象类,其中包含以一致方式发布数据。然后在每个现有类中实现抽象类。

C#:
    [COLOR=#569cd6][B]abstract[/B][/COLOR] [COLOR=#569cd6][B]class[/B][/COLOR] [COLOR=#4ec9b0]AbstractPublisher[/COLOR]
    {
        [COLOR=#569cd6][B]public[/B][/COLOR] [COLOR=#569cd6][B]abstract[/B][/COLOR] [COLOR=#569cd6][B]string[/B][/COLOR] [COLOR=white]MyData[/COLOR] { [COLOR=#569cd6][B]get[/B][/COLOR]; [COLOR=#569cd6][B]set[/B][/COLOR]; }    
    }
 
    [COLOR=#569cd6][B]class[/B][/COLOR] [COLOR=#4ec9b0]MyClass[/COLOR]:[COLOR=#4ec9b0]AbstractPublisher[/COLOR]
    {
 
        [COLOR=#569cd6][B]public[/B][/COLOR] [COLOR=#569cd6][B]override[/B][/COLOR] [COLOR=#569cd6][B]string[/B][/COLOR] [COLOR=white]MyData[/COLOR]
        {
            [COLOR=#569cd6][B]get[/B][/COLOR]
            {
                [COLOR=#569cd6][B]throw[/B][/COLOR] [COLOR=#569cd6][B]new[/B][/COLOR] [COLOR=#4ec9b0]NotImplementedException[/COLOR]();
            }
            [COLOR=#569cd6][B]set[/B][/COLOR]
            {
                [COLOR=#569cd6][B]throw[/B][/COLOR] [COLOR=#569cd6][B]new[/B][/COLOR] [COLOR=#4ec9b0]NotImplementedException[/COLOR]();
            }
        }
    }

覆盖抽象属性并使用它们发布数据。
这假设每个派生类型具有相同的一组属性对此有意义。 OP说课程完全不同,所以我不认为这在这种情况下会有意义。
 

Stonecodemonkey.

新成员
加入
2016年7月7日
消息
3
编程经验
10+
当然,但......

这假设每个派生类型具有相同的一组属性对此有意义。 OP说课程完全不同,所以我不认为这在这种情况下会有意义。

当然,但是,OP想要使用公共DGV来显示数据。因此,如果OP具有常见的抽象类,甚至是继承自继承的基类,则简化了产生这些对象的集合。一旦对象处于集合中,它们就可以轻松呈现在DGV中。

简短于实现追踪每个对象类型的每个实例的类,并将需要呈现给DGV的格式或公共对象的数据,导出从公共基础是最简单的方式。

DGV需要一个集合,因此为什么不在必需的属性中烘焙基类,然后将它们添加到适合于DGV的集合类型?

问候,

顺便说一下,基于标题"概念性帮助单一的不同课程 列表 <>?",抽象或基类直接支持列表的想法<AbstractDataSource>。这允许OP获取他们正在寻找的单个列表。

C#:
namespace Abstract
{
    class Program
    {
        static void Main(string[] args)
        {
            MyClass c = new MyClass();
            c.Iterate();
            Console.Read();
        }
    }


    abstract class AbstractDataPublisher
    {
        public abstract string MyData { get; }
    }


    class Class1 : AbstractDataPublisher
    {
        string data;
        public override string MyData
        {
            get
            {
                return data;
            }


        }
        public Class1()
        {
            data = "Class1.Tada!";
        }


    }
    class Class2 : AbstractDataPublisher
    {


        int data;
        public override string MyData
        {
            get
            {
                return string.Format("Class{0}.Tada!", data.ToString());
            }
        }


        public Class2()
        {
            data = 2;
        }
    }
    class Class3 : AbstractDataPublisher
    {
        double data;
        public override string MyData
        {
            get
            {
                return string.Format("Class{0}.Tada!", data.ToString());
            }
        }


        public Class3()
        {
            data = 3d;
        }
    }


    class MyClass
    {
        List<AbstractDataPublisher> myList;


        public MyClass()
        {
            myList = new List<AbstractDataPublisher>();


            myList.Add(new Class1());
            myList.Add(new Class2());
            myList.Add(new Class3());
        }


        public void Iterate()
        {
            foreach (var item in myList)
            {
                Console.WriteLine(item.MyData);
            }
        }


    }
}
 
Last edited:

jmplhinney.

C#论坛主持人
工作人员
加入
2011年4月23日
消息
3,717
地点
悉尼,澳大利亚
编程经验
10+
当然,但是,OP想要使用公共DGV来显示数据。因此,如果OP具有常见的抽象类,甚至是继承自继承的基类,则简化了产生这些对象的集合。一旦对象处于集合中,它们就可以轻松呈现在DGV中。

简短于实现追踪每个对象类型的每个实例的类,并将需要呈现给DGV的格式或公共对象的数据,导出从公共基础是最简单的方式。

DGV需要一个集合,因此为什么不在必需的属性中烘焙基类,然后将它们添加到适合于DGV的集合类型?

问候,

顺便说一下,基于标题"概念性帮助单一的不同课程 列表 <>?",抽象或基类直接支持列表的想法<AbstractDataSource>。这允许OP获取他们正在寻找的单个列表。

C#:
namespace Abstract
{
    class Program
    {
        static void Main(string[] args)
        {
            MyClass c = new MyClass();
            c.Iterate();
            Console.Read();
        }
    }


    abstract class AbstractDataPublisher
    {
        public abstract string MyData { get; }
    }


    class Class1 : AbstractDataPublisher
    {
        string data;
        public override string MyData
        {
            get
            {
                return data;
            }


        }
        public Class1()
        {
            data = "Class1.Tada!";
        }


    }
    class Class2 : AbstractDataPublisher
    {


        int data;
        public override string MyData
        {
            get
            {
                return string.Format("Class{0}.Tada!", data.ToString());
            }
        }


        public Class2()
        {
            data = 2;
        }
    }
    class Class3 : AbstractDataPublisher
    {
        double data;
        public override string MyData
        {
            get
            {
                return string.Format("Class{0}.Tada!", data.ToString());
            }
        }


        public Class3()
        {
            data = 3d;
        }
    }


    class MyClass
    {
        List<AbstractDataPublisher> myList;


        public MyClass()
        {
            myList = new List<AbstractDataPublisher>();


            myList.Add(new Class1());
            myList.Add(new Class2());
            myList.Add(new Class3());
        }


        public void Iterate()
        {
            foreach (var item in myList)
            {
                Console.WriteLine(item.MyData);
            }
        }


    }
}

我同意你刚才所说的一切,但我以前的陈述仍然存在。如果派生的类是op状态,那么你的建议就无法起作用,因为op状态显着不同。如果他们不是太差,那么你的建议很棒。如果他们是那么它根本没有帮助。
 
最佳 底部