在c#中发布订户模式需要建议

我需要为演示构建一些东西，我想知道是否可以使用pub-sub模式来实现Console.Write和Console.ReadLine 我想打印一组问题和答案，但找不到实现答案的方法

您将把Console.Write（）和Console.ReadLine（）放在哪里；把它传回去

请看我的noddy示例

namespace PubSubOne
{
    class Program
    {
        static void Main()
        {
            var processQuestions = new ProcessQuestions();
            processQuestions.StartQuestions();

            Console.Read();
        }
    }

    public class ProcessQuestions
    {
        NewsSubscriber subscriber = new NewsSubscriber();
        NewsPublisher publisher = new NewsPublisher();

        public ProcessQuestions()
        {

            publisher.QuestionChanged += subscriber.Update;


        }
        public void StartQuestions()
        {
            publisher.PublishQuestion("what is your favourite Newspaper?");

        }
    }
    public class NewsSubscriber
    {
        public void Update(string question)
        {
            Console.Write(question);
        }
    }
    public class NewsPublisher
    {
        private readonly List<string> _questions = new List<string>();

        public delegate void NotifyObserversHandler(string question);

        public event NotifyObserversHandler QuestionChanged;

        public void PublishQuestion(string question)
        {
            _questions.Add(question);

            QuestionChanged(_questions[_questions.Count - 1]);
        }
    }
}

名称空间PubSubOne
{
班级计划
{
静态void Main（）
{
var processQuestions=新的processQuestions（）；
processQuestions.StartQuestions（）；
Console.Read（）；
}
}
公开课问题
{
NewsSubscriber=NewsSubscriber（）；
NewsPublisher=新的NewsPublisher（）；
公共程序问题（）
{
publisher.QuestionChanged+=subscriber.Update；
}
公共无效开始查询（）
{
publisher.PublishQuestion（“你最喜欢的报纸是什么？”）；
}
}
公共类新闻订户
{
公共无效更新（字符串问题）
{
控制台。写（问题）；
}
}
公共类新闻发布者
{
私有只读列表_questions=new List（）；
公共委托无效NotifyObserversHandler（字符串问题）；
公共事件NotifyObserversHandler问题已更改；
公共无效发布问题（字符串问题）
{
_问题.加入（问题）；
问题更改（_questions[_questions.Count-1]）；
}
}
}

有什么建议吗？ 感谢您抽出时间使用系统

；
using System;
using System.Collections.Generic;

namespace PubSubOne
{
    class Program
    {
        static void Main()
        {
            var processQuestions = new ProcessQuestions();
            processQuestions.StartQuestions();

            Console.ReadLine();
        }
    }

    public class ProcessQuestions
    {
        NewsSubscriber subscriber = new NewsSubscriber();
        NewsPublisher publisher = new NewsPublisher();

        Stack<string> _answers = new Stack<string>();

        public ProcessQuestions()
        {
            publisher.QuestionAsked += subscriber.Asked;
            subscriber.QuestionAnswered += (answer) => _answers.Push(answer);
        }


        public void StartQuestions()
        {
            publisher.PublishQuestion("what is your favourite Newspaper?");
            publisher.PublishQuestion("what is your email?");
            publisher.PublishQuestion("what is your email password?");

            Console.WriteLine("Answers: ");

            foreach (var answer in _answers)
            {
                Console.WriteLine(answer);
            }
        }
    }

    public class NewsSubscriber
    {
        public delegate void NotifyAnswered(string question);

        public event NotifyAnswered QuestionAnswered;

        public void Asked(string question)
        {
            Console.Write(question);

            if (QuestionAnswered != null)
            {
                QuestionAnswered(Console.ReadLine());
            }
        }
    }

    public class NewsPublisher
    {
        private readonly List<string> _questions = new List<string>();

        public delegate void NotifyObserversHandler(string question);

        public event NotifyObserversHandler QuestionAsked;

        public void PublishQuestion(string question)
        {
            _questions.Add(question);
            QuestionAsked(_questions[_questions.Count - 1]);
        }
    }
}

使用System.Collections.Generic；
命名空间PubSubOne
{
班级计划
{
静态void Main（）
{
var processQuestions=新的processQuestions（）；
processQuestions.StartQuestions（）；
Console.ReadLine（）；
}
}
公开课问题
{
NewsSubscriber=NewsSubscriber（）；
NewsPublisher=新的NewsPublisher（）；
堆栈_answers=新堆栈（）；
公共程序问题（）
{
publisher.QuestionAsked+=订阅者.Asked；
subscriber.QuestionResponsed+=（答案）=>\u answers.Push（答案）；
}
公共无效开始查询（）
{
publisher.PublishQuestion（“你最喜欢的报纸是什么？”）；
publisher.PublishQuestion（“你的电子邮件是什么？”）；
publisher.PublishQuestion（“您的电子邮件密码是什么？”）；
控制台。WriteLine（“答案：”）；
foreach（var应答在_应答中）
{
控制台。写线（应答）；
}
}
}
公共类新闻订户
{
公共代表无效（字符串问题）；
公共事件回答问题；
公开提问（字符串问题）
{
控制台。写（问题）；
如果（问题已回答！=null）
{
已回答的问题（Console.ReadLine（））；
}
}
}
公共类新闻发布者
{
私有只读列表_questions=new List（）；
公共委托无效NotifyObserversHandler（字符串问题）；
公共事件NotifyObserversHandler提问；
公共无效发布问题（字符串问题）
{
_问题.加入（问题）；
提问（_questions[_questions.Count-1]）；
}
}
}

