obtenir les titres de toutes les fenêtres ouvertes

Comment puis-je récupérer les titres de toutes les fenêtres ouvertes (y compris windows, tel que les onglets dans Internet Explorer)?

InformationsquelleAutor Alon M | 2011-09-01

.net c#windows

37

Quelque chose comme ceci:
```
using System.Diagnostics;

Process[] processlist = Process.GetProcesses();

foreach (Process process in processlist)
{
    if (!String.IsNullOrEmpty(process.MainWindowTitle))
    {
        Console.WriteLine("Process: {0} ID: {1} Window title: {2}", process.ProcessName, process.Id, process.MainWindowTitle);
    }
}
```
- de cette façon, il ne se la fenêtre principale de chaque processus, il a demandé pour toutes les fenêtres ouvertes dans le système.
- Il dit: "de plus, comme les noms de toutes les applications ouvertes".
- Davide piras est bon, j'ai besoin de toutes les fenêtres ouvertes. comme les onglets dans Intrarnt exploer. De toute façon? Merci encore!
- Une liste de toutes les fenêtres ouvertes dans le système serait énorme. Il devrait être limité aux fenêtres de niveau supérieur ou de bureau windows. Dans le cas d'Internet Explorer, de nombreuses applications de créer des enfants de la manière que IE ne. Si vous pensez cela, il est peu probable que les seuls enfants qui s'appliquerait est IE enfants (onglets) donc la question est un peu floue. Les fenêtres de niveau supérieur de processus versus IE onglets sont totalement différentes dans la réponse.
InformationsquelleAutor CodeCaster

Voici un code que vous pouvez utiliser pour obtenir une liste de toutes les fenêtres ouvertes. En fait, vous obtenez un dictionnaire où chaque élément est une KeyValuePair où est la clé de la poignée (hWnd) de la fenêtre et la valeur de son titre.

using HWND = IntPtr;
///<summary>Contains functionality to get all the open windows.</summary>
public static class OpenWindowGetter
{
///<summary>Returns a dictionary that contains the handle and title of all the open windows.</summary>
///<returns>A dictionary that contains the handle and title of all the open windows.</returns>
public static IDictionary<HWND, string> GetOpenWindows()
{
HWND shellWindow = GetShellWindow();
Dictionary<HWND, string> windows = new Dictionary<HWND, string>();
EnumWindows(delegate(HWND hWnd, int lParam)
{
if (hWnd == shellWindow) return true;
if (!IsWindowVisible(hWnd)) return true;
int length = GetWindowTextLength(hWnd);
if (length == 0) return true;
StringBuilder builder = new StringBuilder(length);
GetWindowText(hWnd, builder, length + 1);
windows[hWnd] = builder.ToString();
return true;
}, 0);
return windows;
}
private delegate bool EnumWindowsProc(HWND hWnd, int lParam);
[DllImport("USER32.DLL")]
private static extern bool EnumWindows(EnumWindowsProc enumFunc, int lParam);
[DllImport("USER32.DLL")]
private static extern int GetWindowText(HWND hWnd, StringBuilder lpString, int nMaxCount);
[DllImport("USER32.DLL")]
private static extern int GetWindowTextLength(HWND hWnd);
[DllImport("USER32.DLL")]
private static extern bool IsWindowVisible(HWND hWnd);
[DllImport("USER32.DLL")]
private static extern IntPtr GetShellWindow();
}

Et voici un code qui l'utilise:

foreach(KeyValuePair<IntPtr, string> window in OpenWindowGetter.GetOpenWindows())
{
IntPtr handle = window.Key;
string title = window.Value;
Console.WriteLine("{0}: {1}", handle, title);
}

De crédit: http://www.tcx.be/blog/2006/list-open-windows/

Essayé d'utiliser ce code, a dû modifier la première ligne using HWND = System.IntPtr; au lieu

InformationsquelleAutor cREcker

Basée sur la réponse précédente que me donner quelques erreurs, finalement je utiliser ce code avec GetOpenedWindows fonction:

