C# 这些类之间的通信实现

我正在寻找关于实现以下内容的最佳方法的提示：

我有一个类，它接收输入，比如说，每秒接收一次输入，并在接收到该输入时触发一个事件（随它一起发送输入信息）

此活动由其他几个班级订阅。
每个类都有一个：

• “排名”（一个

  int

  字段），
  
• bool方法

  条件

  （其中 根据事件的输入检查条件）和 方法名为run。
  

触发事件时，所有类都调用

条件

方法。如果该方法返回true，我希望仅在具有最高排名的类上调用run方法

我实现它的方式是在触发事件时，所有类都将排名和run方法添加到列表中（如果不满足条件，则添加0排名）。
当列表达到一个设定的数量时，它会选择排名最高的，并调用相关的方法

代码如下：

class mainClass
{
    void Input(int input)
    {
         goEvent?.Invoke(input);
    }

    public event Action<int> goEvent;

    public int TEMP_COUNTER=0;
    public int TEMP_RANK=0;
    public string TEMP_METHODNAME = "";
}

class class1
{
    //...
    int rank = 4;

    bool condition(int n)
    {
      if(n > 10)
          return true;
      else
          return false;
    }

    void run(){}

    void mainClassEventHandler(int input)
    {
        if (condition(input)
        {
            addtolist(rank,run)
        }
        else
        {
          addtolist(0,null)
        }
    }
}

class class2
{
    //...
    int rank = 3;

    bool condition(int n)
    {
        if(n > 20)
            return true;
        else
            return false;
    }

    void run(){}

    void mainClassEventHandler(int input)
    {
      if (condition(input)
          addtolist(rank,run)
      else
          addtolist(0,null)
    }
}

class类main类
{
无效输入（int输入）
{
goEvent？调用（输入）；
}
公共事件行动；
公共int TEMP_计数器=0；
公共内部温度等级=0；
公共字符串TEMP_METHODNAME=“”；
}
一班
{
//...
int秩=4；
布尔条件（整数n）
{
如果（n>10）
返回true；
其他的
返回false；
}
无效运行（）{}
void mainClassEventHandler（int输入）
{
if（条件（输入）
{
地址列表（排名、运行）
}
其他的
{
addtolist（0，空）
}
}
}
二级
{
//...
int秩=3；
布尔条件（整数n）
{
如果（n>20）
返回true；
其他的
返回false；
}
无效运行（）{}
void mainClassEventHandler（int输入）
{
if（条件（输入）
地址列表（排名、运行）
其他的
addtolist（0，空）
}
}

我认为订阅模式不适合这个问题。您的“MainClass”需要更多地充当编排器（选择排名最高的可运行）来执行vs盲目生成事件

因此，让我们从“runner”类的接口开始：

现在，让我们添加一些实现：

   class Runner1 : RankedRunner
    {
        public int Rank => 3;

        public void Run()
        {
        }

        public bool Runnable(int input)
        {
            return input > 20;
        }
    }

    class Runner2 : RankedRunner
    {
        public int Rank => 4;

        public void Run()
        {
        }

        public bool Runnable(int input)
        {
            return input > 10;
        }
    }

最后，让我们根据一些输入协调调用跑步者：

    class Orchestration
    {
        private SortedList<RankedRunner, RankedRunner> runners;

        Orchestration()
        {
            // We need to sort our runners based on their rank. If two runners
            // have the same rank then use the object comparator.
            // Note that x and y get swapped so the largest rank will be ordered first.
            this.runners = new SortedList<RankedRunner, RankedRunner>(
                Comparer<RankedRunner>.Create(
                    (x, y) =>
                    {
                        return x.Rank == y.Rank
                            ? Comparer<RankedRunner>.Default.Compare(y, x)
                            : Comparer<int>.Default.Compare(y.Rank, x.Rank);
                    }));
        }

        Orchestration addRankedRunner(RankedRunner runner)
        {
            this.runners.Add(runner, runner);
            return this;
        }

        void Input(int input)
        {  
            // Find the highest ranked runner that is runnable.
            foreach(RankedRunner runner in runners.Values)
            {
                if(runner.Runnable(input))
                {
                    runner.Run();
                    break;
                }
            }
        }
    }

---

我认为订阅模式不适合这个问题。您的“MainClass”需要更多地充当编排器（选择排名最高的可运行）来执行vs盲目生成事件

因此，让我们从“runner”类的接口开始：

现在，让我们添加一些实现：

   class Runner1 : RankedRunner
    {
        public int Rank => 3;

        public void Run()
        {
        }

        public bool Runnable(int input)
        {
            return input > 20;
        }
    }

    class Runner2 : RankedRunner
    {
        public int Rank => 4;

        public void Run()
        {
        }

        public bool Runnable(int input)
        {
            return input > 10;
        }
    }

最后，让我们根据一些输入协调调用跑步者：

    class Orchestration
    {
        private SortedList<RankedRunner, RankedRunner> runners;

        Orchestration()
        {
            // We need to sort our runners based on their rank. If two runners
            // have the same rank then use the object comparator.
            // Note that x and y get swapped so the largest rank will be ordered first.
            this.runners = new SortedList<RankedRunner, RankedRunner>(
                Comparer<RankedRunner>.Create(
                    (x, y) =>
                    {
                        return x.Rank == y.Rank
                            ? Comparer<RankedRunner>.Default.Compare(y, x)
                            : Comparer<int>.Default.Compare(y.Rank, x.Rank);
                    }));
        }

        Orchestration addRankedRunner(RankedRunner runner)
        {
            this.runners.Add(runner, runner);
            return this;
        }

        void Input(int input)
        {  
            // Find the highest ranked runner that is runnable.
            foreach(RankedRunner runner in runners.Values)
            {
                if(runner.Runnable(input))
                {
                    runner.Run();
                    break;
                }
            }
        }
    }