Приложение, позволяющее рисовать (одним цветом) во окне формы при помощи мыши

void Main()
{
    Application.Run(new MainForm());
}
 
class DelayedEvent: IDisposable
{
    private System.Windows.Forms.Timer _timer;
    private TimeSpan _delay;
    
    public DelayedEvent(TimeSpan delay)
    {
        _delay = delay;
    }
    
    public void Raise()
    {
        _timer?.Dispose();
        _timer = new System.Windows.Forms.Timer() { Enabled = true, Interval = (int)_delay.TotalMilliseconds };
        
        _timer.Tick += (_, __) =>
        {
            _timer?.Dispose();
            Proc?.Invoke();
        };
    }
    
    public void Dispose()
    {
        _timer?.Dispose();
    }
    
    public event Action Proc;
}
 
/// <summary>
/// Обертка над Bitmap для быстрого чтения и изменения пикселов.
/// Также, класс контролирует выход за пределы изображения: при чтении за границей изображения - возвращает DefaultColor, при записи за границей изображения - игнорирует присвоение.
/// </summary>
public class ImageWrapper : IDisposable, IEnumerable<Point>
{
    /// <summary>
    /// Ширина изображения
    /// </summary>
    public int Width { get; private set; }
    /// <summary>
    /// Высота изображения
    /// </summary>
    public int Height { get; private set; }
    /// <summary>
    /// Цвет по-умолачнию (используется при выходе координат за пределы изображения)
    /// </summary>
    public Color DefaultColor { get; set; }
 
    private unsafe byte* data 
    { 
        get
        {
            return (byte*)bmpData.Scan0.ToPointer();
        }
    } //буфер исходного изображения
    private int stride;
    private BitmapData bmpData;
    private Bitmap bmp;
 
    /// <summary>
    /// Создание обертки поверх bitmap.
    /// </summary>
    /// <param name="copySourceToOutput">Копирует исходное изображение в выходной буфер</param>
    public ImageWrapper(Bitmap bmp)
    {
        Width = bmp.Width;
        Height = bmp.Height;
        this.bmp = bmp;
 
        bmpData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
        stride = bmpData.Stride;
    }
 
    /// <summary>
    /// Возвращает пиксел из исходнго изображения.
    /// Либо заносит пиксел в выходной буфер.
    /// </summary>
    unsafe public Color this[int x, int y]
    {
        get
        {
            var i = GetIndex(x, y);
            return i < 0 ? DefaultColor : Color.FromArgb(data[i + 3], data[i + 2], data[i + 1], data[i]);
        }
 
        set
        {
            var i = GetIndex(x, y);
            if (i >= 0)
            {
                data[i] = value.B;
                data[i + 1] = value.G;
                data[i + 2] = value.R;
                data[i + 3] = value.A;
            };
        }
    }
 
    /// <summary>
    /// Возвращает пиксел из исходнго изображения.
    /// Либо заносит пиксел в выходной буфер.
    /// </summary>
    public Color this[Point p]
    {
        get { return this[p.X, p.Y]; }
        set { this[p.X, p.Y] = value; }
    }
 
    /// <summary>
    /// Заносит в выходной буфер значение цвета, заданные в double.
    /// Допускает выход double за пределы 0-255.
    /// </summary>
    public void SetPixel(Point p, double r, double g, double b)
    {
        if (r < 0) r = 0;
        if (r >= 256) r = 255;
        if (g < 0) g = 0;
        if (g >= 256) g = 255;
        if (b < 0) b = 0;
        if (b >= 256) b = 255;
 
        this[p.X, p.Y] = Color.FromArgb((int)r, (int)g, (int)b);
    }
 
    int GetIndex(int x, int y)
    {
        return (x < 0 || x >= Width || y < 0 || y >= Height) ? -1 : x * 4 + y * stride;
    }
 
    /// <summary>
    /// Заносит в bitmap выходной буфер и снимает лок.
    /// Этот метод обязателен к исполнению (либо явно, лмбо через using)
    /// </summary>
    public void Dispose()
    {
        bmp.UnlockBits(bmpData);
    }
 
    /// <summary>
    /// Перечисление всех точек изображения
    /// </summary>
    public IEnumerator<Point> GetEnumerator()
    {
        for (int y = 0; y < Height; y++)
            for (int x = 0; x < Width; x++)
                yield return new Point(x, y);
    }
 
    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}
 
class DisposableCollection : IDisposable
{
    private List<IDisposable> _items = new List<IDisposable>();
    
    public T Register<T>(T obj) where T : class
    {
        var disposable = obj as IDisposable;
        
        if (disposable != null)
            _items.Add(disposable);
            
        return obj;
    }
    
    public void Dispose(object obj)
    {
        var disposable = obj as IDisposable;
        
        disposable?.Dispose();
        _items.Remove(disposable);
    }
    
    public void Dispose()
    {
        _items.ForEach(e => e.Dispose());
    }
}
 
class MainForm : Form
{
    private DisposableCollection _components = new DisposableCollection();
 
    protected override void Dispose(bool disposing)
    {
        _components.Dispose();
        base.Dispose(disposing);
    }
    
    private Bitmap _image;
    
    private Point? _previousMark;
    private void Mark(Point location)
    {
        if (_previousMark != null)
        {
            using (var g = Graphics.FromImage(_image))
            using (var pen = new Pen(Color.LightGreen, 1))
            {
                g.SmoothingMode = SmoothingMode.HighQuality;
                g.DrawLine(pen, (Point)_previousMark, location);
            }
        }
        _previousMark = location;
    }
    
    public MainForm()
    {
        base.DoubleBuffered = true;
        base.BackColor = Color.Black;
        
        _image = _components.Register(new Bitmap(ClientSize.Width, ClientSize.Height));
        
        bool mouseDown = false;
 
        MouseDown += (_, e) =>
        {
            if (e.Button != MouseButtons.Left) return;
            
            mouseDown = true;
            Mark(e.Location);
            Invalidate();
        };
 
        MouseUp += (_, e) =>
        {
            if (e.Button != MouseButtons.Left) return;
            
            mouseDown = false;
            Mark(e.Location);
            _previousMark = null;
            Invalidate();
        };
 
        MouseMove += (_, e) =>
        {
            if (!mouseDown) return;
            
            Mark(e.Location);
            Invalidate();
        };
 
        var delayed = _components.Register(new DelayedEvent(TimeSpan.FromMilliseconds(100)));
        
        delayed.Proc += () =>
        {
            var newImage = _components.Register(new Bitmap(Math.Max(ClientSize.Width, 1), Math.Max(ClientSize.Height, 1)));
        
            using (var sourceImage = new ImageWrapper(_image))
            using (var destImage = new ImageWrapper(newImage))
                foreach (var p in sourceImage)
                    destImage[p] = sourceImage[p];
        
            _components.Dispose(_image);
            _image = newImage;
        
            Invalidate();
        };
 
        Click += (_, e) =>
        {
            if ((e as MouseEventArgs).Button == MouseButtons.Right)
            {
                using (var g = Graphics.FromImage(_image))
                using (var brush = new SolidBrush(BackColor))
                {
                    g.FillRectangle(brush, g.ClipBounds);
                    Invalidate();
                }
            }
        };
 
        Resize += (_, __) =>
        {
            _previousMark = null;
            delayed.Raise();
        };
    }
    
    protected override void OnPaint(PaintEventArgs e)
    {
        e.Graphics.DrawImage(_image, Point.Empty);
    }
}