Obtenir une capture d'écran d'une application spécifique

Je sais que je peux obtenir la copie d'écran de la totalité de l'écran à l'aide de Graphiques.CopyFromScreen(). Cependant, que faire si je veux juste la capture d'écran d'une application spécifique?

InformationsquelleAutor Hao Wooi Lim | 2009-05-21
  1. 35

    Voici un peu de code pour vous aider à démarrer:

    public void CaptureApplication(string procName)
{
    var proc = Process.GetProcessesByName(procName)[0];
    var rect = new User32.Rect();
    User32.GetWindowRect(proc.MainWindowHandle, ref rect);

    int width = rect.right - rect.left;
    int height = rect.bottom - rect.top;

    var bmp = new Bitmap(width, height, PixelFormat.Format32bppArgb);
    Graphics graphics = Graphics.FromImage(bmp);
    graphics.CopyFromScreen(rect.left, rect.top, 0, 0, new Size(width, height), CopyPixelOperation.SourceCopy);

    bmp.Save("c:\\tmp\\test.png", ImageFormat.Png);
}

private class User32
{
    [StructLayout(LayoutKind.Sequential)]
    public struct Rect
    {
        public int left;
        public int top;
        public int right;
        public int bottom;
    }

    [DllImport("user32.dll")]
    public static extern IntPtr GetWindowRect(IntPtr hWnd, ref Rect rect);
}

    Il fonctionne, mais il faut améliorer:

    • Vous souhaiterez peut-être utiliser un autre mécanisme pour obtenir le handle de processus (ou au moins faire quelques défensive de codage)
    • Si votre fenêtre cible n'est pas au premier plan, vous vous retrouverez avec une capture d'écran dont la taille/position, mais va juste être rempli avec tout ce qui est au premier plan (ce qui est probablement souhaitez tirer la fenêtre donnée dans le premier plan premier)
    • Vous voulez sans doute faire autre chose que de simplement enregistrer bmp à un répertoire temp
    • cela n'apporte pas la fenêtre pour le processus sélectionné au premier plan dans win7, de façon à obtenir une capture d'écran avec la fenêtre active
    • j'ai utilisé votre code pour prendre un instantané de bloc-notes .mais il a pris un instantané de visual studio qui est la fenêtre active .peut-on l'utiliser pour prendre une photo d'aucune fenêtre active ?
    • J'allais vous suggère d'essayer l'autre réponse, mais je vois vos commentaires qui qui ne fonctionne pas non plus... une Autre option pourrait être d'essayer de trouver une pinvoke méthode qui tire la cible app/fenêtre en avant première. Par exemple, SwitchToThisWindow, peut-être...
    InformationsquelleAutor Alconja
  2. 105

    La PrintWindow win32 api de capture d'une fenêtre bitmap, même si la fenêtre est recouverte par d'autres fenêtres ou si elle est hors de l'écran:

    [DllImport("user32.dll")]
public static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);
[DllImport("user32.dll")]
public static extern bool PrintWindow(IntPtr hWnd, IntPtr hdcBlt, int nFlags);

public static Bitmap PrintWindow(IntPtr hwnd)    
{       
    RECT rc;        
    GetWindowRect(hwnd, out rc);

    Bitmap bmp = new Bitmap(rc.Width, rc.Height, PixelFormat.Format32bppArgb);        
    Graphics gfxBmp = Graphics.FromImage(bmp);        
    IntPtr hdcBitmap = gfxBmp.GetHdc();        

    PrintWindow(hwnd, hdcBitmap, 0);  

    gfxBmp.ReleaseHdc(hdcBitmap);               
    gfxBmp.Dispose(); 

    return bmp;   
}

    La référence à l'RECT ci-dessus peuvent être résolus avec la classe suivante:

    [StructLayout(LayoutKind.Sequential)]
