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

weixin_41760208 2019-04-27 11:57:02
在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，则停止。
...全文
1250 16 打赏 收藏 转发到动态 举报
写回复
用AI写文章
16 条回复
切换为时间正序
请发表友善的回复…
发表回复
闭包客 2019-04-29
  • 打赏
  • 举报
 回复
你只要知道 warning() 是不是在执行中就行了。
jx315425246 2019-04-29
  • 打赏
  • 举报
 回复
引用 楼主 weixin_41760208 的回复:
在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，则停止。


新建一个类



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()

            }

        }


wanghui0380 2019-04-29
  • 打赏
  • 举报
 回复
实际上你的问题都不是什么检测，你的问题是，同步执行------你给个阻塞的10秒，没完成后面就等着，然后你就觉着积压了，所以你想说我后10秒的不做，这种有些头疼医脚的意思的 我们的方式是说，你要么不管他直接让他异步去自己做，直到收到取消报警 要么干脆直接一个 信号量就好 System.Threading.SemaphoreSlim _slim=new SemaphoreSlim(1,1); if (_slim.CurrentCount == 0) { return; //前面的没做完，直接忽略 } await _slim.WaitAsync(); 报警(); _slim.Release();
wanghui0380 2019-04-29
  • 打赏
  • 举报
 回复 
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次一来也不复杂，代码比较多，不过核心代码不多，主要是模拟构造数据麻烦点
wanghui0380 2019-04-29
  • 打赏
  • 举报
 回复 
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版的把，你能不能接受那就看你自己了。
~王者归来~ 2019-04-29
  • 打赏
  • 举报
 回复
很简单的问题，用time定时1秒，然后在定时器触发事件里面判断flag是否等于1 ，等于1 则持续报警，等于0则不报警。
以专业开发人员为伍 2019-04-28
  • 打赏
  • 举报
 回复
引用 楼主 weixin_41760208 的回复:
2.我的需求是持续监测flag，如果一直是flag=1，就持续执行warning()，比如检测了10次flag都是1，只执行一次warning()，检测了20次flag都是1，只执行两次warning()，当然如果检测到flag是0，则立即停止执行warning()，请问我该怎么做呢？
那么你当然是要一直知道上一次检测结果啊？！你需要声明一个变量来记录啊！ 贴出你自己的程序设计。自己贴出各种程序设计过程，这个是初学者必须经过的过程。
以专业开发人员为伍 2019-04-28
  • 打赏
  • 举报
 回复
引用 楼主 weixin_41760208 的回复:
在C# windows应用程序中： 1.每1秒钟检测一个状态flag，如果flag=1，则执行函数warning()（需要10秒钟），这样的话就会产生操作积压，请问应该如何处理呢？？
这是个业务逻辑问题，而不是什么“函数”语句问题。假设处理业务的时候，要不要暂时停止所谓定时“检测”？如果不要那么就必须容许积压。如果要停止定时检测，那么就才是要看你懂不懂定时操作的语句，而不是纠结什么“函数”。
Acme_Thanatos 2019-04-28
  • 打赏
  • 举报
 回复
观察者模式了解一下
大鱼> 2019-04-28
  • 打赏
  • 举报
 回复
没仔细看你的需求，你的需求不太适合观察者模式了
大鱼> 2019-04-28
  • 打赏
  • 举报
 回复
2# 说的不错，既然是一个事件的产生触发另外一个事件作出相应的回应可以采用观察者模式去实现 在产生报警的时候触发声音提示，很显然也符合这样的一个场景
以专业开发人员为伍 2019-04-28
  • 打赏
  • 举报
 回复
或者提不出这个需求 --> 或者不知道如何用语言来表达这个需求
以专业开发人员为伍 2019-04-28
  • 打赏
  • 举报
 回复
假设定时一秒钟执行一次某个时间处理方法，那么事件处理方法的一句话，通常我们就把这个定时器 stop 了，然后处理完操作之后再对本身这个定时器执行 start。 但是假设你没有这个需求，或者提不出这个需求，就需要多想想自己。
好奇都是要学的 2019-04-28
  • 打赏
  • 举报
 回复
还有就是 有没有返回啊， 是否要多线程操作啊， 是否要异步啊， 这都是通过逻辑来定义的。
好奇都是要学的 2019-04-28
  • 打赏
  • 举报
 回复
flag=1的情况 warning() 执行10秒， 这个时候 你要做什么 这是逻辑问题， 可以在这10秒里 忽悠任何flag=1的情况， 也就是有在warning()的情况 有10次 检测直接扔掉了， 不管是0还是1 另一种 就是 需要记录 那就FI(FLAG==1) a++ warning() 是根据A的 次数来的 每次10秒结束后 a-- 具体 逻辑要看你自己 这个和代码没关系吧
写代码的程序员 2019-04-27
  • 打赏
  • 举报
 回复
第一种方法：
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
C#海康解码器上大屏代码事例
最近公司开发一个项目  需要用到海康的视频sh
java工程师笔试面试题
1. J2EE 是什么？它包括哪些技术？ 解答：从整体上讲，J2EE 是使用 Java 技术开发企业级应用的工业标准，它是 Java 技术不断适应和促进企业级应用过程中的产物.适用于企业级应用的 J2EE,提供一个平台独立的、可移植的、多用户的、安全的和基于标准的企业级平台，从而简化企业应用的开发、管理和部署。J2EE 是一个标准，而不是一个现成的产品。 主要包括以下这些技术： 1) Ser
软考高项:信息网络安全模拟题
280、在TCP/IP的体系架构中，ARP协议位于()，它的作用是()。A.网络层将MAC地址解析为IP地址 B.链路层将MAC地址解析为IP地址C.网络层将IP地址解析为MAC地址 D.链路层将lP地址解析为MAC地址正确答案:D 解析:在TCP/IP的体系架构中，ARP协议位于链路层，它的作用是将IP地址解析为MAC地址。281、物联网是把任何物品与互联网连接起来进行信息交换和通讯，以实现智能化识别、定位、跟踪、监控和管理的一种网络，以下说法错误的是()。A.物联网就是移动互
红胖子网络科技博文大全：开发技术集合（包含Qt实用技术、树莓派、三维、OpenCV、OpenGL、ffmpeg、OSG、单片机、软硬结合等等）持续更新中...
各位读者，知识无穷而人力有穷， 所以，要么改需求，要么找专业人士，要么自己研究。大家可以点赞、收藏、关注、评论我啦 、需要完整文件随时联系我或交流哟~！
基于.net core微服务（Consul、Ocelot、Docker、App.Metrics+InfluxDB+Grafana、Exceptionless、数据一致性、Jenkins）
1、微服务简介 一种架构模式，提倡将单一应用程序划分成一组小的服务，服务之间互相协调、互相配合，为用户提供最终价值。每个服务运行在其独立的进程中，服务与服务间采用轻量级的通信机制互相沟通（RESTful API）。每个服务都围绕着具体的业务进行构建，并且能够被独立地部署到生产环境、类生产环境等。应尽量避免统一的、集中式的服管理机制，对具体的一个服务而言，应根据业务上下文，选择合适的语言、工具对其进行构建。　　　　　　　　　　　　　　　　　　　　——马丁•福勒 1.1、.net core下的微服务构件 .
C#

110,533

社区成员

642,574

社区内容

发帖
与我相关
我的任务
社区描述
.NET技术 C#
社区管理员
  • C#
  • Web++
  • by_封爱
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

查看更多榜单
社区公告

让您成为最强悍的C#开发者

试试用AI创作助手写篇文章吧

+ 用AI写文章