计时器中graphics.DrawLine上的“ System.ArgumentException参数无效”

Question

I am trying to make one of my classes draw a flashing red line on my window for 10 seconds, but I get the System.ArgumentException: parameter is not valid error at my graphics.DrawLine . Trying to find the problem, I've went as far as recreating it with the minimal parts included. The red and dark functions, that draw the line work perfectly outside the timer's aTick event, but give the mentioned error while activated by it. Others get this error when the graphics or the Pen object is invalid, but to me it appears that this isn't the case here.

About my code: I've started programming quite recently, and I've heard only legends about databinding, and that it could've simplified my code, but curently it is out of my capabilities, so I've made the possibly quite crude, but otherwise working workaround of performing an action when a bool turns true (then turning it back false). That's what I'm using to initiate the flashing and also to redraw my graphics at each tick of the timer. I also needed a second Redraw bool because when I tried to change the redraw true at the end of the aTick event, it said: Cannot use ref or out parameter 'redraw' inside an anonymous method, lambda expression, or query expression . As you'll see I worked around it by adding that second bool, but it'd be great if you could also explain to me why is that happening and what's a better solution for it.

Here's the code of my Form:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace GrafikaTeszt
{
    public partial class Form1 : Form
    {

        bool flash = false; //can we draw the line?
        bool redraw = false;    //should we redraw?

        public Form1()
        {
            InitializeComponent();
        }

        Class1 classic = new Class1();

        private void Form1_Paint(object sender, PaintEventArgs e)
        {
            if (flash)
            {
                classic.makeitflash(e.Graphics, out redraw);

                if (redraw)
                {
                    Invalidate();
                }
            }
        }

        private void button1_Click(object sender, EventArgs e)
        {
            flash = true;
            Invalidate();
        }
    }
}

And Here's the code from the class from which I'm trying to draw the line:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Drawing;

namespace GrafikaTeszt
{
    class Class1
    {
        Timer clock;
        int ticks;

        public void makeitflash(Graphics g, out bool redraw)
        {
            redraw = false;
            bool Redraw = false;
            ticks = 0; 
            clock.Start();
            clock.Tick += new EventHandler(aTick);

            void aTick(object sender, EventArgs e)
            {
                if (ticks % 2 == 0)
                {
                    red();  //draw a red line
                }
                else
                {
                    dark();     //draw a darkred line
                }

                if (ticks == 20)
                {
                    clock.Stop();
                }
                ticks++;
                Redraw = true;
            }
            void red() { g.DrawLine(Pens.Red, 100, 100, 500, 500); }
            void dark() { g.DrawLine(Pens.DarkRed, 100, 100, 500, 500); }

            redraw = Redraw;
        }

        public Class1()
        {
            clock = new Timer();
            clock.Interval = 200;
        }
    }
}

Answer 1

You are making things way too hard. The basic diagnosis offered by the other answer is correct, but you got yourself into that situation by over-thinking the problem. Your new version is better, but still over-complicates things; it fails to use the modern async / await idiom, which can be used to write asynchronous code (like code that involves a timer) in a linear/synchronous way, and it still uses local methods for no apparent beneficial reason.

Here is a version of your code that is IMHO is significantly simpler and better:

public partial class Form1 : Form
{
    private Pen _currentPen = Pens.Black;

    public Form1()
    {
        InitializeComponent();
    }

    protected override void OnPaint(PaintEventArgs e)
    {
        base.OnPaint(e);

        e.Graphics.DrawLine(_currentPen, 100, 100, 500, 500);
    }

    private void button1_Click(object sender, EventArgs e)
    {
        // Ignore returned task...nothing more to do.
        var task = FlashLine(TimeSpan.FromMilliseconds(200), TimeSpan.FromSeconds(4));
    }

