When you set Checked property in a RadioBox, can you suppress the CheckChanged event?

I'm new to C# and Windows Form but if I have a radiobutton and I call radiobutton1.Checked=true, is there a way for it to not fire the CheckedChange event? I wan开发者_运维百科t to distinguish between the user clicking on the radiobutton and me setting the radiobutton programmatically. Is this possible?

Stop trying to defeat the design of the CheckedChanged event. It's specifically supposed to include programmatic changes.

If you want user-triggered changes and not programmatic changes, use the Click event instead. (You may be thinking that you don't want to restrict yourself to mouse clicks, don't worry, there's a MouseClick event for that, Click includes keyboard changes as well.)

Here's a straightforward method of using the event when you feel like it.

private bool SuppressRadioButton1Event { get; set; }

private void radioButton1_CheckedChanged(object sender, EventArgs e)
{
    if (!this.SuppressRadioButton1Event)
    {
        MessageBox.Show("Not suppressed!");
    }
}

private void button1_Click(object sender, EventArgs e)
{
    this.SetRadioButton1(false);
}

private void SetRadioButton1(bool checkedOn)
{
    this.SuppressRadioButton1Event = true;
    radioButton1.Checked = checkedOn;
    this.SuppressRadioButton1Event = false;
}

A very easy way:

public void radio_OnCheckChanged(object sender, EventArgs e)
{
   RadioButton r = sender as RadioButton;
   bool isUserChange = r.Tag.Equals(1);
   if (isUserChange) blabla
   else blabla
   r.Tag = null;       
}

public void MyMethod()
{
   radio1.Tag = 1;
   radio.Checked = true;
}

You can use any kind of flag which users can't do by their clicking.But you can do via your code.

Why should your code care who checked the radiobutton?

EDIT: There are ways around this (subclass, flag), but don't. The only "legit" reason I can think of for wanting this is to prevent some side-effect from happening when the value is initially (programatically) displayed, and even that is suspect. Rethink the side-effect, does it really belong on the change-event, or the commit?

More info one why/what would help. On the surface, this looks like a design error.

One (hackish) way to do it would be to subclass RadioButton and override the OnCheckChanged virtual method, suppressing the event if the Checked property has been set programmatically.

However, since radio-buttons belong to a group, the event always fires in pairs (oen for the uncheck, one for the check). You will therefore want to suppress the event for the entire group when you choose the selected button programmatically. Here's an example implementation:

public class CustomRadioButton : RadioButton
{
    private bool _suppressCheckedEvent;

    public void SetChecked(bool value, bool suppressCheckedEvent)
    {
        if (!suppressCheckedEvent)
            Checked = value;
        else
        {
            SetSupressModeForGroup(true);
            Checked = value;
            SetSupressModeForGroup(false);
        }
    }

    private void SetSupressModeForGroup(bool suppressCheckedEvent)
    {
        foreach (var crb in Parent.Controls.OfType<CustomRadioButton>())
            crb._suppressCheckedEvent = suppressCheckedEvent;
    }

    protected override void OnCheckedChanged(EventArgs e)
    {
        if (!_suppressCheckedEvent)
            base.OnCheckedChanged(e);
    }   
}

In this implementation, changing the checked-state through the Checked property will always fire the event. When you call the SetChecked method, you have the choice to suppress the event.

You could try to attach the event programmatically. Based on my application configuration I check several radio buttons but I don't want to fire events. To attach an event programmatically:

chbOptionX.CheckedChanged += new System.EventHandler(this.chbShowStockBySizeAndColor_CheckedChanged);