标签: eventhandler

我正在尝试做一个相对简单的 javascript 程序/页面，只有 3 个滑块 RGB 来影响正方形和圆形的颜色。

当我将事件侦听器与输入元素“内联”时，它工作得很好：即， onchange="someFunction(x,y)"

但是，当我将事件侦听器移到 javascript 中并使用 时addEventListener，它仅在页面加载时工作一次，然后再也不会工作......几乎就像 aremoveEventListener已被调用，但我还没有这样做。

是的，在调用 javascript 之前，我确保所有元素都加载到页面上。

我已经修改了这段代码，只是为了给我一个 ALERT 而不是实际调用我想要的函数slideUpdate，只是为了调试目的。

这是： JAVASCRIPT：

var colorBox = document.getElementById("colorbox");
var colorCircle = document.getElementById("colorCircle");
var colorPicker = document.getElementById("colorPicker");
var sliderRed = document.getElementById("Red");
var sliderGreen = document.getElementById("Green");
var sliderBlue = document.getElementById("Blue");

//sliderRed.addEventListener("onchange", alertForDebug() );
//sliderRed.addEventListener("onclick", alert(sliderRed.value) );

document.addEventListener('DOMContentLoaded', function () {
    alert("document loaded!");
    sliderRed.addEventListener("change", alert(sliderRed.value) );
    //document.querySelector('#Red').addEventListener('change', slideUpdate(sliderRed.value, sliderRed.id) );
    //document.querySelector('#Green').addEventListener('onchange', slideUpdate(this.value, this.id) );
    //document.querySelector('#Blue').addEventListener('onchange', slideUpdate(this.value, this.id) );
} …

我想创建一个由列表框所选项目的更改或单选按钮所选项目的更改触发的事件。是否可以？我使用这段代码：

def getScript(event):
    state = rb.get()
    listScript = []
    processor = ()
    processor = lb1.get(lb1.curselection())
    if processor :
        if (state == 1):
            print processor
        if (state == 2):
            pass
        if (state == 3):
            pass


frame2 = Frame(top)
frame2.pack(fill = X)
rb = IntVar()

R1 = Radiobutton(frame2, text = "Parallel Test", 
                 variable = rb, value = 1, command = getScript)
R2 = Radiobutton(frame2, text = "Non Parallel Test", 
                 variable = rb, value = 2, command = getScript)
R3 = Radiobutton(frame2, text …

因此，我查看了SO，发现如何解除匿名事件处理程序的挂接，这没有问题。但是我有一个问题是如何在事件处理程序本身的实例内部解开事件处理程序。

例如，我有一个计时器：

System.Timers.Timer aTimer = new System.Timers.Timer();
System.Timers.ElapsedEventHandler handler = ((sender, args)
  =>
  {
      //aTimer.Elapsed -= handler;
      wc.CancelAsync();
  });
aTimer.Elapsed += handler;
aTimer.Interval = 100000;
aTimer.Enabled = true;

随着行注释掉，这很好。但是后来我意识到可能存在内存泄漏，因为ElapsedEventHandler它永远不会被钩住。因此，我尝试将注释掉的行添加到我的行中，ElapsedEventHanlder以将计时器从其自身上取消。

但是由于错误，我无法编译代码：

使用未分配的局部变量“处理程序”

我的计时器完成后，是否可以解开Elapsed我的事件Timer？

我正在尝试重写这段代码

new EventHandler<MouseEvent>() {

    @Override
    public void handle(MouseEvent e) {
        System.out.println(e.hashCode());
    }
};

作为

new EventHandler<MouseEvent>(e -> System.out.println(e.hashCode()));

我收到错误。我在这里犯了什么错误？

我读了很多资料，但我还是听不懂，请问有人可以解释一下吗？

我知道什么：

声明一个事件：

public event MyEvent myEvent;

VS.

声明EventHandler：

public EventHandler MyEventHandler;

虽然EventHandler是.NET中的关键字：

public delegate void EventHandler (Send object, EventArgs e);

那么，EventHandler是一个委托，而不是一个事件，因为关键字'event'中没有使用它？

以及何时应使用“事件”和“事件处理程序”？

PerformClick我在用于调用事件处理程序的 Windows 窗体应用程序中遇到问题async。事件处理程序似乎没有，await而是立即返回。我创建了这个简单的应用程序来显示问题（它只是一个带有 3 个按钮的表单，很容易自己测试）：

string message = "Not Started";

private async void button1_Click(object sender, EventArgs e)
{
    await MyMethodAsync();
}

private void button2_Click(object sender, EventArgs e)
{
    button1.PerformClick();
    MessageBox.Show(message);
}

private void button3_Click(object sender, EventArgs e)
{
    MessageBox.Show(message);
}

private async Task MyMethodAsync()
{
    message = "Started";
    await Task.Delay(2000);
    message = "Finished";
}

message这里有趣的问题是，当我点击 时，你认为会显示什么Button2？ 令人惊讶的是，它显示“开始”，而不是您所期望的“完成”。换句话说，它不会await MyMethod()，它只是启动任务，然后继续。

编辑：

在这个简单的代码中，我可以通过直接从 Button2 事件处理程序调用来使其工作await Method()，如下所示：

private async void button2_Click(object …

我是C++的新手,最近开始了一个项目,我需要访问一个设备,收集某些数据并将其转发到本地网络上的数据流.

虽然我的应用程序完成所有需要它缺乏功能:当我关闭窗口时,应用程序正在运行它不会停止硬件设备.结果是,每次我完成程序时都必须进行硬件复位.这不仅不方便,而且对于程序的预期用途是不可能的.

我基本上只想设置一个函数的回调函数,当程序关闭时执行该函数(通过单击x,按Alt-F4等)

这可能吗？我有可能为这样的事件创建一个处理程序:

BOOL WINAPI ConsoleHandler(DWORD dwCtrlEvent)
{
    switch (dwCtrlEvent)
    {
    case CTRL_CLOSE_EVENT:
        // something
    case CTRL_SHUTDOWN_EVENT:
        // the same?
    default:
        return FALSE;
    }
}

如果这是一个正确的方法,我想知道如何使用这个处理程序？我是否需要在我的程序中创建这样的处理程序并且不断更新？

我很感激任何帮助乔纳斯

我建立了一个React切换菜单,由一个按钮触发,问题是这发生了一次所以,如果我再次点击按钮,菜单仍然打开而不是关闭.我应该包括隐藏功能但不知道如何.任何人都可以告诉我应该改变什么？我在这个例子中使用它如何使用ReactJS构建滑动菜单

Import { Menu } from '../../components';

export default class ToggleMenu extends React.Component {

  showRight = () => {
    this.right.show();
  }


  constructor(props) {
    super(props);
    this.showRight = this.showRight.bind(this);
  }

  render() {

    return (
      <div>
      <button onClick={this.showRight}>Show Right Menu!</button>
      <Menu ref={right => this.right = right} alignment="right">
      <MenuItem hash="first-page">First Page</MenuItem>
      <MenuItem hash="second-page">Second Page</MenuItem>
      <MenuItem hash="third-page">Third Page</MenuItem>
      </Menu>
      </div>
    );
  }
}

从'react'导入React;

export default class Menu extends React.Component {
    state = {
      visible: false,
    };

    show() {
      this.setState({ visible: true });
    } …

允许将通常的事件处理程序从 void 转换为基于任务并等待它，如下所示？

Something.PropertyChanged += async (o, args) => await IsButtonVisible_PropertyChanged(o, args);  
Something.PropertyChanged -= async (o, args) => await IsButtonVisible_PropertyChanged(o, args);  

private Task IsButtonVisible_PropertyChanged(object sender,PropertyChangedEventArgs e)
{
   if (IsSomthingEnabled)
   {
       return SomeService.ExecuteAsync(...);
   }

   return Task.CompletedTask;
}

或者像这样做？

Something.PropertyChanged += IsButtonVisible_PropertyChanged;  
Something.PropertyChanged -= IsButtonVisible_PropertyChanged;  

private void IsButtonVisible_PropertyChanged(object sender,PropertyChangedEventArgs e)
{
   if (IsSomthingEnabled)
   {
       _ = SomeService.ExecuteAsync(...);
   }
}

更新： 或者这个，我知道 use Task void 应该被禁止，因为它没有捕获异常，但对于事件处理程序的情况可能没问题，因为事件处理程序不返回。

Something.PropertyChanged += IsButtonVisible_PropertyChanged;  
Something.PropertyChanged -= IsButtonVisible_PropertyChanged;  

private async void IsButtonVisible_PropertyChanged(object sender,PropertyChangedEventArgs e)
{
   if (IsSomthingEnabled)
   {
       await …

我正在使用该答案中的AddEventHandler方法，但是当在具有值类型参数的EventHandler上执行此操作时，会发生：

using System.Reflection;

public class Program
{
    public static event EventHandler<bool> MyEvent;

    public static void Main()
    {
        EventInfo eventInfo = typeof(Program).GetEvent(nameof(MyEvent));
        AddEventHandler(eventInfo, null, (s, e) => {
            if (e == null) return; // either if condition or null conditional operator
            Console.WriteLine(e?.ToString());
        });
        MyEvent(null, true);
    }

    public static void AddEventHandler(EventInfo eventInfo, object client, EventHandler handler)
    {
        object eventInfoHandler = eventInfo.EventHandlerType
            .GetConstructor(new[] { typeof(object), typeof(IntPtr) })
            .Invoke(new[] { handler.Target, handler.Method.MethodHandle.GetFunctionPointer() });

        eventInfo.AddEventHandler(client, (Delegate)eventInfoHandler);
    }
}