有一些任务,特别是那些涉及删除文件夹作为SU的任务,在我按下Enter键之前我做得很周到.我想如果其他人看到我以我认真的速度做这些,他们会畏缩.您认为值得进行的关键编程任务是否值得这种深思熟虑的考虑?
我正在尝试为Action创建一个方便的扩展方法,以便在延迟后基本上运行该操作:到目前为止,我的扩展看起来像这样
public static void DelayAction(this Action DelayedAction, int millisecondDelay, CancellationToken Token)
{
Task t = Task.Factory.StartNew(() => { Thread.Sleep(millisecondDelay); }, Token, TaskCreationOptions.None, TaskScheduler.Default);
t.ContinueWith(_ => DelayedAction, Token, TaskContinuationOptions.None, TaskScheduler.FromCurrentSynchronizationContext());
}
Run Code Online (Sandbox Code Playgroud)
我有一个函数我调用它反过来使用这些扩展
private void DelayTask(Action ActiontoDelay, int millisecondDelay)
{
ActiontoDelay.DelayAction(millisecondDelay, _TokenSource.Token);
}
Run Code Online (Sandbox Code Playgroud)
我称之为:
DelayTask(() => { _SomeFunction(SomeArgs); }, 1500);
Run Code Online (Sandbox Code Playgroud)
但这一切似乎都落到了整体而且行动从未触发过.我哪里错了?
编辑17-11-11 2300hrs:
我删除了通用扩展方法,因为它与此示例无关.
此处也发表评论,因为它没有在评论中清楚地格式化代码
如果不是通话
DelayTask(() => { _SomeFunction(SomeArgs); }, 1500);
Run Code Online (Sandbox Code Playgroud)
我直接这样做:
Task t = Task.Factory.StartNew(() => { Thread.Sleep(1500); }, Token, TaskCreationOptions.None, TaskScheduler.Default);
t.ContinueWith(() => { _SomeFunction(SomeArgs); }, Token, TaskContinuationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()); …Run Code Online (Sandbox Code Playgroud) 从像源在TPL内联读了之后在这里,我得到的印象是,以Task.Wait(通话)将启动尚未开始(至少使用默认的调度器)的任务.但是,写一个快速演示,如:
var taskB = new Task(
() =>
{
Console.WriteLine("In TaskB");
System.Threading.Thread.Sleep(5000);
Console.WriteLine("Leaving TaskB");
});
var taskA = new Task(
() =>
{
Console.WriteLine("In TaskA");
System.Threading.Thread.Sleep(500);
Console.WriteLine("Waiting on TaskB");
taskB.Wait();
Console.WriteLine("Leaving TaskA");
});
taskA.Start();
taskA.Wait();
Run Code Online (Sandbox Code Playgroud)
造成死锁.TaskA进入taskB.Wait()行,但taskB永远不会启动.我没有搞乱调度程序或任何东西,所以我不确定为什么对taskB的.Wait()调用不会导致它启动.
这些是我的任务.我应该如何修改它们以防止此错误.我检查了其他类似的线程,但我正在使用等待并继续.那怎么会发生这个错误呢?
通过等待任务或访问其Exception属性,未观察到任务的异常.结果,终结器线程重新抛出了未观察到的异常.
var CrawlPage = Task.Factory.StartNew(() =>
{
return crawlPage(srNewCrawledUrl, srNewCrawledPageId, srMainSiteId);
});
var GetLinks = CrawlPage.ContinueWith(resultTask =>
{
if (CrawlPage.Result == null)
{
return null;
}
else
{
return ReturnLinks(CrawlPage.Result, srNewCrawledUrl, srNewCrawledPageId, srMainSiteId);
}
});
var InsertMainLinks = GetLinks.ContinueWith(resultTask =>
{
if (GetLinks.Result == null)
{
}
else
{
instertLinksDatabase(srMainSiteURL, srMainSiteId, GetLinks.Result, srNewCrawledPageId, irCrawlDepth.ToString());
}
});
InsertMainLinks.Wait();
InsertMainLinks.Dispose();
Run Code Online (Sandbox Code Playgroud) 我有一个脚本任务,执行动态创建的SQL还原语句.这对前6次运行没有问题,但是.bak文件变得太大而不能在30秒内运行.
我到处都看到了我能想到的超时选项.我已将连接管理器的常规超时重置为500(据我所知,这是几秒钟).这些都还没有奏效.
我在哪里/如何设置这个值(或者我可以)?
BIDS版本信息:Microsoft Visual Studio 2008版本9.0.30729.4462 QFE
Microsoft .Net Framework版本3.5 SP1
我的程序遇到了一些麻烦.
我有一个进程调用一个函数(Take_Job),它应该保持阻塞状态,直到一个时间(MINIMUM_WAIT)通过.如果不是这样,将出现通知这种情况的消息.
for Printer_Id in Type_Printer_Id loop
select
delay MINIMUM_WAIT
Pragma_Assert (True, "");
then abort
Take_Job (Controller,
Printer_Id,
Max_Tonner,
Job,
Change_Tonner);
Pragma_Assert
(False,
"Testing of Take_Job hasn't been successful. It should have remained blocked.");
end select;
end loop;
Run Code Online (Sandbox Code Playgroud)
函数Take_Job调用受保护对象中的条目:
procedure Take_Job (R : in out Controller_Type;
Printer : in Type_Printer_Id;
Siz : in Typo_Volume;
Job : out Typo_Job;
Excep_Tonner : out Boolean) is
begin
R.Take_Job(Printer, Siz, Job, Excep_Tonner);
end Take_Job;
Run Code Online (Sandbox Code Playgroud)
其中"R"是受保护对象.
以下代码是受保护对象的条目.实际上,"when"条件为True,因为我需要使用条目的参数检查一些内容.由于Ada不允许我这样做,我复制受保护对象内的参数并调用"延迟条目",然后在"延迟条目"中,我将确保在继续之前满足条件.
entry Take_Job(Printer_Id: in Type_Printer_Id; Remaining: in Type_Volume; Job: …Run Code Online (Sandbox Code Playgroud) 在这个问题中,我试图缓存单个值,让我们称之为foo.如果未缓存该值,则需要一段时间才能检索.
我的问题不是实现它,而是测试它.
为了测试它,我使用Task.WhenAll()来启动5个同步任务来获取缓存值.第一个进入锁并以异步方式检索值,而其他4个线程应等待锁.在等待之后,他们应该逐个重新检查缓存的值,发现它已被缓存它的第一个线程检索到,并在没有第二次检索的情况下返回它.
[TestClass]
public class Class2
{
private readonly Semaphore semaphore = new Semaphore(1, 1);
private bool? foo;
private async Task<bool> GetFoo()
{
bool fooValue;
// Atomic operation to get current foo
bool? currentFoo = this.foo;
if (currentFoo.HasValue)
{
Console.WriteLine("Foo already retrieved");
fooValue = currentFoo.Value;
}
else
{
semaphore.WaitOne();
{
// Atomic operation to get current foo
currentFoo = this.foo;
if (currentFoo.HasValue)
{
// Foo was retrieved while waiting
Console.WriteLine("Foo retrieved while waiting"); …Run Code Online (Sandbox Code Playgroud) 我从一个沉重的java背景中对C#有点新,并且仍在试图弄清楚await和async是如何工作的,这里有什么令我困惑的事情:
假设我有一个这样的函数(下面的Hackish代码仅用于实验):
public static bool CheckInternetConnection()
{
Task<bool> result = CheckInternetConnectionAsync();
return result.Result;
}
public async static Task<bool> CheckInternetConnectionAsync()
{
if (NetworkInterface.GetIsNetworkAvailable())
{
SomeClass details = await ReturnARunningTask();
return details.IsSuccessful;
}
return false;
}
public Task<SomeClass> ReturnARunningTask()
{
return Task.Run(() => checkInternet());
}
Run Code Online (Sandbox Code Playgroud)
在主执行线程中,如果我调用它:
CheckInternetConnection();
Run Code Online (Sandbox Code Playgroud)
它将无限期地阻塞,我的假设是控制在"await"关键字上留下CheckInternetConnectionAsync()并阻止".Result".等待恢复时,主线程已被阻止并保持阻塞状态
我假设的原因是我可以看到任务完成并返回,但是await之后的代码永远不会被执行
但是,如果我这样做:
bool result = Task.Run(() => CheckInternetConnection()).Result;
Run Code Online (Sandbox Code Playgroud)
然后执行await语句后的代码,主线程继续
我的期望是它也会阻塞,因为主线程将在中间任务上被阻塞.中间任务将被阻止在.Result上
那么......有什么不同?在这种情况下,await执行后的代码是什么?
我想创建一个异步函数,因为我想将结果返回到UI并且不想让它挂起,但无论如何它都是.
谁能告诉我为什么会挂?
public ActionResult Index()
{
return View(FunctionThreeAsync().Result);
}
private async Task<MyType> FunctionThreeAsync()
{
return await FunctionThree();
}
private Task<MyType> FunctionThree()
{
return Task.Run<MyType>(() => { /* code */ });
}
Run Code Online (Sandbox Code Playgroud) 我知道在正在等待的任务上调用ConfigureAwait(false)有时会产生性能优势,因为它可以防止不必要的返回原始SynchroniZationContext.
例如:
async Task Something()
{
// Let's say I'm on the UI context
//...
await AnotherTask.ConfigureAwait(false);
// Code here is no longer running on the UI context.
// It runs in a thread pool synchronization context (i.e. null).
}
Run Code Online (Sandbox Code Playgroud)
我的问题是:如果任务调用在方法的最后一行,并且我们跳过ConfigureAwait(false),编译器是否足够智能以防止不必要地返回到原始上下文?
async Task Something()
{
// Let's say I'm on the UI context
//...
await AnotherTask; // Dropped -> .ConfigureAwait(false);
}
Run Code Online (Sandbox Code Playgroud)
即使在等待调用之后方法中没有任何内容,这里是否会存在性能损失或潜在的死锁?