EnumWindows (user32)
Last changed: -98.152.226.218

.
Summary

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:

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().

Documentation
EnumWindows on MSDN

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)