Question

我想将2种类实例排入队列。例如，如下，

要排队的课程

class A{
    int a1;
    int a2;
}
class B{
    string b1;
    string b2;
}

的Sample1）

ConcurrentQueue<Object> queue = ConcurrentQueue<Object>();
queue.Enqueue(new A());
queue.Enqueue(new B());
Object item;
while (queue.TryDequeue(out item))
{
    A a = item as A;
    B b = item as B;
    if(a != null){
    }
    else if(b != null){
    }
}

样品2）

class AorB{
    public A a = null;
    public B b = null;
    public AorB(A a){ this.a = a; }
    public AorB(B b){ this.b = b; }
}
ConcurrentQueue<AorB> queue = new ConcurrentQueue<AorB>();
queue.Enqueue(new AorB(new A()));
queue.Enqueue(new AorB(new B()));
AorB item;
while (queue.TryDequeue(out item))
{
    if(item.a != null){
    }
    else if(item.b != null){
    }
}

哪种方式更好，Sample1，Sample2或其他？

Answer 1

它们都不是一个好的实现。如果（正如您在评论中提到的那样）它们用于打印或哔哔声等命令，并且它们的成员不同，那么您应该考虑他们做什么。一个更好的解决方法是将他们正在做的事情提取到诸如

之类的界面中

public interface ICommand
{
    void Execute();
}

然后让A和B实现ICommand，以便他们的打印和哔哔声由A和B处理。这样你的调用代码就会变成这样：

ConcurrentQueue<ICommand> queue = ConcurrentQueue<ICommand>();
queue.Enqueue(new A());
queue.Enqueue(new B());
Object item;
while (queue.TryDequeue(out item))
{
    item.execute();
}

这也符合“告诉，不要问”。

Answer 2

这是应用Command模式的完美情况。

让每个对象实现一个公开Execute方法的公共接口。然后让对象通过任何必要的手段来处理命令。通过将命令的执行封装到对象本身中，这使代码更清晰，更具可扩展性。

这是记事本代码，因此语法可能会有轻微错误。

namespace
{
    public interface ICommand
    {
        public void Execute();
    }

    public class CommandA : ICommand
    {
        public int value;

        public void Execute()
        {
            // Do something here
        }
    }

    public class CommandB : ICommand
    {
        public string value;

        public void Execute()
        {
            // Do something here
        }
    }

    public class Program
    {
        private Queue<ICommand> commands = new Queue<ICommand>();

        public Program()
        {
            this.commands.Enqueue(new CommandA());
            this.commands.Enqueue(new CommandB());

            // Much later
            while (item = this.commands.Dequeue())
            {
                item.Execute();
            }
        }
    }
}

Answer 3

嗯，他们俩都不是。如果你需要将另一个类的实例排队，比如C，那么你的if语句将变得可维护。

你必须考虑如何处理出列物品。如果您只是将其存储在队列中，则为每种类型使用两个或更多队列。如果您将它们用于某些事物而不管它们是什么类型，那么请考虑使用类型实现的接口或其他类型将继承的基类。

由于您没有提供此用例，我的建议是抽象的。

Answer 4

我实际上不会说1或2.

如果A和B共享一个公共接口，为什么不使用任何继承，否则只有两个队列，如果它们没有任何共同点，则每个队列对应一个队列。

如果他们没有任何共同点，也许你不应该只使用一段代码来使用它们。两种线程，每种类型一个看起来可能很好，具体取决于用例。

排队不同类型的类实例

4 个答案: