Синхронизация (потоки)

class LabelInfo
{
    public string Text { get; }
    public Color Color { get; }
    public Point Position { get; }
    
    public LabelInfo(string text, Color color, Point position)
    {
        if (text == null)
        {
            throw new ArgumentNullException(nameof(text));
        }
        Text = text;
        Color = color;
        Position = position;
    }
}
 
class LabelAddedEventArgs : EventArgs
{
    public string Text { get; }
    public Color Color { get; }
    
    public LabelAddedEventArgs(string text, Color color)
    {
        Text = text;
        Color = color;
    }
}
 
interface ILabelManager
{
    Point CurrentPosition { set; }
    void AddLabel(string text, Color color);
    event EventHandler ContentAdded;
    IEnumerable<LabelInfo> Labels { get; }
}
 
class LabelManager : ILabelManager
{
    private List<LabelInfo> _labels = new List<LabelInfo>();
    public Point CurrentPosition { private get; set; }
    
    public void AddLabel(string text, Color color)
    {
        if (text == null)
        {
            throw new ArgumentNullException(nameof(text));
        }
        _labels.Add(new LabelInfo(text, color, CurrentPosition));
        ContentAdded?.Invoke(this, EventArgs.Empty);
    }
    
    public IEnumerable<LabelInfo> Labels => _labels.ToList();
    
    public event EventHandler ContentAdded;
}
 
interface IThreadManager
{
    int MaxThreads { set; }
    int MaxCounterValue { set; }
    bool TryAddThread();
    event EventHandler<LabelAddedEventArgs> LabelAdded;
}
 
class ThreadManager : IThreadManager
{
    private TimeSpan _delay;
    
    public ThreadManager(TimeSpan delay)
    {
        _delay = delay;
    }
    
    private int _maxThreads;
    public int MaxThreads
    {
        private get { return _maxThreads; }
        set
        {
            if (value < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(value));
            }
            _maxThreads = value;
        }
    }
 
    private int _maxCounterValue;
    public int MaxCounterValue
    {
        private get { return  _maxCounterValue; }
        set
        {
            if (value < 1)
            {
                throw new ArgumentOutOfRangeException(nameof(value));
            }
            _maxCounterValue = value;
        }
    }
    
    private void GenerateLabels(Color color)
    {
        int counter = 1;
        while (counter <= MaxCounterValue)
        {
            Thread.Sleep(_delay);
            if (counter <= MaxCounterValue)
            {
                LabelAdded?.Invoke(this, new LabelAddedEventArgs(counter.ToString(), color));
                counter += 1;
            }
        }
        FinishGeneration();
    }
    
    private void FinishGeneration()
    {
        lock (_counterLocker)
        {
            _currentThreadsCounter -= 1;
            if (_currentThreadsCounter == 0)
            {
                Monitor.PulseAll(_counterLocker);
            }
            while (_currentThreadsCounter > 0)
            {
                Monitor.Wait(_counterLocker);
            }
        }
    }
 
    public event EventHandler<LabelAddedEventArgs> LabelAdded;
    
    private int _currentThreadsCounter;
    private object _counterLocker = new object();
 
    public bool TryAddThread()
    {
        Color[] colors = { Color.Red, Color.Green, Color.Blue, Color.Black, Color.Beige };
        Color color;
        lock (_counterLocker)
        {
            if (_currentThreadsCounter >= MaxThreads)
            {
                return false;
            }
            color = colors[_currentThreadsCounter % colors.Length];
            _currentThreadsCounter += 1;
        };
        new Thread(_ => GenerateLabels(color)) { IsBackground = true }.Start();
        return true;
    }
}
 
interface IModel
{
    bool TryAddThread();
    Point CursorPosition { set; }
    int MaxThreads { set; }
    int MaxCounterValue { set; }
    IEnumerable<LabelInfo> Labels { get; }
    event EventHandler ContentChanged;
}
 
class Model : IModel
{
    private ILabelManager _labelManager;
    private IThreadManager _threadManager;
    private object _locker = new object();
    
