.NET (Core and Framework)

public override void EndInit()  
{  
    base.EndInit();  
    customersRowChanging += customersRowChangeEvent;  
}  

public void customersRowChangeEvent(object sender, customersRowChangeEvent e)  
{  
    if (e.Row.Name.Length == 0)  
    {  
        e.Row.SetColumnError("name", "Customer name cannot be empty");  
    }  
    else  
    {  
        e.Row.SetColumnError("name", "");  
    }  
}  

try
     {
         Validate();
         customersBindingSource.EndEdit();
         customersTableAdapter.Update(samDataSet.customers);
         // other stuff here, close the form, etc.
     }
     catch(Exception ex)
     {
         // ... show a message box with the error.

     }

public void customersRowChangeEvent(object sender, customersRowChangeEvent e)  
{  
    if (e.Row.Name.Length == 0)  
    {  
        e.Row.SetColumnError("name", "Customer name cannot be empty"); 
        throw new System.Exception("Customer Name cannot be empty"); 
    }  
    else  
    {  
        e.Row.SetColumnError("name", "");  
    }  
}  

Public Function ShootPicture() As StorageFile
    Dim captureUI As New CameraCaptureUI
    captureUI.PhotoSettings.Format = CameraCaptureUIPhotoFormat.Jpeg
    captureUI.PhotoSettings.AllowCropping = False
    Dim GetPhotoTask As Task(Of StorageFile) = captureUI.CaptureFileAsync(CameraCaptureUIMode.Photo)
    GetPhotoTask.Wait() ' Blocks current thread until CaptureFileAsync task completes'
    Dim result As StorageFile = GetPhotoTask.Result
    Return result
End Function

Dim GetPhotoTask As Task(Of StorageFile) = captureUI.CaptureFileAsync(CameraCaptureUIMode.Photo)
      Dim Photo As StorageFile = Await GetPhotoTask

public StorageFile ShootPicture()
{
    CameraCaptureUI captureUI = new CameraCaptureUI();
    captureUI.PhotoSettings.Format = CameraCaptureUIPhotoFormat.Jpeg;
    captureUI.PhotoSettings.AllowCropping = false;
    Task<StorageFile> GetPhotoTask = captureUI.CaptureFileAsync(CameraCaptureUIMode.Photo);
    GetPhotoTask.Wait();
    // Blocks current thread until CaptureFileAsync task completes
    StorageFile result = GetPhotoTask.Result;
    return result;
}

<Window x:Class="InputTaskQueue.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:behav="clr-namespace:InputTaskQueue.Behaviors"
        mc:Ignorable="d"
        Title="MainWindow" Height="350" Width="525">
    <StackPanel Orientation="Vertical">
        <TextBox Name="tbInput"
                 behav:TextChangedCommand.ChangedCommand="{Binding SearchCommand}"
                 HorizontalAlignment="Left" VerticalAlignment="Bottom"
                 Width="100" Height="20"/>

        <TextBlock Text="{Binding SearchStringResult,UpdateSourceTrigger=PropertyChanged,Mode=OneWay}" Width="100" Height="100" />
    </StackPanel>
</Window>

using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;

public static class TextChangedCommand
{
    // Field of attached ICommand property
    private static readonly DependencyProperty ChangedCommandProperty = DependencyProperty.RegisterAttached(
        "ChangedCommand",
        typeof(ICommand),
        typeof(TextChangedCommand),
        new PropertyMetadata(null, OnTextChangedCommandChange));

    public static void SetChangedCommand(DependencyObject source, ICommand value)
    {
        source.SetValue(ChangedCommandProperty, value);
    }

    public static ICommand GetChangedCommand(DependencyObject source)
    {
        return (ICommand)source.GetValue(ChangedCommandProperty);
    }

    private static void OnTextChangedCommandChange(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        TextBox uiElement = d as TextBox;   // Remove the handler if it exist to avoid memory leaks

        if (uiElement != null)
        {
            uiElement.TextChanged -= OnText_Changed;

            var command = e.NewValue as ICommand;
            if (command != null)
            {
                // the property is attached so we attach the Drop event handler
                uiElement.TextChanged += OnText_Changed;
            }
        }
    }

    private static void OnText_Changed(object sender, TextChangedEventArgs e)
    {
        TextBox uiElement = sender as TextBox;

        // Sanity check just in case this was somehow send by something else
        if (uiElement == null)
            return;

        // Bugfix: A change during disabled state is likely to be caused by a bound property
        //         in a viewmodel (a machine based edit rather than user input)
        //         -> Lets break the message loop here to avoid unnecessary CPU processings...
        if (uiElement.IsEnabled == false)
            return;

        ICommand changedCommand = TextChangedCommand.GetChangedCommand(uiElement);

        // There may not be a command bound to this after all
        if (changedCommand == null)
            return;

        var item = uiElement.Text;

        // Check whether this attached behaviour is bound to a RoutedCommand
        if (changedCommand is RoutedCommand)
        {
            // Execute the routed command
            (changedCommand as RoutedCommand).Execute(item, uiElement);
        }
        else
        {
            // Execute the Command as bound delegate
            changedCommand.Execute(item);
        }
    }
}

private string _SearchStrinResult;

/// <summary>
/// Gets a search string to match in the tree view.
/// </summary>
public string SearchStringResult
{
    get { return _SearchStrinResult; }
    private set
    {
        if (_SearchStrinResult != value)
        {
            _SearchStrinResult = value;
            NotifyPropertyChanged(() => SearchStringResult);
        }
    }
}
#endregion properties

#region methods
/// <summary>
/// Gets a command that filters the display of nodes in a treeview
/// with a filterstring (node is shown if filterstring is contained).
/// </summary>
public ICommand SearchCommand
{
    get
    {
        if (_SearchCommand == null)
        {
            _SearchCommand = new RelayCommand<object>((p) =>
            {
                string findThis = p as string;

                if (string.IsNullOrEmpty(findThis) == true)
                    return;

                SearchCommand_ExecutedAsync(findThis);
            },
            (p =>
            {
                return true;
            })
            );
        }

        return _SearchCommand;
    }
}

private List<string> _Queue = new List<string>();
private static SemaphoreSlim SlowStuffSemaphore = new SemaphoreSlim(1, 1);

private async void SearchCommand_ExecutedAsync(string input)
{
    _Queue.Add(input);

    // Issue 1: Not sure how to lock this with the correct semaphore信号
    //to make sure the task always processes the last input but is not started twice
    await SlowStuffSemaphore.WaitAsync();
    try
    {
        // There is more recent input to process so we ignore this one
        if (_Queue.Count > 1)
        {
            _Queue.Remove(input);
            return;
        }
        else
        {
            Console.WriteLine("Queue Count: {0}", _Queue.Count);
        }

        await createTask(input);

        _Queue.Remove(input);

        this.SearchStringResult = input;
    }
    catch (Exception exp)
    {
        Console.WriteLine(exp.Message);
    }
    finally
    {
        SlowStuffSemaphore.Release();
    }
}

private Task createTask(string input)
{
    return Task.Run(() =>
    {
        Console.WriteLine("searching:" + input);
        System.Threading.Thread.Sleep(5000);

    }) // simulate processing
    .ContinueWith((p) =>
    {
    });
}