public struct RECT
{
private int _Left;
private int _Top;
private int _Right;
private int _Bottom;
public RECT(RECT Rectangle) : this(Rectangle.Left, Rectangle.Top, Rectangle.Right, Rectangle.Bottom)
{
}
public RECT(int Left, int Top, int Right, int Bottom)
{
_Left = Left;
_Top = Top;
_Right = Right;
_Bottom = Bottom;
}
public int X {
get { return _Left; }
set { _Left = value; }
}
public int Y {
get { return _Top; }
set { _Top = value; }
}
public int Left {
get { return _Left; }
set { _Left = value; }
}
public int Top {
get { return _Top; }
set { _Top = value; }
}
public int Right {
get { return _Right; }
set { _Right = value; }
}
public int Bottom {
get { return _Bottom; }
set { _Bottom = value; }
}
public int Height {
get { return _Bottom - _Top; }
set { _Bottom = value + _Top; }
}
public int Width {
get { return _Right - _Left; }
set { _Right = value + _Left; }
}
public Point Location {
get { return new Point(Left, Top); }
set {
_Left = value.X;
_Top = value.Y;
}
}
public Size Size {
get { return new Size(Width, Height); }
set {
_Right = value.Width + _Left;
_Bottom = value.Height + _Top;
}
}
public static implicit operator Rectangle(RECT Rectangle)
{
return new Rectangle(Rectangle.Left, Rectangle.Top, Rectangle.Width, Rectangle.Height);
}
public static implicit operator RECT(Rectangle Rectangle)
{
return new RECT(Rectangle.Left, Rectangle.Top, Rectangle.Right, Rectangle.Bottom);
}
public static bool operator ==(RECT Rectangle1, RECT Rectangle2)
{
return Rectangle1.Equals(Rectangle2);
}
public static bool operator !=(RECT Rectangle1, RECT Rectangle2)
{
return !Rectangle1.Equals(Rectangle2);
}
public override string ToString()
{
return "{Left: " + _Left + "; " + "Top: " + _Top + "; Right: " + _Right + "; Bottom: " + _Bottom + "}";
}
public override int GetHashCode()
{
return ToString().GetHashCode();
}
public bool Equals(RECT Rectangle)
{
return Rectangle.Left == _Left && Rectangle.Top == _Top && Rectangle.Right == _Right && Rectangle.Bottom == _Bottom;
}
public override bool Equals(object Object)
{
if (Object is RECT) {
return Equals((RECT)Object);
} else if (Object is Rectangle) {
return Equals(new RECT((Rectangle)Object));
}
return false;
}
}
    • Excellente solution. Je veux juste souligner que, parfois, PixelFormat.Format32bppArgb donne blanc artefacts. Dans ce cas, essayez d'utiliser un autre format au lieu de cela, comme PixelFormat.Format24bppRgb
    • pas si son minimisé si, il fait également la fenêtre cible à clignoter lorsque vous PrintWindow()
    • comment puis-je utiliser cette méthode? PrintWindow(what to pass here)
    • Le HWND de la fenêtre de premier niveau que vous souhaitez obtenir une image de
    • comment puis-je obtenir un HWND?
    • je suis entièrement de noir de l'image ?pourquoi??
    • Probablement parce que c'est un DirectX fenêtre, je pense qu'il y est une certaine façon de les capturer sur Windows 10, mais n'ai pas regardé c'
    • Merci pour cette. Juste au cas où quelqu'un d'autre avait à le chercher, Le referencefor DLLimport est using System.Runtime.InteropServices;
    • J'ai eu le même problème. Je suppose que vous êtes le démarrage d'un nouveau processus et souhaitez capturer. Le problème, c'est que votre fenêtre n'est pas encore initialisé. C'est le cas même si vous appelez Process.WaitForIdle(). Je suis un homme simple et enveloppé la extern appel à GetWindowRect(hwnd, out rc); dans un do-while, avec rc.Width == 0 || rc.Height == 0 que la condition de sortie.
    • A l'image noire de la solution été ajoutés à cette solution? Je suis en cours d'exécution dans la même chose sur Windows 10
    • Pour obtenir le HWND utiliser cette this.Handle
    • Toujours un noir bitmap pour UWP apps. Je ne peux même pas sembler obtenir DWM vignettes pour un UWP application alors que je suis dans le même bureau que l'UWP app. Cependant, je peux obtenir le DWM vignette pour un UWP app quand je ne suis pas sur le même bureau que lui. C'est me rend fou.
    • Quelle est la cause lorsque le résultat de l'image est en noir?

    InformationsquelleAutor Maurice Flanagan
  3. 9

    Basé sur Alconja réponse, j'ai fait quelques améliorations:

    [StructLayout(LayoutKind.Sequential)]
