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:
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)
