C# Signature:

[DllImport("user32.dll")]
static extern bool EnumWindowStations(EnumWindowStationsDelegate lpEnumFunc,
   IntPtr lParam);

VB Signature:

<DllImport("user32.dll", EntryPoint:="EnumWindowStations", _

Public Function EnumWindowStations(ByVal lpEnumFunc As EnumWindowStationsDelegate, ByVal lParam As IntPtr) As Boolean

    ' Leave function empty - DLLImport attribute forwards calls
    End Function
[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:

Public Delegate Function EnumWindowStationsDelegate(<MarshalAs(UnmanagedType.LPTStr)> ByVal windowsStation As String, ByVal lParam As IntPtr) As Boolean

User-Defined Types:

EnumWindowsProc

Notes:

None.

Notes:

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

Tips & Tricks:

Please add some!

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

Sample Code:

{

    class Program
    {
    [DllImport( "user32.dll" )]
    private static extern bool EnumWindowStations( EnumWindowStationsDelegate lpEnumFunc, IntPtr lParam );

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

    private delegate bool EnumWindowStationsDelegate( string windowsStation, IntPtr lParam );

SAMPLE CODE!!

    private static bool EnumWindowStationsCallback( string windowStation, IntPtr lParam )
    {
        GCHandle gch       = GCHandle.FromIntPtr( lParam );
        IList<string> list = gch.Target as List<string>;
using System.Runtime.InteropServices;

        if ( null == list ) {
        return (false);
        }
public delegate bool CallBackPtr(int hwnd, int lParam);
private CallBackPtr callBackPtr;

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

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

    static void Main()
    {
        IList<string> list           = new List<string>();
        GCHandle gch             = GCHandle.Alloc( list );
        EnumWindowStationsDelegate childProc = new EnumWindowStationsDelegate( EnumWindowStationsCallback );
     // 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);
}

        EnumWindowStations( childProc, GCHandle.ToIntPtr( gch ) );

Sample Code 2 (C#):

        foreach ( string a in list ) {
        Console.WriteLine( a );
        }
      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);

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

Alternative Managed API:

Do you know one? Please contribute it!

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