Warum print-Anzeige in einer Windows-Dienst zurück ein Schwarzes Bild?

protected override void OnStart(string[] args)
{
    base.OnStart(args);
    CaptureScreen();

}

protected override void OnStop()
{
    base.OnStop();

}

private void CaptureScreen()
{

    Bitmap printscreen = new Bitmap(Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height);

    Graphics graphics = Graphics.FromImage(printscreen as Image);

    graphics.CopyFromScreen(0, 0, 0, 0, printscreen.Size);

    printscreen.Save(@"L:\" + Counter++ + ".jpg", ImageFormat.Jpeg);
}
  • Ich überprüfte die Interaktion mit desktop
  • versucht, das localService-Konto & user
  • Welches Betriebssystem?
  • Anmerkung: Ein service kann nicht wissen, über ein zugeordnetes L: - Laufwerk (in der Regel Benutzer-abhängig. Verwenden Sie einen UNC-Pfad (\\server\Pfad).
  • L:\\ lokale Festplatte und das os ist win 7 64bit
  • In Windows Vista und späteren Windows-Dienste können nicht die direkte Interaktion mit dem desktop. In der Tat, ein service ist nicht im Zusammenhang mit einer bestimmten Benutzer-desktop, so gibt es im wesentlichen nichts auf dem Bildschirm zu erfassen. Siehe meine Antwort hier für weitere details.
InformationsquelleAutor Rami | 2011-01-17
  1. 7

    Dies ist ein Teil der session-0-isolation-Funktion, die Hinzugefügt wurde, um Vista. Dienste laufen nun Ihrer eigenen Sitzung, mit Ihrer eigenen Arbeitsstation und desktop. Ähnlich wie die Sitzung, für die der login-prompt und Bildschirmschoner ausgeführt werden. Nehmen Sie einen screenshot der Sitzung der desktop, es gibt nichts in ihm. Für den Zugriff auf das Benutzer-desktop ist nicht mehr möglich. Es ist ein Sicherheits-feature, es verhindert, dass shatter-Angriffe. Zugegeben, ich verstehe nicht, warum die "Interaktion mit desktop" aktivieren nicht entfernt werden.

    Müssen Sie ändern, um Ihr Programm laufen zu lassen, wie eine "windows-Anwendung", nicht um einen Dienst. Setzen Sie eine Verknüpfung in den Autostart-Ordner oder verwenden Sie die Run-Registrierungsschlüssel. Das ist okay, es ist nichts sehr viel Wert, das einrasten, wenn kein Benutzer angemeldet ist.

    InformationsquelleAutor Hans Passant
  2. 2

    Müssen Sie Ihren Dienst für die Benutzer von windows entfernt. Das ist nicht mein code und ich kann mich nicht erinnern, wo ich das habe.
    Fügen Sie diese zwei Klassen
    dann erstellen Sie ein Desktop-Objekt

    Desktop-userDesk = new Desktop();

    Dann, wenn Sie müssen Ihren Dienst für die Interaktion mit der Benutzer-Sitzung, die Sie schreiben würde

    userDesk.BeginInteraction();

    und schließlich zurück zu Ihrem Dienst die Sitzung rufen Sie

    userDesk.EndInteraction();

    internal class Desktop
{
    private IntPtr m_hCurWinsta = IntPtr.Zero;
    private IntPtr m_hCurDesktop = IntPtr.Zero;
    private IntPtr m_hWinsta = IntPtr.Zero;
    private IntPtr m_hDesk = IntPtr.Zero;

    ///<summary>
    ///associate the current thread to the default desktop
    ///</summary>
    ///<returns></returns>
    internal bool BeginInteraction()
    {
        EndInteraction();
        m_hCurWinsta = User32DLL.GetProcessWindowStation();
        if (m_hCurWinsta == IntPtr.Zero)
            return false;

        m_hCurDesktop = User32DLL.GetDesktopWindow();
        if (m_hCurDesktop == IntPtr.Zero)
            return false;

        m_hWinsta = User32DLL.OpenWindowStation("winsta0", false,
            WindowStationAccessRight.WINSTA_ACCESSCLIPBOARD |
            WindowStationAccessRight.WINSTA_ACCESSGLOBALATOMS |
            WindowStationAccessRight.WINSTA_CREATEDESKTOP |
            WindowStationAccessRight.WINSTA_ENUMDESKTOPS |
            WindowStationAccessRight.WINSTA_ENUMERATE |
            WindowStationAccessRight.WINSTA_EXITWINDOWS |
            WindowStationAccessRight.WINSTA_READATTRIBUTES |
            WindowStationAccessRight.WINSTA_READSCREEN |
            WindowStationAccessRight.WINSTA_WRITEATTRIBUTES
            );
        if (m_hWinsta == IntPtr.Zero)
            return false;

        User32DLL.SetProcessWindowStation(m_hWinsta);

        m_hDesk = User32DLL.OpenDesktop("default", OpenDesktopFlag.DF_NONE, false,
                DesktopAccessRight.DESKTOP_CREATEMENU |
                DesktopAccessRight.DESKTOP_CREATEWINDOW |
                DesktopAccessRight.DESKTOP_ENUMERATE |
                DesktopAccessRight.DESKTOP_HOOKCONTROL |
                DesktopAccessRight.DESKTOP_JOURNALPLAYBACK |
                DesktopAccessRight.DESKTOP_JOURNALRECORD |
                DesktopAccessRight.DESKTOP_READOBJECTS |
                DesktopAccessRight.DESKTOP_SWITCHDESKTOP |
                DesktopAccessRight.DESKTOP_WRITEOBJECTS
                );
        if (m_hDesk == IntPtr.Zero)
            return false;

        User32DLL.SetThreadDesktop(m_hDesk);

        return true;
    }

    ///<summary>
    ///restore
    ///</summary>
    internal void EndInteraction()
    {
        if (m_hCurWinsta != IntPtr.Zero)
            User32DLL.SetProcessWindowStation(m_hCurWinsta);

        if (m_hCurDesktop != IntPtr.Zero)
            User32DLL.SetThreadDesktop(m_hCurDesktop);

        if (m_hWinsta != IntPtr.Zero)
            User32DLL.CloseWindowStation(m_hWinsta);

        if (m_hDesk != IntPtr.Zero)
            User32DLL.CloseDesktop(m_hDesk);
    }
}
public static class User32DLL
{
    ///<summary>
    ///The GetDesktopWindow function returns a handle to the desktop window. 
    ///The desktop window covers the entire screen. 
    ///The desktop window is the area on top of which other windows are painted. 
    ///</summary>
    ///<returns>The return value is a handle to the desktop window. </returns>
    [DllImport("User32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
    public static extern IntPtr GetDesktopWindow();


    ///<summary>
    ///Retrieves a handle to the current window station for the calling process.
    ///</summary>
    ///<returns>If the function succeeds,
    ///the return value is a handle to the window station.
    ///If the function fails, the return value is NULL.</returns>
    [DllImport("User32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
    public static extern IntPtr GetProcessWindowStation();


    ///<summary>
    ///Retrieves a handle to the desktop assigned to the specified thread.
    ///</summary>
    ///<param name="dwThread">[in] Handle to the thread
    ///    for which to return the desktop handle.</param>
    ///<returns>If the function succeeds, the return value is a handle to the 
    ///desktop associated with the specified thread. 
    ///If the function fails, the return value is NULL.</returns>
    [DllImport("User32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
    public static extern IntPtr GetThreadDesktop(uint dwThread);


    ///<summary>
    ///Opens the specified window station.
    ///</summary>
    ///<param name="lpszWinSta">Pointer to a null-terminated
    ///          string specifying the name of the window station 
    ///to be opened. Window station names are case-insensitive.
    ///This window station must belong to the current session.
    ///</param>
    ///<param name="fInherit">[in] If this value
    ///           is TRUE, processes created by this process 
    ///will inherit the handle. Otherwise, 
    ///the processes do not inherit this handle. 
    ///</param>
    ///<param name="dwDesiredAccess">[in] Access to the window station</param>
    ///<returns>If the function succeeds, the return value
    ///         is the handle to the specified window station.
    ///If the function fails, the return value is NULL.</returns>
    [DllImport("User32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
    public static extern IntPtr OpenWindowStation(string lpszWinSta
        , bool fInherit
        , WindowStationAccessRight dwDesiredAccess
        );


    ///<summary>
    ///Assigns the specified window station to the calling process. 
    ///This enables the process to access objects in the window
    ///station such as desktops, the clipboard, and global atoms. 
    ///All subsequent operations on the window station
    ///use the access rights granted to hWinSta.
    ///</summary>
    ///<param name="hWinSta">[in] Handle to the window
    ///        station to be assigned to the calling process</param>
    ///<returns>If the function succeeds, the return value is nonzero.
    ///If the function fails, the return value is zero. </returns>
    [DllImport("User32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
    public static extern IntPtr SetProcessWindowStation(IntPtr hWinSta);


    ///<summary>
    ///Closes an open window station handle.
    ///</summary>
    ///<param name="hWinSta">[in] Handle
    ///        to the window station to be closed.</param>
    ///<returns>If the function succeeds, the return value is nonzero.
    ///If the function fails, the return value is zero. </returns>
    [DllImport("User32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
    public static extern IntPtr CloseWindowStation(IntPtr hWinSta);


    ///<summary>
    ///Opens the specified desktop object.
    ///</summary>
    ///<param name="lpszDesktop">[in] Pointer to null-terminated string 
    ///specifying the name of the desktop to be opened. 
    ///Desktop names are case-insensitive.
    ///This desktop must belong to the current window station.</param>
    ///<param name="dwFlags">[in] This parameter can
    ///         be zero or DF_ALLOWOTHERACCOUNTHOOK=0x0001</param>
    ///<param name="fInherit">[in] If this value is TRUE, processes created by 
    ///this process will inherit the handle. 
    ///Otherwise, the processes do not inherit this handle. </param>
    ///<param name="dwDesiredAccess">[in] Access
    ///        to the desktop. For a list of access rights</param>
    ///<returns>If the function succeeds, the return value is a handle to the opened desktop. 
    ///When you are finished using the handle, call the CloseDesktop function to close it.
    ///If the function fails, the return value is NULL.
    ///</returns>
    [DllImport("User32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
    public static extern IntPtr OpenDesktop(string lpszDesktop
        , OpenDesktopFlag dwFlags
        , bool fInherit
        , DesktopAccessRight dwDesiredAccess
        );


    ///<summary>
    ///Closes an open handle to a desktop object.
    ///</summary>
    ///<param name="hDesktop">[in] Handle to the desktop to be closed.</param>
    ///<returns>If the function succeeds, the return value is nonzero.
    ///If the function fails, the return value is zero. </returns>
    [DllImport("User32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
    public static extern IntPtr CloseDesktop(IntPtr hDesktop);

    ///<summary>
    ///Assigns the specified desktop to the calling thread. 
    ///All subsequent operations on the desktop use the access rights granted to the desktop.
    ///</summary>
    ///<param name="hDesktop">[in] Handle to the desktop
    ///          to be assigned to the calling thread.</param>
    ///<returns>If the function succeeds, the return value is nonzero.
    ///If the function fails, the return value is zero. </returns>
    [DllImport("User32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
    public static extern bool SetThreadDesktop(IntPtr hDesktop);
}

///<summary>
///REF MSDN:Window Station Security and Access Rights
///ms-help://MS.MSDN.vAug06.en/dllproc/base/window_station_security_and_access_rights.htm
///</summary>
[FlagsAttribute]
public enum WindowStationAccessRight : uint
{
    ///<summary>All possible access rights for the window station.</summary>
    WINSTA_ALL_ACCESS = 0x37F,

    ///<summary>Required to use the clipboard.</summary>
    WINSTA_ACCESSCLIPBOARD = 0x0004,

    ///<summary>Required to manipulate global atoms.</summary>
    WINSTA_ACCESSGLOBALATOMS = 0x0020,

    ///<summary>Required to create new desktop
    ///objects on the window station.</summary>
    WINSTA_CREATEDESKTOP = 0x0008,

    ///<summary>Required to enumerate existing desktop objects.</summary>
    WINSTA_ENUMDESKTOPS = 0x0001,

    ///<summary>Required for the window station to be enumerated.</summary>
    WINSTA_ENUMERATE = 0x0100,

    ///<summary>Required to successfully call the ExitWindows or ExitWindowsEx function. 
    ///Window stations can be shared by users and this access type can prevent other users 
    ///of a window station from logging off the window station owner.</summary>
    WINSTA_EXITWINDOWS = 0x0040,

    ///<summary>Required to read the attributes of a window station object. 
    ///This attribute includes color settings 
    ///and other global window station properties.</summary>
    WINSTA_READATTRIBUTES = 0x0002,

    ///<summary>Required to access screen contents.</summary>
    WINSTA_READSCREEN = 0x0200,

    ///<summary>Required to modify the attributes of 
    ///a window station object. 
    ///The attributes include color settings 
    ///and other global window station properties.</summary>
    WINSTA_WRITEATTRIBUTES = 0x0010,
}

///<summary>
///OpenDesktop 2nd param
///</summary>
public enum OpenDesktopFlag : uint
{
    ///<summary>
    ///Default value
    ///</summary>
    DF_NONE = 0x0000,

    ///<summary>
    ///Allows processes running in other accounts on the desktop
    ///to set hooks in this process.
    ///</summary>
    DF_ALLOWOTHERACCOUNTHOOK = 0x0001,
}

///<summary>
///REF MSDN:Desktop Security and Access Rights
///ms-help://MS.MSDN.vAug06.en/dllproc/base/desktop_security_and_access_rights.htm
///</summary>
[FlagsAttribute]
public enum DesktopAccessRight : uint
{
    ///<summary>Required to create a menu on the desktop. </summary>
    DESKTOP_CREATEMENU = 0x0004,

    ///<summary>Required to create a window on the desktop. </summary>
    DESKTOP_CREATEWINDOW = 0x0002,

    ///<summary>Required for the desktop to be enumerated. </summary>
    DESKTOP_ENUMERATE = 0x0040,

    ///<summary>Required to establish any of the window hooks. </summary>
    DESKTOP_HOOKCONTROL = 0x0008,

    ///<summary>Required to perform journal playback on a desktop. </summary>
    DESKTOP_JOURNALPLAYBACK = 0x0020,

    ///<summary>Required to perform journal recording on a desktop. </summary>
    DESKTOP_JOURNALRECORD = 0x0010,

    ///<summary>Required to read objects on the desktop. </summary>
    DESKTOP_READOBJECTS = 0x0001,

    ///<summary>Required to activate the desktop
    ///         using the SwitchDesktop function. </summary>
    DESKTOP_SWITCHDESKTOP = 0x0100,

    ///<summary>Required to write objects on the desktop. </summary>
    DESKTOP_WRITEOBJECTS = 0x0080,
}
    InformationsquelleAutor Justin Davis
  3. 0

    Der service ist "headless", kein UI und ohne 100% sicher (Die Dokumentation für die CopyFromScreen eher vage ist), würde ich erwarten, dass, um Fehler beim ausführen von headless. Wie würde der Dienst wissen, welche Bildschirm, um die Kopie in dem Fall, wo mehrere Benutzer angemeldet sind an der gleichen Zeit?

    sehen diese Fragen sowie

    • also, was sollte ich tun, um es erfassen des aktuellen Benutzers
    • Sie fehlt der Punkt. Wenn mehrere Benutzer angemeldet sind, gibt es keine Vorstellung von "aktuellen Benutzer" - Sie alle sind "aktuell", aus Ihrer individuellen Perspektive. Aus einer Außenstehenden position, viel beobachten, wie eine Schar von Menschen, die alle gleich sind(ly interessant).
    • ich bin nicht mit einem server, also alles, was ich habe, ist, einzelne Benutzer zu einer Zeit und vielen Dank
    • Sie immer haben mehrere Benutzer. Im Zweifelsfall öffnen Sie den task-manager und zeigen Sie die Prozesse für alle Benutzer. Es könnte nur mit Anmeldung Privilegien, aber das ist nicht das gleiche
    InformationsquelleAutor Rune FS
  4. 0

    Im Fall von XP/2003 die Interaktion mit Desktop sollte helfen.
    Im Fall von Windows 7/Windows 2008 eine Interaktion mit Desktop funktioniert anders.

    Die beste Lösung für Sie wäre, zu analysieren, logon-sessions aus dem Dienst und für die neue Sitzung starten Sie das "desktop" - Prozess in der user-Sitzung und die Kommunikation mit diesem Prozess, um Bildschirme.

    • können Sie mir sagen, was zu tun ist in mehr detals
    • Ok. Zuerst, Ihre service-Bedürfnisse zu kommunizieren, mit allen login-Sitzungen. Es sollte aufzuzählen kontinuierlich und, sobald der neue logon-session angezeigt wird, erstellen Sie den Prozess in diesem logon-Sitzung, die bitmaps zu erfassen. Dann kann der Dienst die Kommunikation mit bitmap-capture-Anwendung über TCP/IP, shared memory etc. Der service sollte auch überprüfen, ob die Anwendung aktiv ist. Wenn der Benutzer beendet die Anwendung, den service starten muss, um es wieder auf. Mit den details wäre das schreiben dieser Anwendung.
    • Ja... der Blick in die Kommentar-zur Verfügung gestellt von Cody Grau in einem anderen thread sehe ich, dass ich einen Fehler gemacht, vorausgesetzt, dass der Dienst auch starten, Benutzer-Prozess sehr einfach. Wahrscheinlich gibt es einige Wege um die Anwendung zu starten, und befestigen Sie es auf dem desktop... Keine schnelle Antwort.
    InformationsquelleAutor Denis Mazourick
Schreibe einen Kommentar