这是"这是可能的,如果是这样,你能给我一个简单的例子,因为我找不到一个在线的吗?" 有点问题.
我有许多完全独立的(即"令人尴尬的并行")进程,我想使用C#在.NET Framework 4中使用任务并行库并行运行.其中一些过程需要使用可通过COM/OLE自动化访问的软件.
具体来说,有一个Parallel.Foreach()循环将任务从项列表中分开,基本上调用Parallel.Foreach中的不同函数来处理处理(因此其中一些函数使用COM库来工作).
这可能吗?谢谢.
当使用TcpClient中的标准BeginRead和EndRead方法并使用Task.Factory.FromAsync时,我有非常相似的代码.
以下是一些示例..错误处理代码未显示.
Task.Factory.FromAsync:
private void Read(State state)
{
Task<int> read = Task<int>.Factory.FromAsync(state.Stream.BeginRead, state.Stream.EndRead, state.Bytes, state.BytesRead, state.Bytes.Length - state.BytesRead, state, TaskCreationOptions.AttachedToParent);
read.ContinueWith(FinishRead);
}
private void FinishRead(Task<int> read)
{
State state = (State)read.AsyncState;
state.BytesRead += read.Result;
}
Run Code Online (Sandbox Code Playgroud)
使用BeginRead和EndRead标准使用回调:
private void Read(State state)
{
client.BeginRead(state.Bytes, state.BytesRead, state.Bytes.Length - state.Bytes.Read, FinishRead, state);
}
private void FinishRead(IAsyncResult async)
{
State state = (State)async.AsyncState;
state.BytesRead += state.Stream.EndRead(async);
}
Run Code Online (Sandbox Code Playgroud)
这两个都很好,但我很好奇他们的差异.两者的代码行几乎相同,它们似乎都执行完全相同的功能并具有相同的效率.哪个更好?您更喜欢在生产代码中看到什么?
我的问题是如何停止长时间运行的任务(.net 4)?我已经实现了TPL并尝试使用CancellationTokenSource,但它似乎不适用于我的场景.我见过的所有例子都假设你在while循环中工作,这样你就可以检查任务是否已被取消,而我只需要一个需要很长时间的操作.我不能等待工作完成,因为我需要假设它可能永远不会完成.这是我尝试过的代码:
bool? result = null;
var cs = new CancellationTokenSource();
var ct = cs.Token;
var doWorkTask = new Task(() =>
{
Console.WriteLine("start dowork task");
result = Work.LongRunning();
}, ct);
doWorkTask.Start();
Task.WaitAny(new Task[] { doWorkTask }, timetowait);
if (doWorkTask.IsCompleted)
{
Console.WriteLine("dowork task completed");
doWorkTask.Dispose();
}
else
{
Console.WriteLine("dowork task has timedout");
cs.Cancel();
throw new TimeoutException("Timeout hit.");
}
Run Code Online (Sandbox Code Playgroud)
代码可以工作但是如果"超时"发生并且正在完成的工作访问"非托管代码"即资源,则永远不会处理任务.那说IsCancelledRequested不能在Work.LongRunning()中使用,所以我不能ThrowIfCancellationRequested.
我对其他想法持开放态度,并且我尝试过BackgroundWorker,但这似乎也不合适.
新例子:
var service = new System.ServiceProcess.ServiceController(ServiceName, ServerName);
var serviceTask = Task.Factory.StartNew(() =>
{
result = (service.Status == ServiceControllerStatus.Running
|| service.Status == …Run Code Online (Sandbox Code Playgroud) 我已阅读了许多技术文档,其中包括一些Microsoft团队或其他作者详细介绍了新TPL Dataflow库的功能,async/await并发框架和TPL.但是,我并没有真正遇到任何明确描述使用时间的内容.我知道每个都有自己的位置和适用性,但我特别想知道以下情况:
我有一个完全在进程中运行的数据流模型.在顶部是数据生成组件(A),它生成数据并通过数据流块链接或通过将事件提升到处理组件(B)来传递数据.(B)中的某些部分必须同步运行,而(A)大量受益于并行性,因为大多数进程是I/O或CPU绑定的(从磁盘读取二进制数据,然后对它们进行反序列化和排序).最后,处理组件(B)将转换后的结果传递给(C)以供进一步使用.
我特别想知道何时使用任务,async/await和TPL数据流块以下内容:
启动数据生成组件(A).我显然不想锁定gui /仪表板,因此这个过程必须在某个不同的线程/任务上运行.
如何在(A),(B)和(C)中调用不直接参与数据生成和处理过程但执行可能需要几百毫秒/秒返回的配置工作的方法.我的预感是,这是async/await闪耀的地方?
我最挣扎的是如何最好地设计从一个组件传递到下一个组件的消息.TPL Dataflow看起来非常有趣,但有时候我的目的太慢了.(最后请注意性能问题).如果不使用TPL Dataflow,如何通过进程间任务/并发数据传递实现响应性和并发性?例如,如果我在一个任务中引发一个事件,订阅的事件处理程序在同一个任务中运行而不是传递给另一个任务,那么对吗?总之,组件(A)在将数据传递给组件(B)之后如何进行业务,而组件(B)检索数据并专注于处理数据?这里最好使用哪种并发模型?我在这里实现了数据流块,但这真的是最好的方法吗?
我想总结上面的要点是我在如何使用标准实践设计和实现API类型组件方面的努力?方法是否应设计为异步,数据输入为数据流块,数据输出为数据流块还是事件?一般来说最好的方法是什么?我问,因为上面提到的大多数组件都应该独立工作,因此它们基本上可以在内部交换或独立更改,而无需重新编写访问器和输出.
关于性能的注意事项:我提到TPL Dataflow块有时很慢.我处理高吞吐量,低延迟类型的应用程序和目标磁盘I/O限制,因此tpl数据流块通常比例如同步处理单元执行得慢得多.问题是我不知道如何将进程嵌入到自己的任务或并发模型中,以实现与tpl数据流块已经处理的类似的东西,但没有tpl df带来的开销.
可能重复:
并行处理期间的C#值存储
我今天在我的控制台应用程序中运行了一些性能测试,我偶然发现了一些非常意外的事情.我的代码:
int iterations = 1000000;
var mainList = new List<string>();
for (int i = 0; i < iterations; i++)
{
mainList.Add(i.ToString());
}
var listA = new List<string>();
Parallel.ForEach(mainList, (listItem) =>
{
if (Int32.Parse(listItem)%2 == 0)
{
listA.Add(listItem);
}
});
Console.WriteLine("Parallel Count: {0}", listA.Count);
var listB = new List<string>();
foreach (var listItem in mainList)
{
if (Int32.Parse(listItem) % 2 == 0)
{
listB.Add(listItem);
}
}
Console.WriteLine("Sequential Count: {0}", listB.Count);
Run Code Online (Sandbox Code Playgroud)
这产生了一个输出:
平行计数:495939
顺序计数:500000
我运行了几次,并行循环似乎永远不会在适当的时间执行.任何人都能解释这种"不端行为"吗?并行循环是否值得信赖?
PS我知道在提供的代码示例中有很多废话,比如ToString()调用一个整数而不是解析它们但这只是我在测试时提出的随机代码.提前致谢.
以下是跟踪进度的最佳方法
long total = Products.LongCount();
long current = 0;
double Progress = 0.0;
Parallel.ForEach(Products, product =>
{
try
{
var price = GetPrice(SystemAccount, product);
SavePrice(product,price);
}
finally
{
Interlocked.Decrement(ref this.current);
}});
Run Code Online (Sandbox Code Playgroud)
我想将进度变量从0.0更新为1.0(当前/总)但我不想使用会对并行性产生负面影响的任何内容.
我正在寻找TPL数据流库的.NET 4.0版本.
Nuget包有一个4.0版本的库,但它似乎以.NET 4.5为目标.
我发现了4.0版本的各种引用,就像在这个论坛中一样:
但是提到的链接只是将我重定向到库的Nuget页面.
有谁知道我在哪里可以找到一个针对.NET 4.0的工作版本?
在等待API帖子完成我如何解决这个问题时,AggregateException正在抛出?
我的API调用类似于此
using (var httpClient = new HttpClient())
{
httpClient.BaseAddress = new Uri(workflowUrl);
var task = httpClient.PostAsJsonAsync("api/apiname/execute/", executeModel)
.ContinueWith(x => x.Result.Content.ReadAsAsync<bool>().Result);
Task continuation = task.ContinueWith(x =>
{
bool response = x.Result;
});
continuation.Wait();
}
Run Code Online (Sandbox Code Playgroud)
在等待POST完成时,我得到了Exception.
System.AggregateException was caught
Message=One or more errors occurred.
Source=mscorlib
StackTrace:
at System.Threading.Tasks.Task.ThrowIfExceptional(Boolean includeTaskCanceledExceptions)
at System.Threading.Tasks.Task.Wait(Int32 millisecondsTimeout, CancellationToken cancellationToken)
at System.Threading.Tasks.Task.Wait()
at
InnerException: System.AggregateException
Message=One or more errors occurred.
Source=mscorlib
StackTrace:
at System.Threading.Tasks.Task.ThrowIfExceptional(Boolean includeTaskCanceledExceptions)
at System.Threading.Tasks.Task`1.get_Result()
at
at System.Threading.Tasks.Task`1.<>c__DisplayClass17.<ContinueWith>b__16(Object obj)
at System.Threading.Tasks.Task.InnerInvoke()
at System.Threading.Tasks.Task.Execute()
InnerException: System.AggregateException …Run Code Online (Sandbox Code Playgroud) 我正在处理一个任务并行问题,我有许多任务可能会或可能不会抛出异常.
我想处理所有正确完成的任务并记录其余的任务.在Task.WaitAll不允许我收集其余结果的情况下支持Task异常.
static readonly Task<string> NormalTask1 = Task.FromResult("Task result 1");
static readonly Task<string> NormalTask2 = Task.FromResult("Task result 2");
static readonly Task<string> ExceptionTk = Task.FromException<string>(new Exception("Bad Task"));
var results = await Task.WaitAll(new []{ NormalTask1,NormalTask2,ExceptionTk});
Run Code Online (Sandbox Code Playgroud)
在Task.Waitall 与抛出的异常ExcceptionTk忽略其它结果.我怎样才能得到忽略异常的结果并同时记录异常?
我可以将任务包装到try{...}catch(){...}内部异常的另一个任务中,但我无法访问它们,我希望我不必添加这个开销.
我很困惑,为什么Task.Delay().Wait()需要4倍更长的时间,然后Thread.Sleep()?
例如,task-00 仅在第9个线程上运行并占用了2193ms?我知道,同步等待在任务中很糟糕,因为整个线程被阻止了.它只是为了测试.
控制台应用中的简单测试:
bool flag = true;
var sw = Stopwatch.StartNew();
for (int i = 0; i < 10; i++)
{
var cntr = i;
{
var start = sw.ElapsedMilliseconds;
var wait = flag ? 100 : 300;
flag = !flag;
Task.Run(() =>
{
Console.WriteLine($"task-{cntr.ToString("00")} \t ThrID: {Thread.CurrentThread.ManagedThreadId.ToString("00")},\t Wait={wait}ms, \t START: {start}ms");
//Thread.Sleep(wait);
Task.Delay(wait).Wait();
Console.WriteLine($"task-{cntr.ToString("00")} \t ThrID: {Thread.CurrentThread.ManagedThreadId.ToString("00")},\t Wait={wait}ms, \t END: {sw.ElapsedMilliseconds}ms");
;
});
}
}
Console.ReadKey();
return;
Run Code Online (Sandbox Code Playgroud)
使用 …
c# ×8
.net ×4
.net-4.0 ×2
task ×2
tpl-dataflow ×2
asp.net ×1
async-await ×1
asynchronous ×1
c#-4.0 ×1
com ×1
exception ×1
nuget ×1
ole ×1
plinq ×1
timeout ×1