C#

<SfDropDownList  DataSource  = "@lines" TValue="string" TItem="FeederTableQuery" Placeholder="Select a feeder" @bind-Value = "@FeederDropValue" @bind-Index="@ddlIndex">
	<DropDownListFieldSettings Text="FeederId" Value="FeederId"></DropDownListFieldSettings>
</SfDropDownList>

<DashboardLayoutPanel Column="2" Row="1" SizeX="2" SizeY="2">
	<HeaderTemplate>
		<div class="e-header-text">Feeder Details</div>
		<div class="header-border"></div>
	</HeaderTemplate>
	<ContentTemplate>
		<div class="panel-content">
			<p>Selected value was @FeederDropValue</p>
			<p>Selected index was @ddlIndex</p>
			@lines.ElementAt(ddlIndex).ToString(); 
		</div>
	</ContentTemplate>
</DashboardLayoutPanel>

@code
{
	private int? ddlIndex { get; set; } = 0;
	public string FeederDropValue;
	private IEnumerable <FeederTableQuery> lines { get; set; }
}

cannot convert from 'int?' to 'System.Index

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();
}