我有一个任务,启动几个子任务.(例如,任务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) 我在Visual Studio 2012中有C#的代码.
public Task SwitchLaserAsync(bool on)
{
return Task.Run(new Action(() => SwitchLaser(on)));
}
Run Code Online (Sandbox Code Playgroud)
这将执行SwitchLaser方法(类的公共非静态成员MyClass)作为参数bool on的任务.
我想在托管C++/CLI中做类似的事情.但我无法找到如何运行任务的任何方法,该任务将执行采用一个参数的成员方法.
目前的解决方案是这样的:
Task^ MyClass::SwitchLaserAsync( bool on )
{
laserOn = on; //member bool
return Task::Run(gcnew Action(this, &MyClass::SwitchLaserHelper));
}
Run Code Online (Sandbox Code Playgroud)
执行SwitchLaserHelper功能:
void MyClass::SwitchLaserHelper()
{
SwitchLaser(laserOn);
}
Run Code Online (Sandbox Code Playgroud)
必须有一些像C#中的解决方案而不是创建辅助函数和成员(这不是线程安全的).
我有一个创建多个任务的循环,如下所示.每个任务完成后,如何更新屏幕(使用某些数据向文本框添加新行)?
如何检测所有任务何时完成?
C#代码
for (int i = 0; i < int.Parse(radTextBoxFloodRequests.Text); i++)
{
int x = i;
// Create a task and supply a user delegate by using a lambda expression.
var taskA = new Task(() => TaskRequest(int.Parse(radTextBoxFirstNumber.Text), int.Parse(radTextBoxSecondNumber.Text), int.Parse(radTextBoxFloodDelay.Text), x));
// Start the task.
taskA.Start();
}
private void TaskRequest(int number1, int number2, int delay, int count)
{
// Some long running method
}
Run Code Online (Sandbox Code Playgroud) 我想在调用relay命令时启动任务,但是只要该任务正在运行,我想禁用该按钮
举个例子
private ICommand update;
public ICommand Update
{
get
{
if (update == null)
{
update = new RelayCommand(
param => Task.Factory.StartNew(()=> StartUpdate()),
param => true); //true means the button will always be enabled
}
return update;
}
}
Run Code Online (Sandbox Code Playgroud)
检查该任务是否正在运行的最佳方法是什么?
这是我的解决方案,但不确定它是否是最佳方式
class Vm : ObservableObject
{
Task T;
public Vm()
{
T = new Task(() => doStuff());
}
private ICommand myCommand;
public ICommand MyCommand
{
get { return myCommand ?? (myCommand = new RelayCommand( p => { T = …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))并且仍然具有该缓存管理封装整齐?
我试图单元测试一个返回任务>的方法:
void Main()
{
var mockRepo = new Mock<IRepository>();
mockRepo.Setup(x => x.GetAll()).Returns(new List<MyModel>() { new MyModel { Name = "Test" } }); // works
mockRepo.Setup(x => x.GetAllAsync()).Returns(Task.FromResult(new List<MyModel>() { new MyModel { Name = "Test" } })); // error
var result = mockRepo.Object.GetAll();
result.Dump();
}
public interface IRepository
{
Task<IList<MyModel>> GetAllAsync();
IList<MyModel> GetAll();
}
public class MyModel
{
public string Name { get; set; }
}
Run Code Online (Sandbox Code Playgroud)
但Task返回方法会生成编译器错误:
CS1503参数1:无法从'System.Threading.Tasks.Task <System.Collections.Generic.List <UserQuery.MyModel>'转换为'System.Threading.Tasks.Task <System.Collections.Generic.IList <UserQuery.MyModel >"
我究竟做错了什么?
task ×10
c# ×7
asynchronous ×3
async-await ×2
.net ×1
.net-4.0 ×1
action ×1
arguments ×1
c++-cli ×1
delay ×1
icommand ×1
moq ×1
mvvm ×1
python ×1
threadpool ×1
unit-testing ×1