<jco-blog/>

Software Development Project Notes

Category Archives: C#

Home / C#

48 Posts

(This is a C# LinqPad script)

Finds the SQL Command Variable definitions in a SQL script and parses their names and values.
Finds the SQL Command Variable references and parses their names.
Determines which references have no definitions.
Determines which definitions have no references.

The definition names and reference names are case insensitive.
A definition is in the form of :setvar name “value”
A reference is in the form of $(name)

void Main()
{
	//sql file path
	string file = @"C:\temp\my.sql";
	
	//Token definition pattern for :setvar name "value"
	string tokenDefPattern = @"(\:setvar [^""]* ""[^""]*"")";
	string tokenDefNamePattern = @"\:setvar ([^ ""]*)";
	string tokenDefValuePattern = @"""([^""]*)""";	
	
	//Token reference pattern for $(name)
	string tokenRefPattern = @"(\$\([^)]*\))";
	string tokenRefNamePattern = @"\$\(([^)]*)\)";
	
	string text = System.IO.File.ReadAllText(file);
	
	var tokenDefs = Token.GetAllFirstCapturedMatches(text,tokenDefPattern).Distinct().ToDictionary(x=>x,y=>new Token(y,tokenDefNamePattern,tokenDefValuePattern));
	var tokenRefs = Token.GetAllFirstCapturedMatches(text,tokenRefPattern).Distinct().ToDictionary(x=>x,y=>new Token(y,tokenRefNamePattern,null));
	
	tokenDefs.Select(x=>x.Value).OrderBy (x => x.Name).ToList().Dump("Token Definitions");
	tokenDefs.Where(x=> !tokenRefs.Any(y => y.Value.Name == x.Value.Name)).Select(x=>x.Value).OrderBy(x => x.Name).ToList().Dump("Token definitions without a reference");
	tokenRefs.Where(x=> !tokenDefs.Any(y => y.Value.Name == x.Value.Name)).Select(x=>x.Value).OrderBy(x => x.Name).ToList().Dump("Token references without a definition");
}

public class Token
{
	public Token(){}
	
	public Token(string Raw, string namePattern, string  valuePattern)
	{
		this.Raw = Raw;
		if(!string.IsNullOrWhiteSpace(namePattern)) Name = Token.GetFirstCapturedMatch(Raw,namePattern);
		if(!string.IsNullOrWhiteSpace(valuePattern)) Value = Token.GetFirstCapturedMatch(Raw,valuePattern);
	}

	public string Name {get;set;}
	public string Value {get;set;}
	public string Raw {get;set;}
	
	public static string GetFirstCapturedMatch(string value, string pattern)
	{
		var match = Regex.Match(value,pattern);
		if(match!=null && match.Success && match.Groups.Count>1)
		{
			return match.Groups[1].Value;
		}
		return null;
	}
	
	public static List<string> GetAllFirstCapturedMatches(string value, string pattern)
	{
		var list = new List<string>();
		var matches = Regex.Matches(value,pattern);
		foreach(Match match in matches)
		{
			if(match!=null && match.Success && match.Groups.Count>1) 
			{
				list.Add(match.Groups[1].Value);
			}
		}
		return list;
	}
}

void Main()

{

//sql file path

string file = @"C:\temp\my.sql";

//Token definition pattern for :setvar name "value"

string tokenDefPattern = @"(\:setvar [^""]* ""[^""]*"")";

string tokenDefNamePattern = @"\:setvar ([^ ""]*)";

string tokenDefValuePattern = @"""([^""]*)""";

//Token reference pattern for $(name)

string tokenRefPattern = @"(\$$[^)]*$)";

string tokenRefNamePattern = @"\$$([^)]*)$";

string text = System.IO.File.ReadAllText(file);

var tokenDefs = Token.GetAllFirstCapturedMatches(text,tokenDefPattern).Distinct().ToDictionary(x=>x,y=>new Token(y,tokenDefNamePattern,tokenDefValuePattern));

var tokenRefs = Token.GetAllFirstCapturedMatches(text,tokenRefPattern).Distinct().ToDictionary(x=>x,y=>new Token(y,tokenRefNamePattern,null));

tokenDefs.Select(x=>x.Value).OrderBy (x => x.Name).ToList().Dump("Token Definitions");

tokenDefs.Where(x=> !tokenRefs.Any(y => y.Value.Name == x.Value.Name)).Select(x=>x.Value).OrderBy(x => x.Name).ToList().Dump("Token definitions without a reference");

tokenRefs.Where(x=> !tokenDefs.Any(y => y.Value.Name == x.Value.Name)).Select(x=>x.Value).OrderBy(x => x.Name).ToList().Dump("Token references without a definition");

}

public class Token

{

public Token(){}

public Token(string Raw, string namePattern, string valuePattern)

{

this.Raw = Raw;

if(!string.IsNullOrWhiteSpace(namePattern)) Name = Token.GetFirstCapturedMatch(Raw,namePattern);

if(!string.IsNullOrWhiteSpace(valuePattern)) Value = Token.GetFirstCapturedMatch(Raw,valuePattern);

}

public string Name {get;set;}

public string Value {get;set;}

public string Raw {get;set;}

public static string GetFirstCapturedMatch(string value, string pattern)

{

var match = Regex.Match(value,pattern);

if(match!=null && match.Success && match.Groups.Count>1)

{

return match.Groups[1].Value;

}

return null;

}

public static List<string> GetAllFirstCapturedMatches(string value, string pattern)

{

var list = new List<string>();

var matches = Regex.Matches(value,pattern);

foreach(Match match in matches)

{

if(match!=null && match.Success && match.Groups.Count>1)

{

list.Add(match.Groups[1].Value);

}

return list;

}

It appears that the virtual machine manager in HyperV (VMM) reports the VM as running though the OS may not yet be fully loaded. We need to wait until the OS is responsive before continuing VM configuration. This observed behavior is more empirical than scientific and requires investigation, but a stop-gap solution is to wait until the VMM reports that the VM is running and then wait for the machine to respond to pings. This code does the second part.

using System.Net.NetworkInformation;

public class Test
{
	public static bool Ping(string name, int waitForPostivePingTimeout = 0) 
	{
		if(string.IsNullOrEmpty(name)) return false;
		if(waitForPostivePingTimeout < 0) waitForPostivePingTimeout = 0;
		var timeout = DateTime.Now.AddMilliseconds(waitForPostivePingTimeout);
		
		do
		{
			try
			{
				Ping p = new Ping();
				PingReply reply = p.Send(name, 2000);
				if(reply.Status == IPStatus.Success) return true;
			}
			catch{}
		} while(DateTime.Now < timeout);
		return false;
	}
}

using System.Net.NetworkInformation;

public class Test

{

public static bool Ping(string name, int waitForPostivePingTimeout = 0)

{

if(string.IsNullOrEmpty(name)) return false;

if(waitForPostivePingTimeout < 0) waitForPostivePingTimeout = 0;

var timeout = DateTime.Now.AddMilliseconds(waitForPostivePingTimeout);

{

try

{

Ping p = new Ping();

PingReply reply = p.Send(name, 2000);

if(reply.Status == IPStatus.Success) return true;

}

catch{}

} while(DateTime.Now < timeout);

return false;

}

originally posted 2015-3-2

1	originally posted 2015-3-2

Note that this doesn’t work so well with method name obfuscation!

using System.Reflection;
void Main()
{
  new Foo().DoSomething();
  Helper.GetOperationsAsString().Dump("Operations");
}

public class Foo
{
    public void DoSomething()
    {
        var mb = MethodBase.GetCurrentMethod();
        Helper.AppendOperation(mb, "something 1");
        DoSomethingElse();
        Helper.AppendOperation(mb, "something 2");
    }

    public void DoSomethingElse()
    {
        var mb = MethodBase.GetCurrentMethod();
        Helper.AppendOperation(mb, "something else 1");
    }
}

public static class Helper
{  
    public static List<string> Operations = new List<string>();

    public static string GetOperationsAsString()
    {
         return String.Join("\n", Operations.ToArray());
    }

    public static void AppendOperation(System.Reflection.MethodBase mb, string message = null, params object[] messageArgs)
    {
        if (mb != null)
        {
            string msg = string.Empty;
            if (!string.IsNullOrEmpty(message))
            {
                msg = " : " + string.Format(message, messageArgs);
            }
            Operations.Add(string.Format("{0}.{1}{2}", mb.DeclaringType.Name, mb.Name, msg));
        }
    }
}

using System.Reflection;

void Main()

{

new Foo().DoSomething();

Helper.GetOperationsAsString().Dump("Operations");

}

public class Foo

{

public void DoSomething()

{

var mb = MethodBase.GetCurrentMethod();

Helper.AppendOperation(mb, "something 1");

DoSomethingElse();

Helper.AppendOperation(mb, "something 2");

}

public void DoSomethingElse()

{

var mb = MethodBase.GetCurrentMethod();

Helper.AppendOperation(mb, "something else 1");

}

public static class Helper

{

public static List<string> Operations = new List<string>();

public static string GetOperationsAsString()

{

return String.Join("\n", Operations.ToArray());

}

public static void AppendOperation(System.Reflection.MethodBase mb, string message = null, params object[] messageArgs)

{

if (mb != null)

{

string msg = string.Empty;

if (!string.IsNullOrEmpty(message))

{

msg = " : " + string.Format(message, messageArgs);

}

Operations.Add(string.Format("{0}.{1}{2}", mb.DeclaringType.Name, mb.Name, msg));

}

Results
[Operations]
Foo.DoSomething : something 1
Foo.DoSomethingElse : something else 1
Foo.DoSomething : something 2

originally posted 2012-8-24

1	originally posted 2012-8-24

WCF throws System.ServiceModel.FaultExceptions (FE) between the client and server. The FE is a System.Exception so the client does not need to explicitly catch FaultException, but the FE is missing something. It does not take an InnerException in its constructor, so the server-side chain of exceptions and stack trace data are not available to the client. The typical response to this is “That’s the way it’s supposed to work!”, but if you own/control the consumers of your web service and you want the exception chain and stack trace data, then you’ll want to use FaultException.

The first thing is to decorate your service operations with the FaultContract attribute:

//service interface
public interface IService
{

 [OperationContract(IsOneWay = false)]
 [FaultContract(typeof(ExceptionDetail))]
 Foo GetFoo(Guid id);
}

//service interface

public interface IService

{

[OperationContract(IsOneWay = false)]

[FaultContract(typeof(ExceptionDetail))]

Foo GetFoo(Guid id);

}

By default, the service implementation will throw all unhandled exceptions back to the client as a regular FaultException. To avoid this, catch exceptions and re-throw them as FaultException as such…

//service implementation
public sealed partial class Service : IService
{
 Foo IService.GetFoo(Guid id)
        {
            try
            {
         
                return FooLib.GetFoo(id);
            }
            catch (Exception ex)
            {
                throw new FaultException<ExceptionDetail>(new ExceptionDetail(ex), ex.Message);
            }
        }
}

//service implementation

public sealed partial class Service : IService

{

Foo IService.GetFoo(Guid id)

{

try

{

return FooLib.GetFoo(id);

}

catch (Exception ex)

{

throw new FaultException<ExceptionDetail>(new ExceptionDetail(ex), ex.Message);

}

Great! All that detail is on its way to your client.

FaultException and FaultException<>; are derived from System.Exception, so when you don’t care about the detail, just catch Exception. When you want the detail, catch FaultException and inspect …

try
{
 ...
 ServiceReference.Foo foo = proxy.CreateFoo(fooId);

}
catch (FaultException<ExceptionDetail> fe)
{
 string message = fe.Message; //the equivalent of Exception.Message

 ExceptionDetail detail = fe.Detail; //the latest exception data
 string trace = detail.StackTrace; //stack info
 ExceptionDetail nextError = detail.InnerException; //exception chain

}
catch (Exception ex)
{
 ...
}

try

{

...

ServiceReference.Foo foo = proxy.CreateFoo(fooId);

}

catch (FaultException<ExceptionDetail> fe)

{

string message = fe.Message; //the equivalent of Exception.Message

ExceptionDetail detail = fe.Detail; //the latest exception data

string trace = detail.StackTrace; //stack info

ExceptionDetail nextError = detail.InnerException; //exception chain

}

catch (Exception ex)

{

...

}

An instance of ExceptionDetail stores a copy of the underlying Exception data as well as the Exception’s InnerException data, which is also converted to a ExceptionDetail, thus preserving the data of the Exception chain. This means that custom exception types thrown by the server cannot specifically be caught by the client. It also means that the client does not need to reference these exception types. However, the client can determine the type of exception thrown by the server…

The client wishes to detect the ABC.EmptyGuidException thrown by a library called by the service implementation.

//a library called by the service implementation
public static class FooLib
{
 public static GetFoo(Guid id)
 {
  if(Guid.Equals(Guid.Empty) throw new ABC.EmptyGuidException("No!")
  ...
 
 }
}
 
//the client 
try
{
 ...
 ServiceReference.Foo foo = proxy.CreateFoo(fooId);

}
catch (FaultException<ExceptionDetail> fe)
 {
 ExceptionDetail detail = fe.Detail;
 switch(detail.Type) //this is the type's FullName!
 {
  case "ABC.EmptyGuidException":
   //do something here
   break;
  ...
 }
}
catch (Exception ex)
{
 ...
}

//a library called by the service implementation

public static class FooLib

{

public static GetFoo(Guid id)

{

if(Guid.Equals(Guid.Empty) throw new ABC.EmptyGuidException("No!")

...

}

//the client

try

{

...

ServiceReference.Foo foo = proxy.CreateFoo(fooId);

}

catch (FaultException<ExceptionDetail> fe)

{

ExceptionDetail detail = fe.Detail;

switch(detail.Type) //this is the type's FullName!

{

case "ABC.EmptyGuidException":

//do something here

break;

...

}

catch (Exception ex)

{

...

}

Clunky, but attainable.

originally posted 2013-7-25

1	originally posted 2013-7-25

A Unix timestamp is defined as the number of seconds elapsed between January 1, 1970 00:00:00 and a given date/time expressed in Universal Coordinated Time.
A timestamp can be generated up to the date 2038-1-19 3:14:7 before overflowing a 32-bit integer.
http://en.wikipedia.org/wiki/Unix_time

--create a Unix timestamp from current server UTC time
create function [dbo].[fGetUnixTimestamp]()
returns int
as 
begin
   return datediff(s,'1970-1-1',sysutcdatetime());
end
go

--convert a Unix timestamp to a datetime in UTC
create function [dbo].[fConvertUnixTimestampToDateTime] (@timestamp int)
returns datetime
as
begin
   return dateadd(s,@timestamp,'1970-1-1')
end
go

--convert a Unix timestamp to a datetime adjusted to the server's time zone
create function [dbo].[fConvertUnixTimestampToLocalDateTime] (@timestamp int)
returns datetime
as
begin
   return dateadd(hh,datediff(hh,sysutcdatetime(),getdate()),dateadd(s,@timestamp,'1970-1-1'))
end
go

--[TEST]

declare @ts int
select @ts = [dbo].[fGetUnixTimestamp]()

select [Timestamp] = @ts
,[UTC Time] = [dbo].[fConvertUnixTimestampToDateTime](@ts)
,[Local Time] = [dbo].[fConvertUnixTimestampToLocalDateTime](@ts)
,[Local Time Zone Offset from UTC] = datediff(hh,sysutcdatetime(),getdate())

/*
[EXAMPLE RESULTS]
Timestamp Local Time = 1374776005   
UTC Time  = Jul 25 2013  6:13PM
Local Time = Jul 25 2013 11:13AM
Local Time Zone Offset from UTC = -7
*/

--create a Unix timestamp from current server UTC time

create function [dbo].[fGetUnixTimestamp]()

returns int

begin

return datediff(s,'1970-1-1',sysutcdatetime());

end

--convert a Unix timestamp to a datetime in UTC

create function [dbo].[fConvertUnixTimestampToDateTime] (@timestamp int)

returns datetime

begin

return dateadd(s,@timestamp,'1970-1-1')

end

--convert a Unix timestamp to a datetime adjusted to the server's time zone

create function [dbo].[fConvertUnixTimestampToLocalDateTime] (@timestamp int)

returns datetime

begin

return dateadd(hh,datediff(hh,sysutcdatetime(),getdate()),dateadd(s,@timestamp,'1970-1-1'))

end

--[TEST]

declare @ts int

select @ts = [dbo].[fGetUnixTimestamp]()

select [Timestamp] = @ts

,[UTC Time] = [dbo].[fConvertUnixTimestampToDateTime](@ts)

,[Local Time] = [dbo].[fConvertUnixTimestampToLocalDateTime](@ts)

,[Local Time Zone Offset from UTC] = datediff(hh,sysutcdatetime(),getdate())

[EXAMPLE RESULTS]

Timestamp Local Time = 1374776005

UTC Time = Jul 25 2013 6:13PM

Local Time = Jul 25 2013 11:13AM

Local Time Zone Offset from UTC = -7

An alternative, encoding a DateTime into a BigInt and back again.

create function [dbo].[fEncodeDateTimeToBigInt](@dt datetime)
returns bigint
as
begin
 --note: resolution is to the second
 if(@dt is not null)
  return convert(bigint,
   DATEPART(second, @dt) +
   DATEPART(minute, @dt) * 100 +
   DATEPART(hour, @dt) * 10000 +
   DATEPART(day, @dt) * 1000000 +
   DATEPART(month, @dt) * 100000000 +
   DATEPART(year, @dt) * 10000000000)
 return null;
end
go

create function [dbo].[fDecodeBigIntToDateTime](@bi bigint)
returns datetime
as
begin
 if(@bi is not null)
 begin
  declare @str nvarchar(30)
  set @str = convert(nvarchar(30),@bi)
     if(len(@str)=14) return convert(datetime,
  substring(@str,1,4) + '-' 
  + substring(@str,5,2) + '-' 
  + substring(@str,7,2) + ' ' 
  + substring(@str,9,2) + ':' 
  + substring(@str,11,2) + ':' 
  + substring(@str,13,2));
 end
 return null;
end

--TEST
declare @nowUtc datetime
set @nowUtc = sysutcdatetime();

declare @bi bigint
set @bi = [dbo].[fEncodeDateTimeToBigInt](@nowUtc);

declare @dt datetime 
set @dt = [dbo].[fDecodeBigIntToDateTime](@bi);

select [Input DateTime] = @nowUtc, [Encoded BigInt] = @bi, [Decoded DateTime] = @dt

/*
[Example Results]
Input DateTime = 2013-07-25 20:55:30.293
Encoded BigInt = 20130725205530 
Decoded DateTime = 2013-07-25 20:55:30.000
*/

create function [dbo].[fEncodeDateTimeToBigInt](@dt datetime)

returns bigint

begin

--note: resolution is to the second

if(@dt is not null)

return convert(bigint,

DATEPART(second, @dt) +

DATEPART(minute, @dt) * 100 +

DATEPART(hour, @dt) * 10000 +

DATEPART(day, @dt) * 1000000 +

DATEPART(month, @dt) * 100000000 +

DATEPART(year, @dt) * 10000000000)

return null;

end

create function [dbo].[fDecodeBigIntToDateTime](@bi bigint)

returns datetime

begin

if(@bi is not null)

begin

declare @str nvarchar(30)

set @str = convert(nvarchar(30),@bi)

if(len(@str)=14) return convert(datetime,

substring(@str,1,4) + '-'

+ substring(@str,5,2) + '-'

+ substring(@str,7,2) + ' '

+ substring(@str,9,2) + ':'

+ substring(@str,11,2) + ':'

+ substring(@str,13,2));

end

return null;

end

--TEST

declare @nowUtc datetime

set @nowUtc = sysutcdatetime();

declare @bi bigint

set @bi = [dbo].[fEncodeDateTimeToBigInt](@nowUtc);

declare @dt datetime

set @dt = [dbo].[fDecodeBigIntToDateTime](@bi);

select [Input DateTime] = @nowUtc, [Encoded BigInt] = @bi, [Decoded DateTime] = @dt

[Example Results]

Input DateTime = 2013-07-25 20:55:30.293

Encoded BigInt = 20130725205530

Decoded DateTime = 2013-07-25 20:55:30.000

originally posted 2013-8-29

1	originally posted 2013-8-29

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;

namespace NPT.Common
{
    /// &amp;lt;summary&amp;gt;
    /// Polls the system periodically and raises the IsIdle event if the
    /// user interface has been idle for at least the specfied number of seconds.
    /// Stops polling once the IsIdle is fired, use Start() to resume polling.
    /// &amp;lt;/summary&amp;gt;
    public class IdleTimer : IDisposable
    {
        [DllImport("user32.dll")]
        static extern bool GetLastInputInfo(ref LASTINPUTINFO plii);

        internal struct LASTINPUTINFO
        {
            public Int32 cbSize;
            public Int32 dwTime;
        }

        private int timeoutSeconds = 0;
        private int pollSeconds = 0;
        private System.Timers.Timer timer = null;
        private System.ComponentModel.ISynchronizeInvoke sychronizingObject = null;

        //ctor
        public IdleTimer(int idleTimeoutSeconds, System.ComponentModel.ISynchronizeInvoke sychronizingObject = null)
        {
            if (System.Diagnostics.Debugger.IsAttached) System.Diagnostics.Debug.WriteLine("IdleTimer: Created");
            pollSeconds = 5;
            if (idleTimeoutSeconds &amp;lt; 5) 
            {
                idleTimeoutSeconds = 5;
                pollSeconds = 4;
            }
            this.timeoutSeconds = idleTimeoutSeconds;
            this.sychronizingObject = sychronizingObject;

        public void Start()
        {
            System.Diagnostics.Debug.WriteLine("IdleTimer: Started");
            StartPolling();
        }

        public void Stop()
        {
            System.Diagnostics.Debug.WriteLine("IdleTimer: Stopped");
            StopPolling();
        }

        //event
        public delegate void IsIdleEventHandler(object sender, IdleTimerEventArgs e);
        public event IsIdleEventHandler IsIdle;
        protected virtual void OnIsIdle(IdleTimerEventArgs e)
        {
            //raise event
            StopPolling();
            if (IsIdle != null) IsIdle(this, e);
        }

        //start polling idle time
        private void StartPolling()
        {
            if (timer == null)
            {
                timer = new System.Timers.Timer(pollSeconds * 1000);
                timer.Elapsed += new System.Timers.ElapsedEventHandler(Poll);
                if (sychronizingObject != null) timer.SynchronizingObject = sychronizingObject;
            }
            timer.Start();
        }

        //stop polling idle time
        private void StopPolling()
        {
            if (timer != null) timer.Stop();
        }

        //poll idle time
        private void Poll(object sender, System.Timers.ElapsedEventArgs e)
        {
            StopPolling();
            int idleSeconds = GetIdleTime();
            if (idleSeconds &amp;gt;= timeoutSeconds)
            {
                if (System.Diagnostics.Debugger.IsAttached)
                {
                    System.Diagnostics.Debug.WriteLine("IdleTimer: Idle - Timeout = {1} seconds, Idle time = {0} seconds", idleSeconds, timeoutSeconds);
                }

                //system has been idle for at least timeoutSeconds seconds
                OnIsIdle(new IdleTimerEventArgs(idleSeconds:idleSeconds,timeoutSeconds:timeoutSeconds)); 
            }
            StartPolling();
        }

        /// &amp;lt;summary&amp;gt;
        /// Returns system idle time in seconds
        /// &amp;lt;/summary&amp;gt;
        /// &amp;lt;returns&amp;gt;&amp;lt;/returns&amp;gt;
        public int GetIdleTime()
        {
            int systemUptime = Environment.TickCount;
            int lastInputTicks = 0;
            int idleTicks = 0;

            LASTINPUTINFO lastInputInfo = new LASTINPUTINFO();
            lastInputInfo.cbSize = (Int32)Marshal.SizeOf(lastInputInfo);
            lastInputInfo.dwTime = 0;

            if (GetLastInputInfo(ref lastInputInfo))
            {
                lastInputTicks = (int)lastInputInfo.dwTime;
                idleTicks = systemUptime - lastInputTicks;
            }
            Int32 seconds = idleTicks / 1000;
            return seconds;
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                StopPolling();
                timer = null;
                sychronizingObject = null;
                if (System.Diagnostics.Debugger.IsAttached)
                {
                    System.Diagnostics.Debug.WriteLine("IdleTimer: Disposed");
                }
            }
        }
    }

    public class IdleTimerEventArgs : EventArgs
    {
        public IdleTimerEventArgs(int idleSeconds, int timeoutSeconds)
        {
            IdleSeconds = idleSeconds;
            TimeoutSeconds = timeoutSeconds;
        }

        public int IdleSeconds { get; set; }
        public int TimeoutSeconds {get; set;}
    }
}

using System;
using System.Text;
using System.Runtime.InteropServices;
using System.Security.Permissions;
using System.Threading;

//obsolete: [assembly: SecurityPermission(SecurityAction.RequestMinimum, UnmanagedCode = true)]
namespace System.Windows.Forms
{
    public class MessageBoxEx
    {
        public static DialogResult Show(string text, uint timeoutSeconds)
        {
            Setup("", timeoutSeconds);
            return MessageBox.Show(text);
        }

        public static DialogResult Show(string text, string caption, uint timeoutSeconds)
        {
            Setup(caption, timeoutSeconds);
            return MessageBox.Show(text, caption);
        }

        public static DialogResult Show(string text, string caption, MessageBoxButtons buttons, uint timeoutSeconds)
        {
            Setup(caption, timeoutSeconds);
            return MessageBox.Show(text, caption, buttons);
        }

        public static DialogResult Show(string text, string caption, MessageBoxButtons buttons, MessageBoxIcon icon, uint timeoutSeconds)
        {
            Setup(caption, timeoutSeconds);
            return MessageBox.Show(text, caption, buttons, icon);
        }

        public static DialogResult Show(string text, string caption, MessageBoxButtons buttons, MessageBoxIcon icon, MessageBoxDefaultButton defButton, uint timeoutSeconds)
        {
            Setup(caption, timeoutSeconds);
            return MessageBox.Show(text, caption, buttons, icon, defButton);
        }

        public static DialogResult Show(string text, string caption, MessageBoxButtons buttons, MessageBoxIcon icon, MessageBoxDefaultButton defButton, MessageBoxOptions options, uint timeoutSeconds)
        {
            Setup(caption, timeoutSeconds);
            return MessageBox.Show(text, caption, buttons, icon, defButton, options);
        }

        public static DialogResult Show(IWin32Window owner, string text, uint timeoutSeconds)
        {
            Setup("", timeoutSeconds);
            return MessageBox.Show(owner, text);
        }

        public static DialogResult Show(IWin32Window owner, string text, string caption, uint timeoutSeconds)
        {
            Setup(caption, timeoutSeconds);
            return MessageBox.Show(owner, text, caption);
        }

        public static DialogResult Show(IWin32Window owner, string text, string caption, MessageBoxButtons buttons, uint timeoutSeconds)
        {
            Setup(caption, timeoutSeconds);
            return MessageBox.Show(owner, text, caption, buttons);
        }

        public static DialogResult Show(IWin32Window owner, string text, string caption, MessageBoxButtons buttons, MessageBoxIcon icon, uint timeoutSeconds)
        {
            Setup(caption, timeoutSeconds);
            return MessageBox.Show(owner, text, caption, buttons, icon);
        }

        public static DialogResult Show(IWin32Window owner, string text, string caption, MessageBoxButtons buttons, MessageBoxIcon icon, MessageBoxDefaultButton defButton, uint timeoutSeconds)
        {
            Setup(caption, timeoutSeconds);
            return MessageBox.Show(owner, text, caption, buttons, icon, defButton);
        }

        public static DialogResult Show(IWin32Window owner, string text, string caption, MessageBoxButtons buttons, MessageBoxIcon icon, MessageBoxDefaultButton defButton, MessageBoxOptions options, uint timeoutSeconds)
        {
            Setup(caption, timeoutSeconds);
            return MessageBox.Show(owner, text, caption, buttons, icon, defButton, options);
        }

        public delegate IntPtr HookProc(int nCode, IntPtr wParam, IntPtr lParam);
        public delegate void TimerProc(IntPtr hWnd, uint uMsg, UIntPtr nIDEvent, uint dwTime);

        public const int WH_CALLWNDPROCRET = 12;
        public const int WM_DESTROY = 0x0002;
        public const int WM_INITDIALOG = 0x0110;
        public const int WM_TIMER = 0x0113;
        public const int WM_USER = 0x400;
        public const int DM_GETDEFID = WM_USER + 0;

        [DllImport("User32.dll")]
        public static extern UIntPtr SetTimer(IntPtr hWnd, UIntPtr nIDEvent, uint uElapse, TimerProc lpTimerFunc);

        [DllImport("User32.dll")]
        public static extern IntPtr SendMessage(IntPtr hWnd, int Msg, IntPtr wParam, IntPtr lParam);

        [DllImport("user32.dll")]
        public static extern IntPtr SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hInstance, int threadId);

        [DllImport("user32.dll")]
        public static extern int UnhookWindowsHookEx(IntPtr idHook);

        [DllImport("user32.dll")]
        public static extern IntPtr CallNextHookEx(IntPtr idHook, int nCode, IntPtr wParam, IntPtr lParam);

        [DllImport("user32.dll")]
        public static extern int GetWindowTextLength(IntPtr hWnd);

        [DllImport("user32.dll")]
        public static extern int GetWindowText(IntPtr hWnd, StringBuilder text, int maxLength);

        [DllImport("user32.dll")]
        public static extern int EndDialog(IntPtr hDlg, IntPtr nResult);

        [StructLayout(LayoutKind.Sequential)]
        public struct CWPRETSTRUCT
        {
            public IntPtr lResult;
            public IntPtr lParam;
            public IntPtr wParam;
            public uint message;
            public IntPtr hwnd;
        };

        private const int TimerID = 42;
        private static HookProc hookProc;
        private static TimerProc hookTimer;
        private static uint hooktimeoutSeconds;
        private static string hookCaption;
        private static IntPtr hHook;

        static MessageBoxEx()
        {
            hookProc = new HookProc(MessageBoxHookProc);
            hookTimer = new TimerProc(MessageBoxTimerProc);
            hooktimeoutSeconds = 0;
            hookCaption = null;
            hHook = IntPtr.Zero;
        }

        private static void Setup(string caption, uint timeoutSeconds)
        {
            if (hHook != IntPtr.Zero)
                throw new NotSupportedException("multiple calls are not supported");

            hooktimeoutSeconds = timeoutSeconds*1000;
            hookCaption = caption != null ? caption : "";

            //"AppDomain.GetCurrentThreadId()" is obsolete, however, its replacement "Thread.CurrentThread.ManagedThreadId" isn't correct this context.
            //See: http://stackoverflow.com/questions/772354/appdomain-getcurrentthreadid-vs-thread-managedthreadid-for-windows-api-calls
            #pragma warning disable 618 //disable the obsolete warning
            hHook = SetWindowsHookEx(WH_CALLWNDPROCRET, hookProc, IntPtr.Zero, AppDomain.GetCurrentThreadId()); //obsolete: 
            #pragma warning restore 618 //enable the obsolete warning
        }

        private static IntPtr MessageBoxHookProc(int nCode, IntPtr wParam, IntPtr lParam)
        {
            if (nCode &amp;lt; 0)
                return CallNextHookEx(hHook, nCode, wParam, lParam);

            CWPRETSTRUCT msg = (CWPRETSTRUCT)Marshal.PtrToStructure(lParam, typeof(CWPRETSTRUCT));
            IntPtr hook = hHook;

            if (hookCaption != null &amp;amp;&amp;amp; msg.message == WM_INITDIALOG)
            {
                int nLength = GetWindowTextLength(msg.hwnd);
                StringBuilder text = new StringBuilder(nLength + 1);

                GetWindowText(msg.hwnd, text, text.Capacity);

                if (hookCaption == text.ToString())
                {
                    hookCaption = null;
                    SetTimer(msg.hwnd, (UIntPtr)TimerID, hooktimeoutSeconds, hookTimer);
                    UnhookWindowsHookEx(hHook);
                    hHook = IntPtr.Zero;
                }
            }

            return CallNextHookEx(hook, nCode, wParam, lParam);
        }

        private static void MessageBoxTimerProc(IntPtr hWnd, uint uMsg, UIntPtr nIDEvent, uint dwTime)
        {
            if (nIDEvent == (UIntPtr)TimerID)
            {
                short dw = (short)SendMessage(hWnd, DM_GETDEFID, IntPtr.Zero, IntPtr.Zero);

                EndDialog(hWnd, (IntPtr)dw);
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using NPT.Common;

namespace WinFormsIdleTimerTest
{
    public partial class BaseForm : Form
    {
        private IdleTimer idleTimer = null;

        public BaseForm()
        {
            InitializeComponent();
        }

        protected int IdleTimeoutSeconds { get; set; }
        
        protected virtual void StartIdleTimer()
        {
            if (idleTimer == null)
            {
                StopIdleTimer();
                idleTimer = new IdleTimer(idleTimeoutSeconds: IdleTimeoutSeconds, sychronizingObject: this);
                idleTimer.IsIdle += new IdleTimer.IsIdleEventHandler(IdleTimer_IsIdle);
            }
            idleTimer.Start();
        }

        protected virtual void StopIdleTimer()
        {
            if (idleTimer != null) idleTimer.Stop();
        }

        protected virtual void IdleTimer_IsIdle(object sender, IdleTimerEventArgs e)
        {
            //handle IsIdle event, close the form (override in inherting classes to do something different)
            Close();
        }

        public new void Close()
        {
            StopIdleTimer();
            base.Close();
        }

        public new void Hide()
        {
            StopIdleTimer();
            base.Hide();
        }
    }
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using NPT.Common;

namespace WinFormsIdleTimerTest
{
    public partial class MainForm : BaseForm
    {
        public MainForm()
        {
            InitializeComponent();
            IdleTimeoutSeconds = 5;
            StartIdleTimer();
        }

        private void CancelButton_Click(object sender, EventArgs e)
        {
            Close();
        }

        protected override void IdleTimer_IsIdle(object sender, IdleTimerEventArgs e)
        {
            //an optional override of the BaseForm implementation to do something more than just closing the form
            //MessageBoxEx is an implementation of MessageBox that dismisses itself after a specified number of seconds
            var response = MessageBoxEx.Show(
                    "Is there anybody out there?",
                    string.Format("System Idle Detected ({0} seconds)", e.IdleSeconds),
                    MessageBoxButtons.YesNo,
                    MessageBoxIcon.Question,
                    MessageBoxDefaultButton.Button2,
                    10);
            if (response == System.Windows.Forms.DialogResult.No)
            {

                MessageBoxEx.Show(
                    "\tGoodbye blue sky.",
                    string.Empty,
                    MessageBoxButtons.OK,
                    MessageBoxIcon.None,
                    MessageBoxDefaultButton.Button1,
                    3);

                Close();
                return;
            }
            StartIdleTimer();
        }
    }
}

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

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Runtime.InteropServices;

namespace NPT.Common

{

/// &lt;summary&gt;

/// Polls the system periodically and raises the IsIdle event if the

/// user interface has been idle for at least the specfied number of seconds.

/// Stops polling once the IsIdle is fired, use Start() to resume polling.

/// &lt;/summary&gt;

public class IdleTimer : IDisposable

{

[DllImport("user32.dll")]

static extern bool GetLastInputInfo(ref LASTINPUTINFO plii);

internal struct LASTINPUTINFO

{

public Int32 cbSize;

public Int32 dwTime;

}

private int timeoutSeconds = 0;

private int pollSeconds = 0;

private System.Timers.Timer timer = null;

private System.ComponentModel.ISynchronizeInvoke sychronizingObject = null;

//ctor

public IdleTimer(int idleTimeoutSeconds, System.ComponentModel.ISynchronizeInvoke sychronizingObject = null)

{

if (System.Diagnostics.Debugger.IsAttached) System.Diagnostics.Debug.WriteLine("IdleTimer: Created");

pollSeconds = 5;

if (idleTimeoutSeconds &lt; 5)

{

idleTimeoutSeconds = 5;

pollSeconds = 4;

}

this.timeoutSeconds = idleTimeoutSeconds;

this.sychronizingObject = sychronizingObject;

public void Start()

{

System.Diagnostics.Debug.WriteLine("IdleTimer: Started");

StartPolling();

}

public void Stop()

{

System.Diagnostics.Debug.WriteLine("IdleTimer: Stopped");

StopPolling();

}

//event

public delegate void IsIdleEventHandler(object sender, IdleTimerEventArgs e);

public event IsIdleEventHandler IsIdle;

protected virtual void OnIsIdle(IdleTimerEventArgs e)

{

//raise event

StopPolling();

if (IsIdle != null) IsIdle(this, e);

}

//start polling idle time

private void StartPolling()

{

if (timer == null)

{

timer = new System.Timers.Timer(pollSeconds * 1000);

timer.Elapsed += new System.Timers.ElapsedEventHandler(Poll);

if (sychronizingObject != null) timer.SynchronizingObject = sychronizingObject;

}

timer.Start();

}

//stop polling idle time

private void StopPolling()

{

if (timer != null) timer.Stop();

}

//poll idle time

private void Poll(object sender, System.Timers.ElapsedEventArgs e)

{

StopPolling();

int idleSeconds = GetIdleTime();

if (idleSeconds &gt;= timeoutSeconds)

{

if (System.Diagnostics.Debugger.IsAttached)

{

System.Diagnostics.Debug.WriteLine("IdleTimer: Idle - Timeout = {1} seconds, Idle time = {0} seconds", idleSeconds, timeoutSeconds);

}

//system has been idle for at least timeoutSeconds seconds

OnIsIdle(new IdleTimerEventArgs(idleSeconds:idleSeconds,timeoutSeconds:timeoutSeconds));

}

StartPolling();

}

/// &lt;summary&gt;

/// Returns system idle time in seconds

/// &lt;/summary&gt;

/// &lt;returns&gt;&lt;/returns&gt;

public int GetIdleTime()

{

int systemUptime = Environment.TickCount;

int lastInputTicks = 0;

int idleTicks = 0;

LASTINPUTINFO lastInputInfo = new LASTINPUTINFO();

lastInputInfo.cbSize = (Int32)Marshal.SizeOf(lastInputInfo);

lastInputInfo.dwTime = 0;

if (GetLastInputInfo(ref lastInputInfo))

{

lastInputTicks = (int)lastInputInfo.dwTime;

idleTicks = systemUptime - lastInputTicks;

}

Int32 seconds = idleTicks / 1000;

return seconds;

}

public void Dispose()

{

Dispose(true);

GC.SuppressFinalize(this);

}

protected virtual void Dispose(bool disposing)

{

if (disposing)

{

StopPolling();

timer = null;

sychronizingObject = null;

if (System.Diagnostics.Debugger.IsAttached)

{

System.Diagnostics.Debug.WriteLine("IdleTimer: Disposed");

}

public class IdleTimerEventArgs : EventArgs

{

public IdleTimerEventArgs(int idleSeconds, int timeoutSeconds)

{

IdleSeconds = idleSeconds;

TimeoutSeconds = timeoutSeconds;

}

public int IdleSeconds { get; set; }

public int TimeoutSeconds {get; set;}

}

using System;

using System.Text;

using System.Runtime.InteropServices;

using System.Security.Permissions;

using System.Threading;

//obsolete: [assembly: SecurityPermission(SecurityAction.RequestMinimum, UnmanagedCode = true)]

namespace System.Windows.Forms

{

public class MessageBoxEx

{

public static DialogResult Show(string text, uint timeoutSeconds)

{

Setup("", timeoutSeconds);

return MessageBox.Show(text);

}

public static DialogResult Show(string text, string caption, uint timeoutSeconds)

{

Setup(caption, timeoutSeconds);

return MessageBox.Show(text, caption);

}

public static DialogResult Show(string text, string caption, MessageBoxButtons buttons, uint timeoutSeconds)

{

Setup(caption, timeoutSeconds);

return MessageBox.Show(text, caption, buttons);

}

public static DialogResult Show(string text, string caption, MessageBoxButtons buttons, MessageBoxIcon icon, uint timeoutSeconds)

{

Setup(caption, timeoutSeconds);

return MessageBox.Show(text, caption, buttons, icon);

}

public static DialogResult Show(string text, string caption, MessageBoxButtons buttons, MessageBoxIcon icon, MessageBoxDefaultButton defButton, uint timeoutSeconds)

{

Setup(caption, timeoutSeconds);

return MessageBox.Show(text, caption, buttons, icon, defButton);

}

public static DialogResult Show(string text, string caption, MessageBoxButtons buttons, MessageBoxIcon icon, MessageBoxDefaultButton defButton, MessageBoxOptions options, uint timeoutSeconds)

{

Setup(caption, timeoutSeconds);

return MessageBox.Show(text, caption, buttons, icon, defButton, options);

}

public static DialogResult Show(IWin32Window owner, string text, uint timeoutSeconds)

{

Setup("", timeoutSeconds);

return MessageBox.Show(owner, text);

}

public static DialogResult Show(IWin32Window owner, string text, string caption, uint timeoutSeconds)

{

Setup(caption, timeoutSeconds);

return MessageBox.Show(owner, text, caption);

}

public static DialogResult Show(IWin32Window owner, string text, string caption, MessageBoxButtons buttons, uint timeoutSeconds)

{

Setup(caption, timeoutSeconds);

return MessageBox.Show(owner, text, caption, buttons);

}

public static DialogResult Show(IWin32Window owner, string text, string caption, MessageBoxButtons buttons, MessageBoxIcon icon, uint timeoutSeconds)

{

Setup(caption, timeoutSeconds);

return MessageBox.Show(owner, text, caption, buttons, icon);

}

public static DialogResult Show(IWin32Window owner, string text, string caption, MessageBoxButtons buttons, MessageBoxIcon icon, MessageBoxDefaultButton defButton, uint timeoutSeconds)

{

Setup(caption, timeoutSeconds);

return MessageBox.Show(owner, text, caption, buttons, icon, defButton);

}

public static DialogResult Show(IWin32Window owner, string text, string caption, MessageBoxButtons buttons, MessageBoxIcon icon, MessageBoxDefaultButton defButton, MessageBoxOptions options, uint timeoutSeconds)

{

Setup(caption, timeoutSeconds);

return MessageBox.Show(owner, text, caption, buttons, icon, defButton, options);

}

public delegate IntPtr HookProc(int nCode, IntPtr wParam, IntPtr lParam);

public delegate void TimerProc(IntPtr hWnd, uint uMsg, UIntPtr nIDEvent, uint dwTime);

public const int WH_CALLWNDPROCRET = 12;

public const int WM_DESTROY = 0x0002;

public const int WM_INITDIALOG = 0x0110;

public const int WM_TIMER = 0x0113;

public const int WM_USER = 0x400;

public const int DM_GETDEFID = WM_USER + 0;

[DllImport("User32.dll")]

public static extern UIntPtr SetTimer(IntPtr hWnd, UIntPtr nIDEvent, uint uElapse, TimerProc lpTimerFunc);

[DllImport("User32.dll")]

public static extern IntPtr SendMessage(IntPtr hWnd, int Msg, IntPtr wParam, IntPtr lParam);

[DllImport("user32.dll")]

public static extern IntPtr SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hInstance, int threadId);

[DllImport("user32.dll")]

public static extern int UnhookWindowsHookEx(IntPtr idHook);

[DllImport("user32.dll")]

public static extern IntPtr CallNextHookEx(IntPtr idHook, int nCode, IntPtr wParam, IntPtr lParam);

[DllImport("user32.dll")]

public static extern int GetWindowTextLength(IntPtr hWnd);

[DllImport("user32.dll")]

public static extern int GetWindowText(IntPtr hWnd, StringBuilder text, int maxLength);

[DllImport("user32.dll")]

public static extern int EndDialog(IntPtr hDlg, IntPtr nResult);

[StructLayout(LayoutKind.Sequential)]

public struct CWPRETSTRUCT

{

public IntPtr lResult;

public IntPtr lParam;

public IntPtr wParam;

public uint message;

public IntPtr hwnd;

};

private const int TimerID = 42;

private static HookProc hookProc;

private static TimerProc hookTimer;

private static uint hooktimeoutSeconds;

private static string hookCaption;

private static IntPtr hHook;

static MessageBoxEx()

{

hookProc = new HookProc(MessageBoxHookProc);

hookTimer = new TimerProc(MessageBoxTimerProc);

hooktimeoutSeconds = 0;

hookCaption = null;

hHook = IntPtr.Zero;

}

private static void Setup(string caption, uint timeoutSeconds)

{

if (hHook != IntPtr.Zero)

throw new NotSupportedException("multiple calls are not supported");

hooktimeoutSeconds = timeoutSeconds*1000;

hookCaption = caption != null ? caption : "";

//"AppDomain.GetCurrentThreadId()" is obsolete, however, its replacement "Thread.CurrentThread.ManagedThreadId" isn't correct this context.

//See: http://stackoverflow.com/questions/772354/appdomain-getcurrentthreadid-vs-thread-managedthreadid-for-windows-api-calls

#pragma warning disable 618 //disable the obsolete warning

hHook = SetWindowsHookEx(WH_CALLWNDPROCRET, hookProc, IntPtr.Zero, AppDomain.GetCurrentThreadId()); //obsolete:

#pragma warning restore 618 //enable the obsolete warning

}

private static IntPtr MessageBoxHookProc(int nCode, IntPtr wParam, IntPtr lParam)

{

if (nCode &lt; 0)

return CallNextHookEx(hHook, nCode, wParam, lParam);

CWPRETSTRUCT msg = (CWPRETSTRUCT)Marshal.PtrToStructure(lParam, typeof(CWPRETSTRUCT));

IntPtr hook = hHook;

if (hookCaption != null &amp;&amp; msg.message == WM_INITDIALOG)

{

int nLength = GetWindowTextLength(msg.hwnd);

StringBuilder text = new StringBuilder(nLength + 1);

GetWindowText(msg.hwnd, text, text.Capacity);

if (hookCaption == text.ToString())

{

hookCaption = null;

SetTimer(msg.hwnd, (UIntPtr)TimerID, hooktimeoutSeconds, hookTimer);

UnhookWindowsHookEx(hHook);

hHook = IntPtr.Zero;

}

return CallNextHookEx(hook, nCode, wParam, lParam);

}

private static void MessageBoxTimerProc(IntPtr hWnd, uint uMsg, UIntPtr nIDEvent, uint dwTime)

{

if (nIDEvent == (UIntPtr)TimerID)

{

short dw = (short)SendMessage(hWnd, DM_GETDEFID, IntPtr.Zero, IntPtr.Zero);

EndDialog(hWnd, (IntPtr)dw);

}

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Forms;

using NPT.Common;

namespace WinFormsIdleTimerTest

{

public partial class BaseForm : Form

{

private IdleTimer idleTimer = null;

public BaseForm()

{

InitializeComponent();

}

protected int IdleTimeoutSeconds { get; set; }

protected virtual void StartIdleTimer()

{

if (idleTimer == null)

{

StopIdleTimer();

idleTimer = new IdleTimer(idleTimeoutSeconds: IdleTimeoutSeconds, sychronizingObject: this);

idleTimer.IsIdle += new IdleTimer.IsIdleEventHandler(IdleTimer_IsIdle);

}

idleTimer.Start();

}

protected virtual void StopIdleTimer()

{

if (idleTimer != null) idleTimer.Stop();

}

protected virtual void IdleTimer_IsIdle(object sender, IdleTimerEventArgs e)

{

//handle IsIdle event, close the form (override in inherting classes to do something different)

Close();

}

public new void Close()

{

StopIdleTimer();

base.Close();

}

public new void Hide()

{

StopIdleTimer();

base.Hide();

}

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Forms;

using NPT.Common;

namespace WinFormsIdleTimerTest

{

public partial class MainForm : BaseForm

{

public MainForm()

{

InitializeComponent();

IdleTimeoutSeconds = 5;

StartIdleTimer();

}

private void CancelButton_Click(object sender, EventArgs e)

{

Close();

}

protected override void IdleTimer_IsIdle(object sender, IdleTimerEventArgs e)

{

//an optional override of the BaseForm implementation to do something more than just closing the form

//MessageBoxEx is an implementation of MessageBox that dismisses itself after a specified number of seconds

var response = MessageBoxEx.Show(

"Is there anybody out there?",

string.Format("System Idle Detected ({0} seconds)", e.IdleSeconds),

MessageBoxButtons.YesNo,

MessageBoxIcon.Question,

MessageBoxDefaultButton.Button2,

10);

if (response == System.Windows.Forms.DialogResult.No)

{

MessageBoxEx.Show(

"\tGoodbye blue sky.",

string.Empty,

MessageBoxButtons.OK,

MessageBoxIcon.None,

MessageBoxDefaultButton.Button1,

3);

Close();

return;

}

StartIdleTimer();

}

originally posted 2014-08-06

1	originally posted 2014-08-06

Generates a unique namespace that conforms to DNS name format from the input.

Releated: Validate Format of a Domain Name post

Input formats:

If email address, the host part is used.

If URI, the primary domain name is used.

If neither of the above formats then uses the input as is.

Looks in the [Subscription] table of the specified database table for the [Namespace] column to determine uniqueness.

//LinqPad Query, Language = "C# Program"
void Main()
{
  string value = "justin@elementalp.com";
  GenerateNamespace(value).Dump(value + " becomes...");
  
  value = "The ABC Company!";
  GenerateNamespace(value).Dump(value + " becomes...");
  
  value = "Foo";
  GenerateNamespace(value).Dump(value + " becomes...");	
}

/// &amp;lt;summary&amp;gt;
/// Uses an input value as the basis for generating a unique namespace
/// If the formatted input name is already in use, a number will be appended to it until a unique namespace results.
/// Input value defaults to "ORG"
/// Output is made to confirm to DNS name requirements.
/// Examines the SQL object "[npt_cloud].[dbo].[Subscription].[Namespace]" to check for uniqueness.
/// &amp;lt;/summary&amp;gt;
public string GenerateNamespace(string value)
{

  //string value = "https://this.that.these.those.elementalp.com";
  //string value = "----= The-ElementalP-Company =----";
  string result = null;
  
  const string sql =
  @"declare @pattern nvarchar(100) = '%[^0-9A-Za-z\-]%' --filter chars that are not alpha, numerics, or dashes
  declare @defaultName nvarchar(100) = 'ORG'; --the default namespace name
  declare @try nvarchar(100) = null

  	if(@ns is null or len(@ns)=0) goto thenext;

  --remove characters not in the pattern
  while patindex(@pattern, @ns) &amp;gt; 0 set @ns = stuff(@ns, patindex(@pattern, @ns), 1, '');
  set @ns = ltrim(rtrim(@ns));
  if(@ns is null or len(@ns)=0) goto thenext;
  
  --remove leading dashes
  while (patindex('-%', @ns) = 1) set @ns = substring(@ns,2,len(@ns));
  
  --remove trailing dashes
  while (patindex('%-', @ns) = len(@ns)) set @ns = substring(@ns,1,len(@ns)-1);
  
  --shorten to 63 chars, make upper case, and trim                   
  set @ns = ltrim(rtrim(upper(substring(@ns,1,63))));
    
  thenext:
  
  --default empty namespace
  if(@ns is null or len(@ns)=0) set @ns = @defaultName  --goto theend;
    
  set @try = @ns
  
  declare @num int = 0;
  while (1=1)
  begin
    if exists (select [Namespace] from [dbo].[Subscription] where [Namespace] like @try)
    begin
      set @num = @num + 1;
      set @try = @ns + convert(nvarchar(10),@num)
    end
  else break;
  
  end
  theend:
  select [Namespace] = @try;";

  System.Diagnostics.Debug.WriteLine(string.Format("Input: {0}",  value!=null ? string.Format("\"{0}\"",value) : "null"));
    
  //parse host name from namespace
  if(!string.IsNullOrWhiteSpace(value))value = ParseNamespace(value);
  
  if(value==null) value = string.Empty;

  using (var connection = new SqlConnection("Data Source=.;Initial Catalog=npt_cloud;Application Name=npt;Integrated Security=true;"))
  {
    connection.Open();
    using (var command = new SqlCommand(sql, connection))
    {
      var param = new SqlParameter("@ns", System.Data.SqlDbType.NVarChar);
      param.Value = value;
      command.Parameters.Add(param);
    
      result = command.ExecuteScalar() as string;
      connection.Close();
      return result;
    }
  }
}

/// &amp;lt;summary&amp;gt;
/// Parses a namespace from input value.
/// If the input value is an email address, the output will be the host name.
/// If the input value is a URL, the output is the primary domain name.
/// If the input value is not one of the above formats, the input text before the first period (if any) is returned.
/// &amp;lt;/summary&amp;gt;
public static string ParseNamespace(string text)
{
  string ns = null;
  try
  {
      //try get domain as email address
      var addr = new MailAddress(text);
      ns = addr.Host;
  }
  catch (System.FormatException ex1)
  {
      try
      {
          //try get domain as uri
          var uri = new Uri(text);
          string[] hostParts = uri.Host.Split(new string[1] { "." }, StringSplitOptions.RemoveEmptyEntries);
          ns = hostParts[hostParts.Length-2];
      }
      catch (System.UriFormatException ex2)
      {
          //use id as the domain
          ns = text;
      }
  }

  if (ns != null) ns = ns.Split(new char[] { '.' }, 2)[0];
  
  return ns;
}

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

//LinqPad Query, Language = "C# Program"

void Main()

{

string value = "justin@elementalp.com";

GenerateNamespace(value).Dump(value + " becomes...");

value = "The ABC Company!";

GenerateNamespace(value).Dump(value + " becomes...");

value = "Foo";

GenerateNamespace(value).Dump(value + " becomes...");

}

/// &lt;summary&gt;

/// Uses an input value as the basis for generating a unique namespace

/// If the formatted input name is already in use, a number will be appended to it until a unique namespace results.

/// Input value defaults to "ORG"

/// Output is made to confirm to DNS name requirements.

/// Examines the SQL object "[npt_cloud].[dbo].[Subscription].[Namespace]" to check for uniqueness.

/// &lt;/summary&gt;

public string GenerateNamespace(string value)

{

//string value = "https://this.that.these.those.elementalp.com";

//string value = "----= The-ElementalP-Company =----";

string result = null;

const string sql =

@"declare @pattern nvarchar(100) = '%[^0-9A-Za-z\-]%' --filter chars that are not alpha, numerics, or dashes

declare @defaultName nvarchar(100) = 'ORG'; --the default namespace name

declare @try nvarchar(100) = null

if(@ns is null or len(@ns)=0) goto thenext;

--remove characters not in the pattern

while patindex(@pattern, @ns) &gt; 0 set @ns = stuff(@ns, patindex(@pattern, @ns), 1, '');

set @ns = ltrim(rtrim(@ns));

if(@ns is null or len(@ns)=0) goto thenext;

--remove leading dashes

while (patindex('-%', @ns) = 1) set @ns = substring(@ns,2,len(@ns));

--remove trailing dashes

while (patindex('%-', @ns) = len(@ns)) set @ns = substring(@ns,1,len(@ns)-1);

--shorten to 63 chars, make upper case, and trim

set @ns = ltrim(rtrim(upper(substring(@ns,1,63))));

thenext:

--default empty namespace

if(@ns is null or len(@ns)=0) set @ns = @defaultName --goto theend;

set @try = @ns

declare @num int = 0;

while (1=1)

begin

if exists (select [Namespace] from [dbo].[Subscription] where [Namespace] like @try)

begin

set @num = @num + 1;

set @try = @ns + convert(nvarchar(10),@num)

end

else break;

end

theend:

select [Namespace] = @try;";

System.Diagnostics.Debug.WriteLine(string.Format("Input: {0}", value!=null ? string.Format("\"{0}\"",value) : "null"));

//parse host name from namespace

if(!string.IsNullOrWhiteSpace(value))value = ParseNamespace(value);

if(value==null) value = string.Empty;

using (var connection = new SqlConnection("Data Source=.;Initial Catalog=npt_cloud;Application Name=npt;Integrated Security=true;"))

{

connection.Open();

using (var command = new SqlCommand(sql, connection))

{

var param = new SqlParameter("@ns", System.Data.SqlDbType.NVarChar);

param.Value = value;

command.Parameters.Add(param);

result = command.ExecuteScalar() as string;

connection.Close();

return result;

}

/// &lt;summary&gt;

/// Parses a namespace from input value.

/// If the input value is an email address, the output will be the host name.

/// If the input value is a URL, the output is the primary domain name.

/// If the input value is not one of the above formats, the input text before the first period (if any) is returned.

/// &lt;/summary&gt;

public static string ParseNamespace(string text)

{

string ns = null;

try

{

//try get domain as email address

var addr = new MailAddress(text);

ns = addr.Host;

}

catch (System.FormatException ex1)

{

try

{

//try get domain as uri

var uri = new Uri(text);

string[] hostParts = uri.Host.Split(new string[1] { "." }, StringSplitOptions.RemoveEmptyEntries);

ns = hostParts[hostParts.Length-2];

}

catch (System.UriFormatException ex2)

{

//use id as the domain

ns = text;

}

if (ns != null) ns = ns.Split(new char[] { '.' }, 2)[0];

return ns;

}

originally posted 2015-01-06

1	originally posted 2015-01-06

select 
[Product] = convert(nvarchar(25),
  case when [Version] like '12.%' then 'SQL Server 2014'
  when [Version] like '11.%' then 'SQL Server 2012'
  when [Version] like '10.50%' then 'SQL Server 2008 R2'
  when [Version] like '10.%' then 'SQL Server 2008'
  when [Version] like '9.%' then 'SQL Server 2005'
  when [Version] like '8.%' then 'SQL Server 2000'
  else 'Unknown'
  end)
,[Version]
,[VersionMajor] = convert(int, left([Version], charindex('.', [Version], 0)-1))
,[VersionInfo] = @@version
,[Level]
,[Edition]
,[BackupCompression] = convert(bit,
  case when [Version] like '12.%' and ([Edition] like '%enterprise%' or [Edition] like '%intelligence%' or [Edition] like '%standard%') then 1 --2014
  when [Version] like '11.%' and ([Edition] like '%enterprise%' or [Edition] like '%intelligence%' or [Edition] like '%standard%') then 1 --2012
  when [Version] like '10.%' and [Edition] like '%enterprise%' then 1 --2008
  else 0
  end)
from 
(
  select 
  [Version] = convert(sysname,serverproperty('ProductVersion'))
  ,[Level] = convert(sysname,serverproperty ('productlevel'))
  ,[Edition] =  convert(sysname,serverproperty ('edition'))
) as v

select

[Product] = convert(nvarchar(25),

case when [Version] like '12.%' then 'SQL Server 2014'

when [Version] like '11.%' then 'SQL Server 2012'

when [Version] like '10.50%' then 'SQL Server 2008 R2'

when [Version] like '10.%' then 'SQL Server 2008'

when [Version] like '9.%' then 'SQL Server 2005'

when [Version] like '8.%' then 'SQL Server 2000'

else 'Unknown'

end)

,[Version]

,[VersionMajor] = convert(int, left([Version], charindex('.', [Version], 0)-1))

,[VersionInfo] = @@version

,[Level]

,[Edition]

,[BackupCompression] = convert(bit,

case when [Version] like '12.%' and ([Edition] like '%enterprise%' or [Edition] like '%intelligence%' or [Edition] like '%standard%') then 1 --2014

when [Version] like '11.%' and ([Edition] like '%enterprise%' or [Edition] like '%intelligence%' or [Edition] like '%standard%') then 1 --2012

when [Version] like '10.%' and [Edition] like '%enterprise%' then 1 --2008

else 0

end)

from

(

select

[Version] = convert(sysname,serverproperty('ProductVersion'))

,[Level] = convert(sysname,serverproperty ('productlevel'))

,[Edition] = convert(sysname,serverproperty ('edition'))

) as v

originally posted 2015-02-05

1	originally posted 2015-02-05

//determines if a path is a UNC path
[DllImport("shlwapi.dll", CharSet = CharSet.Unicode)]
[ResourceExposure(ResourceScope.None)]
[return: MarshalAsAttribute(UnmanagedType.Bool)]
public static extern bool PathIsUNC(
[MarshalAsAttribute(UnmanagedType.LPWStr), In] string pszPath);

//determines if a path is a UNC path

[DllImport("shlwapi.dll", CharSet = CharSet.Unicode)]

[ResourceExposure(ResourceScope.None)]

[return: MarshalAsAttribute(UnmanagedType.Bool)]

public static extern bool PathIsUNC(

[MarshalAsAttribute(UnmanagedType.LPWStr), In] string pszPath);

originally posted 2015-02-05

1	originally posted 2015-02-05

We have a ClickOnce application for which we are merging and/or embedding all of our dependency assemblies into a single assembly and obfuscating with Red Gate’s SmartAssembly. ClickOnce doesn’t know about the merging and embedding, so it includes the non-obfuscated individual assembly files when it publishes. It turns out that it’s easy to exclude these files from the deployment at publish-time from Visual Studio.

From Project properties …
Publish tab …
Application Files button …
Select “Exclude” for the Publish Status of the desired files …
Save project …
Publish.

To do this to an already-published ClickOnce application requires more work. Here’s a LINQPad script example to programmatically find a file, remove it and re-sign the appropriate files.

/*
Written with LINQPad 
Programmatically remove files from a published ClickOnce application
using System.Diagnostics;
using System.IO;
using System.Xml;
*/

string sourceDir = @"C:\published\my_app_1_0_0_135\";
string manifestFilePath = sourceDir + @"\my_app.exe.manifest";
string applicationManifestFilePath = sourceDir + @"\my_app.application";
string mageFilePath = @"C:\Program Files (x86)\Microsoft SDKs\Windows\v8.1A\bin\NETFX 4.5.1 Tools\mage.exe";
string certFilePath = @"C:\certificates\MyAuthenticodeCertificate.pfx";
string certPassword = "foo";

//load .manifest XML
var doc = XDocument.Load(manifestFilePath);

//rename the files w/o the .deploy extension
string[] filePaths = Directory.GetFiles(sourceDir,"*.deploy");
foreach(string filePath in filePaths)
{
  string realName = filePath.Replace(".deploy",string.Empty);
  File.Move(filePath,realName);
  File.Delete(filePath);
}

//locate and remove the desired entry (e.g. the "MyComponentToRemove.dll" of dependency type of "install")
XNamespace ns = "urn:schemas-microsoft-com:asm.v2";
doc.Descendants(ns + "dependentAssembly")
   .Where(x =&amp;gt; (string)x.Attribute("dependencyType") == "install")
   .Where(x=&amp;gt; ((string)x.Attribute("codebase")).Equals("MyComponentToRemove.dll"))
   .Select(x =&amp;gt; x.Parent)
   .Remove();
 
//save .manifest XML
doc.Save(manifestFilePath);
 
//re-sign .manifest
Process process = new System.Diagnostics.Process();
System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo();
startInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
startInfo.FileName = mageFilePath;
startInfo.Arguments = string.Format("-update \"{0}\" -cf \"{1}\" -pwd \"{2}\"",manifestFilePath,certFilePath,certPassword);
process.StartInfo = startInfo;
process.Start();

//re-sign .application
process = new System.Diagnostics.Process();
startInfo = new System.Diagnostics.ProcessStartInfo();
startInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
startInfo.FileName = mageFilePath;
startInfo.Arguments = string.Format("-update \"{0}\" -appmanifest \"{1}\" -cf \"{2}\" -pwd \"{3}\"",applicationManifestFilePath,manifestFilePath,certFilePath,certPassword);
process.StartInfo = startInfo;
process.Start();

//rename files with .deploy extension
foreach(string filePath in filePaths)
{
  string realName = filePath.Replace(".deploy",string.Empty);
  File.Move(realName,filePath);
  File.Delete(realName);
}

Written with LINQPad

Programmatically remove files from a published ClickOnce application

using System.Diagnostics;

using System.IO;

using System.Xml;

string sourceDir = @"C:\published\my_app_1_0_0_135\";

string manifestFilePath = sourceDir + @"\my_app.exe.manifest";

string applicationManifestFilePath = sourceDir + @"\my_app.application";

string mageFilePath = @"C:\Program Files (x86)\Microsoft SDKs\Windows\v8.1A\bin\NETFX 4.5.1 Tools\mage.exe";

string certFilePath = @"C:\certificates\MyAuthenticodeCertificate.pfx";

string certPassword = "foo";

//load .manifest XML

var doc = XDocument.Load(manifestFilePath);

//rename the files w/o the .deploy extension

string[] filePaths = Directory.GetFiles(sourceDir,"*.deploy");

foreach(string filePath in filePaths)

{

string realName = filePath.Replace(".deploy",string.Empty);

File.Move(filePath,realName);

File.Delete(filePath);

}

//locate and remove the desired entry (e.g. the "MyComponentToRemove.dll" of dependency type of "install")

XNamespace ns = "urn:schemas-microsoft-com:asm.v2";

doc.Descendants(ns + "dependentAssembly")

.Where(x =&gt; (string)x.Attribute("dependencyType") == "install")

.Where(x=&gt; ((string)x.Attribute("codebase")).Equals("MyComponentToRemove.dll"))

.Select(x =&gt; x.Parent)

.Remove();

//save .manifest XML

doc.Save(manifestFilePath);

//re-sign .manifest

Process process = new System.Diagnostics.Process();

System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo();

startInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;

startInfo.FileName = mageFilePath;

startInfo.Arguments = string.Format("-update \"{0}\" -cf \"{1}\" -pwd \"{2}\"",manifestFilePath,certFilePath,certPassword);

process.StartInfo = startInfo;

process.Start();

//re-sign .application

process = new System.Diagnostics.Process();

startInfo = new System.Diagnostics.ProcessStartInfo();

startInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;

startInfo.FileName = mageFilePath;

startInfo.Arguments = string.Format("-update \"{0}\" -appmanifest \"{1}\" -cf \"{2}\" -pwd \"{3}\"",applicationManifestFilePath,manifestFilePath,certFilePath,certPassword);

process.StartInfo = startInfo;

process.Start();

//rename files with .deploy extension

foreach(string filePath in filePaths)

{

string realName = filePath.Replace(".deploy",string.Empty);

File.Move(realName,filePath);

File.Delete(realName);

}

<jco-blog/>

Find definitions and references of SQL Command Variables in a SQL script

Ping until a machine responds

C# Current Class.Method Logging

WCF Client-Side Exceptions (getting full service-side exception detail)

Unix Timestamp in SQL Server

Windows Forms Inactivity Timeout Class

Generate Unique Namespace (in DNS Name Format)

Get SQL Server Version Info

Determine if a path is a UNC

Removing files from ClickOnce application manifest