相关疑难解决方法(0)

我正在尝试确定删除字符串的方法是最快的.

我只是得到开始和结束时间并显示差异.

但结果是如此多变,例如如下所示,相同的方法可以从60毫秒到231毫秒.

获得更准确结果的更好方法是什么？

替代文字http://www.deviantsart.com/upload/1q4t3rl.png

using System;
using System.Collections;
using System.Collections.Generic;

namespace TestRemoveFast
{
    class Program
    {
        static void Main(string[] args)
        {
            for (int j = 0; j < 10; j++)
            {
                string newone = "";
                List<string> tests = new List<string>();
                for (int i = 0; i < 100000; i++)
                {
                    tests.Add("{http://company.com/Services/Types}ModifiedAt");
                }

                DateTime start = DateTime.Now;
                foreach (var test in tests)
                {
                    //newone = ((System.Xml.Linq.XName)"{http://company.com/Services/Types}ModifiedAt").LocalName;
                    newone = Clean(test);
                }

                Console.WriteLine(newone);
                DateTime …

我注意到一些奇怪的行为，这些行为可能特定于也可能不是特定于我的系统。（运行 Windows 8 的联想 t430）

使用这个脚本：

import time

now = time.time()
while True:
    then = now
    now = time.time()
    dif = now - then
    print(dif)
    time.sleep(0.01)

在浏览器打开的情况下，我得到以下输出（我认为是名义上的）。

但是，如果没有打开浏览器，我会观察到严重的每个循环延迟。

显然，这是违反直觉的，因为我认为当并发进程较少时，任何人都希望获得更好的性能。

对这些结果的任何见解或简单复制将不胜感激。

编辑： 有趣的是，我观察到与此代码类似的延迟：

import time

now = time.time()

def newSleep(mark,duration):
    count = 0
    while time.time()-mark < duration:
        count+=1
    print(count)


while True:
    then = now
    now = time.time()
    dif = now - then
    print(dif)
    #time.sleep(0.01)
    newSleep(now,0.01)

虽然它确实提供了额外的洞察力 - 即潜在循环的一些实例是由于缺乏处理器可用性（通过打印 0 的计数来表示） - 我仍然注意到 15ms 的行为，其中打印的计数将高达 70k.. . 和 10 毫秒的行为，计数约为 40k。

我遇到了间歇性失败的单元测试,因为经过的时间不是我预期的.

此测试的示例如下:

Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();

TimeSpan oneSecond = new TimeSpan(0, 0, 1);

for(int i=0; i<3; i++)
{
    Thread.Sleep(oneSecond);
}

stopwatch.Stop();

Assert.GreaterOrEqual(stopwatch.ElapsedMilliseconds, 2999);

这种情况大部分时间都过去了,但至少有一次失败,因为:

预期:大于或等于2999但是:2998

我不明白它怎么可能不到3秒钟.我不知道Thread.Sleep或者Stopwatch是否存在准确性问题？

正如以下一些问题的更新.正在进行单元测试的场景是一个类,它允许一个方法调用一个方法来执行某些操作,如果它失败则等待一秒并调用该方法.上面显示的测试只是对正在发生的事情的近似.

假设我想调用方法DoSomething()...但是如果DoSomething()抛出异常,我希望能够重试最多调用它3次,但每次尝试之间等待1秒.在这种情况下,单元测试的目的是验证当我们请求3次重试,每次重试之间等待1秒钟时,所花费的总时间大于3秒.

Thread.Sleep()分辨率从1到15.6ms不等

鉴于此控制台应用:

class Program
{
    static void Main()
    {
        int outer = 100;
        int inner = 100;
        Stopwatch sw = new Stopwatch();

        for (int j = 0; j < outer; j++)
        {
            int i;
            sw.Restart();
            for (i = 0; i < inner; i++)
                Thread.Sleep(1);
            sw.Stop();
            Console.WriteLine(sw.ElapsedMilliseconds);
        }
    }
}

我期望输出为100个数字接近100.相反,我得到这样的东西:

99 99 99 100 99 99 99 106 106 99 99 99 100 100 99 99 99 99 101 99 99 99 99 99 99 99 99 99 99 99 …

我正在尝试编写一个帮助方法,它允许我传递任意任务和超时.如果任务在超时之前完成,则调用成功委托,否则调用错误委托.该方法如下所示:

    public static async Task AwaitWithTimeout(Task task, int timeout, Action success, Action error)
    {
        if (await Task.WhenAny(task, Task.Delay(timeout)) == task)
        {
            if (success != null)
            {
                success();
            }
        }
        else
        {
            if (error != null)
            {
                error();
            }
        }
    }

现在这似乎在大部分时间都有效,但我也想写一些测试以确保.令我意外的是,此测试失败了,并调用错误委托而不是成功:

        var taskToAwait = Task.Delay(1);
        var successCalled = false;

        await TaskHelper.AwaitWithTimeout(taskToAwait, 10, () => successCalled = true, null);

        Assert.IsTrue(successCalled);

但是,此测试为绿色:

        var taskToAwait = Task.Run(async () =>
        {
            await Task.Delay(1);
        });

        var successCalled = false;

        await TaskHelper.AwaitWithTimeout(taskToAwait, 10, () …