.NET (Core and Framework)

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) =>
    {
    });
}

An unhandled exception of type 'System.AccessViolationException' occurred in System.Data.dll

Additional information: Attempted to read or write protected memory. This is often an indication that other memory is corrupt. 

        public static string ConvertXlsAndXlstToPipeDelimitedFile(string strSourceFilePath, bool isFirstRowColumnHeader, string sheetName)
        {
            string strConn = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" +
                strSourceFilePath + ";Extended Properties=\"Excel 8.0;HDR=Yes;IMEX=1\"";

            OleDbConnection conn = null;
            StreamWriter wrtr = null;
            OleDbCommand cmd = null;
            OleDbDataAdapter da = null;

            string destinationFilePath = string.Empty;

            conn = new OleDbConnection(strConn);           

            try
            {
                if (conn.State != ConnectionState.Open)
                {
                    conn.Open();
                }

                cmd = new OleDbCommand("SELECT * FROM [" + sheetName + "$]", conn); //"Sheet1"
                cmd.CommandType = CommandType.Text;

                da = new OleDbDataAdapter(cmd);
                DataTable dt = new DataTable();
                da.Fill(dt);

                string strDirectory = (System.IO.Path.GetDirectoryName(strSourceFilePath));

                if (!System.IO.Directory.Exists(strDirectory))
                {
                    System.IO.Directory.CreateDirectory(strDirectory);
                }

                Path.GetFileNameWithoutExtension(strSourceFilePath);

                destinationFilePath = (strDirectory + (@"\" + (Path.GetFileNameWithoutExtension(strSourceFilePath) + ".csv")));

                wrtr = new StreamWriter(destinationFilePath);

                int ColCount = 0; string rowString = "";
                for (int y = 0; y < dt.Columns.Count; y++)
                {
                    rowString += dt.Columns[y].ColumnName + "|";

                }
                wrtr.WriteLine(rowString);

                for (int x = 0; x < dt.Rows.Count; x++)
                {
                    rowString = "";
                    for (int y = 0; y < dt.Columns.Count; y++)
                    {
                        rowString += "\"" + dt.Rows[x][y].ToString() + "\"|";
                    }
                    wrtr.WriteLine(rowString);
                }

                if (File.Exists(destinationFilePath))
                    return destinationFilePath;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (conn != null)
                {
                    if (conn.State != ConnectionState.Closed)
                    {
                        conn.Close();
                    }
                    conn.Dispose();
                }

                if (cmd != null)
                {
                    cmd.Dispose();
                }
                if (da != null)
                {
                    da.Dispose();
                }

                if (wrtr != null)
                {
                    wrtr.Close();
                    wrtr.Dispose();
                }
            }
            //MessageBox.Show("Done");
            return string.Empty;
        }