C#

public override ValueTask<bool> SaveChanges()
{
    bool isValid = Validate();
    if (isValid)
    {
        var task = Company.Id == 0
            ? Task.Run(() => AppCore.BizObject.AddCompany(Company))
            : Task.Run(() => AppCore.BizObject.UpdateCompany(Company));
        
        /*
        Preferably:
        var task = Company.Id == 0
            ? AppCore.BizObject.AddCompanyAsync(Company)
            : AppCore.BizObject.UpdateCompanyAsync(Company);
        */
        
        await task;
        // Do cleanup stuff
    }
    
    return isValid;
}

public interface IServerAPI
{
    Task AddCompanyAsync(CompanyEntity entity);

    Task UpdateCompanyAsync(CompanyEntity entity);
}

public class ServerAPI : IServerAPI
{
    public async Task AddCompanyAsync(CompanyEntity entity)
    {
        var t = await Task.Factory.StartNew(() =>
        {
            // Add the company and return the new PK
            return 1;

        });

        return t;
    }

    public async Task UpdateCompanyAsync(CompanyEntity entity)
    {
        await Task.Factory.StartNew(() =>
        {
            // Update the company

        });
    }
}

public partial class MainWindow : Window, INotifyPropertyChanged
{
    #region Base Class Abstract Code
    // This command is really in abase class. It calls an abstract method called SaveChanges, which I 
    // could modify to be async and call the SaveChanges with await, as I did here: 
    private ICommand _SaveCommand;
    public ICommand SaveCommand
    {
        get
        {
            if (_SaveCommand == null)
                _SaveCommand = new RelayCommand(p => SaveExecuted(), p => SaveCanExecute());
            return _SaveCommand;
        }
    }

    private bool SaveCanExecute()
    {
        return true;
    }

    private async void SaveExecuted()
    {
        try
        {
            await SaveChanges();
        }
        catch (Exception e)
        {
            throw;
        }
        finally
        {
            // Do post-Save stuff here
        }
    }
    #endregion Base Class Abstract Code

    private async Task SaveChanges()
    {
        IServerAPI serverAPI = new ServerAPI();

        if (Company.Id == 0)
        {
            var newId = await serverAPI.AddCompanyAsync(Company);
            Company.Id = newId;
        }
        else
        {
            await serverAPI.UpdateCompanyAsync(Company);
        }
    }
}

private void SaveExecuted()
{
    _ = SaveAsync();
}

private async Task SaveAsync()
{
    try
    {
        IServerAPI serverAPI = new ServerAPI();
        if (Company.Id == 0)
        {
            Company.Id = await serverAPI.AddCompanyAsync(Company);
        }
        else
        {
            await serverAPI.UpdateCompanyAsync(Company);
        }
    }
    finally
    {
        // Do post-save stuff here
    }
}

Richard Deeming wrote:

Not really. Spinning up a new Task and awaiting it is only really useful if you want to move the processing onto a background thread. On the server, that doesn't make any sense.

public async Task<int> DoSomethingAsync()
{
    var result = await CallDependencyAsync();
    return result + 1;
}

public int Foo()
{
    return 42;
}

public async Task<int> BarAsync()
{
    using (var connection = new SqlConnection("..."))
    using (var command = new SqlCommand("...", connection))
    {
        await connection.OpenAsync();
        object result = await command.ExecuteScalarAsync();
        return Convert.ToInt32(result);
    }
}

private readonly HttpClient _client;

public async Task<int> FooAsync()
{
    using (var response = await _client.GetAsync("/api/foo"))
    {
        response.EnsureSuccessStatusCode();
        return await response.ReadAsAsync<int>();
    }
}

public async Task<int> BarAsync()
{
    using (var response = await _client.GetAsync("/api/bar"))
    {
        response.EnsureSuccessStatusCode();
        return await response.ReadAsAsync<int>();
    }
}

command.ExecuteScalarAsync()

