关于c#：以编程方式确定锁定工作站的持续时间？

Programmatically Determine a Duration of a Locked Workstation?

如何用代码确定机器被锁定了多长时间？

也欢迎使用C#之外的其他想法。

我喜欢Windows服务的想法(并且已经接受了它)是为了简洁和整洁，但是不幸的是，我认为在这种情况下它不会对我有用。我想在办公室而不是在家(或者我想在家中)上在工作站上运行它，但是出于国防部的考虑，它的工作受到了很大的限制。这实际上就是我自己滚动自己的原因的一部分。

我还是把它写出来，看看它是否有效。谢谢大家！

我以前没有发现过，但是从任何应用程序中，您都可以连接SessionSwitchEventHandler。显然，您的应用程序将需要运行，但是只要它是：

1
2
3
4
5
6
7
8
9
10
11
12
13

Microsoft.Win32.SystemEvents.SessionSwitch += new Microsoft.Win32.SessionSwitchEventHandler(SystemEvents_SessionSwitch);

void SystemEvents_SessionSwitch(object sender, Microsoft.Win32.SessionSwitchEventArgs e)
{
if (e.Reason == SessionSwitchReason.SessionLock)
{
//I left my desk
}
else if (e.Reason == SessionSwitchReason.SessionUnlock)
{
//I returned to my desk
}
}

我将创建一个Windows Service(Visual Studio 2005项目类型)来处理OnSessionChange事件，如下所示：

1
2
3
4
5
6
7
8
9
10
11

protected override void OnSessionChange(SessionChangeDescription changeDescription)
{
if (changeDescription.Reason == SessionChangeReason.SessionLock)
{
//I left my desk
}
else if (changeDescription.Reason == SessionChangeReason.SessionUnlock)
{
//I returned to my desk
}
}

此时，您如何记录活动以及如何记录活动取决于您，但是Windows服务可提供对Windows事件(如启动，关闭，登录/注销以及锁定和解锁事件)的快速便捷访问。

下面的解决方案使用Win32 API。工作站锁定时调用OnSessionLock，解锁时调用OnSessionUnlock。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

[DllImport("wtsapi32.dll")]
private static extern bool WTSRegisterSessionNotification(IntPtr hWnd,
int dwFlags);

[DllImport("wtsapi32.dll")]
private static extern bool WTSUnRegisterSessionNotification(IntPtr
hWnd);

private const int NotifyForThisSession = 0; // This session only

private const int SessionChangeMessage = 0x02B1;
private const int SessionLockParam = 0x7;
private const int SessionUnlockParam = 0x8;

protected override void WndProc(ref Message m)
{
// check for session change notifications
if (m.Msg == SessionChangeMessage)
{
if (m.WParam.ToInt32() == SessionLockParam)
OnSessionLock(); // Do something when locked
else if (m.WParam.ToInt32() == SessionUnlockParam)
OnSessionUnlock(); // Do something when unlocked
}

base.WndProc(ref m);
return;
}

void OnSessionLock()
{
Debug.WriteLine("Locked...");
}

void OnSessionUnlock()
{
Debug.WriteLine("Unlocked...");
}

private void Form1Load(object sender, EventArgs e)
{
WTSRegisterSessionNotification(this.Handle, NotifyForThisSession);
}

// and then when we are done, we should unregister for the notification
// WTSUnRegisterSessionNotification(this.Handle);

我知道这是一个老问题，但是我找到了一种获取给定会话的锁定状态的方法。

我在这里找到了答案，但是它是用C语言编写的，所以我尽可能地将其翻译为C#以获取锁定状态。

所以去了：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

