小编i3a*_*non的帖子

我正在尝试在Visual Studio 2013上的xamarin共享项目中使用Azure api的Azure媒体服务.这是我用来获取访问令牌的代码.

public HttpFactory()
{
    string token = GetToken(serviceURI).Result;
    //some more methods also async tasks
}

private async Task<string> GetToken(Uri serviceUri)
{
    HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(serviceURI);
    request.Accept = "application/json";
    request.Method = "GET";
    request.Headers["Host"] = "media.windows.net";
    request.Headers["x-ms-version"] = "2.9";
    request.Headers["Authorization"] = "Bearer " + token;
    var response = (HttpWebResponse) await request.GetResponseAsync();

    if (response.StatusCode == HttpStatusCode.MovedPermanently)
    {
        serviceURI = new Uri(response.Headers["Location"]);
        HttpWebRequest req = ( HttpWebRequest)WebRequest.Create(serviceURI);
        var res = (HttpWebResponse)await req.GetResponseAsync();

        using (Stream responseStream = res.GetResponseStream())
        {
            using (StreamReader reader …

我有一个应用程序，它不断（+-100 毫秒）从 PLC 读取订单，然后将它们放入一个模型中，然后由多个客户端读取。为此，我使用 lock 语句。

订单阅读线程：

lock (model) {
//update object
}

客户阅读：

lock (model) {
//serialize object to json string
}
send over tcp stream to client.

但我也可以用于更新：

Interlocked.ExChange(oldObj, newObj)

我不希望我的客户必须等待订单读取线程中发生的锁定。而且我绝对不希望客户阻止我的订单阅读线程。

我最好使用 Interlocked 吗？

感谢您的建议！

我只是想知道，是否有更好的方法来初始化 C# 多维对象数组（引用类型）。

这是我的代码：

Board = new Field[BoardHeight, BoardWidth];

for (int i = 0; i < BoardHeight; i++)
{
    for (int j = 0; j < BoardWidth; j++)
    {
        Board[i, j] = new Field();
    }
}

如果我可以摆脱 for/for 循环并用单行替换它？那太好了。

我们有一个泛型Job类,它有一个HeavyTask像这样的抽象方法:

abstract class Job {
    private Task m_task; 
    protected abstract void HeavyTask(); 

    public void StartJob(){
        m_task = Task.Run(() => HeavyTask());
    }
    public async Task WaitJob(){
        await m_task; 
    }
}

派生类重写该HeavyTask函数并使其异步:

class JobFoo : Job {
    protected override async void HeavyTask()
    {
        await Task.Delay(1000);
        Debug.WriteLine("JobFoo is done");
    }
}

然后,当我们使用这种方法时,似乎HeavyTask()没有等待:

Job job = new JobFoo();
job.StartJob();
await job.WaitJob();
Debug.WriteLine("All Done");

输出:

所有完成
JobFoo已完成

如果我们没有async覆盖HeavyTask,那么它按预期工作.但我不能保证那些超越的Job人不会做出的HeavyTask async.我想明白为什么不能等待它成功,有没有办法确保它等待？如果可以的话,你能否解释一下如何将非异步函数覆盖为async是一个好习惯,如上所示？

我有一个要包装的函数，以便可以使用async / await模式：

wcfClientService.GetSomeString(parameter);

这是来自WCF客户端的呼叫，我正在尝试使其异步，但这并不重要（我知道WCF支持异步，但是假设我们无权访问WCF代码）。

我正在尝试用该Task<T>.Factory.FromAsync方法包装该方法，但似乎无法正确处理它：

private Task<string> WrapWcfServiceAsyncTask(uint parameter)
{
    Func<uint, string> func = i => { return wcfClientService.GetSomeString(parameter); };

    var t = Task<string>.Factory.FromAsync(
                                           // What goes here?
                                          );
    return t;
}

甚至更好的是，有人可以编写一个将方法作为参数并包装并Task<T>为其返回的方法吗？

鉴于此代码:

s_Batch = new BatchBlock<PerformanceRecord>(500);
s_Action = new ActionBlock<PerformanceRecord[]>(a => SendToDatabase(a));
s_Batch.LinkTo(s_Action);

当我完成后,我需要打电话Complete()给每个街区吗？或者将完成s_Batch触发链接到它的块中的完整？

我有一个async功能.有多个级别的函数调用都返回a Task.在这个链中的某个点上,我必须修改结果的值.我想这样做而不会中断async函数的流程.注意:

[HttpGet]
[Route("GetWeb")]
public async Task<IHttpActionResult> GetResult([FromUri] string url)
{
    var result = await GetPageText(url);
    return Ok(result);
}

private Task<string> GetPageText(string url)
{
    Task<string> data = GetDataAsync(url);
    //here I would like to manipulate the data variable
    return data;
}

在该函数中,GetPageText如何在不中断异步流的情况下操作数据变量.这可能吗？

我需要使用一个提供对自己数据库的访问的库.不幸的是,所有方法都是经典同步.我宁愿有async方法来卸载IO负载,就像我们已经说过的SQL Server一样.

我知道这是一个非常通用的问题,没有太多具体信息.有没有办法移动到那一点,还是太糟糕了？

非常感谢示例和/或链接.

我的数据有以下结构

public enum ParamType
{
    Integer=1,
    String=2,
    Boolean=3,
    Double=4
}

public class Gateway
{
    public int _id { get; set; }
    public string SerialNumber { get; set; }
    public List<Device> Devices { get; set; }
}

public class Device
{        
    public string DeviceName { get; set; }
    public List<Parameter> Parameters { get; set; }
}

public class Parameter
{
    public string ParamName { get; set; }
    public ParamType ParamType { get; set; }
    public string Value { get; set; } …

您好我有以下代码创建任务.然后将其设置为开始.该任务旨在添加对ConcurrentBag列表的响应.但等待似乎并不等待完成所有任务.但他们被标记为已完成.列表中只有一个任务.使用时效果很好Task.Run!

public async void RunT1()
{          

    DoesNotWork();

}

public async void RunT2()
{          

    DoesWork();

}

public async void DoesNotWork()
{
    ConcurrentBag<string> concurrentBag = new ConcurrentBag<string>();
    List<Task> taskList = new List<Task>();

    Task task1 = new Task(async () =>
    {

        var xml = await LongWorkingMethod();
        concurrentBag.Add(xml);

    });

    taskList.Add(task1);

    taskList[0].Start();
    await Task.WhenAll(taskList);

    if (concurrentBag.Count > 0)//concurrentBag is empty even though the task has finished
    {
        Debug.Print("success");
    }
}

public async void DoesWork()
{
    ConcurrentBag<string> concurrentBag = new ConcurrentBag<string>();
    List<Task> …