小编Gen*_*нин的帖子

我有一个常规的C#代码.我没有例外.我想以编程方式记录当前堆栈跟踪以进行调试.例:

public void executeMethod() 
{
    logStackTrace();
    method();
}

我不太明白之间的差别Task.Wait和await.

我在ASP.NET WebAPI服务中有类似于以下函数:

public class TestController : ApiController
{
    public static async Task<string> Foo()
    {
        await Task.Delay(1).ConfigureAwait(false);
        return "";
    }

    public async static Task<string> Bar()
    {
        return await Foo();
    }

    public async static Task<string> Ros()
    {
        return await Bar();
    }

    // GET api/test
    public IEnumerable<string> Get()
    {
        Task.WaitAll(Enumerable.Range(0, 10).Select(x => Ros()).ToArray());

        return new string[] { "value1", "value2" }; // This will never execute
    }
}

哪里Get会僵局.

什么可能导致这个？当我使用阻塞等待而不是await Task.Delay？时,为什么这不会导致问题？

我安装了新的Visual Studio 2012 Ultimate.

我用我的解决方案创建了一个测试项目,它包含一些默认的单元测试.但是,右键单击新方法不再显示"创建单元测试"上下文菜单.

请参阅Visual Studio 2010 Ultimate:

和Visual Studio 2012旗舰版:

知道为什么会这样吗？

更新:

Visual Studio 2012和2013的解决方案:

微软已经在这里承认了它,并提供了修补它的补丁的官方工作.下载,安装和享受!

在过去的几天里,我测试了.net 4.5和c#5的新功能.

我喜欢它的新async/await功能.之前我曾使用BackgroundWorker通过响应式UI在后台处理更长的进程.

我的问题是:在拥有这些不错的新功能之后,我何时应该使用async/await和什么时候使用BackgroundWorker？两者的常见情况是什么？

MSDN解释了这样的Lookup:

一个Lookup<TKey, TElement> 酷似Dictionary<TKey, TValue>.不同之处在于 Dictionary <TKey,TValue>将键映射到单个值,而 Lookup <TKey,TElement>将键映射到值集合.

我没有发现这种解释特别有用.Lookup用于什么？

我正在开始一个新项目,并希望从一开始就获得我的表名和列名.例如,我总是在表名中使用复数,但最近学到的单数是正确的.

那么,如果我得到一个表"用户"然后我得到的产品只有用户会有,那么这个表应该命名为"user_product"还是只是"product"？这是一对多的关系.

进一步说,如果我(由于某种原因)每个产品的几个产品描述,它会是"user_product_description"或"product_description"还是只是"描述"？当然有正确的外键设置..命名它只描述会有问题,因为我也可以有用户说明或帐户描述或其他..

如果我想要一个只有两列的纯关系表(多对多),那会是什么样子呢？"user_stuff"或者类似"rel_user_stuff"的内容？如果是第一个,可以区分它,例如"user_product"？

任何帮助都非常感谢,如果有你们推荐的某种命名约定标准,请随时链接.

谢谢

我正在使用Tasks在我的ViewModel中运行长时间运行的服务器调用,结果将被重新编组Dispatcher使用TaskScheduler.FromSyncronizationContext().例如:

var context = TaskScheduler.FromCurrentSynchronizationContext();
this.Message = "Loading...";
Task task = Task.Factory.StartNew(() => { ... })
            .ContinueWith(x => this.Message = "Completed"
                          , context);

这在我执行应用程序时工作正常.但是当我运行我的NUnit测试时,Resharper我在调用时收到错误消息FromCurrentSynchronizationContext:

当前的SynchronizationContext可能不会用作TaskScheduler.

我想这是因为测试是在工作线程上运行的.如何确保测试在主线程上运行？欢迎任何其他建议.

我试图获取某个字符的出现次数,如&下面的字符串.

string test = "key1=value1&key2=value2&key3=value3";

如何确定上述测试字符串变量中有2个和号(&)？

因此,只要应用程序正在运行或请求取消,我的应用程序几乎需要连续执行操作(每次运行之间暂停10秒左右).它需要做的工作可能需要30秒.

是否更好地使用System.Timers.Timer并使用AutoReset确保它在前一个"tick"完成之前不执行操作.

或者我应该在LongRunning模式下使用带有取消令牌的常规任务,并且在其内部有一个常规的无限while循环调用在调用之间使用10秒Thread.Sleep执行工作的操作？至于async/await模型,我不确定它在这里是否合适,因为我没有任何工作的返回值.

CancellationTokenSource wtoken;
Task task;

void StopWork()
{
    wtoken.Cancel();

    try 
    {
        task.Wait();
    } catch(AggregateException) { }
}

void StartWork()
{
    wtoken = new CancellationTokenSource();

    task = Task.Factory.StartNew(() =>
    {
        while (true)
        {
            wtoken.Token.ThrowIfCancellationRequested();
            DoWork();
            Thread.Sleep(10000);
        }
    }, wtoken, TaskCreationOptions.LongRunning);
}

void DoWork()
{
    // Some work that takes up to 30 seconds but isn't returning anything.
}

或者只是在使用AutoReset属性时使用简单的计时器,并调用.Stop()取消它？

我是.Net 4.0的任务的新手,我无法找到我认为基于任务的替换或实现定时器,例如定期任务.有这样的事吗？

更新 我提出了我认为是我的需求的解决方案,即将"计时器"功能包装在具有子任务的任务中,所有任务都利用CancellationToken并返回任务以便能够参与进一步的任务步骤.

public static Task StartPeriodicTask(Action action, int intervalInMilliseconds, int delayInMilliseconds, CancellationToken cancelToken)
{ 
    Action wrapperAction = () =>
    {
        if (cancelToken.IsCancellationRequested) { return; }

        action();
    };

    Action mainAction = () =>
    {
        TaskCreationOptions attachedToParent = TaskCreationOptions.AttachedToParent;

        if (cancelToken.IsCancellationRequested) { return; }

        if (delayInMilliseconds > 0)
            Thread.Sleep(delayInMilliseconds);

        while (true)
        {
            if (cancelToken.IsCancellationRequested) { break; }

            Task.Factory.StartNew(wrapperAction, cancelToken, attachedToParent, TaskScheduler.Current);

            if (cancelToken.IsCancellationRequested || intervalInMilliseconds == Timeout.Infinite) { break; }

            Thread.Sleep(intervalInMilliseconds);
        }
    };

    return Task.Factory.StartNew(mainAction, cancelToken);
}