C# Signature:

/// <summary>
///     Enumerates all top-level windows on the screen by passing the handle to each window, in turn, to an
///     application-defined callback function. <see cref="EnumWindows" /> continues until the last top-level window is
///     enumerated or the callback function returns FALSE.
///     <para>
///     Go to https://msdn.microsoft.com/en-us/library/windows/desktop/ms633497%28v=vs.85%29.aspx for more
///     information
///     </para>
/// </summary>
/// <param name="lpEnumFunc">
///     C++ ( lpEnumFunc [in]. Type: WNDENUMPROC )<br />A pointer to an application-defined callback
///     function. For more information, see
///     <see cref="!:https://msdn.microsoft.com/en-us/library/windows/desktop/ms633498%28v=vs.85%29.aspx">EnumWindowsProc</see>
///     .
/// </param>
/// <param name="lParam">
///     C++ ( lParam [in]. Type: LPARAM )<br />An application-defined value to be passed to the callback
///     function.
/// </param>
/// <returns>
///     <c>true</c> if the return value is nonzero., <c>false</c> otherwise. If the function fails, the return value
///     is zero.<br />To get extended error information, call GetLastError.<br />If <see cref="EnumWindowsProc" /> returns
///     zero, the return value is also zero. In this case, the callback function should call SetLastError to obtain a
///     meaningful error code to be returned to the caller of <see cref="EnumWindows" />.
/// </returns>
/// <remarks>
///     The <see cref="EnumWindows" /> function does not enumerate child windows, with the exception of a few
///     top-level windows owned by the system that have the WS_CHILD style.
///     <para />
///     This function is more reliable than calling the
///     <see cref="!:https://msdn.microsoft.com/en-us/library/windows/desktop/ms633515%28v=vs.85%29.aspx">GetWindow</see>
///     function in a loop. An application that calls the GetWindow function to perform this task risks being caught in an
///     infinite loop or referencing a handle to a window that has been destroyed.<br />Note For Windows 8 and later,
///     EnumWindows enumerates only top-level windows of desktop apps.
/// </remarks>
[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)

Please edit this page!

Do you have...

• helpful tips or sample code to share for using this API in managed code?
• corrections to the existing content?
• variations of the signature you want to share?
• additional languages you want to include?

Select "Edit This Page" on the right hand toolbar and edit it! Or add new pages containing supporting types needed for this API (structures, delegates, and more).