我有一个任务,启动几个子任务.(例如,任务A创建B,C,D,E,F).我还创建了System.Threading.Timer一个每10秒轮询一次数据库的程序,以检查计划项是否被请求取消.如果是,则设置CancellationTokenSource为任务知道取消.每个子任务(在本例中为B,C,D,E,F)将在适当时取消(它们通过文件循环并移动它们).
自从Task实现以来IDisposable,我想知道Task.WaitAll从catch块中再次调用是否是一个好主意,等待取消传播.在处理取消请求时,子任务可能处于循环的中间,并且在完成之前不能取消
但是,根据MSDN:
在释放对任务的最后一个引用之前,请始终调用Dispose.否则,在垃圾收集器调用Task对象的Finalize方法之前,不会释放它正在使用的资源.
我应该在我的任务数组上再次调用wait来正确调用数组中的Dispose()每个任务吗?
public class MyCancelObject
{
CancellationTokenSource Source { get;set;}
int DatabaseId { get;set;}
}
private void CheckTaskCancelled(object state)
{
MyCancelObject sourceToken = (MyCancelObject)state;
if (!sourceToken.CancelToken.IsCancellationRequested)
{
//Check database to see if cancelled -- if so, set to cancelled
sourceToken.CancelToken.Cancel();
}
}
private void SomeFunc()
{
Task.StartNew( () =>
{
MyCancelObject myCancelObject = new MyCancelObject(
databaseId,
new CancellationTokenSource());
System.Threading.Timer cancelTimer = new Timer( …Run Code Online (Sandbox Code Playgroud) 我正在考虑使用Task.Delay()不间断计时器,因为它更简单,更易读.
由于我是.NET的新手,我发现两个代码之间没有显着差异.你能告诉我他们之间的区别(如果有的话)吗?
// Create variable at some place
DispatcherTimer timer = new DispatcherTimer();
timer.Interval = TimeSpan.FromSeconds(5);
timer.Tick += timer_Elapsed;
timer.Start();
// Function other place
void timer_Elapsed(object sender, EventArgs e)
{
//Do stuff
}
Run Code Online (Sandbox Code Playgroud)
VS
// Every thing inside a function
async void TaskTimer()
{
while (true)
{
await Task.Delay(5000);
// Do stuff
}
}
Run Code Online (Sandbox Code Playgroud) 我想知道一个活动是否在android 5.0及更高版本的app apping下被锁定.请帮帮我!
谢谢!
task android-activity android-5.0-lollipop android-screen-pinning
根据我是使用基于异步/等待的代码还是基于TPL的代码,我在逻辑清理方面有两种不同的行为CallContext.
CallContext如果我使用以下async/await代码,我可以完全按照我的预期设置和清除逻辑:
class Program
{
static async Task DoSomething()
{
CallContext.LogicalSetData("hello", "world");
await Task.Run(() =>
Debug.WriteLine(new
{
Place = "Task.Run",
Id = Thread.CurrentThread.ManagedThreadId,
Msg = CallContext.LogicalGetData("hello")
}))
.ContinueWith((t) =>
CallContext.FreeNamedDataSlot("hello")
);
return;
}
static void Main(string[] args)
{
DoSomething().Wait();
Debug.WriteLine(new
{
Place = "Main",
Id = Thread.CurrentThread.ManagedThreadId,
Msg = CallContext.LogicalGetData("hello")
});
}
}
Run Code Online (Sandbox Code Playgroud)
以上输出如下:
{Place = Task.Run,Id = 9,Msg = world}
{Place = Main,Id = 8,Msg =}
注意,Msg =这表明CallContext主线程已被释放且为空.
但是,当我切换到纯TPL/TAP代码时,我无法达到同样的效果......
class Program
{ …Run Code Online (Sandbox Code Playgroud) 任何人都可以提供有关如何在python asyncio模块的任务和协同程序之间进行选择的实用建议吗?
如果我要以异步方式实现某些目标,我可以做以下2中的任何一项 -
import asyncio
@asyncio.coroutine
def print_hello():
print('Hello')
loop = asycio.get_event_loop()
loop.run_until_complete(print_hello)
loop.close()
Run Code Online (Sandbox Code Playgroud)
要么
import asyncio
@asyncio.coroutine
def print_hello():
print('Hello')
print_task = asyncio.ensure_future(print_hello)
loop = asycio.get_event_loop()
loop.run_until_complete(asyncio.wait_for(print_task))
loop.close()
Run Code Online (Sandbox Code Playgroud)
哪些因素决定了上述两种方法中的哪一种?
更新:@usr指出我错误地认为Lazy<T>默认的线程安全模式是LazyThreadSafetyMode.PublicationOnly......
我想懒洋洋地通过async工厂方法计算一个值(即它返回Task<T>)并在成功时缓存它.在例外情况下,我想让我可以使用它.我不然而,要堕入了异常缓存的行为是Lazy<T>在其默认模式(LazyThreadSafetyMode.ExecutionAndPublication)
异常缓存:使用工厂方法时,会缓存异常.也就是说,如果工厂方法在线程第一次尝试访问Lazy对象的Value属性时抛出异常,则每次后续尝试都会抛出相同的异常.这确保了对Value属性的每次调用都会产生相同的结果,并避免在不同的线程获得不同结果时可能出现的细微错误.懒惰代表一个实际的T,否则它将在某些早期点(通常在启动期间)初始化.在那个早期点失败通常是致命的.如果存在可恢复故障的可能性,我们建议您将重试逻辑构建到初始化例程(在本例中为工厂方法),就像您不使用延迟初始化一样.
Stephen Toub的AsyncLazy课程和写作似乎恰到好处:
public class AsyncLazy<T> : Lazy<Task<T>>
{
public AsyncLazy(Func<Task<T>> taskFactory) :
base(() => Task.Factory.StartNew(() => taskFactory()).Unwrap())
{ }
public TaskAwaiter<T> GetAwaiter() { return Value.GetAwaiter(); }
}
Run Code Online (Sandbox Code Playgroud)
然而,这实际上与默认行为相同Lazy<T>- 如果出现问题,则不会重试.
我正在寻找一个Task<T>兼容的等价物Lazy<T>(Func<T>, LazyThreadSafetyMode.PublicationOnly),即它应该按照指定的行为: -
锁定的替代方法在某些情况下,您可能希望避免Lazy对象的默认锁定行为的开销.在极少数情况下,可能存在死锁的可能性.在这种情况下,您可以使用Lazy(LazyThreadSafetyMode)或Lazy(Func,LazyThreadSafetyMode)构造函数,并指定LazyThreadSafetyMode.PublicationOnly.如果线程同时调用Value属性,这使Lazy对象能够在多个线程中的每个线程上创建一个延迟初始化对象的副本.Lazy对象确保所有线程使用延迟初始化对象的相同实例并丢弃未使用的实例.因此,降低锁定开销的成本是您的程序有时可能会创建并丢弃昂贵对象的额外副本.在大多数情况下,这不太可能.Lazy(LazyThreadSafetyMode)和Lazy(Func,LazyThreadSafetyMode)构造函数的示例演示了此行为.
重要
指定PublicationOnly时,即使指定了工厂方法,也不会缓存异常.
是否有任何FCL Nito.AsyncEx或类似的结构可能适合这里?如果没有这个,任何人都可以看到一种优雅的方式来控制"尝试进行中"位(我很好,每个调用者以与Lazy<T>(... 相同的方式进行自己的尝试(LazyThreadSafetyMode.PublicationOnly))并且仍然具有该缓存管理封装整齐?
以这样的方式,它不在子外壳中。我需要它能够准备环境...设置环境变量。
"version": "0.1.0",
"command": "${workspaceFolder}/Invoke-Task.ps1",
/*"command": "powershell", creates subshell so doesn't work*/
"isShellCommand": false,
"args": [],
"showOutput": "always",
"echoCommand": true,
"suppressTaskName": true,
"tasks": [
{
"taskName": "task1",
"args": ["task1"]
},
{
"taskName": "task2",
"args": ["task2"]
}
]
Run Code Online (Sandbox Code Playgroud) msdn文档Task.ContinueWith只有一个代码示例,其中一个任务(dTask)在后台运行,后跟(使用ContinueWith)第二个任务(dTask2).样品的本质如下所示;
Task dTask = Task.Factory.StartNew( () => {
... first task code here ...
} );
Task dTask2 = dTask.ContinueWith( (continuation) => {
... second task code here ...
} );
Task.WaitAll( new Task[] {dTask, dTask2} );
Run Code Online (Sandbox Code Playgroud)
我的问题很简单; 使用.ContinueWith调用第二个代码块的优点是什么,而不是简单地将它附加到第一个代码块,后者已经在后台运行并将代码更改为这样的代码?
Task dTask = Task.Factory.StartNew( () => {
... first task code here ...
if (!cancelled) //and,or other exception checking wrapping etc
{
... second task code here ...
}
} );
Task.Wait(dTask);
Run Code Online (Sandbox Code Playgroud)
在建议的修订版中,ContinueWith完全避免调用,第二个代码块仍然在后台运行,加上没有上下文切换代码来访问闭包的状态......我不明白?感觉有点愚蠢,我做了一些谷歌搜索,也许只是没有找到正确的短语来搜索.
更新: Hans Passant发布了更多MSDN …
这里问的一个问题的延续:
在上述问题中,我有以下函数返回Task类型的对象(用于增量测试目的):
private static Task<object> GetInstance( ) {
return new Task<object>( (Func<Task<object>>)(async ( ) => {
await SimpleMessage.ShowAsync( "TEST" );
return new object( );
} ) );
}
Run Code Online (Sandbox Code Playgroud)
当我调用时await GetInstance( );,函数被调用(我假设任务被返回,因为没有抛出异常),但随后任务就在那里.
我只能猜测我做错了.
我不希望此函数返回已在运行的任务(即IMPERATIVE).
如何异步运行此函数返回的任务?
我有一个接口我在两个地方实现,如:
interface I
{
Task DoSomething();
}
Run Code Online (Sandbox Code Playgroud)
该接口具有异步Task DoSomething方法API,然后在A类中实现,如:
class A : I {....}
class B : I {....}
Run Code Online (Sandbox Code Playgroud)
在A类中,DoSomething的实现如下所示,这是正常的:
public async Task DoSomething()
{
if (...)
{
await DoIt();
}
}
Run Code Online (Sandbox Code Playgroud)
但是,在B类中,DoSomething()的实现不应该做任何事情.所以,它的实现看起来像这样:
public async Task DoSomething()
{
// nothing
}
Run Code Online (Sandbox Code Playgroud)
这编译但我不确定除了方法没用之外,做这样的事情是多么正确.
但在这种情况下"无用"在这种情况下是可以的,因为它的实现只是因为实现接口I的B类需要它.
我想知道这是否是一种正确的方法来实现一个返回异步任务但没有等待或返回的方法?我知道这个方法很简单,无法同步执行,因为没有调用await.
更新:此处已经提出了类似的问题,我在询问这一问题之前已经检查了所有这些问题.没有人问我要问的是什么
task ×10
c# ×7
async-await ×4
asynchronous ×3
.net ×2
delay ×1
powershell ×1
python ×1
vscode-tasks ×1