public CompanyEntity GetCompanyById(int companyId)
{
    using (var dc = GetDataContext())
    {
        var cust = (from c in dc.Companies
                    where c.Id == companyId
                    select new CompanyEntity
                    {
                        Id = c.Id,
                        CompanyName = c.CompanyName
                    }).FirstOrDefault();

        return cust;
    }
}

public override void Load(int id)
{
    Customer = AppCore.BizObject.GetCustomerById(id);
}

public override async void Load(int id)
{
    await Task.Factory.StartNew(() =>
    {
        var customer = AppCore.BizObject.GetCustomerByIdAsync(id);
    });
}

public Task<CompanyEntity> GetCompanyByIdAsync(int companyId)
{
    using (var dc = GetDataContext())
    {
        var cust = (from c in dc.Companies
                    where c.Id == companyId
                    select new CompanyEntity
                    {
                        Id = c.Id,
                        CompanyName = c.CompanyName
                    }).FirstOrDefault();

        return cust;
    }
}

protected override void Load()
{
    _ = LoadAsync();
}

private async Task LoadAsync()
{
    var customer = await AppCore.BizObject.GetCustomerByIdAsync(id);
    ...
}

public async Task<CompanyEntity> GetCompanyByIdAsync(int companyId)
{
    using (var dc = GetDataContext())
    {
        var query = (from c in dc.Companies
                     where c.Id == companyId
                     select new CompanyEntity
                     {
                         Id = c.Id,
                         CompanyName = c.CompanyName
                     });

        using (var command = (SqlCommand)dc.GetCommand(query))
        using (var reader = await command.ExecuteReaderAsync())
        {
            return dc.Translate<CompanyEntity>(reader).FirstOrDefault();
        }
    }
}

Richard Deeming wrote:

It's perfectly valid to have an async method on the client calling a synchronous method on the server.

public Task<int> Foo()
{
    return Task.FromResult(42);
}

public class foo
    {
    public int val { get; set; }
    }

List<foo> foos = new List<foo>();
for (int i = 0; i < 10; i++)
    {
    foos.Add(new foo() { val = i });
    }
foos.ForEach(f => f.val += 10);
foreach (foo foo in foos)
    {
    Console.WriteLine(foo.val);
    }

IWorkbook workbook = spreadsheetControl.Document;
           Worksheet worksheet = workbook.Worksheets["Sheet1"];
           CellRange range = worksheet.GetUsedRange();
           int LastRow = range.BottomRowIndex;

           List<int> emptyRows = new List<int>();
           for (int i = 0; i < LastRow+1; i++)
           {
               if (worksheet.Cells[i, 0].Value.IsEmpty == true)
               {
                   emptyRows.Add(i);
               }
           }

           Search:
           if (emptyRows.Count >= 1)
           {
               foreach (var item in emptyRows)
               {
                   worksheet.Rows[item].Delete();
                   emptyRows.RemoveAt(item);
                   goto Update;
               }
           }

           Update:
           if (emptyRows.Count >= 1)
           {
               for (int i = 0; i < emptyRows.Count; i++)
               {
                   emptyRows[i] = emptyRows[i]-1;
                   //MessageBox.Show(Convert.ToString(emptyRows[i]));
               }
               goto Search;
           }

foreach (var item in emptyRows.Reverse<int>())
            {
                worksheet.Rows[item].Delete();
            }

for (int index = emptyRows.Count - 1; index >= 0; index--)
{
    int item = emptyRows[index];
    worksheet.Rows[item].Delete();
}

group new 
{ 
    a.ViolationSubtypeId, 
    e.ViolationTypeName, 
    a?.ViolationTypeId, 
    ViolationTypeName2 = b?.ViolationTypeName, 
    b?.ParentViolationId, 
    d?.BranchId, 
    d?.Name, 
    a.PenaltyAssessed, 
    a.ViolationId, 
    a.ViolationNumber 
}