    private async Task FlashLine(TimeSpan interval, TimeSpan duration)
    {
        TimeSpan nextInterval = interval;
        Stopwatch sw = Stopwatch.StartNew();
        bool red = true;

        while (sw.Elapsed < duration)
        {
            TimeSpan wait = nextInterval - sw.Elapsed;

            // Just in case we got suspended long enough that the
            // next interval is already here
            if (wait > TimeSpan.Zero)
            {
                // "await" will suspend execution of this method, returning
                // control to the caller (i.e. freeing up the UI thread for
                // other UI activities). This method will resume execution
                // when the awaited task completed (in this case, a simple delay)
                await Task.Delay(wait);
            }

            _currentPen = red ? Pens.Red : Pens.Black;
            red = !red;
            Invalidate();

            // Just in case it the operation took too long and the initial next
            // interval time is still in the past. Use "do/while" to make sure
            // interval is always incremented at least once, because Task.Delay()
            // can occasionally return slightly (and imperceptibly) early and the
            // code in this example is so simple, that the nextInterval value might
            // still be later than the current time by the time execution reaches
            // this loop.
            do
            {
                nextInterval += interval;
            } while (nextInterval < sw.Elapsed);
        }

        _currentPen = Pens.Black;
        Invalidate();
    }
}

The most complicated element of the above is logic I added to ensure flashing as close as possible to the apparently-desired 200ms interval. Fact is, you can achieve nearly identical results even more simply if you're willing to allow for the flashing to wind up maybe dozens of milliseconds off (something no human user will ever notice):

    private async Task FlashLine(TimeSpan interval, TimeSpan duration)
    {
        int iterations = (int)(duration.TotalSeconds / interval.TotalSeconds);
        bool red = true;

        while (iterations-- > 0)
        {
            await Task.Delay(interval);

            _currentPen = red ? Pens.Red : Pens.Black;
            red = !red;
            Invalidate();
        }

        _currentPen = Pens.Black;
        Invalidate();
    }

Either way, this is IMHO much better than using a Timer , making a whole new class to handle all the logic, and using local methods just to deal with drawing a line. Of course, even if you decide you really want to use local methods and a separate class, the above can easily be refactored to accommodate that without the messiness of the Timer .

Answer 2

Your code is using the Windows paint event in a way it is not intended to be used.

Although documentation may not mention it , the Graphics object that is passed as an argument to the Form.Paint event handler, is valid for the duration of a single event only. Your code passes it to a timer, which attempts to access and use it long after the event handler has exited.

The second issue is the confusing use of the Redraw / redraw variables. A paint region should not be invalidated from within its Paint event handler.

Let the timer handle the state machine of the flashing, and have it call Invalidate . Then read the state from inside the Paint event handler and draw accordingly. MSDN even has some useful examples for this.

Answer 3

According to Hans Passant's diagnosis (e.Graphics can only be accessed by the function if you Invalidated at the exact moment) I managed to fix the problem after restructuring my program. By making most of my class public ( :( ), I could put the timer in the Form and still access my class. Having the timer in the Form, I can Invalidate at each tick, allowing the use of e.Graphics at the right moment. Here's the new code: Form:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace GrafikaTeszt
{
    public partial class Form1 : Form
    {
        Timer clock;
        Class1 classic;
        bool stop;

        public Form1()
        {
            InitializeComponent();
            clock = new Timer();
            clock.Interval = 200;
            clock.Tick += new EventHandler(ticked);
            classic = new Class1();
            stop = false;
        }

        void ticked(object sender, EventArgs e)
        {
            classic.ticks++;
            Invalidate();
        }

        private void Form1_Paint(object sender, PaintEventArgs e)
        {
            if (classic.flashing)
            {
                classic.draw(e.Graphics, out stop);
                if (stop)
                {
                    clock.Stop();
                    classic.flashing = false;
                    Invalidate();
                }
            }
        }

        private void button1_Click(object sender, EventArgs e)
        {
            clock.Start();
            classic.flashing = true;
            classic.ticks = 0;
        }
    }
}

Class:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Drawing;

namespace GrafikaTeszt
{
    class Class1
    {
        public int ticks;
        public bool flashing;

        public void draw(Graphics g, out bool stop)
        {
            stop = false;
            if (ticks % 2 == 0)
            {
                red();  //draw a red line
            }
            else
            {
                dark();     //draw a darkred line
            }

            if (ticks == 20)
            {
                stop = true;
            }

            void red() { g.DrawLine(Pens.Red, 100, 100, 500, 500); }
            void dark() { g.DrawLine(Pens.DarkRed, 100, 100, 500, 500); }
        }

        public Class1()
        {
            flashing = false;
        }
    }
}

Thank you for your help.