Using setvar in T-SQL

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;
	}
}

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;
	}
}

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));
        }
    }
}

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

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);
}

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);
            }
        }
}

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)
{
 ...
}

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)
{
 ...
}

Clunky, but attainable.

originally posted 2013-7-25

--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
*/

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
*/

originally posted 2013-8-29

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

namespace NPT.Common
{
    /// <summary>
    /// 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.
    /// </summary>
    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 < 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 >= 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();
        }

        /// <summary>
        /// Returns system idle time in seconds
        /// </summary>
        /// <returns></returns>
        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 < 0)
                return CallNextHookEx(hHook, nCode, wParam, lParam);

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

            if (hookCaption != null && 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

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

//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...");	
}

/// <summary>
/// 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.
/// </summary>
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) > 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;
    }
  }
}

/// <summary>
/// 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.
/// </summary>
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

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

//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

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 => (string)x.Attribute("dependencyType") == "install")
   .Where(x=> ((string)x.Attribute("codebase")).Equals("MyComponentToRemove.dll"))
   .Select(x => 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);
}