In my opinion you should forget about DoEvents and prefer background worker
threads for non UI related processing.
DoEvents is a hack invented for languages that don't support multithreading,
running such applications will not take advantage of multicore CPU's at
all.....

Now your question about "flooding the UI", all depends on how frequently you
need/want to update the UI. I suppose you want to keep the impact of the
file processing time by this UI update as small as possible, and you don't
need to update the UI so frequently that the user can't visually see the
difference between successive updates.
Consider following small sample:
The DoWork function runs on a background thread and reads a file
(mscorlib.xml - 4790 KB) in chunks of 256 bytes, asynchronously updating the
UI every 4096 bytes read. On a entry level box, this will take less than a
couple of seconds when the file is not in the cache, and less than a second
if the file is cached.
During that time the UI will be updated 1196 times which is
1. way to fast for a good user experience.
2. UI thread and thread switching takes to much processing power
So what you have to do is find an acceptable interval to update the UI,
without
Note that I'm not exactly processing the file data, so I need to give up my
thread quantum each time I want to update the UI, in a real world scenario
this may not be necessary as the scheduler will preempt to worker thread at
regular intervals to let the UI thread process it's message queue.
Compile and run the program, and play a bit with the frequency of updates to
see exactly what I mean.

Willy.

#using <system.windows.forms.dll>
#using <system.dll>
#using <system.drawing.dll>
using namespace System;
using namespace System::IO;
using namespace System::Text;
using namespace System::Windows::Forms;
using namespace System::Drawing;
using namespace System::Threading;
namespace Win
{
  __delegate void StringParameterDelegate(String * s);

public  __gc class Form1 : public Form
   {
 // Methods
 public:
 Form1()
  { InitializeComponent();}
 protected:
  virtual  void Dispose(Boolean disposing)
  {
   __super::Dispose(disposing);
  }
  private: Button*  button1;
   Label  * cntText;
   System::ComponentModel::Container __gc * components;
  void InitializeComponent(void)
  {
     this->button1 = (new Button());
     this->cntText = new Label();
     this->SuspendLayout();
     this->button1->Location = System::Drawing::Point(65, 25);
     this->button1->Size = System::Drawing::Size(60, 25);
     this->button1->TabIndex = 0;
     this->button1->Text = L"button1";
     this->button1->Click += new System::EventHandler(this,
&Form1::button1_Click);
     this->cntText->Location = System::Drawing::Point(5, 5);
     this->cntText->Size = System::Drawing::Size(185, 15);
     this->AutoScaleDimensions = System::Drawing::SizeF(6, 13);
     this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font;
     this->ClientSize = System::Drawing::Size(200, 62);
     this->Controls->Add(this->button1);
     this->Controls->Add(this->cntText);
     this->Text = L"MThreaded Form";
     this->ResumeLayout(false);
 }
 private: void button1_Click(System::Object*  sender, System::EventArgs*
e)
 {
  ThreadStart* myThreadDelegate = new ThreadStart(this,
&Win::Form1::DoWork);
  Thread* t = new Thread(myThreadDelegate);
  t->IsBackground = true;
  t->Start();
 }
 void DoWork()
 {
  FileStream* fs =
File::OpenRead("C:\\WINDOWS\\Microsoft.NET\\Framework\\v1.1.4322\\mscorlib.xml");
  String* status;
  int bytesRead = 0;
  int offset = 0;
  int count = 0;
  try {
   Byte b[] = new Byte[256];
   UTF8Encoding* temp = new UTF8Encoding(true);
   while ((bytesRead = fs->Read(b, 0, b->Length)) > 0) {
    offset += bytesRead;
    if(offset % 4096 == 0)
      {
     status = String::Format(S"UI Thread accessed {0} times.",
__box(count++));
     UpdateUIStatus(status);
     Threading::Thread::Sleep(0); // Give other threads a chance to run by
giving up our thread quantum
      }
   }
  }
  __finally
  {
   if (fs) __try_cast<IDisposable*>(fs)->Dispose();
  }
       }
   void UpdateUIStatus(String *value)
   {
   // Are we running on the UI thread?
    if (InvokeRequired)
    {
     StringParameterDelegate *spd = new StringParameterDelegate(this,
&Win::Form1::UpdateUIStatus);
     String *obj __gc[] = { value};
     // We're not in the UI thread, so we need to call BeginInvoke
     BeginInvoke(spd, obj);
     return;
    }
    // Must be on the UI thread if we've got this far
    // Here we can safely touch the UI, or do anything the UI can do
    cntText->ForeColor = Color::Red;
    cntText->Text = value;
 }
    };
}
using namespace Win;
[STAThreadAttribute]
int main()
{
Application::Run(new Form1());
return 0;
}