在C# windows应用程序中，持续监测一个状态，声音报警如何写......

Question

在C# windows应用程序中：
1.每1秒钟检测一个状态flag，如果flag=1，则执行函数warning()（需要10秒钟），这样的话就会产生操作积压，请问应该如何处理呢？？
2.我的需求是持续监测flag，如果一直是flag=1，就持续执行warning()，比如检测了10次flag都是1，只执行一次warning()，检测了20次flag都是1，只执行两次warning()，当然如果检测到flag是0，则立即停止执行warning()，请问我该怎么做呢？
3.也就是说前台检测某个状态flag，如果一直是1，持续warning（），如果是0，则停止。

Answer 1

第一种方法：
using System; 
using System.Runtime.InteropServices; 
class test 
{ 
            [DllImport("kernel32.dll")] 
            private static extern int Beep(int dwFreq ,int dwDuration) ;             public static void Main() 
            { 
                        int a=0X7FF; 
                        int b=1000; 
                        Beep(a,b); 
} 
}第二种方法：http://msdn.microsoft.com/zh-cn/library/4fe3hdb1(VS.85).aspx

Answer 2

flag=1的情况 warning() 执行10秒，  这个时候  你要做什么 这是逻辑问题，  可以在这10秒里 忽悠任何flag=1的情况，  也就是有在warning()的情况 有10次 检测直接扔掉了， 不管是0还是1另一种 就是 需要记录
那就FI(FLAG==1)  a++  
warning() 是根据A的 次数来的 每次10秒结束后 a--  具体 逻辑要看你自己  这个和代码没关系吧

Answer 3

假设定时一秒钟执行一次某个时间处理方法，那么事件处理方法的一句话，通常我们就把这个定时器 stop 了，然后处理完操作之后再对本身这个定时器执行 start。但是假设你没有这个需求，或者提不出这个需求，就需要多想想自己。

Answer 4

做复杂了，报警直接循环播放，直到不报警了（或者用户手动确认已经处理了）那么这东西就简化成了 一个属性 bool 报警 {         set {
                     if(xxx!=value)
                        //触发事件
            }
}
触发事件处理（）
{
          if(报警)
           {
                 正在报警，忽略。让他自己循环去
                 没报警就报警
           }
           else
          {
                 直接停止报警（这里如果是CancelTokenSource 就直接 CancelTokenSource?.cancel() 就好）
           }
}ps：rx.net做这个简单，不过嘛rxnet不是受天朝neter欢迎的东西（话说人家天朝js，安卓，ios，pyton，go都能理解rx，为啥天朝neter接受这玩意就这么困难呢）
 
             

Answer 5

你只要知道 warning() 是不是在执行中就行了。

Answer 6

很简单的问题，用time定时1秒，然后在定时器触发事件里面判断flag是否等于1 ，等于1 则持续报警，等于0则不报警。

Answer 7

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reactive.Linq;
using System.Reactive.Subjects;
using System.Text;
using System.Threading;
using System.Threading.Tasks;namespace ConsoleApp2
{
    class Program
    {
        private static CancellationTokenSource cts;
        static void Main(string[] args)
        {
            using (Subject<int> source = new Subject<int>())            {
                source.AsObservable().Subscribe(p =>
                {
                    Console.WriteLine($"收到数据{p}");
                });                source.AsObservable().DistinctUntilChanged().Subscribe(async p =>
                {
                    if (p == 1)
                    {
                        Console.WriteLine($"{p}到达，启动报警");
                        cts = new CancellationTokenSource();
                        await alert(cts.Token);
                    }
                    else if (p == 0)
                    {
                        if (cts != null&&!cts.IsCancellationRequested)
                        {
                            Console.WriteLine($"{p}到达，停止报警");
                         
                                cts.Cancel();
                      
                        }
                    }                });
                //模拟数据
                Task.Run(async () =>
                {                    source.OnNext(0);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(0);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(0);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                    source.OnNext(0);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                });                Console.ReadKey();
            }
        }        static async Task alert(CancellationToken token)
        {
            while (!token.IsCancellationRequested)
            {
                Console.WriteLine("报警中");                try
                {
                    await Task.Delay(TimeSpan.FromMilliseconds(500), token);
                }
                catch (Exception e)
                {                }            }            Console.WriteLine("报警已取消");
        }
    }
}
来个rx版的把，你能不能接受那就看你自己了。

Answer 8

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reactive.Linq;
using System.Reactive.Subjects;
using System.Text;
using System.Threading;
using System.Threading.Tasks;namespace ConsoleApp2
{
    class Program
    {
        private static CancellationTokenSource cts;
        static void Main(string[] args)
        {
            using (Subject<int> source = new Subject<int>())            {
                var source1 = source.AsObservable().Publish().RefCount();
                source1.Subscribe(p =>
                {
                    Console.WriteLine($"收到数据{p}");
                });                source1.DistinctUntilChanged().Subscribe(async p =>
                {
                    if (p == 1)
                    {
                        Console.WriteLine($"{p}到达，开始报警");
                        int i = 1;
                        Console.WriteLine($"---报警{i++}次");
                        source1.SkipWhile(c=>c==1).Buffer(10).Subscribe(c =>
                        {
                            Console.WriteLine($"报警{i++}次");
                        });
                    }
                    else if (p == 0)
                    {
                            Console.WriteLine($"{p}到达，停止报警");                                                             
                    }                });
                //模拟数据
                Task.Run(async () =>
                {                    source.OnNext(0);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(0);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(0);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                    source.OnNext(1);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                    source.OnNext(0);
                    await Task.Delay(TimeSpan.FromMilliseconds(200));
                });                Console.ReadKey();
            }
        }  
    }
}
按你说的10次一来也不复杂，代码比较多，不过核心代码不多，主要是模拟构造数据麻烦点

Answer 9

实际上你的问题都不是什么检测，你的问题是，同步执行------你给个阻塞的10秒，没完成后面就等着，然后你就觉着积压了，所以你想说我后10秒的不做，这种有些头疼医脚的意思的我们的方式是说，你要么不管他直接让他异步去自己做，直到收到取消报警要么干脆直接一个 信号量就好
    System.Threading.SemaphoreSlim _slim=new SemaphoreSlim(1,1);
                    if (_slim.CurrentCount == 0)
                    {
                        return; //前面的没做完，直接忽略
                    }
                    await _slim.WaitAsync();
                    报警();
                    _slim.Release();

Answer 10

新建一个类
public class test
    {
        public delegate void GetFlagHandler(int flag);
        public event GetFlagHandler GetFlag;        public int flag; //如何获取你没有说，用这个变量代替        private Thread pro;        public test()
        {
            pro = new Thread(new ThreadStart(FlagTest));
            pro.Start();
        }        private void FlagTest()
        {
            while (true)
            {
                GetFlag(flag);
                Thread.Sleep(1000);
            }
        }        public void Close()
        {
            while (pro.ThreadState == ThreadState.Running)
            {
                pro.Abort();
                Thread.Sleep(100);
            }
        }
    }主线程中：
test ts;ts = new test();
 ts.GetFlag+=new test.GetFlagHandler(ts_GetFlag);写 ts_GetFlag函数
private void ts_GetFlag(int i)
        {
            if (i == 1)
            {
                warning()
            }
            else
            {
                Stop_warning()
            }
        }