static class SessionInfo {
private const Int32 FALSE = 0;

private static readonly IntPtr WTS_CURRENT_SERVER = IntPtr.Zero;

private const Int32 WTS_SESSIONSTATE_LOCK = 0;
private const Int32 WTS_SESSIONSTATE_UNLOCK = 1;

private static bool _is_win7 = false;

static SessionInfo() {
var os_version = Environment.OSVersion;
_is_win7 = (os_version.Platform == PlatformID.Win32NT && os_version.Version.Major == 6 && os_version.Version.Minor == 1);
}

[DllImport("wtsapi32.dll")]
private static extern Int32 WTSQuerySessionInformation(
IntPtr hServer,
[MarshalAs(UnmanagedType.U4)] UInt32 SessionId,
[MarshalAs(UnmanagedType.U4)] WTS_INFO_CLASS WTSInfoClass,
out IntPtr ppBuffer,
[MarshalAs(UnmanagedType.U4)] out UInt32 pBytesReturned
);

[DllImport("wtsapi32.dll")]
private static extern void WTSFreeMemoryEx(
WTS_TYPE_CLASS WTSTypeClass,
IntPtr pMemory,
UInt32 NumberOfEntries
);

private enum WTS_INFO_CLASS {
WTSInitialProgram = 0,
WTSApplicationName = 1,
WTSWorkingDirectory = 2,
WTSOEMId = 3,
WTSSessionId = 4,
WTSUserName = 5,
WTSWinStationName = 6,
WTSDomainName = 7,
WTSConnectState = 8,
WTSClientBuildNumber = 9,
WTSClientName = 10,
WTSClientDirectory = 11,
WTSClientProductId = 12,
WTSClientHardwareId = 13,
WTSClientAddress = 14,
WTSClientDisplay = 15,
WTSClientProtocolType = 16,
WTSIdleTime = 17,
WTSLogonTime = 18,
WTSIncomingBytes = 19,
WTSOutgoingBytes = 20,
WTSIncomingFrames = 21,
WTSOutgoingFrames = 22,
WTSClientInfo = 23,
WTSSessionInfo = 24,
WTSSessionInfoEx = 25,
WTSConfigInfo = 26,
WTSValidationInfo = 27,
WTSSessionAddressV4 = 28,
WTSIsRemoteSession = 29
}

private enum WTS_TYPE_CLASS {
WTSTypeProcessInfoLevel0,
WTSTypeProcessInfoLevel1,
WTSTypeSessionInfoLevel1
}

public enum WTS_CONNECTSTATE_CLASS {
WTSActive,
WTSConnected,
WTSConnectQuery,
WTSShadow,
WTSDisconnected,
WTSIdle,
WTSListen,
WTSReset,
WTSDown,
WTSInit
}

public enum LockState {
Unknown,
Locked,
Unlocked
}

[StructLayout(LayoutKind.Sequential)]
private struct WTSINFOEX {
public UInt32 Level;
public UInt32 Reserved; /* I have observed the Data field is pushed down by 4 bytes so i have added this field as padding. */
public WTSINFOEX_LEVEL Data;
}

[StructLayout(LayoutKind.Sequential)]
private struct WTSINFOEX_LEVEL {
public WTSINFOEX_LEVEL1 WTSInfoExLevel1;
}

[StructLayout(LayoutKind.Sequential)]
private struct WTSINFOEX_LEVEL1 {
public UInt32 SessionId;
public WTS_CONNECTSTATE_CLASS SessionState;
public Int32 SessionFlags;

/* I can't figure out what the rest of the struct should look like but as i don't need anything past the SessionFlags i'm not going to. */

}

public static LockState GetSessionLockState(UInt32 session_id) {
IntPtr ppBuffer;
UInt32 pBytesReturned;

Int32 result = WTSQuerySessionInformation(
WTS_CURRENT_SERVER,
session_id,
WTS_INFO_CLASS.WTSSessionInfoEx,
out ppBuffer,
out pBytesReturned
);

if (result == FALSE)
return LockState.Unknown;

var session_info_ex = Marshal.PtrToStructure<WTSINFOEX>(ppBuffer);

if (session_info_ex.Level != 1)
return LockState.Unknown;

var lock_state = session_info_ex.Data.WTSInfoExLevel1.SessionFlags;
WTSFreeMemoryEx(WTS_TYPE_CLASS.WTSTypeSessionInfoLevel1, ppBuffer, pBytesReturned);

if (_is_win7) {
/* Ref: https://msdn.microsoft.com/en-us/library/windows/desktop/ee621019(v=vs.85).aspx
* Windows Server 2008 R2 and Windows 7: Due to a code defect, the usage of the WTS_SESSIONSTATE_LOCK
* and WTS_SESSIONSTATE_UNLOCK flags is reversed. That is, WTS_SESSIONSTATE_LOCK indicates that the
* session is unlocked, and WTS_SESSIONSTATE_UNLOCK indicates the session is locked.
* */
switch (lock_state) {
case WTS_SESSIONSTATE_LOCK:
return LockState.Unlocked;

case WTS_SESSIONSTATE_UNLOCK:
return LockState.Locked;

default:
return LockState.Unknown;
}
}
else {
switch (lock_state) {
case WTS_SESSIONSTATE_LOCK:
return LockState.Locked;

case WTS_SESSIONSTATE_UNLOCK:
return LockState.Unlocked;

default:
return LockState.Unknown;
}
}
}
}

