La fenêtre de l'application flash comme orange sur la barre des tâches lorsque minimiser

C#: Flash Fenêtre dans la barre des tâches via Win32 FlashWindowEx cela fonctionne pour moi.

L'API Windows (Win32) a la FlashWindowEx méthode au sein de la User32
bibliothèque; cette méthode permet (le développeur) à Flash d'une Fenêtre,
signifier à l'utilisateur que certains des principaux événements survenus au sein de l'
application qui requiert toute leur attention. L'utilisation la plus commune de ce
est de faire clignoter la fenêtre jusqu'à ce que l'utilisateur active l'
application. Cependant, vous pouvez également flasher la fenêtre d'un nombre spécifié
des fois, ou tout simplement continuer à clignoter jusqu'à ce que vous décider d'arrêter.

L'utilisation de la FlashWindowEx méthode n'est cependant pas intégré dans la .NET
Cadre de n'importe où. Pour y accéder, vous devez utiliser la Plate-forme
Invoke (PInvoke) les fonctionnalités .NET pour "chute" à l'API Windows
(Win32) et de l'appeler directement. Aussi, comme beaucoup d'autres fonctionnalités
dans l'API Windows (qui ne sont pas directement exposés par .NET) l'
FlashWindowEx méthode peut être un peu difficile à utiliser si vous n'êtes pas
familier avec le travail avec l'API Windows de l'intérieur .NET.

Maintenant plutôt que d'aller trop profondément dans les détails de PInvoke ou Win32
FlashWindowEx méthode ci-dessous est une simple classe statique en C# qui permet
vous pouvez facilement utiliser cette méthode. Il est en fait assez un peu de
informations nécessaires pour expliquer comment utiliser PInvoke à utiliser les
L'API Windows (Win32), donc peut-être que je vais couvrir que dans un futur article.

Voici quelques exemple d'utilisation de cette classe statique:

//One this to note with this example usage code, is the "this" keyword is referring to
//the current System.Windows.Forms.Form.

//Flash window until it recieves focus
FlashWindow.Flash(this);

//Flash window 5 times
FlashWindow.Flash(this, 5);

//Start Flashing "Indefinately"
FlashWindow.Start(this);

//Stop the "Indefinate" Flashing
FlashWindow.Stop(this);

Une chose à noter à propos de la FlashWindowEx méthode est qu'elle requiert
(et ne fonctionne que sur Windows 2000 ou plus tard.

Voici le code pour la classe statique en C#:

public static class FlashWindow
{
[DllImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool FlashWindowEx(ref FLASHWINFO pwfi);
[StructLayout(LayoutKind.Sequential)]
private struct FLASHWINFO
{
///<summary>
///The size of the structure in bytes.
///</summary>
public uint cbSize;
///<summary>
///A Handle to the Window to be Flashed. The window can be either opened or minimized.
///</summary>
public IntPtr hwnd;
///<summary>
///The Flash Status.
///</summary>
public uint dwFlags;
///<summary>
///The number of times to Flash the window.
///</summary>
public uint uCount;
///<summary>
///The rate at which the Window is to be flashed, in milliseconds. If Zero, the function uses the default cursor blink rate.
///</summary>
public uint dwTimeout;
}
///<summary>
///Stop flashing. The system restores the window to its original stae.
///</summary>
public const uint FLASHW_STOP = 0;
///<summary>
///Flash the window caption.
///</summary>
public const uint FLASHW_CAPTION = 1;
///<summary>
///Flash the taskbar button.
///</summary>
public const uint FLASHW_TRAY = 2;
///<summary>
///Flash both the window caption and taskbar button.
///This is equivalent to setting the FLASHW_CAPTION | FLASHW_TRAY flags.
///</summary>
public const uint FLASHW_ALL = 3;
///<summary>
///Flash continuously, until the FLASHW_STOP flag is set.
///</summary>
public const uint FLASHW_TIMER = 4;
///<summary>
///Flash continuously until the window comes to the foreground.
///</summary>
public const uint FLASHW_TIMERNOFG = 12;
///<summary>
///Flash the spacified Window (Form) until it recieves focus.
///</summary>
///<param name="form">The Form (Window) to Flash.</param>
///<returns></returns>
public static bool Flash(System.Windows.Forms.Form form)
{
//Make sure we're running under Windows 2000 or later
if (Win2000OrLater)
{
FLASHWINFO fi = Create_FLASHWINFO(form.Handle, FLASHW_ALL | FLASHW_TIMERNOFG, uint.MaxValue, 0);
return FlashWindowEx(ref fi);
}
return false;
}
private static FLASHWINFO Create_FLASHWINFO(IntPtr handle, uint flags, uint count, uint timeout)
{
FLASHWINFO fi = new FLASHWINFO();
fi.cbSize = Convert.ToUInt32(Marshal.SizeOf(fi));
fi.hwnd = handle;
fi.dwFlags = flags;
fi.uCount = count;
fi.dwTimeout = timeout;
return fi;
}
///<summary>
///Flash the specified Window (form) for the specified number of times
///</summary>
///<param name="form">The Form (Window) to Flash.</param>
///<param name="count">The number of times to Flash.</param>
///<returns></returns>
public static bool Flash(System.Windows.Forms.Form form, uint count)
{
if (Win2000OrLater)
{
FLASHWINFO fi = Create_FLASHWINFO(form.Handle, FLASHW_ALL, count, 0);
return FlashWindowEx(ref fi);
}
return false;
}
///<summary>
///Start Flashing the specified Window (form)
///</summary>
///<param name="form">The Form (Window) to Flash.</param>
///<returns></returns>
public static bool Start(System.Windows.Forms.Form form)
{
if (Win2000OrLater)
{
FLASHWINFO fi = Create_FLASHWINFO(form.Handle, FLASHW_ALL, uint.MaxValue, 0);
return FlashWindowEx(ref fi);
}
return false;
}
///<summary>
///Stop Flashing the specified Window (form)
///</summary>
///<param name="form"></param>
///<returns></returns>
public static bool Stop(System.Windows.Forms.Form form)
{
if (Win2000OrLater)
{
FLASHWINFO fi = Create_FLASHWINFO(form.Handle, FLASHW_STOP, uint.MaxValue, 0);
return FlashWindowEx(ref fi);
}
return false;
}
///<summary>
///A boolean value indicating whether the application is running on Windows 2000 or later.
///</summary>
private static bool Win2000OrLater
{
get { return System.Environment.OSVersion.Version.Major >= 5; }
}
}

Les gars j'ai trouvé un moyen beaucoup plus facile de le faire! Si c'est le cas, vous êtes de l'utiliser pour.

Dans .NET 4.0, C#, si vous utilisez seulement

this.WindowState = FormWindowState.Normal;
this.Activate();

La première ligne permet de s'assurer qu'il n'est pas réduit, le deuxième ligne rend la mise au point. Je ne sais pas exactement pourquoi (ou de ne pas le faire), mais, si vous affiche une boîte de message à partir de ce formulaire, votre programme clignote en orange dans la barre des tâches!