What is the proper way to call an async method containing a loop without blocking the UI?

I have the below code when run blocks the UI from updating.

The ProcessDocumentRange method’s job is to loop through a range and call the BuildDocumentList method to add a document reference to List<Document> for each iteration of the loop.

 public List<Document> _queuedDocuments = new List<Document>();
public string _instID = "";        
static String _dest = "c:\\test";
static Int32 _startId = 50001;
static Int32 _endId = 65001;

private async void _btnStartClick(object sender, EventArgs e)
{
await ProcessRecords();
}

private async Task ProcessRecords()
{
// Call to Method which freezes UI
await ProcessDocumentRange(_startId, _dest);
}

public async Task ProcessDocumentRange(int _startID, string _root)
{
int year = 28;
for (int i = _startID; i < _endId; i++) //Start of loop that freezes UI
{
_instID = year.ToString() + i.ToString().PadLeft(5, '0');
await BuildDocumentList(year, i, _instID, _root);
}
}

private async Task BuildDocumentList(int year, int image, string instID, string root)
{
string documentIndexFile = root + year.ToString() + "\\" + instID + ".txt";
if (!File.Exists(documentIndexFile))
_queuedDocuments.Add(new Document { Year = year, Image = image });
}

I have tried calling the Method like the following and the UI doesn't freeze, but the loop exits and never builds the list: await Task.Run(() => ProcessDocumentRange(_startId, _dest));

Any help would b greatly appreciated.

Update to code that now throws Exception: "The calling thread must be STA, because many UI components require this."

    public partial class MainWindow : Window
    {
        public List<Document> _queuedDocuments = new List<Document>();

        public MainWindow()
        {
            InitializeComponent();
            _tbURL.Text = _url;
            _tbDest.Text = _dest;
            _tbStartId.Text = _startId.ToString();
            _tbEndID.Text = _endId.ToString();
        }

        private async void _btnStartClick(object sender, EventArgs e)
        {
            await ProcessDocumentRange(_startId, _dest);
        }

        public async Task ProcessDocumentRange(int _startID, string _root)
        {
            //Exception thrown at await Task.Run below.
            //Exception may have something to do with adding an item to the list
            await Task.Run(() =>
            {
                int year = 28;
                for (int i = _startID; i < _endId; i++)
                {
                    _instID = year.ToString() + i.ToString().PadLeft(5, '0');
                    BuildDocumentList(year, i, _instID, _root);

                }
            });
        }

        private void BuildDocumentList(int year, int image, string instID, string root)
        {
            string documentIndexFile = root + year.ToString() + "\\" + instID + ".txt";

            if (!File.Exists(documentIndexFile))
                _queuedDocuments.Add(new Document { Year = year, Image = image });
        }

//Document Class
    public class Document : MainWindow
    {        
        private int _year = -1;
        public int Year
        {
            get
            {
                return _year;
            }
            set
            {
                _year = value;
            }
        }


        private int _image = -1;
        public int Image
        {
            get
            {
                return _image;
            }
            set
            {
                _image = value;
            }
        }
   }

Your methods are executing synchronously because non of them returns an actual Task. But most important, you failed to reach your goal because you did not off-load the CPU intensive work to relief the UI thread. It's the loop that still exhausts the UI thread and therefore freezes the UI.
To move it to a different thread, a background thread, you must call Task.Run:

private async void _btnStartClick(object sender, EventArgs e)
{
  // Call to Method which no longer freezes the UI.
  // Use await to wait asynchronously for the method to return
  await ProcessDocumentRangeAsync(_startId, _dest);

  // TODO::Do something with the populated list
}

public async Task ProcessDocumentRangeAsync(int startID, string root)
{
  // Execute loop on a background thread
  await Task.Run(() =>
  {
    int year = 28;
    for (int i = startID; i < _endId; i++)
    {
      _instID = year.ToString() + i.ToString().PadLeft(5, '0');
      BuildDocumentList(year, i, _instID, root);
    }
  });
}

private BuildDocumentList(int year, int image, string instID, string root)
{
  string documentIndexFile = root + year.ToString() + "\\" + instID + ".txt";
  if (File.Exists(documentIndexFile))
  {
    return;
  }

  // Because Document extends MainWindow, 
  // we must create the instance on the original Dispatcher thread (UI thread).
  // This is required because MainWindow inherits the DispatcherObject from Window.  
  // DispatcherObject instances have thread affinity (Dispatcher affinity).
  // Creating them on or accessing them from a thread that is not the associated Dispatcher thread
  // will throw a cross-thread exception (InvalidOperationException).
  // To solve this, we must execute the instantiation on the Dispatcher thread using the Dispatcher.
  // We use DispatcherPriority.Background to prevent the loop from exhausting the UI thread.
  // We could improve the performance if we could get rid of the Dispatcher.Invoke,
  // for example by avoiding making Document a Window. 
  // Instead it should be a simple data model (and not a control).
  this.Dispatcher.InvokeAsync(
    () => CreateDocument(year, image), 
    DispatcherPriority.Background);
}

private void CreateDocument(int year, int image)
{
  var newDocument = new Document { Year = year, Image = image };
  _queuedDocuments.Add(newDocument);
}

If you don't have anything to do after the list is populated, you don't have to use await. Simply create the background thread and return to the UI thread and continue:

private async void _btnStartClick(object sender, EventArgs e)
{
  // Call to Method which no longer freezes the UI.
  // Because of we don't await anything here 
  // the method is a pure concurrent method and we can 
  // immediately continue to do work on the current thread.
  ProcessDocumentRange(_startId, _dest);

  // TODO::The list is not populated at this point. 
  // The operation is still executing in parallel-
}

public void ProcessDocumentRange(int startID, string root)
{
  // Execute loop concurrently on a background thread 
  // and return immediately to the caller (click handler) 
  Task.Run(() =>
  {
    int year = 28;
    for (int i = startID; i < _endId; i++)
    {
      _instID = year.ToString() + i.ToString().PadLeft(5, '0');
      BuildDocumentList(year, i, _instID, root);
    }
  });
}

private BuildDocumentList(int year, int image, string instID, string root)
{
  string documentIndexFile = root + year.ToString() + "\\" + instID + ".txt";
  if (File.Exists(documentIndexFile))
  {
    return;
  }

  // Because Document extends MainWindow, 
  // we must create the instance on the original Dispatcher thread (UI thread).
  // This is required because MainWindow inherits the DispatcherObject from Window.  
  // DispatcherObject instances have thread affinity (Dispatcher affinity).
  // Creating them on or accessing them from a thread that is not the associated Dispatcher thread
  // will throw a cross-thread exception (InvalidOperationException).
  // To solve this, we must execute the instantiation on the Dispatcher thread using the Dispatcher.
  // We use DispatcherPriority.Background to prevent the loop from exhausting the UI thread.
  // We could improve the performance if we could get rid of the Dispatcher.Invoke,
  // for example by avoiding making Document a Window. 
  // Instead it should be a simple data model (and not a control).
  this.Dispatcher.InvokeAsync(
    () => CreateDocument(year, image), 
    DispatcherPriority.Background);
}

private void CreateDocument(int year, int image)
{
  var newDocument = new Document { Year = year, Image = image };
  _queuedDocuments.Add(newDocument);
}