    public Model(ILabelManager labelManager, IThreadManager threadManager)
    {
        if (labelManager == null)
        {
            throw new ArgumentNullException(nameof(labelManager));
        }
        if (threadManager == null)
        {
            throw new ArgumentNullException(nameof(threadManager));
        }
        _labelManager = labelManager;
        _threadManager = threadManager;
        _labelManager.ContentAdded += delegate { ContentChanged?.Invoke(this, EventArgs.Empty); };
        _threadManager.LabelAdded += (_, e) =>
        {
            lock (_locker)
            {
                _labelManager.AddLabel(e.Text, e.Color);
            }
        };
    }
    
    public bool TryAddThread()
    {
        return _threadManager.TryAddThread();
    }
 
    public Point CursorPosition
    {
        set { _labelManager.CurrentPosition = value; }
    }
 
    public int MaxThreads
    {
        set { _threadManager.MaxThreads = value; }
    }
 
    public int MaxCounterValue
    {
        set { _threadManager.MaxCounterValue = value; }
    }
 
    public IEnumerable<LabelInfo> Labels
    {
        get
        {
            lock (_locker)
            {
                return _labelManager.Labels;
            }
        }
    }
    
    public event EventHandler ContentChanged;
}
 
class MainForm : Form
{
    private IModel _model;
    
    public MainForm()
    {
        MouseClick += HandleMouseClick;
        MouseMove += HandleMouseMove;
        base.DoubleBuffered = true;
        base.Width = 400;
        base.MinimumSize = new Size(400, 200);
    }
    
    private void BuildControls()
    {
        foreach (var control in Controls.Cast<Control>())
        {
            control.Dispose();
        }
        var lblMaxThreads = new Label { Text = "Максимум потоков:", Width = 200, Parent = this };
        var nudMaxThreads = new NumericUpDown { Minimum = 0, Increment = 1, Left = lblMaxThreads.Right + Padding.All, Parent = this };
        nudMaxThreads.ValueChanged += (sender, _) =>
        {
            int value = (int)((NumericUpDown)sender).Value;
            _model.MaxThreads = value;
        };
        nudMaxThreads.Value = 1;
 
        var lblMaxCounterValue = new Label { Text = "Максимальное значение счётчика:", Width = 200, Top = lblMaxThreads.Bottom + Padding.All, Parent = this };
        var nudMaxCounterValue = new NumericUpDown
        {
            Minimum = 1,
            Increment = 1,
            Left = lblMaxCounterValue.Right + Padding.All,
            Top = lblMaxCounterValue.Top,
            Parent = this
        };
        nudMaxCounterValue.ValueChanged += (sender, _) =>
        {
            int value = (int)((NumericUpDown)sender).Value;
            _model.MaxCounterValue = value;
        };
        nudMaxCounterValue.Value = 5;
    }
    
    private void HandleMouseMove(object sender, EventArgs e)
    {
        if (_model == null)
        {
            return;
        }
        var mouse = (MouseEventArgs)e;
        _model.CursorPosition = mouse.Location;
    }
    
    private void HandleMouseClick(object sender, EventArgs e)
    {
        if (_model == null)
        {
            return;
        }
        var mouse = (MouseEventArgs)e;
        if (mouse.Button != MouseButtons.Left)
        {
            return;
        }
        _model.TryAddThread();
    }
    
    public void Build(IModel model)
    {
        if (model == null)
        {
            throw new ArgumentNullException(nameof(model));
        }
        _model = model;
        _model.ContentChanged += delegate { BeginInvoke(new Action(() => Invalidate())); };
        BuildControls();
    }
    
    protected override void OnPaint(PaintEventArgs e)
    {
        using (var font = new Font(FontFamily.GenericSansSerif, 30))
        {
            foreach (var labelInfo in _model.Labels)
            {
                using (var brush = new SolidBrush(labelInfo.Color))
                {
                    e.Graphics.DrawString(labelInfo.Text, font, brush, new PointF(labelInfo.Position.X, labelInfo.Position.Y));
                }
            }
        }
    }
}
 
void Main()
{
    ILabelManager labelManager = new LabelManager();
    IThreadManager threadManager = new ThreadManager(TimeSpan.FromMilliseconds(500));
    IModel model = new Model(labelManager, threadManager);
    var form = new MainForm();
    form.Build(model);
    Application.Run(form);
}