/// <inheritdoc />
public virtual void Dispose()
{
lock (ValueChangedHandlers)
{
ValueChangedHandlers.Clear();
ValueChangedTimer?.Dispose();
}
}
public void UnregisterValueChangedEventHandler(Func <byte[], bool> eventHandler)
{
lock (ValueChangedHandlers)
{
ValueChangedHandlers.Remove(eventHandler);
if (ValueChangedHandlers.Count == 0)
{
StopTimer();
LastValue = null;
}
}
}
public void RegisterValueChangedEventHandler(Func <byte[], bool> eventHandler,
int size,
int offset = 0,
int frequencyMs = 200)
{
lock (ValueChangedHandlers)
{
Frequency = Math.Min(frequencyMs,
Frequency);
if (ValueChangedTimer == null)
{
ValueChangedOffset = offset;
LastValue = Read(size,
ValueChangedOffset);
ValueChangedTimer = new Timer(CheckValueChanged,
null,
frequencyMs,
Timeout.Infinite);
}
ValueChangedHandlers.Add(eventHandler);
}
}
private void CheckValueChanged(object _)
{
ValueChangedMutex.WaitOne();
try
{
if (ValueChangedSuspended)
{
return;
}
byte[] newValue = null;
try
{
newValue = Read(LastValue.Length,
ValueChangedOffset);
}
catch (Win32Exception)
{
if (LastValue == null)
{
return;
}
}
if (newValue?.SequenceEqual(LastValue) == false)
{
var toRm = new List <Func <byte[], bool> >();
LastValue = newValue;
lock (ValueChangedHandlers)
foreach (var handler in ValueChangedHandlers)
{
try
{
if (handler(newValue))
{
toRm.Add(handler);
}
}
catch
{
// ignored
}
}
foreach (var handler in toRm)
{
UnregisterValueChangedEventHandler(handler);
}
}
if (Process.Native.HasExited)
{
lock (ValueChangedHandlers)
{
StopTimer();
ValueChangedHandlers.Clear();
}
}
else
{
RestartTimer();
}
}
finally
{
ValueChangedMutex.ReleaseMutex();
}
}
