C#

arnold_w wrote:

How many pool threads does a PC have?

arnold_w wrote:

Can I somehow dictate what pool thread the different Com ports should issue events onto?

Ralf Meier wrote:

Why do you want to use Threading or a Backgroundworker for this approach ?

Ralf Meier wrote:

For example a ListView

Ralf Meier wrote:

But you should realize that each and every list has an End

Ralf Meier wrote:

If you want to write to an Excel-Sheet it isn't necessary to know something about VBA - this work could be done complete inside your Application.

Ralf Meier wrote:

What problem do you have with a DataGridView ?

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.