注意：上面的代码是从一个更大的项目中提取的，所以如果我错过了一点抱歉。我没有时间测试上面的代码，但计划在一两周后回来检查所有内容。我现在才发布它是因为我不想忘记这样做。

如果您有兴趣编写Windows服务以"发现"这些事件，请使用topshelf(使编写Windows服务更加容易的库/框架)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

public interface IMyServiceContract
{
void Start();

void Stop();

void SessionChanged(Topshelf.SessionChangedArguments args);
}

public class MyService : IMyServiceContract
{

public void Start()
{
}

public void Stop()
{

}

public void SessionChanged(SessionChangedArguments e)
{
Console.WriteLine(e.ReasonCode);
}
}

，现在是将topshelf服务连接到上面的接口/混凝土的代码

除了我标记为

的两行外，以下所有内容均为"典型" topshelf设置...。

/ *这是魔术线* /

这些是激发SessionChanged方法的原因。

我在Windows 10 x64上对此进行了测试。我锁定并解锁了机器，并得到了预期的结果。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

IMyServiceContract myServiceObject = new MyService(); /* container.Resolve<IMyServiceContract>(); */

HostFactory.Run(x =>
{
x.Service<IMyServiceContract>(s =>
{
s.ConstructUsing(name => myServiceObject);
s.WhenStarted(sw => sw.Start());
s.WhenStopped(sw => sw.Stop());
s.WhenSessionChanged((csm, hc, chg) => csm.SessionChanged(chg)); /* THIS IS MAGIC LINE */
});

x.EnableSessionChanged(); /* THIS IS MAGIC LINE */

/* use command line variables for the below commented out properties */
/*
x.RunAsLocalService();
x.SetDescription("My Description");
x.SetDisplayName("My Display Name");
x.SetServiceName("My Service Name");
x.SetInstanceName("My Instance");
*/

x.StartManually(); // Start the service manually. This allows the identity to be tweaked before the service actually starts

/* the below map to the"Recover" tab on the properties of the Windows Service in Control Panel */
x.EnableServiceRecovery(r =>
{
r.OnCrashOnly();
r.RestartService(1); ////first
r.RestartService(1); ////second
r.RestartService(1); ////subsequents
r.SetResetPeriod(0);
});

x.DependsOnEventLog(); // Windows Event Log
x.UseLog4Net();

x.EnableShutdown();

x.OnException(ex =>
{
/* Log the exception */
/* not seen, I have a log4net logger here */
});
});

我的packages.config提供有关版本的提示：

1
2
3

注意：这不是答案，而是对Timothy Carter答案的(贡献)，因为到目前为止，我的声誉不允许我发表评论。

以防万一有人尝试了Timothy Carter的答案中的代码，并且没有立即在Windows服务中使它正常工作，则需要在的构造函数中将一个属性设置为true。服务。
只需在构造函数中添加以下行：

1	CanHandleSessionChangeEvent = true;

并确保在启动服务后不要设置此属性，否则将抛出InvalidOperationException。

在Windows Task Scheduler中，您可以创建触发on workstation lock和on workstation unlock的任务。每个任务都可以将标记和时间戳记写入文件，以表明工作站是被锁定还是未锁定以及它何时发生。

我意识到这不是编程方式。它比编写服务更简单。它不会丢失任何事件，因为在锁定/解锁转换时您的程序恰巧没有运行。

下面是100％工作代码，用于查找PC??是否已锁定。

在使用此名称之前，请使用名称空间System.Runtime.InteropServices。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

[DllImport("user32", EntryPoint ="OpenDesktopA", CharSet = CharSet.Ansi,SetLastError = true, ExactSpelling = true)]
private static extern Int32 OpenDesktop(string lpszDesktop, Int32 dwFlags, bool fInherit, Int32 dwDesiredAccess);

[DllImport("user32", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
private static extern Int32 CloseDesktop(Int32 hDesktop);

[DllImport("user32", CharSet = CharSet.Ansi,SetLastError = true,ExactSpelling = true)]
private static extern Int32 SwitchDesktop(Int32 hDesktop);

public static bool IsWorkstationLocked()
{
const int DESKTOP_SWITCHDESKTOP = 256;
int hwnd = -1;
int rtn = -1;

hwnd = OpenDesktop("Default", 0, false, DESKTOP_SWITCHDESKTOP);

if (hwnd != 0)
{
rtn = SwitchDesktop(hwnd);
if (rtn == 0)
{
// Locked
CloseDesktop(hwnd);
return true;
}
else
{
// Not locked
CloseDesktop(hwnd);
}
}
else
{
// Error:"Could not access the desktop..."
}

return false;
}