无限而循环问题

本文关键字：问题 循环 无限 | 更新日期: 2023-09-27 17:56:01

我刚刚开始用 C# 编程，我遇到了一个小问题，后台线程无限运行，而它们内部循环。

一点背景：我正在尝试为 Outlook 制作物理通知灯。现在，我正在WPF应用程序中对其进行测试，然后再将其放入Outlook加载项。

我有一个按钮可以打开一个新的后台线程并运行此类的新实例：

public class LightControl
{
    private byte light;
    public byte Light
    {
        get { return light; }
        set { light = value; }
    }
    private string color;
    public string Color
    {
        get { return color; }
        set { color = value; }
    }
    private int delay;
    public int Delay
    {
        get { return delay; }
        set { delay = value; }
    }
    private bool status;
    public bool Status
    {
        get { return status; }
        set { status = value; }
    }
    public void notification()
    {
        Action<byte, string, int, bool> lightNot =
                                    delegate(byte i, string c, int d, bool s)
                                    { lightLoop(i, c, d, s); };
        lightNot(light, color, delay, status);
    }

    private void lightLoop(byte index, string color, int delay, bool state)
    {
        BlinkStick device = BlinkStick.FindFirst();
        if (device != null && device.OpenDevice())
        {
            while (state)
            {
                device.SetColor(0, index, color);
                Thread.Sleep(delay);
                device.SetColor(0, index, "black");
                Thread.Sleep(delay);
            }

        }
    }
}

我还有另一个按钮，它将 false 输入到此类的状态成员中，该按钮应该向下渗透到私有方法 lightLoop 并杀死该无限循环。在此过程中杀死整个线程。

不过，它并没有这样做。循环继续运行。可能是什么原因呢？

对此的任何帮助将不胜感激。

这是我启动线程的方式：

 private void lightStart(byte index)
    {
        Random random = new Random();
        int randNumber = random.Next(0, 5);
        LightControl light = new LightControl();
        light.Light = index;
        light.Color = colors[randNumber]; //random color generator just for fun.
        light.Delay = 500;
        light.Status = status; //global bool on the MainWindow Class
        Thread lightThread = new Thread(new ThreadStart(light.notification));
        lightThread.IsBackground = true;
        lightThread.Start();

    }

对于术语中的任何不准确之处，我提前道歉，这些术语仍然困扰着我。

无限而循环问题

另一种选择是使用ref来实现您想要的。从本质上讲，它允许您在评估时传递对bool的引用，而不是实际值。这允许对值的更改影响它传递到的方法，即使它是值类型。

这是一个基本示例，您可以从中获取概念并将其应用于您的情况。

static bool state = true;
public static void _Main(string[] args)
{
    Console.WriteLine("1. Main thread: {0}", DateTime.Now.ToString("HH:mm:ss.fffffff"));
    Thread t = new Thread(new ThreadStart(StartLoop));
    t.Start();
    Console.WriteLine("2. Main thread: {0}", DateTime.Now.ToString("HH:mm:ss.fffffff"));
    Thread.Sleep(5000);
    state = false;
    Console.WriteLine("3. Main thread: {0}", DateTime.Now.ToString("HH:mm:ss.fffffff"));
}
delegate void MyDelegate(ref bool s);
public static void StartLoop()
{
    MyDelegate myDelegate = LoopMethod;
    myDelegate(ref state);
}
public static void LoopMethod(ref bool state)
{
    while (state)
    {
        Console.WriteLine("LoopMethod running: {0}", DateTime.Now.ToString("HH:mm:ss.fffffff"));
        Thread.Sleep(1000);
    }
}

输出：

1. Main thread: 20:00:28.3693277
2. Main thread: 20:00:28.3753284
LoopMethod running: 20:00:28.3793309
LoopMethod running: 20:00:29.3813856
LoopMethod running: 20:00:30.3816387
LoopMethod running: 20:00:31.3818790
LoopMethod running: 20:00:32.3829344
3. Main thread: 20:00:33.3760889

不打印任何其他内容。

这还需要将delegate从匿名delegate更改为强类型delegate。

如@JohnKoerner的评论中所述，布尔值是值类型，因此如果您传递参数并在方法外部更改值，它将永远不会反映在其中。

要解决它，请将其封装在对象中并接收对象作为参数。

参数

public class State
{
    public Boolean IsActive {get;set;}
}

您的循环

while (state.IsActive)
{
    //do the job
}

这样，当您更新 IsActive 属性时，该方法将知道。

相关文章：