程序在此控制台中写入时在控制台中写入

Question

Is it possible to write something in the console while the program is writing something in this console ? It can be useful when you rename, or remove some files, when you do a repetitive action, and the program is writing a lot in the console. Then you will be able to write a command to stop the execution of the repetitive action while the program is continuing to write in the console. I think it's not very clear, well I illustrated you this fact with the code which I think the most apt (but I precise that it doesn't work ;) ). We have 3 classes.

The main class :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        private static bool m_Write;

        public static bool write
        {
            get { return m_Write; }
            set { m_Write = value; }
        }

        static void Main(string[] args)
        {
            int index = 0;

            Console.ReadLine();

            m_Write = true;

            Reader reader = new Reader();

            while (m_Write)
            {
                index++;

                Writer writer = new Writer(index.ToString());
            }

        }
    }
}

The reading class :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;

namespace ConsoleApplication1
{
    class Reader
    {
        private Thread m_Reading_Thread;
        private string m_text_To_Read;

        public Reader()
        {
            m_Reading_Thread = new Thread(new ThreadStart(Read));
            m_Reading_Thread.Start();
        }

        public void Read()
        {
            m_text_To_Read = Console.ReadLine();

            if (m_text_To_Read == "Stop")
            {
                Program.write = false;
            }
        }
    }
}

And the writing class :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;

namespace ConsoleApplication1
{
    class Writer
    {
        private Thread m_Writing_Thread;
        private string m_Text_To_Write;

        public Writer(string text_To_Write)
        {
            m_Text_To_Write = text_To_Write;

            m_Writing_Thread = new Thread(new ThreadStart(Write));
            m_Writing_Thread.Start();
        }

        public void Write()
        {
            Console.WriteLine(m_Text_To_Write);
        }
    }
}

Answer 1

This isn't nearly as complicated as you're trying to make it. In general there are two ways you can do this. You can start a background thread to do the writing, and have the main thread block on the console waiting for the read, or you can have the main thread writing and have the background thread do the read. I like the first solution best:

public class Program
{
    private static readonly ManualResetEvent StopWriting = new ManualResetEvent(false);

    private static void Main(string[] args)
    {
        Thread t = new Thread(WriterFunc);
        t.Start();

        string input;
        do
        {
            input = Console.ReadLine();
        } while (input != "stop");

        // Tell the thread to stop writing
        StopWriting.Set();

        // And wait for the thread to exit
        t.Join();
    }

    private static void WriterFunc()
    {
        int index = 0;
        while (!StopWriting.WaitOne(Timeout.Infinite))
        {
            ++index;
            Console.WriteLine(index.ToString());
        }
    }
}

Note that I used a ManualResetEvent here rather than a Boolean flag. An even better solution would be to use a CancellationToken . Using a flag can cause all kinds of interesting problems because the compiler might determine that the variable can't change (it assumes single-threaded access). Your thread might continue running even after the variable is changed.

If you want the main thread to do the writing, and the background thread to do the reading:

public class Program
{
    private static readonly ManualResetEvent StopWriting = new ManualResetEvent(false);

    private static void Main(string[] args)
    {
        Thread t = new Thread(ReaderFunc);
        t.Start();

        int index = 0;
        while (!StopWriting.WaitOne(Timeout.Infinite))
        {
            ++index;
            Console.WriteLine(index.ToString());
        }

        // Wait for the background thread to exit
        t.Join();
    }

    private static void ReaderFunc()
    {
        string input;
        do
        {
            input = Console.ReadLine();
        } while (input != "stop");

        // Tell the main thread to stop writing
        StopWriting.Set();
    }
}

Answer 2

Something like this would work:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            var w = new Writer();
            var r = new Reader();

            while (!r.finish)
            {
                w.enabled = true;
                string k = Console.ReadKey(false).KeyChar.ToString();
                w.enabled = false;

                string line = k + Console.ReadLine();
                r.Read(line);
            }
        }
    }

    class Writer
    {
        public bool enabled = true;

        public Writer()
        {
            var timer = new System.Timers.Timer(1000);
            timer.Elapsed += (a, b) =>
            {
                if(enabled)
                    Console.WriteLine("Test");
            };
            timer.Start();
        }
    }

    class Reader
    {
        public bool finish = false;

        public void Read(string line)
        {
            if (line == "stop")
            {
                finish = true;
            }
        }
    }
}

Don't worry if the Writer writes above what you are typing, the Console.ReadLine() only considers what you have typed.

Answer 3

In the case of a console application, no two threads can write data to the screen at the exact same time.

AFAIK, in the above answer, the Writes()'s constructor is continuously executed until it finishes running. Then the control will be passed to the Reader(). So I don't think that works for what you need. Correct me if I am wrong.