小编i3a*_*non的帖子

我尝试了async/await的一些东西,但我真的没有得到它.我想要开始的所有内容是同时从两个不同的线程写入控制台.这是代码:

static void Main(string[] args)
{
    DoSomethingAsync();

    for (int i = 0; i < 1000; i++)
        Console.Write(".");

    Console.ReadLine();
}

static async void DoSomethingAsync()
{
    Console.WriteLine("DoSomethingAsync enter");

    //This does not seem good
    await Task.Delay(1);

    for (int i = 0; i < 1000; i++)
        Console.Write("X");

    Console.WriteLine("DoSomethingAsync exit");
}

使用Threads很容易但是使用async/await我只能在完成这个奇怪的操作时完成它

await Task.Delay(1);

我看到的大多数基本例子都使用过它 但是,当你想做一些不同步的时间时,该怎么做？你不能等待任何东西,因此所有代码都在主线程上运行.如何在不使用Task.Delay()的情况下实现与此代码相同的行为？

我试图通过局部变量获得线程结果.

有代码:

static void Main() 
{   
    long res1 = 0, res2 = 0;

    long n1 = 5000, n2 = 10000; 

    Thread t1 = new Thread(() => 
    { 
        res1 = Factorial(n1); 
    }); 

    Thread t2 = new Thread(() => { res2=Factorial(n2); }); 

    t1.Start();  
    t2.Start(); 
    t1.Join();  
    t2.Join(); 

    Console.WriteLine("Factorial of {0} equals {1}", n1, res1); 
    Console.WriteLine("Factorial of {0} equals {1}", n2, res2); 
} 

输出:

Factorial of 5000 equals 0
Factorial of 10000 equals 0

为什么这段代码返回0？

这是阶乘函数:

static long Factorial(long n) 
{ 
    long res = …

我的AsyncController中有以下异步方法:

public async Task<Dashboard> GetFeeds()
{
    var movies = new HttpClient().GetStringAsync("http://netflix/api/MyMovies");
    var tweets = new HttpClient().GetStringAsync("http://twitter/api/MyTweets");

    await Task.WhenAll(movies, tweets);

    Dashboard dash = new Dashboard();
    dash.Movies = Deserialize<Movies >(movies.Result);
    dash.Tweets = Deserialize<Tweets >(tweets.Result);

    return dash; 
}

在这个方法中做不同的调用API,一个具有彼此不同的返回时间.我无法理解的Task<>是因为我必须等待两人的回归才能更新我的客户？因为我正在创造新的线程.

想象一下我在PartialView中播放每个API的返回,我认为结果会得到:

- 首先我会有我的电影列表(它只需要5s), - >显示给我的用户

- 然后我的推文列表 - >显示给我的用户

但我看到的是:

- 虽然Twitter请求没有结束,但我没有在屏幕上为我的用户播放我从Netflix获得的数据.

最大的问题是:A Task<>仅用于加快处理速度吗？

我根据我订购的每个API的周转时间无法在屏幕上播放信息？

这是对我的方法的调用

public async Task<ActionResult> Index()
{
    var feeds = await GetFeeds();

    return View(feeds);
}

我承认,我很困惑,或者,也许你不明白这个概念Task<>.

简而言之,我有这样的事情:

class MyClass
{
    double SomeProperty {get; private set;}

    public async Task SomeMethod()
    {
        SomeProperty = await someService.SomeAsyncMethod();
    }
}

SomeProperty如果我SomeMethod()同时多次打电话可能会被破坏？

我试图避免将一堆BackgroundWorkers连在一起.我正在做一些事情,要求我在继续执行之前等待UI更新.显然,我不能使用Sleep,因为这会阻止UI线程更新并破坏目的.我发现下面的代码我认为是答案,但似乎该task.Wait();行仍在阻止UI线程.

static void Main(string[] args)
{
    var task = Task.Run(() => DoSomething());
    task.Wait();
    // once the task completes, now do more
}

static void DoSomething()
{
    // something here that is looking for the UI to change
}

我也尝试了以下内容,它做了同样的事情:

static void Main(string[] args)
{
    var task = Task.Run(() => DoSomethingAsync());
    task.Wait();
    // once the task completes, now do more
}

private async Task DoSomethingAsync()
{
    // something here that is looking for the UI to change
}

是否有可能做我想做的事情,如果是这样,我做错了什么？

在Xamarin项目中,Android - 我是android开发的新手.在处理活动时,在OnCreate方法中为a设置自定义适配器ListView.

protected async override void OnCreate (Bundle bundle)
{
    base.OnCreate (bundle);
    SetContentView(Resource.Layout.Main);

    var listAdapter = new CustomListAdapter(this);
    //.................................................
    listView = (ListView) FindViewById(Resource.Id.list);

    // populate the listview with data
    listView.Adapter = listAdapter;
}

在ctor适配器中,在异步调用中创建项列表.

public CustomListAdapter(Activity context) //We need a context to inflate our row view from
    : base()
{
    this.context = context;
    // items is List<Product>
    items = await GetProductList();
}

由于Getproducts是异步调用,因此它将异步加载数据.

问题是,一旦我将适配器设置为列表,它将尝试调用GetView适配器的方法.那时,不会加载项目.所以有一个空的例外.

如何处理这种情况.

谢谢.

我读过，我应该只Result在await我绝对确定操作已完成时使用而不是使用。我不太确定下面会发生什么，想询问经验丰富的程序员这是否是await//Result的完全安全的用法async。

public static bool Success()
{
    return 0 < Execute("DELETE FROM Table WHERE Id = 12").Result;
}

public static async Task<int> Execute(string sql)
{
    using (var con = Connection)
    {
        con.Open();
        return await con.ExecuteAsync(sql);
    }
}

我正在尝试在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 吗？

感谢您的建议！

Task t = new Task(() =>
{
    //I would expect this to be on a worker thread, but it's not!
    Thread.Sleep(1000);
});

Task test = new Task(() =>
{
    Thread.Sleep(1000);
});

test.ContinueWith(x =>
{
    //Do some UI Updates here, but also start another Task running.
    t.Start();
}, TaskScheduler.FromCurrentSynchronizationContext());

test.Start();

为什么t在UI线程上调用gets.据我所知,我创建了一个持续Task反对test其正确地被调用在UI线程上,但我然后开始一个新任务的运行.现在我知道我可以通过指定TaskScheduler.Default作为重载方法来解决这个问题t.Start,但是为什么Task在ui线程上开始新的？