也许不是最好的办法。但这对我很有效。很抱歉没有描述

离题

我们听说你喜欢观察者，所以我们在你的订户里放了一个观察者，这样你可以在观察的时候观察

编辑

无事件订户：

class Program
{
    static void Main()
    {
        var processQuestions = new ProcessQuestions();
        processQuestions.StartQuestions();
        processQuestions.PrintAnswers();
        Console.ReadLine();
    }
}

public class ProcessQuestions
{
    NewsSubscriber subscriber1 = new NewsSubscriber("Tim");
    NewsSubscriber subscriber2 = new NewsSubscriber("Bob");
    NewsPublisher publisher = new NewsPublisher();

    public ProcessQuestions()
    {
        publisher.QuestionAsked += subscriber1.Asked;
        publisher.QuestionAsked += subscriber2.Asked;
    }

    public void StartQuestions()
    {
        publisher.PublishQuestion("what is your favourite Newspaper?");
        publisher.PublishQuestion("what is your email?");
        publisher.PublishQuestion("what is your email password?");
    }

    public void PrintAnswers()
    {
        var subs = new[] {subscriber1, subscriber2};

        foreach (var newsSubscriber in subs)
        {
            Console.WriteLine(newsSubscriber.Name + " answers:");
            foreach (var answer in newsSubscriber.Answers)
            {
                Console.WriteLine(answer);
            }
        }
    }
}

public class NewsSubscriber
{
    private readonly string _name;

    public NewsSubscriber(string name)
    {
        _name = name;
    }

    List<string> _answers = new List<string>();

    public string Name
    {
        get { return _name; }
    }

    public List<string> Answers { get { return _answers; } }

    public void Asked(string question)
    {
        Console.WriteLine(_name + " says: ");
        _answers.Add(Console.ReadLine());
    }
}

public class NewsPublisher
{
    private readonly List<string> _questions = new List<string>();

    public delegate void NotifyObserversHandler(string question);

    public event NotifyObserversHandler QuestionAsked;

    public void PublishQuestion(string question)
    {
        _questions.Add(question);
        Console.Write(question);
        QuestionAsked(_questions[_questions.Count - 1]);
    }
}

类程序
{
静态void Main（）
{
var processQuestions=新的processQuestions（）；
processQuestions.StartQuestions（）；
processQuestions.PrintAnswers（）；
Console.ReadLine（）；
}
}
公开课问题
{
新闻订户subscriber1=新新闻订户（“Tim”）；
新闻订户subscriber2=新新闻订户（“Bob”）；
NewsPublisher=新的NewsPublisher（）；
公共程序问题（）
{
publisher.QuestionAsked+=subscriber1.Asked；
publisher.QuestionAsked+=subscriber2.Asked；
}
公共无效开始查询（）
{
publisher.PublishQuestion（“你最喜欢的报纸是什么？”）；
publisher.PublishQuestion（“你的电子邮件是什么？”）；
publisher.PublishQuestion（“您的电子邮件密码是什么？”）；
}
公开答案（）
{
var subs=new[]{subscriber1，subscriber2}；
foreach（子系统中的var newsSubscriber）
{
Console.WriteLine（newsubscriber.Name+“answers:”）；
foreach（newsSubscriber.Answers中的var应答）
{
控制台。写线（应答）；
}
}
}
}
公共类新闻订户
{
私有只读字符串\u名称；
公共新闻订阅服务器（字符串名称）
{
_名称=名称；
}
列表_answers=新列表（）；
公共字符串名
{
获取{return\u name；}
}
公共列表答案{获取{返回_答案；}}
公开提问（字符串问题）
{
控制台。WriteLine（_name+”表示：）；
_Add（Console.ReadLine（））；
}
}
公共类新闻发布者
{
私有只读列表_questions=new List（）；
公共委托无效NotifyObserversHandler（字符串问题）；
公共事件NotifyObserversHandler提问；
公共无效发布问题（字符串问题）
{
_问题.加入（问题）；
控制台。写（问题）；
提问（_questions[_questions.Count-1]）；
}
}

不使用事件，而是使用派生类

注意环境变量（使用正斜杠而不是窗口）