如何通过Unity EventSystem实现按键检测（无需在Update中处理）

Great question! Let's break this down clearly:

First, the core answer: There isn't a direct equivalent to IPointerClickHandler for keyboard key presses within Unity's Event System—that interface family is designed specifically for UI pointer interactions (like mouse clicks on buttons, touch taps, etc.), not raw keyboard input.

But that doesn't mean you can't achieve event-driven keyboard input without polling in Update()! Here are the two best approaches depending on which input system you're using:

1. Use Unity's New Input System (Recommended) #

The modern Input System is built for event-driven input, so you can bind directly to key press events without writing any Update() logic at all. Here's how to set it up:

Step-by-Step Implementation: #

• Create an Input Action Asset (right-click in Project window > Input Actions > Input Action Asset).
• Open the asset, add an action (e.g., "MoveForward") and bind it to the W key (under the Keyboard section).
• Attach this script to any GameObject in your scene:

using UnityEngine;
using UnityEngine.InputSystem;

public class KeyPressHandler : MonoBehaviour
{
    // Drag your "MoveForward" action from the Input Action Asset here in the Inspector
    public InputAction wKeyAction;

    private void OnEnable()
    {
        // Subscribe to the "performed" event (triggers when the key is pressed)
        wKeyAction.performed += OnWKeyPressed;
        wKeyAction.Enable();
    }

    private void OnDisable()
    {
        // Always unsubscribe to avoid memory leaks
        wKeyAction.performed -= OnWKeyPressed;
        wKeyAction.Disable();
    }

    private void OnWKeyPressed(InputAction.CallbackContext context)
    {
        DoSomething(); // Your logic here
    }

    private void DoSomething()
    {
        Debug.Log("W key pressed! No Update() required.");
    }
}

This approach is clean, scalable, and works across all platforms without rewriting input logic.

2. Workaround with the Old Input System #

If you're still using the legacy Input Manager, you can centralize input polling in a single manager script and use UnityEvent to broadcast events to other scripts. This way, only one Update() exists for input detection, and other scripts don't need to implement it:

Input Manager Singleton: #

using UnityEngine;
using UnityEngine.Events;

public class LegacyInputManager : MonoBehaviour
{
    public static LegacyInputManager Instance { get; private set; }

    // This event will fire when W is pressed
    public UnityEvent OnWKeyDown;

    private void Awake()
    {
        // Set up singleton pattern
        if (Instance != null && Instance != this)
        {
            Destroy(gameObject);
        }
        else
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
        }
    }

    private void Update()
    {
        // Only one Update() handling input
        if (Input.GetKeyDown(KeyCode.W))
        {
            OnWKeyDown?.Invoke();
        }
    }
}

Subscribe to the Event in Your Script: #

using UnityEngine;

public class PlayerController : MonoBehaviour
{
    private void OnEnable()
    {
        LegacyInputManager.Instance.OnWKeyDown.AddListener(DoSomething);
    }

    private void OnDisable()
    {
        LegacyInputManager.Instance.OnWKeyDown.RemoveListener(DoSomething);
    }

    private void DoSomething()
    {
        Debug.Log("W key pressed via centralized input!");
    }
}

This keeps your code decoupled and avoids repeating Input.GetKeyDown checks in multiple Update() methods.

To recap:

• No direct Event System interface for keyboard keys like IPointerClickHandler exists
• The New Input System is the best way to get event-driven keyboard input without Update()
• For legacy projects, a centralized input manager with UnityEvent is a solid workaround

内容的提问来源于stack exchange，提问作者user7799490