C# 如何制作自己的事件处理程序？

我正在用C#制作一个windows窗体项目，其中我制作了一个类

LabelX

，它继承了

System.windows.forms.Label

，然后添加了一个float类型的属性

Mass

现在，我的问题是当

Mass

的值改变时，我该如何处理

例如：
当用户输入值

零

或

小于零

我想发出一条消息，告诉大家“质量不能为零或负”

请尝试以下操作：

// Created an empty form with a LabelX control on it.
public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    // Added this event from the property manager.
    private void labelX1_MassChanged(object sender, EventArgs e)
    {
        var label = (LabelX)sender;

        if (label.Mass <= 0.0)
            MessageBox.Show("Mass is less than or equal to 0");
    }
}

public class LabelX : Label
{
    private float _mass;

    public float Mass
    {
        get { return _mass; }
        set
        {
            if (!value.Equals(_mass))
            {
                _mass = value;
                OnMassChanged(EventArgs.Empty);
            }
        }
    }

    public event EventHandler MassChanged;

    protected virtual void OnMassChanged(EventArgs e)
    {
        if (MassChanged != null)
            MassChanged(this, e);
    }
}

//创建了一个带有LabelX控件的空表单。
公共部分类Form1:Form
{
公共表格1（）
{
初始化组件（）；
}
//从属性管理器中添加此事件。
私有void labelX1_MassChanged（对象发送方，事件参数e）
{
变量标签=（LabelX）发送方；
如果（label.Mass尝试以下操作：

// Created an empty form with a LabelX control on it.
public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    // Added this event from the property manager.
    private void labelX1_MassChanged(object sender, EventArgs e)
    {
        var label = (LabelX)sender;

        if (label.Mass <= 0.0)
            MessageBox.Show("Mass is less than or equal to 0");
    }
}

public class LabelX : Label
{
    private float _mass;

    public float Mass
    {
        get { return _mass; }
        set
        {
            if (!value.Equals(_mass))
            {
                _mass = value;
                OnMassChanged(EventArgs.Empty);
            }
        }
    }

    public event EventHandler MassChanged;

    protected virtual void OnMassChanged(EventArgs e)
    {
        if (MassChanged != null)
            MassChanged(this, e);
    }
}

//创建了一个带有LabelX控件的空表单。
公共部分类Form1:Form
{
公共表格1（）
{
初始化组件（）；
}
//从属性管理器中添加此事件。
私有void labelX1_MassChanged（对象发送方，事件参数e）
{
变量标签=（LabelX）发送方；
如果（label.Mass如果我正确地解释了这一点，那么这有两个部分。首先，您需要检测无效值并引发异常。其次，当属性更改时，您需要引发一个事件。这可以通过以下方式实现

private float mass;
public float Mass
{
    get
    {
        return this.mass;
    }

    set
    {
        if (value <= 0.0F)
        {
            throw new ArgumentOutOfRangeException("Mass cannot be zero or negative.");
        }

        if (this.mass != value)
        {
            this.mass = value;
            OnMassChanged(EventArgs.Empty);
        }
    }
}

public event EventHandler MassChanged;

protected virtual void OnMassChanged(EventArgs args)
{
    var handler = this.MassChanged;
    if (handler != null)
    {
        handler(this, args);
    }
}

private-float-mass；
公众漂浮物
{
得到
{
返回这个.mass；
}
设置
{
如果（value如果我正确地解释了这一点，有两个部分。首先，您需要检测无效值并引发异常。其次，当属性更改时，您需要引发事件。这可以通过以下方式实现

private float mass;
public float Mass
{
    get
    {
        return this.mass;
    }

    set
    {
        if (value <= 0.0F)
        {
            throw new ArgumentOutOfRangeException("Mass cannot be zero or negative.");
        }

        if (this.mass != value)
        {
            this.mass = value;
            OnMassChanged(EventArgs.Empty);
        }
    }
}

public event EventHandler MassChanged;

protected virtual void OnMassChanged(EventArgs args)
{
    var handler = this.MassChanged;
    if (handler != null)
    {
        handler(this, args);
    }
}

private-float-mass；
公众漂浮物
{
得到
{
返回这个.mass；
}
设置
{
如果（值在LabelX类之外，请创建以下类：

public class MassChangedEventArgs : EventArgs
{
   public float Mass { get; private set; }

   public MassChangedEventArgs(float mass)
   {
     this.Mass = mass;
   }
}

同样在LabelX类之外，创建以下委托。这将是您的事件处理程序

public delegate void MassChangedEventHandler(object sender, MassChangedEventArgs e);

在LabelX类中，创建要广播的事件：

public class LabelX
{
   public event MassChangedEventHandler MassChanged;
   //the rest of your code here...
}

您还需要创建一个将触发事件的私有实例方法

public class LabelX
{
   public event MassChangedEventHandler MassChanged;

   private void OnMassChanged()
   {
       if(MassChanged!=null)
          this.MassChanged(this, new MassChangedEventArgs(this.Mass));
   }
   //the rest of your code here...
}

最后，每当体量属性更改时，调用OnMassChanged。例如：

public class LabelX
{
   private float mass;
   public float Mass
   {
       get
       {
         return mass;
       }
       set
       {
         mass = value;
         OnMassChanged();
       }
   }

   public event MassChangedEventHandler MassChanged;

   private void OnMassChanged()
   {
       if(MassChanged!=null)
          this.MassChanged(this, new MassChangedEventArgs(this.Mass));
   }

   //the rest of your code here...
}

当您希望在每个实例的基础上处理该事件时，只需向基础对象的MassChanged事件注册一个侦听器，并执行任何必要的操作。
在LabelX类之外，创建以下类：

public class MassChangedEventArgs : EventArgs
{
   public float Mass { get; private set; }

   public MassChangedEventArgs(float mass)
   {
     this.Mass = mass;
   }
}

同样在LabelX类之外，创建以下委托。这将是您的事件处理程序

public delegate void MassChangedEventHandler(object sender, MassChangedEventArgs e);

在LabelX类中，创建要广播的事件：

public class LabelX
{
   public event MassChangedEventHandler MassChanged;
   //the rest of your code here...
}

您还需要创建一个将触发事件的私有实例方法

public class LabelX
{
   public event MassChangedEventHandler MassChanged;

   private void OnMassChanged()
   {
       if(MassChanged!=null)
          this.MassChanged(this, new MassChangedEventArgs(this.Mass));
   }
   //the rest of your code here...
}

最后，每当体量属性更改时，调用OnMassChanged。例如：

public class LabelX
{
   private float mass;
   public float Mass
   {
       get
       {
         return mass;
       }
       set
       {
         mass = value;
         OnMassChanged();
       }
   }

   public event MassChangedEventHandler MassChanged;

   private void OnMassChanged()
   {
       if(MassChanged!=null)
          this.MassChanged(this, new MassChangedEventArgs(this.Mass));
   }

   //the rest of your code here...
}

当您希望在每个实例的基础上处理该事件时，您只需向基础对象的MassChanged事件注册一个侦听器，并执行任何必要的操作。
事件是框架中使用的常见模式。该过程通常涉及定义一个要用作事件处理程序的委托，声明使用处理程序创建事件，定义引发事件的方法，然后连接到属性和逻辑以引发事件

您描述的消息最好作为一个例外，但下面是一个定义
MassChanged
事件的示例

// Define event args if you have additional
// information to pass to your event handlers
public class MassChangedEventArgs : EventArgs
{
    public MassChangedEventArgs(int oldMass)
    {
        OldMass = oldMass;
    }
    public int OldMass { get; private set; }
}

public class SomeObject
{
    // There's a generic event handler delegate that can be
    // used so you only need to define the event arguments.
    public event EventHandler<MassChangedEventArgs> MassChanged;

    // Convenience method to raise the event
    protected virtual void OnMassChanged(MassChangedEventArgs e)
    {
        if (MassChanged != null)
            MassChanged(this, e);
    }

    public int Mass
    {
        get
        {
            return mass;
        }
        set
        {
            // Your checks here
            if (value <= 0)
                throw new ArgumentOutOfRangeException("Mass", "Mass can't be zero or negative");
            // Should only raise the event if the new value is different
            if (value != mass)
            {
                // Change the mass
                MassChangedEventArgs e = new MassChangedEventArgs(mass);
                mass = value;
                // Raise the event
                OnMassChanged(e);
            }
        }
    }

    private int mass;
}

//如果有其他参数，请定义事件参数
//要传递给事件处理程序的信息
公共类MassChangedEventArgs:EventArgs
{
公共MassChangedEventArgs（int-oldMass）
{
OldMass=OldMass；
}
public int OldMass{get；private set；}
}
公共类对象
{
//有一个通用事件处理程序委托可以
//已使用，因此您只需要定义事件参数。
公共事件事件处理程序已更改；
//引发事件的简便方法
MassChanged上受保护的虚拟无效（MassChangedEventArgs e）
{
if（MassChanged！=null）
（本，e）；
}
公共整数质量
{
得到
{
返回质量；
}
设置
{
//你的支票在这里
if（value事件是框架中使用的常见模式。该过程通常涉及定义要用作事件处理程序的委托，使用处理程序声明事件，定义引发事件的方法，然后连接到属性逻辑以引发事件

您描述的消息最好作为一个例外，但下面是一个定义
MassChanged
事件的示例

// Define event args if you have additional
// information to pass to your event handlers
public class MassChangedEventArgs : EventArgs
{
    public MassChangedEventArgs(int oldMass)
    {
        OldMass = oldMass;
    }
    public int OldMass { get; private set; }
}

public class SomeObject
{
    // There's a generic event handler delegate that can be
    // used so you only need to define the event arguments.
    public event EventHandler<MassChangedEventArgs> MassChanged;

    // Convenience method to raise the event
    protected virtual void OnMassChanged(MassChangedEventArgs e)
    {
        if (MassChanged != null)
            MassChanged(this, e);
    }

    public int Mass
    {
        get
        {
            return mass;
        }
        set
        {
            // Your checks here
            if (value <= 0)
                throw new ArgumentOutOfRangeException("Mass", "Mass can't be zero or negative");
            // Should only raise the event if the new value is different
            if (value != mass)
            {
                // Change the mass
                MassChangedEventArgs e = new MassChangedEventArgs(mass);
                mass = value;
                // Raise the event
                OnMassChanged(e);
            }
        }
    }

    private int mass;
}

//如果有其他参数，请定义事件参数
//要传递给事件处理程序的信息
公共类MassChangedEventArgs:EventArgs
{
公共MassChangedEventArgs（int-oldMass）
{
OldMass=OldMass；
}
public int OldMass{get；private set；}
}
公共类对象
{
//有一个通用事件处理程序委托可以
//已使用，因此您只需要定义事件参数。
公共事件事件处理程序已更改；
//引发事件的简便方法
MassChanged上受保护的虚拟无效（MassChangedEventArgs e）
{
if（MassChanged！=null）
（本，e）；
}
公共整数质量
{
得到
{
返回质量；
}
设置
{
//你的支票在这里
如果（value我很确定您希望在您的案例中“激发”一个例外。
这更多的是一个验证逻辑问题，比如AOP代码契约概念

但如果你真的想为它创建一个活动，你必须至少：
1） 在label类中创建事件存储变量

  public event EventHandler MassChanged;

2） 在您的属性中（请注意，您失去了使用c#3的代码生成函数的能力）