Nsryjdtyk

Okay i am working with orleans and all i really want to do is sort an list after a value in state. i try to this by doing this

public async Task SortEntries()

    {

         State.Entries.OrderBy(GetComparator);

    }



    private async decimal GetComparator(IEntryGrain x)

    {

        var a = await x.GetState();



        return Task.FromResult(a);

    }

but this got two wrongs in them that i am trying to solve. first of the Task SortEntries task lacks an await operator which i guess might still work the problem is that GetComparator says an async method must be void, Task or Task.The most neat way i first thought would be to do all the sorting in SortEntries like this

State.Entries.OrderBy((x) => x.GetState().Result.TotalPoints);

But the GetState() need to be async with an await but i cant do that on the orderBy or sort. Anyone who can push me in the right direction or encountered something similar

1.) OrderBy doesn't work with async/await. A qiuck fix would be to use the Result property of GetState in GetComparator

private decimal GetComparator(IEntryGrain x)

{

    var task = x.GetState();

    task.Wait();



    if(task.IsFaulted)

        throw new Exception($"could not get the state: {task.Exception}", task.Exception);



    return task.Result;

}

2.) OrderBy return only an IEnumerable, so it wont be ordered there. Need to enumerate it once to execute the order by. And you need to return the result because OrderBy only returns a ordered list, but does not order the list itself.

public IList<IEntryGrain> SortEntries()

{

     return State.Entries.OrderBy(GetComparator)

                         .ToList();

}

or write it back to the property if it is writable and thread safe

public void SortEntries()

{

     State.Entries = State.Entries.OrderBy(GetComparator)

                                  .ToList();

}

So you get:

public IList<IEntryGrain> SortEntries()

{

    return State.Entries.OrderBy(GetComparator)

                        .ToList();

}



private decimal GetComparator(IEntryGrain x)

{

    var task = x.GetState();

    task.Wait();



    if(task.IsFaulted)

        throw new Exception($"could not get the state: {task.Exception}", task.Exception);



    return task.Result;

}

I don't see any issue in what you want to achieve, but there's a discrepancy in your question, let me point that out:

From GetComparator method, x.GetState() leads decimal return value, but then finally your OrderBy statement is: .OrderBy((x) => x.GetState().Result.TotalPoints), which is not feasible, therefore GetState() shall lead to a type, which has a decimal property TotalPoints, Now to the Main question.

Check out the following sample, where I have made few assumptions to compile the code

public async Task<IOrderedEnumerable<State>> SortEntries(List<State> stateEntries)

{

    var orderedEnumerable = stateEntries.OrderBy(async y => await GetComparator(y));

    return await Task.FromResult(orderedEnumerable);

}



private async Task<decimal> GetComparator(State x)

{

    var a = await x.GetState();



    return a.TotalPoints;

}



public class State

{

    public int Id {get; set;}



    public decimal TotalPoints {get;set;}



    public async Task<State> GetState()

    {

        return await Task.FromResult(this);

    }

}

Assumptions:

1. 
   State class defines the Schema, which contains Async method GetState, which is used for further logical processing


2. 
   State class contains TotalPoints, which is used for the Ordered Processing

How it Works:

1. 
   Async method shall always return a Task and have at-least 1 await for being truly Asynchronous call, rest of the call can be Synchronous, we normally expect a Network call to be Async / Non blocking


2. 
   Lambda can be Async, as shown in the code, which Async processing for the OrderBy call


3. Wrapping up in Task.FromResult is a convenience, which is used often for testing frameworks


4. 
   SortEntries entries method needn't Async, until and unless Orleans or similar framework needs it. Though ideally Async shall be all the way to the entry point like Main method in the Console, which is entry / starting point

Important point related to Async calls, Await keyword:

• They can return void / Task / Task<T>, with method signature containing async, it can become truly async on usage of keyword await at least once (to avoid blocking Network calls). await is mostly called on methods returning these three types. There's another option ValueTask.


• 
  await on void and Task return functions has not return value, but when used over Task<T>, it unwraps the Task<T> to fetch the result T, now this value T can be utilized in the function locally and when we return like return T, for a function with return value Task<T>, framework would automatically wrap in a Task, so that it can be further awaited till the entry point, which Framework can awaits Asynchronously