C# Signature:

[DllImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, IntPtr lParam);

VB.NET Signature:

<DllImport("user32.dll", SetLastError:=True, CharSet:=CharSet.Auto)> _
Private Shared Function EnumWindows(
ByVal lpEnumFunc As EnumWindowsProc, _
ByVal lParam As IntPtr) As Boolean
End Function

User-Defined Types:

EnumWindowsProc

Notes:

Callback EnumWindowsProc should return true to continue enumerating or false to stop.

Tips & Tricks:

The corresponding unmanaged return type is a 4-byte Win32 'BOOL', so mark the method with the MarshalAsAttribute(UnmanagedType.Bool).

Great sample using managed code and a delegate type for the call back from MSDN:

http://msdn2.microsoft.com/en-us/library/d186xcf0(VS.71).aspx

SAMPLE CODE!!

using System.Runtime.InteropServices;

public delegate bool CallBackPtr(int hwnd, int lParam);
private CallBackPtr callBackPtr;

public class EnumReport
{
    [DllImport("user32.dll")]
    private static extern int EnumWindows(CallBackPtr callPtr, int lPar);

    public static bool Report(int hwnd, int lParam)
    {
        Console.WriteLine("Window handle is "+hwnd);
        return true;
    }
}
static void Main()
{

     // note in other situations, it is important to keep
     // callBackPtr as a member variable so it doesnt GC while you're calling EnumWindows

     callBackPtr = new CallBackPtr(EnumReport.Report);  
    EnumReport.EnumWindows(callBackPtr, 0);
}

Sample Code 2 (C#):

      public delegate bool EnumedWindow(IntPtr handleWindow, ArrayList handles);

      [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
      [return: MarshalAs(UnmanagedType.Bool)]
      public static extern bool EnumWindows(EnumedWindow lpEnumFunc, ArrayList lParam);

      public static ArrayList GetWindows()
      {    
     ArrayList windowHandles = new ArrayList();
     EnumedWindow callBackPtr = GetWindowHandle;
     EnumWindows(callBackPtr, windowHandles);

        return windowHandles;    
      }

      private static bool GetWindowHandle(IntPtr windowHandle, ArrayList windowHandles)
      {
     windowHandles.Add(windowHandle);
     return true;
      }

Sample code demonstrating the passing of an object to the enum proc

Oftentimes you'll want to have the EnumProc retrieve some data from a particular window and return it.

You can do this by:

• Defining a class to hold your custom data, and
• Using a ref to that class in the EnumWindows() signature.

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

public class WndSearcher
{
    public static IntPtr SearchForWindow(string wndclass, string title)
    {
        SearchData sd = new SearchData { Wndclass=wndclass, Title=title };
        EnumWindows(new EnumWindowsProc(EnumProc), ref sd);
        return sd.hWnd;
    }

    public static bool EnumProc(IntPtr hWnd, ref SearchData data)
    {
        // Check classname and title
        // This is different from FindWindow() in that the code below allows partial matches
        StringBuilder sb = new StringBuilder(1024);
        GetClassName(hWnd, sb, sb.Capacity);
        if (sb.ToString().StartsWith(data.Wndclass))
        {
            sb = new StringBuilder(1024);
            GetWindowText(hWnd, sb, sb.Capacity);
            if (sb.ToString().StartsWith(data.Title))
            {
                data.hWnd = hWnd;
                return false;    // Found the wnd, halt enumeration
            }
        }
        return true;
    }

    public class SearchData
    {
        // You can put any dicks or Doms in here...
        public string Wndclass;
        public string Title;
        public IntPtr hWnd;
    }

    private delegate bool EnumWindowsProc(IntPtr hWnd, ref SearchData data);

    [DllImport("user32.dll")]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, ref SearchData data);

    [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Auto)]
    public static extern int GetClassName(IntPtr hWnd, StringBuilder lpClassName, int nMaxCount);

    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    public static extern int GetWindowText(IntPtr hWnd, StringBuilder lpString, int nMaxCount);
}

Then you'd call:

// If you're viewing this page with IE, this *should* return the hwnd of the browser
IntPtr hWnd = WndSearcher.SearchForWindow("IEFrame", "pinvoke.net: EnumWindows");

Alternative Managed API:

The ManagedWindowsApi project (http://mwinapi.sourceforge.net) provides a static

method ManagedWinapi.Windows.SystemWindow.FilterToplevelWindows().

Note:

There are syntax errors in the above code!

callBackPtr declared outside class EnumReport which is illegal !

Main() declared outside class EnumReport which is illegal !

After correction create an object of EnumReport class and call the functions using the object!

Contact me at -- shrijit1991[at-the-rate-symbol]gmail.com

If you feel that what I have written is wrong, feel free to remove it and drop a mail to me stating reasons for the same

so that I can learn from my mistakes. - Thanks (Shrijit).

The correct signature for EnumWindows in the example:

     [DllImport("user32.Dll")]
     [return: MarshalAs(UnmanagedType.Bool)]
     public static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, [MarshalAsAttribute(UnmanagedType.Struct)] ref SearchData data);

(mirelvv)

I never could get the compiler to accept this format. When called I'd get an error on the "ref SearchData" part. I worked around this by reverting the signature back to "int lParam", then using a member variable to hold the SearchData info. It's not pretty, but accomplishes the same thing.

(acg)