C#

using System;
using System.Runtime.InteropServices;
using System.Text;

internal static class NativeMethods
{
    /*
BOOL WINAPI SetWindowText(
  __in      HWND hWnd,
  __in_opt  LPCTSTR lpString
); */
    public static bool SetWindowText(IntPtr hWnd)
    {
        return SetWindowText(hWnd, null);
    }
    [DllImport("User32.dll", SetLastError = true)]
    public static extern bool SetWindowText(IntPtr hWnd, string lpString);

    /*
int WINAPI GetWindowText(
  __in   HWND hWnd,
  __out  LPTSTR lpString,
  __in   int nMaxCount
); */
    public static string GetWindowText(IntPtr hWnd)
    {
        int count = GetWindowTextLength(hWnd) + 1;
        StringBuilder resultBuilder = new StringBuilder(count);
        GetWindowText(hWnd, resultBuilder, count);
        return resultBuilder.ToString();
    }
    [DllImport("User32.dll", SetLastError = true)]
    public static extern int GetWindowText(IntPtr hWnd, StringBuilder lpString, int nMaxCount);

    /*
int WINAPI GetWindowTextLength(
  __in  HWND hWnd
); */
    [DllImport("User32.dll", SetLastError = true)]
    public static extern int GetWindowTextLength(IntPtr hWnd);

    /*
BOOL WINAPI EnumWindows(
  __in  WNDENUMPROC lpEnumFunc,
  __in  LPARAM lParam
); */
    [DllImport("User32.dll", SetLastError = true)]
    public static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, IntPtr lParam);

    /* 
BOOL CALLBACK EnumWindowsProc(
  __in  HWND hwnd,
  __in  LPARAM lParam
); */
    public delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);

    /*
BOOL WINAPI IsWindowVisible(
  __in  HWND hWnd
); */
    [DllImport("User32.dll", SetLastError = true)]
    public static extern bool IsWindowVisible(IntPtr hWnd);
}

// List to hold hWnds
private List<IntPtr> windowHandles = new List<IntPtr>();

private bool EnumWindowsProcHandler(IntPtr hWnd, IntPtr lParam)
{
    windowHandles.Add(hWnd);
    return true;
}

NativeMethods.EnumWindowsProc enumWindowsProc = 
    new NativeMethods.EnumWindowsProc(EnumWindowsProcHandler);

// Get windows
NativeMethods.EnumWindows(enumWindowsProc, IntPtr.Zero);

foreach (IntPtr hWnd in windowHandles)
{
    if (NativeMethods.IsWindowVisible(hWnd))
    {
        string caption = NativeMethods.GetWindowText(hWnd);
        if (!string.IsNullOrEmpty(caption))
        {
            Console.WriteLine(caption); // Log found & visible windows
            if (caption.EndsWith("Microsoft Visual Studio")) // Visual Studio
            {
                NativeMethods.SetWindowText(hWnd, "Changed VS Caption");
            }
        }
    }
}

If the operation raises an exception that your code does not handle, the BackgroundWorker catches the exception and passes it into the RunWorkerCompleted event handler, where it is exposed as the Error property of System.ComponentModel.RunWorkerCompletedEventArgs. If you are running under the Visual Studio debugger, the debugger will break at the point in the DoWork event handler where the unhandled exception was raised. If you have more than one BackgroundWorker, you should not reference any of them directly, as this would couple your DoWork event handler to a specific instance of BackgroundWorker. Instead, you should access your BackgroundWorker by casting the sender parameter in your DoWork event handler

x = Util.ProgressDialog.Show(owner, MyWorkerMethod, "Doing something") as MyResultObject;

private void MyWorkerMethod(BackgroundWorker wkr, DoWorkEventArgs e)
{
  // ...
  e.Result = ...
}

private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
        {
            ChangeMyText("Privet");
        }

        private void ChangeMyText(string myText)
        {
            label1.Text = myText;
        }

label1.Text = myText;

label1.Invoke((Action)delegate
      {
          label1.Text = myText;
      });

NameNotYetTaken wrote:

That's a lot of database queries