public class InfoWindow
{
public IntPtr Handle = IntPtr.Zero;
public FileInfo File = new FileInfo( Application.ExecutablePath );
public string Title = Application.ProductName;
public override string ToString() {
return  File.Name + "\t>\t" + Title;
}
}//CLASS
///<summary>Contains functionality to get info on the open windows.</summary>
public static class RuningWindows
{   
internal static event EventHandler WindowActivatedChanged;    
internal static Timer TimerWatcher = new Timer();    
internal static InfoWindow WindowActive = new InfoWindow();       
internal static void DoStartWatcher() {
TimerWatcher.Interval = 500;
TimerWatcher.Tick += TimerWatcher_Tick;
TimerWatcher.Start();    
}                    
///<summary>Returns a dictionary that contains the handle and title of all the open windows.</summary>
///<returns>A dictionary that contains the handle and title of all the open windows.</returns>
public static IDictionary<IntPtr , InfoWindow> GetOpenedWindows()
{
IntPtr shellWindow = GetShellWindow();
Dictionary<IntPtr , InfoWindow> windows = new Dictionary<IntPtr , InfoWindow>();
EnumWindows( new EnumWindowsProc( delegate( IntPtr hWnd , int lParam ) {
if ( hWnd == shellWindow ) return true;
if ( !IsWindowVisible( hWnd ) ) return true;    
int length = GetWindowTextLength( hWnd );
if ( length == 0 ) return true;    
StringBuilder builder = new StringBuilder( length );
GetWindowText( hWnd , builder , length + 1 );    
var info = new InfoWindow();
info.Handle = hWnd;
info.File = new FileInfo( GetProcessPath( hWnd ) );
info.Title = builder.ToString();    
windows[hWnd] = info;
return true;    
} ) , 0 );    
return windows;
}
private delegate bool EnumWindowsProc( IntPtr hWnd , int lParam );  
public static string GetProcessPath( IntPtr hwnd )
{
uint pid = 0;
GetWindowThreadProcessId( hwnd , out pid );
if ( hwnd != IntPtr.Zero ) {
if ( pid != 0 ) {
var process = Process.GetProcessById( (int) pid );
if ( process != null ) {
return process.MainModule.FileName.ToString();
}
}
}
return "";
}    
[DllImport( "USER32.DLL" )]
private static extern bool EnumWindows( EnumWindowsProc enumFunc , int lParam );
[DllImport( "USER32.DLL" )]
private static extern int GetWindowText( IntPtr hWnd , StringBuilder lpString , int nMaxCount );
[DllImport( "USER32.DLL" )]
private static extern int GetWindowTextLength( IntPtr hWnd );
[DllImport( "USER32.DLL" )]
private static extern bool IsWindowVisible( IntPtr hWnd );
[DllImport( "USER32.DLL" )]
private static extern IntPtr GetShellWindow();
[DllImport( "user32.dll" )]
private static extern IntPtr GetForegroundWindow();
//WARN: Only for "Any CPU":
[DllImport( "user32.dll" , CharSet = CharSet.Auto , SetLastError = true )]
private static extern int GetWindowThreadProcessId( IntPtr handle , out uint processId );    
static void TimerWatcher_Tick( object sender , EventArgs e )
{
var windowActive = new InfoWindow();
windowActive.Handle = GetForegroundWindow();
string path = GetProcessPath( windowActive.Handle );
if ( string.IsNullOrEmpty( path ) ) return;
windowActive.File = new FileInfo( path );
int length = GetWindowTextLength( windowActive.Handle );
if ( length == 0 ) return;
StringBuilder builder = new StringBuilder( length );
GetWindowText( windowActive.Handle , builder , length + 1 );
windowActive.Title = builder.ToString();
if ( windowActive.ToString() != WindowActive.ToString() ) {
//fire:
WindowActive = windowActive;
if ( WindowActivatedChanged != null ) WindowActivatedChanged( sender , e );
Console.WriteLine( "Window: " + WindowActive.ToString() );
}
}
}//CLASS

Attention: Vous ne pouvez compil/debug sous "any CPU" pour l'accès aux Applications 32bits...

InformationsquelleAutor Godvicien

1

vous devez utiliser le EnumWindow API.

il y a beaucoup d'exemples sur la façon de l'utiliser à partir de C#, j'ai trouvé quelque chose ici:

Obtenez de l'Application Poignées de Fenêtre

Problème avec EnumWindows
- Cant le comprendre je afirde. pouvez-vous me donner un exmple, plesae?
- Lien-seulement les réponses ne sont pas des réponses.
InformationsquelleAutor Davide Piras
1

http://pinvoke.net/default.aspx/user32.EnumDesktopWindows

Il est un exemple de l'utilisation de user.dll's EnumWindow en C# pour la liste de toutes les fenêtres ouvertes.
- le lien est cassé!
- pinvoke.net/default.aspx/user32.EnumDesktopWindows
InformationsquelleAutor 62071072SP

Héra est la fonction UpdateWindowsList_WindowMenu() que vous devez appeler après toutes les opérations sont effectuées sur des Onglets.Ici windowToolStripMenuItem est l'élément de menu ajouté à la Fenêtre de Menu à bande.

public void UpdateWindowsList_WindowMenu()  
{  
//get all tab pages from tabControl1  
TabControl.TabPageCollection tabcoll = tabControl1.TabPages;  
//get  windowToolStripMenuItem drop down menu items count  
int n = windowToolStripMenuItem.DropDownItems.Count;  
//remove all menu items from of windowToolStripMenuItem  
for (int i = n - 1; i >=2; i--)  
{  
windowToolStripMenuItem.DropDownItems.RemoveAt(i);  
}  
//read each tabpage from tabcoll and add each tabpage text to windowToolStripMenuItem  
foreach (TabPage tabpage in tabcoll)  
{  
//create Toolstripmenuitem  
ToolStripMenuItem menuitem = new ToolStripMenuItem();  
String s = tabpage.Text;  
menuitem.Text = s;  
if (tabControl1.SelectedTab == tabpage)  
{  
menuitem.Checked = true;  
}  
else  
{  
menuitem.Checked = false;  
}  
//add menuitem to windowToolStripMenuItem  
windowToolStripMenuItem.DropDownItems.Add(menuitem);  
//add click events to each added menuitem  
menuitem.Click += new System.EventHandler(WindowListEvent_Click);  
}  
}  
private void WindowListEvent_Click(object sender, EventArgs e)  
{  
//casting ToolStripMenuItem to ToolStripItem  
ToolStripItem toolstripitem = (ToolStripItem)sender;  
//create collection of tabs of tabContro1  
//check every tab text is equal to clicked menuitem then select the tab  
TabControl.TabPageCollection tabcoll = tabControl1.TabPages;  
foreach (TabPage tb in tabcoll)  
{  
if (toolstripitem.Text == tb.Text)  
{  
tabControl1.SelectedTab = tb;  
//call UpdateWindowsList_WindowMenu() to perform changes on menuitems  
UpdateWindowsList_WindowMenu();  
}  
}  
}

InformationsquelleAutor Pritam Zope

Vous devez vous connecter pour publier un commentaire.