尝试捕捉外面:await Task.Run(() =>有意义或只是在等待中使用它们？
private async void Test()
{
try
{
await Task.Run(() =>
{
try
{
DoingSomething();
}
catch (Exception ex)
{
log.Error(ex.Message);
}
});
}
catch (Exception ex)
{
log.Error(ex.Message);
}
}
使用异步任务方法时,需要在方法之前放置等待.我需要以非UI阻塞方式执行代码,并且不想等待.我唯一的想法是使用:
private void TaskFactory()
{
CancellationTokenSource token_TaskFactory = new CancellationTokenSource();
ParallelOptions parOpts = new ParallelOptions();
parOpts.CancellationToken = token_TaskFactory.Token;
parOpts.MaxDegreeOfParallelism = Environment.ProcessorCount;
TaskCreationOptions atp = new TaskCreationOptions();
atp = TaskCreationOptions.PreferFairness;
Task TaskFactory = Task.Factory.StartNew(() =>
{
if (!token_TaskFactory.IsCancellationRequested)
{
Thread.Sleep(5000);
}
else
{
}
}, token_TaskFactory.Token, atp, TaskScheduler.Default);
}
请建议正确有效地使用ParallelOptions,TaskCreationOptions和Task.Factory.StartNew(()=>的方法是否正确(如果有).
private void NeedToUse_MaxDegreeOfParallelism_Method1()
{
CancellationTokenSource tokenFor_task = new CancellationTokenSource();
ParallelOptions parOpts = new ParallelOptions();
//parOpts.CancellationToken = tokenFor_task_tpl_Pair01.Token;
parOpts.MaxDegreeOfParallelism = Environment.ProcessorCount;
//parOpts.TaskScheduler = TaskScheduler.Default;
TaskCreationOptions tco = new TaskCreationOptions();
tco = TaskCreationOptions.PreferFairness;
Task task = null;
task = Task.Factory.StartNew(() =>
{
while (!tokenFor_task.IsCancellationRequested)
{
LongRunningMethod();
}
}, tokenFor_task.Token, tco, TaskScheduler.Default);
}
private void NeedToUse_MaxDegreeOfParallelism_Method2()
{
//CancellationTokenSource tokenFor_task = new CancellationTokenSource();
ParallelOptions parOpts = new ParallelOptions();
parOpts.CancellationToken = tokenFor_task_tpl_Pair01.Token;
parOpts.MaxDegreeOfParallelism = Environment.ProcessorCount;
parOpts.TaskScheduler = TaskScheduler.Default;
TaskCreationOptions tco = new TaskCreationOptions();
tco …是否有可能结合Text并StringFormat吗？
<TextBlock Text="{Binding Path=Price, StringFormat={Binding Path=DecimalPoints}}" />
DecimalPoints不断变化F0为F15.不幸的是,上面的代码无法编译.
我需要实现的是:
(链接到使用过的AsyncLock).
private async Task MasterAsync()
{
using (await _asyncLock.LockAsync())
{
await Task.Delay(2000);
}
}
private async Task HumbleSlave1Async()
{
using (await _asyncLock.LockAsync())
{
await Task.Delay(5000);
}
}
private async Task HumbleSlave2Async()
{
using (await _asyncLock.LockAsync())
{
await Task.Delay(5000);
}
}
我不确定如何解决它,正在考虑在MasterAsync中为每个奴隶使用两个不同的锁,但是一个锁将在另一个锁中:
private async Task MasterAsync()
{
using (await _asyncLock1.LockAsync())
{
using (await _asyncLock2.LockAsync())
{
await Task.Delay(2000);
}
}
}
private async Task HumbleSlave1Async()
{
using (await _asyncLock1.LockAsync())
{
await Task.Delay(5000);
}
} …我需要尽可能快地执行20次重复的CPU密集型计算.所以有20个任务包含循环方法:
while(!token.IsCancellationRequested)
尽快重复它们.所有计算都是同时进行的.不幸的是,这使得程序没有响应,所以补充说:
await Task.Delay(15);
此时程序不会挂起,但添加延迟不是正确的方法,它会不必要地降低计算速度.它是没有MVVM的WPF程序.你建议用什么方法让所有20个任务同时工作？一旦完成,它们中的每一个都将不断重复.我想将CPU(所有核心)利用率保持在最大值(或接近)以确保最佳效率.
编辑:有20个控件,用户可以调整一些参数.计算完成于:
private async Task Calculate()
{
Task task001 = null;
task001 = Task.Run(async () =>
{
while (!CTSFor_task001.IsCancellationRequested)
{
await Task.Delay(15);
await CPUIntensiveMethod();
}
}, CTSFor_task001.Token);
}
每个控件都是独立的.Calcullations 100%受CPU限制,没有I/O活动.(所有值都来自变量)在计算期间,某些UI项的值会发生变化:
this.Dispatcher.BeginInvoke(new Action(() =>
{
this.lbl_001.Content = "someString";
}));
我需要在 ListView 中显示双值，例如：0.00008。不幸的是，值经常被表示为指数/科学：1E-8。我不希望用户看到 1E-8 类型的值。我不知道也不想知道使用过的双精度数的小数点精度。我不能打双打。我可以使用 c# 解决这个问题：
string s = doubleValue.ToString("0.####################"); // gives what I need: 0,00008
如何使用 xaml 进行完全相同的格式化？
<ListView.View>
<GridView AllowsColumnReorder="False">
<GridView.Columns>
<GridViewColumn.CellTemplate>
<DataTemplate>
<Border>
<Grid>
<TextBlock x:Name="textBlock1" Text="{Binding Path=Profit, StringFormat={{???}}" TextTrimming="CharacterEllipsis" />
</Grid>
</Border>
</DataTemplate>
</GridViewColumn.CellTemplate>
</GridView.Columns>
</GridView>
</ListView.View>
或者如何使用 c# 在后面的代码中将这种格式分配给 textBlock1 ？
可以从代码中的多个位置调用TestAwaitTaskArrayAsync().我需要锁定taskArray的执行并异步等待,直到其所有任务完成,然后下一次调用才会开始执行taskArray.这是代码:
private async Task TestAwaitTaskArrayAsync()
{
Task[] taskArray;
lock (_lock_taskArray)
{
taskArray = new Task[]
{
Task.Run(() =>
{
SomeMethod1();
}),
Task.Run(() =>
{
SomeMethod2();
})
};
}
await Task.WhenAll(taskArray);
}
不允许等待锁定,因此我可以在必要时使用AsyncLock,但尝试保持简单.这段代码是否正确且线程安全？我不确定是否等待Task.WhenAll(taskArray); 可以在锁外,我应该使用AsyncLock吗？
我将属性绑定到 WPF 中的控件。属性值是通过 while 循环中的递归方法分配/更改的。因此，值以 ~ 1 ms 的速率分配。大多数时间值根本没有改变，但即使属性值没有改变，setter 中的 propertychanged 事件也会触发。我在想属性设置器应该只在字段的值发生变化时才引发事件。这是我的代码的简化版本：
public sealed class FX : System.ComponentModel.INotifyPropertyChanged
{
public event PropertyChangedEventHandler PropertyChanged;
public void OnPropertyChanged(string PropertyName)
{
PropertyChangedEventHandler handler = PropertyChanged;
if (handler != null)
{
handler(this, new PropertyChangedEventArgs(PropertyName));
}
}
private bool _someBool1 = false;
public bool SomeBool1
{
get { return _someBool1; }
set
{
_someBool1 = value;
OnPropertyChanged("SomeBool1");
//MessageBox.Show("SomeBool1 : propertychanged event fired!");
}
}
}
根据http://www.codemag.com/Article/0907101 UI 是 PropertyChanged 事件的消费者。虽然许多属性的值会被不断地、尽可能快地分配，这可能会导致不必要的 …
c# ×8
async-await ×4
wpf ×3
locking ×2
xaml ×2
.net ×1
binding ×1
delay ×1
listview ×1
performance ×1
properties ×1
task ×1
textblock ×1
try-catch ×1