我有一个方法,它使用任务和async / await重复工作.

public static Task ToRepeatingWork(this Action work,int delayInMilliseconds)
    {
        Action action = async () =>
        {                
            while (true)
            {
                try
                {
                    work();
                }
                catch (MyException ex)
                {
                    // Do nothing
                }
                await TaskEx.Delay(new TimeSpan(0,delayInMilliseconds));
            }
        };
        return new Task(action,SomeCt,TaskCreationoptions.LongRunning);
    }

我写过相应的测试：

[TestMethod,TestCategory("Unit")]
    public async Task Should_do_repeating_work_and_rethrow_exceptions()
    {
        Action work = () =>
        {
            throw new Exception("Some other exception.");
        };

        var task = work.ToRepeatingWork(1);
        task.Start();
        await task;
    }

我期待这个测试失败,但它通过(并崩溃测试运行器).

但是,如果在ToRepeatingWork方法中,我将操作从异步更改为正常操作并使用等待而不是等待,则测试将按预期运行.

TaskEx.Delay(new TimeSpan(0,delayInMilliseconds)).Wait();

这有什么不对？

你永远不应该使用任务构造函数.如果您有工作要放在线程池上,请使用Task.Run.这是一个问题,但不是导致崩溃的原因.

您还应该避免异步void,因此请使用Func< Task>而不是行动.这就是导致崩溃的原因.

public static Task ToRepeatingWork(this Action work,int delayInMilliseconds)
{
  Func<Task> action = async () =>
  {                
    while (true)
    {
      try
      {
        work();
      }
      catch (MyException ex)
      {
        // Do nothing
      }
      await TaskEx.Delay(new TimeSpan(0,delayInMilliseconds));
    }
  };
  return Task.Run(() => action());
}

[TestMethod,TestCategory("Unit")]
public async Task Should_do_repeating_work_and_rethrow_exceptions()
{
  Action work = () =>
  {
    throw new Exception("Some other exception.");
  };

  var task = work.ToRepeatingWork(1);
  await task;
}

我认为下面的代码会让所有10个线程一次运行两个,然后在调用Release()10次后打印“done”.但那不是发生了什么：

int count = 0;

        Semaphore s = new Semaphore(2,2);
        for (int x = 0; x < 10; x++)
        {
            Thread t = new Thread(new ThreadStart(delegate()
            {
                s.WaitOne();
                Thread.Sleep(1000);
                Interlocked.Increment(ref count);                       
                s.Release();
            }));
            t.Start(x);
        }

        WaitHandle.WaitAll(new WaitHandle[] { s });
        Console.WriteLine("done: {0}",count);

输出：

done: 6

如果实现我正在寻找的功能的唯一方法是将EventWaitHandle传递给每个线程,然后对那些EventWaitHandles的数组执行WaitAll(),那么在仅数组上执行WaitAll()的含义是什么信号量？换句话说,等待线程何时解除阻塞？

WaitHandle.WaitAll(new WaitHandle [] {s});等待s.WaitOne();.它在第一次机会进入.您似乎希望此调用等待所有其他信号量操作,但操作系统无法区分它们.此命令可能是第一个被授予访问信号量的命令.

我认为你需要的是障碍课.它用于fork-join-style并行.

我正在尝试使用NetMQ实现在两个应用程序之间传递的简单消息(稍微更详细地描述了我想要实现的内容).
经过一些试验和错误后,我发现在Connect / Bind调用之后我不能立即发送或接收消息,因为它们是非阻塞的,即使尚未建立连接也会实际返回.
现在我用Thread.Sleep()解决了这个问题,但这对它有不好的品味,对于生产系统来说绝对不行.

所以问题是,如何在NetMQ / ZeroMQ中做到这一点？

客户端示例：

using (NetMQContext ctx = NetMQContext.Create())
        {
            using (var client = ctx.CreatePushSocket())
            {
                client.Connect("tcp://127.0.0.1:5555");
                Thread.Sleep(100); // wait for connection

                for (int i = 0; i < 5; i++) 
                {
                    client.Send("test " + i,true);
                }
            }
        }
    }

服务器示例：

using (NetMQContext ctx = NetMQContext.Create())
    {
        using (var server = ctx.CreatePullSocket())
        {
            server.Bind("tcp://127.0.0.1:5555");
            Thread.Sleep(100); // wait for connection
            while (true)
            {
                var str = server.ReceiveString();
                Console.Out.WriteLine(str);
                Thread.Sleep(60*1000); // do msg processing
            }
        }
    }

我想要实现的目标的描述：

客户端 – 将消息发送到单个服务器.当服务器不可用时,客户端不应阻止并且不应丢弃消息.客户端可以随时离线/在线.

服务器 – 从单个客户端接收消息.服务器将阻塞,直到收到消息.服务器需要对消息进行冗长的处理,并且在处理时不应丢失任何其他消息.服务器可以随时离线/在线.

在服务器端睡眠的最佳解决方案是在拉出套接字上创建套接字轮询器并轮询,直到收到消息.这避免了浪费的睡眠,并且使得代码通常更紧凑.

在客户端,最好的解决方案可能是创建两个套接字(一个用于发送消息,一个用于接收),并让服务器宣布其存在,以便客户端发送消息.由于ZeroMQ可以有效地处理多个连接,因此该解决方案可以很好地工作.

我正在寻找一种最佳的方法来显示一个页面标题,显示一个图像,但文本可见搜索引擎,如果标题图像没有加载.

谷歌最好的建议就是拥有一个< div>对于带有< h1>的标头对于文本.在CSS中,隐藏< h1> with display：none;并将图像添加为< div>的背景图像.这可能适用于搜索引擎,但如果图像未加载(或需要时间加载),则用户在页面顶部看不到任何内容.

所以我真正想要的是一种可见的< h1>文本和图像加载时,它覆盖文本并显示在它前面.

另一轮关于这样做的方法是使用javascript并在图像加载完成后隐藏文本.这是一个相当尴尬的解决方案,远非完美.

做这个的最好方式是什么？

我不太关心图像没有加载问题(我可能在这里是乌托邦).最重要的部分是搜索引擎和屏幕阅读器的标记中都有文本.

我会保持标记最小(总是一个好主意)

<h1>Title of your page</h1>

在CSS中

h1 {
    text-indent: -10000px; /* Will hide text from users,while still showing for search engines/screen readers */
    background: url('../images/logo.png') no-repeat left top;
    width: 200px; /* your image dimensions */
    height: 50px;
}