如何从定时事件恢复功能

我认为如果没有一些回调机制，你无法做到这一点。您可以实现while循环，但这并不有效，因为它会引入旋转。

我的建议是实现一个合适的异步模式或一些简单的东西，比如：

ReadSensor(addr, DoSomethingWithResult);
public void DoSomethingWithResult(string result)
{
    Console.WriteLine (result);
}
public partial class ReadSens : UserControl
{
    private Action<string> _responseCallback;
    public void ReadSensor(byte addr, Action<string> responseCallback)
    {   
        _responseCallback = responseCallback;
        // initiate timer
    }
    private void OnTimedEvent(object source, ElapsedEventArgs e)
    {
        string response = getResponse();
        _responseCallback(response);
    }
}

启动一个单独的线程，然后从该线程将结果写入队列，并返回到主线程中。

class Game1
{
    //We declare a queue, which is like an array that we can extract and enter data easily in a FIFO (first in, first out) style list.
    Queue<string> q = new Queue<string>();
    public void threadStart(object obj)
    {
        //We get the result of your function, while our main function is still looping and waiting.
        string result = readInput()
        //We tell C# that the parameter we passed in, is in fact the Game1 class passed from "t.Start"
        Game1 game = (Game1)obj;
        //This puts our "result" into the queue.
        game.q.Enqueue(result);
    }
    public void start()
    {
        //Declares a new thread, which will run "threadStart" function.
        System.Threading.Thread t = new System.Threading.Thread(threadStart);
        //We start the other thread (that will run in parallel) and pass "this" as the parameter.
        t.Start(this);
        //We loop over and over, sleeping, whilst the other function runs at the same time. This is called "multi- threading"
        while (q.Count == 0)
        {
            System.Threading.Thread.Sleep(10);
        }
        //This gets the last-entered (oldest) value from the queue q.
        string result = q.Deque();
    }
}

因此，这会启动一个线程来获取结果，然后在我的版本中，轮询队列一段时间，直到结果出来，但在你的版本中可以做很多事情，只要你不时地检查队列中的新数据。

编辑：添加了评论，希望能缓解你的一些问题。

这种方法对您来说是有效的解决方案吗？我认为您只是在使用Timer来等待serialPort打开，但它可以通过引发事件进行自我控制。

public class SensorReader
{
    private Sensor sensor;
    private string lastResponse;
    public SensorReader(SerialPort serialPort)
    {
        this.serialPort = aSerialPort.
        this.sensor = new Sensor(serialPort);
        this.sensor.PortOpen += PortOpenEventHandler(OnPortOpen);
    }
    private void OnPortOpen()
    {
        this.ReadPort();
    }
    public string ReadPort(byte address)
    {
        if (!this.sensor.IsOpen)
        {
            this.sensor.OpenPort();
            this.lastResponse = "The serial port doesn't respond... yet!";
        }
        else
        {
            // Read response at this point.
            this.lastResponse = this.GetResponse();
        }           
        return this.lastResponse;
    }
}
public class Sensor
{
    private SerialPort serialPort;
    public Sensor(SerialPort aSerialPort)
    {
        this.serialPort = aSerialPort;
    }
    public bool IsOpen
    {
        get { return this.serialPort.IsOpen; }
    }
    public delegate void PortOpenEventHandler(object sender, EventArgs e);
    public event PortOpenEventHandler PortOpen;
    public void OpenPort()
    {
        // Open port here...
        // ... and throw the PortOpen event.
        if (this.PortOpen != null)
        {
            this.PortOpen(this, EventArgs.Empty);
        }
    }
}