public struct Rect
{
public int left;
public int top;
public int right;
public int bottom;
}
[DllImport("user32.dll")]
private static extern int SetForegroundWindow(IntPtr hWnd);
private const int SW_RESTORE = 9;
[DllImport("user32.dll")]
private static extern IntPtr ShowWindow(IntPtr hWnd, int nCmdShow);
[DllImport("user32.dll")]
public static extern IntPtr GetWindowRect(IntPtr hWnd, ref Rect rect);
public Bitmap CaptureApplication(string procName)
{
Process proc;
//Cater for cases when the process can't be located.
try
{
proc = Process.GetProcessesByName(procName)[0];
}
catch (IndexOutOfRangeException e)
{
return null;
}
//You need to focus on the application
SetForegroundWindow(proc.MainWindowHandle);
ShowWindow(proc.MainWindowHandle, SW_RESTORE);
//You need some amount of delay, but 1 second may be overkill
Thread.Sleep(1000);
Rect rect = new Rect();
IntPtr error = GetWindowRect(proc.MainWindowHandle, ref rect);
//sometimes it gives error.
while (error == (IntPtr)0)
{
error = GetWindowRect(proc.MainWindowHandle, ref rect);
}
int width = rect.right - rect.left;
int height = rect.bottom - rect.top;
Bitmap bmp = new Bitmap(width, height, PixelFormat.Format32bppArgb);
Graphics.FromImage(bmp).CopyFromScreen(rect.left,
rect.top,
0,
0,
new Size(width, height),
CopyPixelOperation.SourceCopy);
return bmp;
}
    • après l'écrémage par le biais de ce que j'ai remarqué que, si le processus se termine au cours de la Thread.Sleep(1000); vous aurez une boucle infinie.
    • est droit. Pour clarifier, le problème est que l'appel de GetWindowRect avec un HWND qui n'est plus valide renvoie toujours zéro, ce qui signifie que le while boucle dans cette réponse ne sera jamais la quitter et il suffit de graver l'UC de toujours, qui est un joli bug grave. Mais sinon, je pense que cette réponse est une solution élégante. Peut-être juste de limiter à un nombre fixe de nouvelles tentatives, et peut-être dormir un peu entre les deux. Ou de ne pas réessayer dans cette méthode.
    • Cette réponse ne dispose pas de la Graphics objet.
    InformationsquelleAutor Hao Wooi Lim
  4. 1

    Vous pourriez regarder dans P/Invoquant win32 façon de faire cela, un article à cet effet... en quelque sorte.

    Fondamentalement, passer par la peine de mettre en place un contrôleur de domaine à une image et l'envoyer WM_PRINT à la fenêtre de l'application en question. Sa jolie coquine, pour tout dire, mais peut travailler pour vous.

    Fonctions dont vous pourriez avoir besoin: SendMessage, GetDC, CreateCompatibleBitmp, et La méthode.

    Je ne peux pas dire que je n'ai jamais fait cela avant, mais c'est ce que je pourrais attaquer le problème. (Eh bien, je serais probablement le faire dans le plus pur C, mais encore; à peu près de la manière que j'avais de l'attaquer).

    InformationsquelleAutor Kevin Montrose