C#

public class Processor
{
    public async Task Process()
    {
        await DoSomething();
    }

    private async Task DoSomething()
    {
        var customers = await GetSomeData();

        // Do some work on the customer data

        await SaveResults(customers);
    }

    private async Task> GetSomeData()
    {
        List customers = null;

        await Task.Run(() =>
        {
            customers = Repository.GetCustomers();
        });
    }

    private async Task SaveResults(List customers)
    {
        await Task.Run(() =>
        {
            Repository.SaveCustomers(customers);
        });
    }
}

public class MainWindowViewModel : _ViewModelBase
{
    private ICommand _ProcessCommand;
    public ICommand ProcessCommand
    {
        get
        {
            if (_ProcessCommand == null)
                _ProcessCommand = new RelayCommand(p => ProcessExecuted(), p => ProcessCanExecute());
            return _ProcessCommand;
        }
    }

    private bool ProcessCanExecute()
    {
        return true;
    }

    private void ProcessExecuted()
    {
        Processor p = new Processor();
        p.Process();
    }
}

p.Proccess

Because this call is not awaited, execution of the current method continues before the call is completed. Consider applying the 'await' operator to the result of the call.

private async Task LoadLists()
{
    var statuses = new List<Status>();
    var states = new List<State>();
    var employees = new List<Employee>();

    var loadDataTasks = new Task[]
    {
        Task.Run(async () => statuses = await LoadStatuses()),
        Task.Run(async () => states = await LoadStates()),
        Task.Run(async () => employees = await LoadEmployees())
    };

    try
    {
        await Task.WhenAll(loadDataTasks);
    }
    catch (Exception ex)
    {
        // handle exception
    }
    finally
    {
        // Populate ViewModel properties
        Statuses = new List(statuses);
        States = new List(states);
        Employees = new List(employees);
    }
}

private async Task> LoadStatuses()
{
    return Repository.GetStatuses();
}

private async Task> LoadStates()
{
    return Repository.GetStates();
}

private async Task> LoadEmployees()
{
    return Repository.GetEmployees();
}

X509Certificate cert = X509Certificate.CreateFromSignedFile("BNDLTOOL.RSA");

MemoryStream ms = new MemoryStream();
BinaryWriter bw = new BinaryWriter(ms);
bw.Write(1);

byte[] data = cert.GetRawCertData();
bw.Write(data);
bw.Write(data.Length);

byte[] buffer = ms.ToArray();

Debug.WriteLine(Convert.ToBase64String(buffer));

PKCS7 pkcs7 = new PKCS7(StreamUtil.readBytes(zipFile.getInputStream(ze)));
Certificate[] certs = pkcs7.getCertificates();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
DataOutputStream dos = new DataOutputStream(baos);
dos.write(certs.length);
for (int i = 0; i < certs.length; i++) {
    byte[] data = certs[i].getEncoded();
    System.out.printf("  --SignatureHash[%d]: %08x\n", i, Arrays.hashCode(data));
    dos.writeInt(data.length);
    dos.write(data);
}
byte[] signatures = baos.toByteArray();
System.out.println(Base64.getEncoder().encodeToString(signatures));

Hello everyone, I have a problem.
I have a project on Winform and it works great, now the customer wants to run this project as a Windows service.
The peculiarity of the project, I use a library (presumably written in C ++) that Winform uses, before calling the library I can translate the service into Windows, and I cannot translate the part where the library works. Is there a way to start a service with Winform support? I am considering all the options right up to the use of paid softs.
The system will be in Sign Out mode most of the time.