MMS Programmer chronicle

Enabling the PPTP for a Windows VPN behind OpenWrt router

2011-10-12T22:51:00.000+03:00

Beside setting up the router by opening the required ports and creating the VPN server on my Windows machine i had to install the following packages to enable the pptp

AVL - Binary balanced tree in C#

2011-09-15T12:41:00.001+03:00

This is my implementation of a binary search tree with both recursive and iterative insert:

 
using System;
using System.Collections.Generic;
using System.Diagnostics;

namespace AVLTree
{
	public class AVLTree<ElementType>
		where ElementType : IComparable<ElementType>
	{
		public Node Root { get; set; }
		public Action<Node, ElementType> PerformActionOnInsertingNodesAllreadyInTheTree { get; set; }

		public void Insert(ElementType value)
		{
			Root = Insert(value, Root);
		}

		public IEnumerable<ElementType> GetContent()
		{
			foreach (var item in GetContent(Root))
				yield return item.Value;
		}

		public int GetHeight()
		{
			int max = int.MinValue;
			foreach (var item in GetContent(Root))
				max = Math.Max(max, item.Height);
			return max;
		}

		private IEnumerable<Node> GetContent(Node node)
		{
			if (null == node)
				yield break;

			foreach (var item in GetContent(node.Left))
				yield return item;
			yield return node;
			foreach (var item in GetContent(node.Right))
				yield return item;
		}

		private Node Insert(ElementType value, Node subtreeNode)
		{
			if (null == subtreeNode)
			{
				subtreeNode = new Node(value);
				return subtreeNode;
			}
			if (0 > value.CompareTo(subtreeNode.Value))
			{
				subtreeNode.Left = Insert(value, subtreeNode.Left);
				if (1 < subtreeNode.Left.Height - Node.HeightOf(subtreeNode.Right))
					if (0 > value.CompareTo(subtreeNode.Left.Value))
						subtreeNode = subtreeNode.RotateWithLeftChild();
					else
						subtreeNode = subtreeNode.DoubleRotateWithLeftChild();
			}
			else if (0 < value.CompareTo(subtreeNode.Value))
			{
				subtreeNode.Right = Insert(value, subtreeNode.Right);
				if (1 < subtreeNode.Right.Height - Node.HeightOf(subtreeNode.Left))
					if (0 < value.CompareTo(subtreeNode.Right.Value))
						subtreeNode = subtreeNode.RotateWithRightChild();
					else
						subtreeNode = subtreeNode.DoubleRotateWithRightChild();
			}
			else
			{
				if (null != PerformActionOnInsertingNodesAllreadyInTheTree)
					PerformActionOnInsertingNodesAllreadyInTheTree(subtreeNode, value);
			}

			subtreeNode.Height = Math.Max(Node.HeightOf(subtreeNode.Left), Node.HeightOf(subtreeNode.Right)) + 1;
			return subtreeNode;
		}

		public void InsertPlain(ElementType value)
		{
			Node current = Root;
			Stack<TreeNavigationStep> pathToCurrentNode = new Stack<TreeNavigationStep>();

			while (null != current)
			{
				if (0 > value.CompareTo(current.Value))
				{
					pathToCurrentNode.Push(new TreeNavigationStep(current, true, true));
					current = current.Left;
				}
				else if (0 < value.CompareTo(current.Value))
				{
					pathToCurrentNode.Push(new TreeNavigationStep(current, false, true));
					current = current.Right;
				}
				else
				{
					if (null != PerformActionOnInsertingNodesAllreadyInTheTree)
					{
						PerformActionOnInsertingNodesAllreadyInTheTree(current, value);
					}
					return;
				}
			}
			Node newNode = new Node(value);
			if (0 == pathToCurrentNode.Count)
			{
				Root = newNode;
				return;
			}

			TreeNavigationStep navigationStep = pathToCurrentNode.Peek();
			current = navigationStep.From;

			if (navigationStep.ToLeft)
			{
				current.Left = newNode;
			}
			else
			{
				current.Right = newNode;
			}

			while(pathToCurrentNode.Count >0)
			{
				var step = pathToCurrentNode.Pop();
				bool performedBalance = false;
				Node parent = step.From;
				Node nodeResultedByBalance = null;
				if (step.FreeToBalance)
				{
					if (step.ToLeft)
					{
						if (1 < parent.Left.Height - Node.HeightOf(parent.Right))
							if (0 > value.CompareTo(parent.Left.Value))
							{
								performedBalance = true;
								nodeResultedByBalance = parent.RotateWithLeftChild();
								if(0<pathToCurrentNode.Count)
								{
									var gradpa = pathToCurrentNode.Peek();
									if(gradpa.ToLeft)
										gradpa.From.Left = nodeResultedByBalance;
									else
										gradpa.From.Right = nodeResultedByBalance;
								}
								pathToCurrentNode.Push(new TreeNavigationStep(nodeResultedByBalance, false, false));
							}
							else
							{
								performedBalance = true;
								nodeResultedByBalance = parent.DoubleRotateWithLeftChild();
								if(0<pathToCurrentNode.Count)
								{
									var gradpa = pathToCurrentNode.Peek();
									if(gradpa.ToLeft)
										gradpa.From.Left = nodeResultedByBalance;
									else
										gradpa.From.Right = nodeResultedByBalance;
								}
								pathToCurrentNode.Push(new TreeNavigationStep(nodeResultedByBalance.Left, false, false));
								pathToCurrentNode.Push(new TreeNavigationStep(nodeResultedByBalance, false, false));
							}
					}
					else
					{
						if (1 < parent.Right.Height - Node.HeightOf(parent.Left))
							if (0 < value.CompareTo(parent.Right.Value))
							{
								performedBalance = true;
								nodeResultedByBalance = parent.RotateWithRightChild();
								if(0<pathToCurrentNode.Count)
								{
									var gradpa = pathToCurrentNode.Peek();
									if(gradpa.ToLeft)
										gradpa.From.Left = nodeResultedByBalance;
									else
										gradpa.From.Right = nodeResultedByBalance;
								}
								pathToCurrentNode.Push(new TreeNavigationStep(nodeResultedByBalance, false, false));
							}
							else
							{
								performedBalance = true;
								nodeResultedByBalance = parent.DoubleRotateWithRightChild();
								if(0<pathToCurrentNode.Count)
								{
									var gradpa = pathToCurrentNode.Peek();
									if(gradpa.ToLeft)
										gradpa.From.Left = nodeResultedByBalance;
									else
										gradpa.From.Right = nodeResultedByBalance;
								}
								pathToCurrentNode.Push(new TreeNavigationStep(nodeResultedByBalance.Right, false, false));
								pathToCurrentNode.Push(new TreeNavigationStep(nodeResultedByBalance, false, false));
							}
					}
					if (performedBalance)
						Root = nodeResultedByBalance;
					else
						Root = parent;
				}
				
				parent.Height = Math.Max(Node.HeightOf(parent.Left), Node.HeightOf(parent.Right)) + 1;
			}
		}

		public class TreeNavigationStep
		{
			public TreeNavigationStep(Node from, bool toLeftChild, bool freeToBalance)
			{
				From = from;
				ToLeft = toLeftChild;
				FreeToBalance = freeToBalance;
			}
			public Node From { get; set; }
			public bool ToLeft { get; set; }
			public bool FreeToBalance { get; set; }
		}

		[DebuggerDisplay("{Value}")]
		public class Node
		{
			public Node(ElementType value)
			{
				Value = value;
			}

			public Node Left { get; set; }
			public Node Right { get; set; }
			public ElementType Value { get; set; }
			public int Height { get; set; }

			public Node RotateWithLeftChild()
			{
				Debug.Assert(null != this.Left);

				Node left = this.Left;
				this.Left = left.Right;
				left.Right = this;

				this.Height = Math.Max(HeightOf(this.Left), HeightOf(this.Right)) + 1;
				left.Height = Math.Max(HeightOf(left.Left), this.Height) + 1;
				return left;
			}

			public Node RotateWithRightChild()
			{
				Debug.Assert(null != this.Right);

				Node right = this.Right;
				this.Right = right.Left;
				right.Left = this;

				this.Height = Math.Max(HeightOf(this.Left), HeightOf(this.Right)) + 1;
				right.Height = Math.Max(HeightOf(right.Right), this.Height) + 1;
				return right;
			}

			public Node DoubleRotateWithLeftChild()
			{
				Debug.Assert(null != this.Left && null != this.Left.Right);

				this.Left = this.Left.RotateWithRightChild();
				return this.RotateWithLeftChild();
			}

			public Node DoubleRotateWithRightChild()
			{
				Debug.Assert(null != this.Right && null != this.Right.Left);

				this.Right = this.Right.RotateWithLeftChild();
				return this.RotateWithRightChild();
			}

			public static int HeightOf(Node node)
			{
				if (null == node)
					return -1;
				return node.Height;
			}
		}
	}
}

Changed the free DNS Hosting

2011-08-04T22:24:00.004+03:00

Just moved from http://free.editdns.net to http://freedns.afraid.org . Tomorrow I will see if the transition was frictionless.

Publish C# formatted code in blogspot

2011-03-17T23:16:00.005+02:00

To show formatted C# code in my blog from now on i will use the SyntaxHighlighter by Alex Gorbatchev

The quick setup is paste the following text in the blog template before the </head> tag.


<link href='http://alexgorbatchev.com/pub/sh/current/styles/shCore.css' rel='stylesheet' type='text/css'/>
<link href='http://alexgorbatchev.com/pub/sh/current/styles/shThemeRDark.css' rel='stylesheet' type='text/css'/>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shCore.js' type='text/javascript'></script>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushCpp.js' type='text/javascript'></script>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushCSharp.js' type='text/javascript'></script>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushCss.js' type='text/javascript'></script>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushJava.js' type='text/javascript'></script>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushJScript.js' type='text/javascript'></script>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushPhp.js' type='text/javascript'></script>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushPython.js' type='text/javascript'></script>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushRuby.js' type='text/javascript'></script>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushSql.js' type='text/javascript'></script>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushVb.js' type='text/javascript'></script>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushXml.js' type='text/javascript'></script>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushPerl.js' type='text/javascript'></script>
<script language='javascript'>
SyntaxHighlighter.config.bloggerMode = true;
SyntaxHighlighter.config.clipboardSwf = 'http://alexgorbatchev.com/pub/sh/current/scripts/clipboard.swf';
SyntaxHighlighter.all();
</script>

On posting you should enclose the Html encoded version of your code with <pre class="brush: csharp"> </pre> tags. For encoding in a friendly html format you can use the html encoder

Sanitize strings against SQL injection using Regex

2011-03-17T14:24:00.010+02:00

If SqlParameters cannot be used this is an anti-pattern that will do the job:

        public static string Sanitize(this string stringValue)
        {
            if (null == stringValue)
                return stringValue;
            return stringValue
                        .RegexReplace("-{2,}", "-")                 // transforms multiple --- in - use to comment in sql scripts
                        .RegexReplace(@"[*/]+", string.Empty)      // removes / and * used also to comment in sql scripts
                        .RegexReplace(@"(;|\s)(exec|execute|select|insert|update|delete|create|alter|drop|rename|truncate|backup|restore)\s", string.Empty, RegexOptions.IgnoreCase);
        }


        private static string RegexReplace(this string stringValue, string matchPattern, string toReplaceWith)
        {
            return Regex.Replace(stringValue, matchPattern, toReplaceWith);
        }

        private static string RegexReplace(this string stringValue, string matchPattern, string toReplaceWith, RegexOptions regexOptions)
        {
            return Regex.Replace(stringValue, matchPattern, toReplaceWith, regexOptions);
        }

And some tests ...

        [TestMethod]
        public void OnNullShouldReturnNull()
        {
            Assert.IsNull(RegexExtensions.Sanitize(null));
        }

        [TestMethod]
        public void OnValidStringShouldReturnTheSameString()
        {
            Assert.AreEqual("a", "a".Sanitize());
            Assert.AreEqual("aa", "aa".Sanitize());
            Assert.AreEqual("-", "-".Sanitize());
            Assert.AreEqual("a-", "a-".Sanitize());
            Assert.AreEqual("-a", "-a".Sanitize());
            Assert.AreEqual("-a-", "-a-".Sanitize());
        }

        [TestMethod]
        public void OnMultipleDahsedShouldReturnJustADash()
        {
            Assert.AreEqual("-", "--".Sanitize());
            Assert.AreEqual("a-", "a--".Sanitize());
            Assert.AreEqual("-a", "--a".Sanitize());
            Assert.AreEqual("-", "---".Sanitize());
            Assert.AreEqual("-a-", "----a----".Sanitize());
        }

        [TestMethod]
        public void ShouldRemoveGroupCommentsSymbols()
        {
            Assert.AreEqual(string.Empty, "/".Sanitize());
            Assert.AreEqual(string.Empty, "*".Sanitize());
            Assert.AreEqual(string.Empty, "/**//*/*/".Sanitize());
            Assert.AreEqual("a", "/*a*/".Sanitize()); 
        }

        [TestMethod]
        public void ShouldRemoveSQLKeyWords()
        {
            Assert.AreEqual("eXec", "eXec".Sanitize());
            Assert.AreEqual(string.Empty, ";eXec ".Sanitize());
            Assert.AreEqual(string.Empty, " eXec ".Sanitize());
            Assert.AreEqual("  ", "  eXec  ".Sanitize());
        }

CustomTypeDescriptors

2011-02-17T20:10:00.003+02:00

Mebyon Kernow had a very nice simplification to commands in wpf using custom type descriptors: http://blogs.msdn.com/b/morgan/archive/2010/06/24/simplifying-commands-in-mvvm-and-wpf.aspx

I pasted some code for future reference:


namespace PersistingWorkflows
{
    /// <summary>
    /// A map that exposes commands in a WPF binding friendly manner
    /// </summary>
    [TypeDescriptionProvider(typeof(CommandMapDescriptionProvider))]
    public class CommandMap
    {
        /// <summary>
        /// Add a named command to the command map
        /// </summary>
        /// <param name="commandName">The name of the command</param>
        /// <param name="executeMethod">The method to execute</param>
        public void AddCommand(string commandName, Action<object> executeMethod)
        {
            Commands[commandName] = new DelegateCommand(executeMethod);
        }

        /// <summary>
        /// Add a named command to the command map
        /// </summary>
        /// <param name="commandName">The name of the command</param>
        /// <param name="executeMethod">The method to execute</param>
        /// <param name="canExecuteMethod">The method to execute to check if the command can be executed</param>
        public void AddCommand(string commandName, Action<object> executeMethod, Predicate<object> canExecuteMethod)
        {
            Commands[commandName] = new DelegateCommand(executeMethod, canExecuteMethod);
        }

        /// <summary>
        /// Remove a command from the command map
        /// </summary>
        /// <param name="commandName">The name of the command</param>
        public void RemoveCommand(string commandName)
        {
            Commands.Remove(commandName);
        }

        /// <summary>
        /// Expose the dictionary of commands
        /// </summary>
        protected Dictionary<string, ICommand> Commands
        {
            get
            {
                if (null == _commands)
                    _commands = new Dictionary<string, ICommand>();

                return _commands;
            }
        }

        /// <summary>
        /// Store the commands
        /// </summary>
        private Dictionary<string, ICommand> _commands;

        /// <summary>
        /// Implements ICommand in a delegate friendly way
        /// </summary>
        private class DelegateCommand : ICommand
        {
            /// <summary>
            /// Create a command that can always be executed
            /// </summary>
            /// <param name="executeMethod">The method to execute when the command is called</param>
            public DelegateCommand(Action<object> executeMethod) : this(executeMethod, null) { }

            /// <summary>
            /// Create a delegate command which executes the canExecuteMethod before executing the executeMethod
            /// </summary>
            /// <param name="executeMethod"></param>
            /// <param name="canExecuteMethod"></param>
            public DelegateCommand(Action<object> executeMethod, Predicate<object> canExecuteMethod)
            {
                if (null == executeMethod)
                    throw new ArgumentNullException("executeMethod");

                this._executeMethod = executeMethod;
                this._canExecuteMethod = canExecuteMethod;
            }

            public bool CanExecute(object parameter)
            {
                return (null == _canExecuteMethod) ? true : _canExecuteMethod(parameter);
            }

            public event EventHandler CanExecuteChanged
            {
                add { CommandManager.RequerySuggested += value; }
                remove { CommandManager.RequerySuggested -= value; }
            }

            public void Execute(object parameter)
            {
                _executeMethod(parameter);
            }

            private Predicate<object> _canExecuteMethod;
            private Action<object> _executeMethod;
        }


        /// <summary>
        /// Expose the dictionary entries of a CommandMap as properties
        /// </summary>
        private class CommandMapDescriptionProvider : TypeDescriptionProvider
        {
            /// <summary>
            /// Standard constructor
            /// </summary>
            public CommandMapDescriptionProvider()
                : this(TypeDescriptor.GetProvider(typeof(CommandMap)))
            {
            }

            /// <summary>
            /// Construct the provider based on a parent provider
            /// </summary>
            /// <param name="parent"></param>
            public CommandMapDescriptionProvider(TypeDescriptionProvider parent)
                : base(parent)
            {
            }

            /// <summary>
            /// Get the type descriptor for a given object instance
            /// </summary>
            /// <param name="objectType">The type of object for which a type descriptor is requested</param>
            /// <param name="instance">The instance of the object</param>
            /// <returns>A custom type descriptor</returns>
            public override ICustomTypeDescriptor GetTypeDescriptor(Type objectType, object instance)
            {
                return new CommandMapDescriptor(base.GetTypeDescriptor(objectType, instance), instance as CommandMap);
            }
        }

        /// <summary>
        /// This class is responsible for providing custom properties to WPF - in this instance
        /// allowing you to bind to commands by name
        /// </summary>
        private class CommandMapDescriptor : CustomTypeDescriptor
        {
            /// <summary>
            /// Store the command map for later
            /// </summary>
            /// <param name="descriptor"></param>
            /// <param name="map"></param>
            public CommandMapDescriptor(ICustomTypeDescriptor descriptor, CommandMap map)
                : base(descriptor)
            {
                _map = map;
            }

            /// <summary>
            /// Get the properties for this command map
            /// </summary>
            /// <returns>A collection of synthesized property descriptors</returns>
            public override PropertyDescriptorCollection GetProperties()
            {
                //TODO: See about caching these properties (need the _map to be observable so can respond to add/remove)
                PropertyDescriptor[] props = new PropertyDescriptor[_map.Commands.Count];

                int pos = 0;

                foreach (KeyValuePair<string, ICommand> command in _map.Commands)
                    props[pos++] = new CommandPropertyDescriptor(command);

                return new PropertyDescriptorCollection(props);
            }

            private CommandMap _map;
        }

        /// <summary>
        /// A property descriptor which exposes an ICommand instance
        /// </summary>
        private class CommandPropertyDescriptor : PropertyDescriptor
        {
            /// <summary>
            /// Construct the descriptor
            /// </summary>
            /// <param name="command"></param>
            public CommandPropertyDescriptor(KeyValuePair<string, ICommand> command)
                : base(command.Key, null)
            {
                _command = command.Value;
            }

            /// <summary>
            /// Always read only in this case
            /// </summary>
            public override bool IsReadOnly
            {
                get { return true; }
            }

            /// <summary>
            /// Nope, it's read only
            /// </summary>
            /// <param name="component"></param>
            /// <returns></returns>
            public override bool CanResetValue(object component)
            {
                return false;
            }

            /// <summary>
            /// Not needed
            /// </summary>
            public override Type ComponentType
            {
                get { throw new NotImplementedException(); }
            }

            /// <summary>
            /// Get the ICommand from the parent command map
            /// </summary>
            /// <param name="component"></param>
            /// <returns></returns>
            public override object GetValue(object component)
            {
                CommandMap map = component as CommandMap;

                if (null == map)
                    throw new ArgumentException("component is not a CommandMap instance", "component");

                return map.Commands[this.Name];
            }

            /// <summary>
            /// Get the type of the property
            /// </summary>
            public override Type PropertyType
            {
                get { return typeof(ICommand); }
            }

            /// <summary>
            /// Not needed
            /// </summary>
            /// <param name="component"></param>
            public override void ResetValue(object component)
            {
                throw new NotImplementedException();
            }

            /// <summary>
            /// Not needed
            /// </summary>
            /// <param name="component"></param>
            /// <param name="value"></param>
            public override void SetValue(object component, object value)
            {
                throw new NotImplementedException();
            }

            /// <summary>
            /// Not needed
            /// </summary>
            /// <param name="component"></param>
            /// <returns></returns>
            public override bool ShouldSerializeValue(object component)
            {
                return false;
            }

            /// <summary>
            /// Store the command which will be executed
            /// </summary>
            private ICommand _command;
        }
    }
}

Tracing .net WPF

2010-05-19T23:29:00.002+03:00

Copy from http://blogs.msdn.com/mikehillberg/archive/2006/09/14/WpfTraceSources.aspx in case that will vanish

Trace sources in WPF

WPF (Avalon) uses the .Net tracing system to provide some diagnostics about what’s going on inside your WPF application. It’s not at all an exhaustive set of traces, and in fact it’s still pretty rudimentary. But frequently it’s enough to help out when you’re trying to debug a problem.

The short story is that WPF defines a set of TraceSource objects that you can configure and use, with all the normal .Net tracing functionality. The TraceSource names are shown below in a sample .Config file. In addition to the .config file, you need to set a flag in the registry. Or you can skip the .config file and/or registry flag, and do everything with the PresentationTraceSources class, either from code or from the Visual Studio Immediate window.

Now the longer story ...

.Net Tracing Background

First a quick background on .Net tracing … The .Net platform provides some classes to allow you to send trace messages, not only to the debug output window, but to a file, or anyone else that wants to listen. You can send traces using the static System.Diagnostics.Trace class in .Net 1.0, and in .Net 2.0 using TraceSource objects.

The basic model is to instrument your code with calls to Trace or TraceSource of interesting events. You (or the user of your program) can then add some entries to the application's .config file to enable those traces, filter them, and capture them (for example to a file).

For more background on tracing in general, the TraceSource documentation in the SDK provides a nice overview. Also, Mike Rousos has a multi-part overview on .Net tracing ... first a basic overview, and then more details here, here, and here.

Enabling WPF Tracing in a .Config File

In general, you configure .Net tracing by configuring the TraceSource objects. The easiest way to configure the traces is with a .config file for the application, or machine-wide (if you're an administrator) by adding entries to the machine.config file.

For WPF, however, you also need to get the trace sources enabled first. Otherwise we don’t even read the .config file to look for settings. The WPF traces can be enabled by setting a flag in registry, or by calling PresentationTraceSources.Refresh from code. I’ll talk more about PresentationTraceSources later in "Enabling and Configuring WPF Trace Sources Programmatically". To enable WPF tracing in the registry, create the key

"hkey_current_user\software\microsoft\tracing\wpf", add a "ManagedTracing" DWORD value, and set it to one.

Additionally, some WPF tracing is enabled automatically when you launch your app from within the debugger. Specifically, this is the case for databinding warnings and errors.

Once you've got the registry set for the WPF trace sources, you still won't get much tracing until you turn it on with the .Config file. The easiest way to explain the rest of this is to show a sample .config file:

type="System.Diagnostics.ConsoleTraceListener"

initializeData="false"/>

type="System.Diagnostics.XmlWriterTraceListener"

traceOutputOptions="None"

initializeData="AvTrace.xml" />

type="System.Diagnostics.TextWriterTraceListener"

initializeData="AvTrace.txt" />

You can put this Xml into a .config file and use it as is. For example, to get tracing for XamlPad.exe, put this in a file named XamlPad.exe.config and put it in the same directory as XamlPad.exe. (If you’re on Windows Vista it might not like you putting a file in to XamlPad’s directory under Program Files, but you can just copy XamlPad.exe out to another directory first.) Note that this Xml includes the tag and the tag, etc. So if you're adding these settings to an existing .config file or to the machine.config file, and it already has those tags, just copy in the content without the tags.

Notice in this Xml that it lists all of the trace sources that WPF creates. Also note that everything is commented out. So you need to un-comment the trace sources that you want to be used. Once you've uncommented a section, you can configure all the settings available from the basic .Net tracing; WPF just uses that and doesn't do anything special.

By default, the above settings write output to a file named "avtrace.txt", but you can choose other trace listeners, including custom trace listeners that you write. You can also filter traces away from listeners by writing custom filters and adding them to the .config file.

Examining the raw output

So let's try an example. Put the above Xml into a XamlPad.exe.config file, put it in the same directly as XamlPad.exe, and remove the comments around the System.Windows.RoutedEvent and System.Windows.NameScope sections. Run XamlPad with the following markup, click on the Button, then close XamlPad:

Now look at the output in avtrace.txt, and the first thing you’ll notice is that there’s a lot of it. The basic format of the output is several fields with:

· The trace source name

· “Start” or “Stop”

· Trace ID (each different type of trace from a trace source has its own ID number)

· Brief description of the event

· A list of parameters for the event.

(As you look at the output, also remember that XamlPad is itself a WPF application, so most of the traces you see are from XamlPad, not your Page and Button.)

As I said earlier, this is all pretty rudimentary. But by building it on the standard .Net tracing system, you can create your own tools to process or filter it, or load it into Excel, create pivot tables, etc.

So here’s an interesting trace from the output, this shows a System.Windows.NameScope trace where the “Button1” name from your markup got registered for the Button:

System.Windows.NameScope Start: 1 : Name has been registered on INameScope; NameScope='System.Windows.NameScope'; NameScope.HashCode='42483779'; NameScope.Type='System.Windows.NameScope'; Name='Button1'; Object='System.Windows.Controls.Button'; Object.HashCode='46809697'; Object.Type='System.Windows.Controls.Button'

Notice the parameters there are defined by the trace. In the case of this trace, it shows the name, and the object getting named. If you write a custom trace filter, you can actually look at the instance of the button. For the standard trace listeners/filters, an object is simply written out by calling ToString, GetHashCode, and GetType. For example, the button was represented in the above trace with:

Object='System.Windows.Controls.Button'; Object.HashCode='46809697'; Object.Type='System.Windows.Controls.Button'

Most of the WPF traces include the relevant object, so a quick-and-dirty way to filter the output is to grep for that object’s hash code in the name registration. That will now show you most everything in the output related to that button, and for example filter out all the traces relating to XamlPad itself.

Now looking through this filtered output, you can more easily see traces such as the MouseEnter event when I first moved the mouse over the button:

System.Windows.RoutedEvent Start: 1 : Raise RoutedEvent; RoutedEvent='Mouse.MouseEnter'; RoutedEvent.HashCode='117163'; RoutedEvent.Type='System.Windows.RoutedEvent'; Element='System.Windows.Controls.Button: Clack'; Element.HashCode='46809697'; Element.Type='System.Windows.Controls.Button'; RoutedEventArgs='System.Windows.Input.MouseEventArgs'; RoutedEventArgs.HashCode='9490272'; RoutedEventArgs.Type='System.Windows.Input.MouseEventArgs'; Handled='False'

And you can see the button click event itself. Here’s the traces for the click event, as well as the MouseUp event that triggered it, along with the other events that are triggered from a MouseUp (the MouseUp and Click events are highlighted):

System.Windows.RoutedEvent Start: 1 : Raise RoutedEvent; RoutedEvent='Mouse.MouseUp'; RoutedEvent.HashCode='7092232'; RoutedEvent.Type='System.Windows.RoutedEvent'; Element='System.Windows.Controls.Button: Clack'; Element.HashCode='46809697'; Element.Type='System.Windows.Controls.Button'; RoutedEventArgs='System.Windows.Input.MouseButtonEventArgs'; RoutedEventArgs.HashCode='63830089'; RoutedEventArgs.Type='System.Windows.Input.MouseButtonEventArgs'; Handled='False'

System.Windows.RoutedEvent Start: 2 : Raise RoutedEvent; RoutedEvent='UIElement.MouseLeftButtonUp'; RoutedEvent.HashCode='37599894'; RoutedEvent.Type='System.Windows.RoutedEvent'; Element='System.Windows.Controls.Button: Clack'; Element.HashCode='46809697'; Element.Type='System.Windows.Controls.Button'; RoutedEventArgs='System.Windows.Input.MouseButtonEventArgs'; RoutedEventArgs.HashCode='63830089'; RoutedEventArgs.Type='System.Windows.Input.MouseButtonEventArgs'; Handled='False'

System.Windows.RoutedEvent Start: 1 : Raise RoutedEvent; RoutedEvent='Mouse.LostMouseCapture'; RoutedEvent.HashCode='2854726'; RoutedEvent.Type='System.Windows.RoutedEvent'; Element='System.Windows.Controls.Button: Clack'; Element.HashCode='46809697'; Element.Type='System.Windows.Controls.Button'; RoutedEventArgs='System.Windows.Input.MouseEventArgs'; RoutedEventArgs.HashCode='25692540'; RoutedEventArgs.Type='System.Windows.Input.MouseEventArgs'; Handled='False'

System.Windows.RoutedEvent Stop: 1 : Raise RoutedEvent; RoutedEvent='Mouse.LostMouseCapture'; RoutedEvent.HashCode='2854726'; RoutedEvent.Type='System.Windows.RoutedEvent'; Element='System.Windows.Controls.Button: Clack'; Element.HashCode='46809697'; Element.Type='System.Windows.Controls.Button'; RoutedEventArgs='System.Windows.Input.MouseEventArgs'; RoutedEventArgs.HashCode='25692540'; RoutedEventArgs.Type='System.Windows.Input.MouseEventArgs'; Handled='False'

System.Windows.RoutedEvent Start: 1 : Raise RoutedEvent; RoutedEvent='ButtonBase.Click'; RoutedEvent.HashCode='42526340'; RoutedEvent.Type='System.Windows.RoutedEvent'; Element='System.Windows.Controls.Button: Clack'; Element.HashCode='46809697'; Element.Type='System.Windows.Controls.Button'; RoutedEventArgs='System.Windows.RoutedEventArgs'; RoutedEventArgs.HashCode='47192740'; RoutedEventArgs.Type='System.Windows.RoutedEventArgs'; Handled='False'

System.Windows.RoutedEvent Stop: 1 : Raise RoutedEvent; RoutedEvent='ButtonBase.Click'; RoutedEvent.HashCode='42526340'; RoutedEvent.Type='System.Windows.RoutedEvent'; Element='System.Windows.Controls.Button: Clack'; Element.HashCode='46809697'; Element.Type='System.Windows.Controls.Button'; RoutedEventArgs='System.Windows.RoutedEventArgs'; RoutedEventArgs.HashCode='47192740'; RoutedEventArgs.Type='System.Windows.RoutedEventArgs'; Handled='False'

System.Windows.RoutedEvent Stop: 2 : Raise RoutedEvent; RoutedEvent='Mouse.MouseUp'; RoutedEvent.HashCode='7092232'; RoutedEvent.Type='System.Windows.RoutedEvent'; Element='System.Windows.Controls.Button: Clack'; Element.HashCode='46809697'; Element.Type='System.Windows.Controls.Button'; RoutedEventArgs='System.Windows.Input.MouseButtonEventArgs'; RoutedEventArgs.HashCode='63830089'; RoutedEventArgs.Type='System.Windows.Input.MouseButtonEventArgs'; Handled='True'

WPF Trace Sources

As you can see from the sample config file above, there are several trace sources created by WPF. They’re all named after the type or namespace that implements them. Here’s a description of all the sources:

· System.Windows.Data
This is probably the most useful trace source, and provides all kinds of information about WPF databinding, including warnings when it wasn’t possible to resolve a binding. This trace source does one thing that the other WPF trace sources do not, it enables itself automatically when you start your app in the debugger.

· System.Windows.DependencyProperty
This is probably the least useful trace source, and just provides information about registration of DPs. Unfortunately it doesn’t provide information such as property values being set and calculated.

· System.Windows.Freezable
This provides tracing about Freezable problems that don’t cause an exception. For example, if you call the CanFreeze method on a Freezable and it returns false, this tracing might be able to help you determine what exactly couldn’t be frozen.

· System.Windows.RoutedEvent
Provides tracing information on the routing of RoutedEvents, including a trace indicating what event listener handled the event.

· System.Windows.Media.Animation
Sends traces when storyboards are started, stopped, paused, resumed, etc.

· System.Windows.NameScope
Sends a trace when a name is registered, providing the name and the object.

· System.Windows.ResourceDictionary
Sends traces when a resource is set, removed, looked up, etc. Since there could be multiple resource dictionaries that define the same resource, this can be a useful way to determine where the resource is actually coming from.

· System.Windows.Markup
This sends traces when Xaml (or Baml) is loaded, with information such as the objects being created, the properties being set, and the type converters being used.

· System.Windows.Documents
Traces information about page formatting errors for paginated documents.

Enabling and Configuring WPF Trace Sources Programmatically

Instead of, or in addition to, the .config file, you can configure the WPF traces from code in your app. The PresentationTraceSources class holds all of the TraceSource objects described above. As a result, you can simply configure the sources with the TraceSource API.

Of special note is the PresentationTraceSources.Refresh method. One thing that this does is call Trace.Refresh, which causes all TraceSource objects in the application (including WPF’s) to re-read the .Config file. But in addition this causes the WPF traces to be enabled first, as if the registry flag described earlier had been set. That is, calling Refresh is a way to turn on WPF debugging without actually modifying the registry.

And you can equivalently call the Refresh method from the Immediate window in Visual Studio for any app; you don’t have to actually call it from code in the app. If you have a .config file, it will be read and trace sources will be configured appropriately. If you don’t have a .config file set, you can still set up the trace sources manually in the Immediate window. For example, running these commands enables the WPF trace sources, and sets up for all RoutedEvent traces to go to the debug output window:

PresentationTraceSources.Refresh()

PresentationTraceSources.RoutedEventSource.Listeners.Add(new DefaultTraceListener() )

PresentationTraceSources.RoutedEventSource.Switch.Level = SourceLevels.All

Trace Switch Levels

As described in the .Net tracing documentation, a TraceSource has a Switch property that can be used to indicate what level of traces should be sent by the source. These switch levels can be set in the .config file, or programmatically via the PresentationTraceSources.

The interesting levels for WPF traces are Warning, ActivityTracing, and All. Not all of the trace sources in WPF provide warnings, but the Freezable and ResourceDictionary provide a few, and Data provides a lot of useful Warning traces as well as Error traces. The ActivityTracing level tends to get a lot more verbose, and of course the simplest thing to do is use All.

The WPF trace sources do one additional thing on top of what TraceSource does automatically. If you’re running under the debugger, and the trace source is enabled in the .config file but set with a level of “Off”. The side-effect of this is that if you set the level to “Off” in the .config file, it will still get promoted to “Warning”, and you’ll see all Warning/Error/Critical traces. To work around this, rather than setting the level to “Off”, set it to “Critical”, as none of the WPF traces are at this high level. If you enable WPF traces by calling PresentationTraceSources.Refresh() from code or from the Immediate Window in Visual Studio, this promotion doesn’t occur.

That’s It

That’s all the gory details … TraceSource objects for WPF features, you can configure them with a .Config file (the big gray block of Xml back at the beginning), you need to enable them with a registry setting, and/or you can configure and enable them with the PresentationTraceSources class, and sometimes a level of “Off” gets promoted to “Warning”.

Finally, for the registry setting, you can do it from the command prompt by putting the following into a file and running it with regini:

hkey_current_user\software\microsoft\tracing\wpf

ManagedTracing = REG_DWORD 1

WPF & Silverlight binding trace & debug

2010-05-19T23:15:00.003+03:00

A copy from http://bea.stollnitz.com/blog/?p=52 in case that this resource will vanish

Data Binding can be tricky to debug. In this post, I will share the techniques I use to debug WPF bindings, including the new debugging improvements we implemented in the latest 3.5 release. I will discuss the following four techniques:

* Scanning Visual Studio’s Output window for errors.
* Using Trace Sources for maximum control.
* Using the new property introduced in WPF 3.5 PresentationTraceSources.TraceLevel.
* Adding a breakpoint to a Converter.

The DataContext of this app is set to a new instance of Star, which is a class that contains two properties: Picture and Caption. Picture is of type BitmapImage and contains an image of the sun, which I included in the project. Caption is a string property that takes a while to be initialized (more details about this later).

Output Window

In the XAML of this application, I have an Image whose Source is data bound to an incorrect property name. This is a simple scenario that causes a Binding to fail.

Every time a Binding fails, the binding engine prints an informative message in the Output window of Visual Studio. In this case, I get the following message:

System.Windows.Data Error: 35 : BindingExpression path error: ‘PictureWrong’ property not found on ‘object’ ”Star’ (HashCode=49535530)’. BindingExpression:Path=PictureWrong; DataItem=’Star’ (HashCode=49535530); target element is ‘Image’ (Name=”); target property is ‘Source’ (type ‘ImageSource’)

This message should give you enough information to quickly figure out the mistake in the property name.

Advantage of this technique:

* It is very easy to look at the Output window, and in most cases it’s sufficient. It should be the first approach you consider when you have a problem with your bindings.

Disadvantage of this technique:

* Most real world applications print so much information to the Output window that it may be hard to find the error you’re looking for.

Trace Sources

The Trace Sources solution was already around in WPF 3.0. It adds a lot more flexibility to the previous solution by allowing you to control the level of detail you care about, where you want that messages to be printed and the WPF feature you want to debug.

The Trace Sources solution relies on a config file for the configuration of its behavior – the App.config file. Here is a portion of the contents of that file:

…

…

…
type="System.Diagnostics.TextWriterTraceListener"
initializeData="DebugTrace.txt" />
…

In this file, I am specifying that:

* I want only messages generated in the Data subarea to be printed. If you’re trying to debug, for example, animations, you would instead add the area System.Windows.Media.Animation.
* I want as much information as possible about data binding. This was done by setting the switch to All. Other possible values are Off, Error, Warning. For a complete list, look up SourceLevels in .NET Reflector.
* I want the messages to be printed to an external file called DebugTrace.txt, instead of the Output Window. This file will be created in the bindebug folder for the application. If you run this application twice, the messages generated the second time will be appended to the existing messages in this file. If you don’t want this behavior, remember to delete the file before running the app.

Other pre-defined listeners allow printing to the Console (ConsoleTraceListener), or to an external file in XML format (XmlWriterTraceListener).

If you run the application with the settings above, you should find a DebugTrace.txt file in the bindebug directory. If you open it, you will see the data binding error we saw previously in the Output Window, plus four “Information” messages. These lower-priority messages are printed because I specified in the switch that I want all the information available about the bindings.

If you want to learn more about this topic, I recommend Mike Hillberg’s blog. He wrote the best article I’ve read about Trace Sources, which I use frequently as a reference.

Advantages of this technique:

* It separates the debug messages you care about from the rest of the information printed in the Output window.
* This solution may help you debug other areas in WPF, not just binding.
* You can get lower-priority messages (such as information or warnings) that are not typically printed to the Output window.

Disadvantages of this technique:

* The text file (or whatever form of output you choose) will contain debug messages about all the bindings in your application. Although this is not as much clutter as the Output window, it may still require some digging for you to find exactly the information you need.
* It won’t help you in scenarios where your Binding actually succeeds, but you still don’t see what you expect in the UI. The first and second techniques I show here only help in scenarios where the Binding fails.

Before you move on, make sure you correct the Path in the Image’s Source so that these errors won’t interfere with the ones I show next.

Trace Level – new in 3.5

In order to understand this feature, let’s start by uncommenting the first TextBlock in the XAML of this application:

This TextBlock attempts to bind to Caption, a property whose value is slow to be initialized. In this case, I am simulating a slow data source by adding a Dispatcher timer to the constructor, but in reality this delay could have many different causes. Notice also that I am *not* raising a property changed notification when Caption changes value.

public string Caption
{
private set
{
this.caption= value;
//OnPropertyChanged("Caption");
}
get
{
return caption;
}
}

public Star()
{
this.Picture = new BitmapImage(new Uri("Images\sun.jpg", UriKind.Relative));
this.Caption = String.Empty;
DispatcherTimer timer = new DispatcherTimer();
timer.Interval = new TimeSpan(0, 0, 3);
timer.Tick += new EventHandler(Timer_Tick);
timer.Start();
}

private void Timer_Tick(object sender, EventArgs e)
{
this.Caption = "Sun";
}

In this scenario, the Binding will succeed (it will bind to the initial value of empty string), but you don’t see what you expect to see in the UI. The unwanted behavior is caused by the fact that the events happen in an order different from what you expect: the Binding will be evaluated before Caption gets its real value. In this case, there are no errors in the Output window or DebugTrace.txt because the Binding succeeds.

You can use the new debugging feature in 3.5 to debug this scenario by adding the attached property PresentationTraceSources.TraceLevel to the Binding, which can be set to None, Low, Medium and High. Since PresentationTraceSource is not in the default namespace mappings for WPF, you will have to write the following XAML:

xmlns:diagnostics="clr-namespace:System.Diagnostics;assembly=WindowsBase"
/>

If you look at the Output window, you will notice that the binding engine generated debug information for every task that may help users find problems with this particular binding:

System.Windows.Data Warning: 47 : Created BindingExpression (hash=25209742) for Binding (hash=3888474)
…
System.Windows.Data Warning: 91 : BindingExpression (hash=25209742): GetValue at level 0 from Star (hash=31609076) using RuntimePropertyInfo(Caption): ‘ ‘
System.Windows.Data Warning: 71 : BindingExpression (hash=25209742): TransferValue – got raw value ‘ ‘
System.Windows.Data Warning: 78 : BindingExpression (hash=25209742): TransferValue – using final value ‘ ‘

In this case, we can scan the debug messages quickly to see that there were no errors, and look at the last few messages to understand that the value found at the Source was the empty string. This information will help you come to the conclusion that there is some timing issue with the scenario.

Advantages of this technique:

* This feature is particularly useful when you know exactly which binding you want to find out more about, which is the most common scenario.
* It allows you to know more about bindings that succeed, which many times helps you find the mistake in your logic.

Disadvantages of this technique:

* If you forget to remove the property after you found the problem, it adds to the clutter of the Output Window (which adds to the time it takes to start your application in debug mode).

Converter

The last solution is extremely simple: you can simply add a no-op Converter to your binding and put a breakpoint in its Convert method. This is what this solution looks like:

public class DebuggingConverter : IValueConverter
{
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
return value; // Add the breakpoint here!!
}

public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
throw new NotImplementedException("This method should never be called");
}
}

If you run this code and set a breakpoint inside the Convert method, you can simply hover over the “value” parameter to see what is being passed from the source to the target. In this case, you will see that “value” contains an empty string. This may help you realize that the source of your binding does not have the value you thought it had.

Advantages of this technique:

* It is really easy to implement. It relies on a concept that most data binding users are familiar with.
* It does not depend on the Output window.
* It helps you find out more about scenarios where the binding doesn’t fail.

Disadvantages to this technique:

* It doesn’t provide as much information as the TraceLevel technique.
* If the Binding fails early, the Converter may not be called.

C# html editor

2010-03-03T19:31:00.001+02:00

http://stackoverflow.com/questions/394751/anyone-know-a-code-editor-i-can-embed-in-a-wpf-window-or-windows-forms

scintilla & sharpdevelop
custom compiler on codeproject

Free GeoCoding ?

2009-08-31T16:30:00.000+03:00

Backup pt http://www.viawindowslive.com/Articles/VirtualEarth/Freereversegeocoding.aspx

This article describes how a website VoyageMap.com utilises a free reverse geocoding
data dump from Geonames.org

I restricted the locations to worldwide cities with greater than 1000 residents. This file was available from http://www.geonames.org/ as a data dump. But you can use their free webservice as well by providing Lat and Long values to http://ws.geonames.org/findNearbyPlaceName?lat=47.3&lng=9

Free reverse geocoding by supplying Lat and Long values.
After downloading Cities data dump and importing into my local database I set up a stored procedure to bring back locations that meet the radius parameter and passed in Lat Long values in following sql

SELECT TOP 3
Country.name as country, City.geonameid,City.name, City.latitude, City.longitude,
Avg(3958.75 * ACos(Sin(@Latitude/57.2958) *
Sin(City.Latitude/57.2958) +
Cos(@Latitude/57.2958) *
Cos(City.Latitude/57.2958) *
Cos(City.Longitude/57.2958 - @Longitude/57.2958))) AS miles
FROM
dbo.GeoNamesCity City
join dbo.GeoNamesCountry Country on City.[country code] = Country.[iso alpha2]
WHERE City.Longitude IS NOT NULL AND City.Longitude <> 0
AND City.Latitude IS NOT NULL AND City.Latitude <> 0
AND @Miles >=
(
3958.75 * ACos(Sin(@Latitude/57.2958) *
Sin(City.Latitude/57.2958) +
Cos(@Latitude/57.2958) *
Cos(City.Latitude/57.2958) *
Cos(City.Longitude/57.2958 - @Longitude/57.2958))
)
GROUP BY Country.name, City.geonameid,City.name, City.latitude, City.longitude
ORDER BY miles
Website users can retrieve upto 3 nearest cities to add travel review by right clicking on map

I used the following code to register the click event

map.AttachEvent("onclick",PopupMenu);
Following is how the event is then handled to popup a menu for users to click on to add review, you can see that left click removes the menu

function PopupMenu(e)
{
if (e.eventName == "onclick")
{
if (e.leftMouseButton)
{
RemovePopupMenu(e);
}
else if (e.rightMouseButton)
{
var menu = document.getElementById('popupmenu');
menu.style.left = e.mapX + 'px' ;
menu.style.top = e.mapY + 'px' ;
menu.style.display='block';
popupmenupoint = DoPixelToLL(e.clientX,e.clientY);
}
}
}

To remove the menu

document.getElementById('popupmenu').style.display='none'
I used a web service to query the database and bring back list of cities (you can also use geonames webservice rather than setup your own), the popupmenupoint variable in javascript holds the LatLong values to run against the geonames data dump.

The site heavily uses AJAX model to give users a seamless experience

Conclusion:
For private websites on a limited budget using MapPoint API is an expensive part of retrieving locations by passing Lat Long values, however with free data sources and web services available you can easily integrate reverse lookup into your website.

I would like to thank geonames.org and viavirtualearth.com to allow me to use their data and code snippets that helped in producing this website.

Article contributed by Mo Majad (VoyageMap.com). Have you got something to contribute?

JX4201BH & JX4201BH 2 Digit LED Display Datasheet tips

2009-06-13T23:28:00.010+03:00

10 pins double digits. The pins are counted from left to right down up counter clockwise facing the part 8.8.
Digits are shown by providing current between 5,6 and [1-4,7-10]

Windows Mobile Emulator network

2009-02-25T14:09:00.002+02:00

Microsoft Pocket PC Emulator and Network

If you have to develop a software with Microsoft Visual Studio 2005 for a mobile device (for example Pocket PC 2003) which has to access to your network (local area or internet) you must enable the support for the network into the emulator. These are the steps:

1. Download and install the Virtual Machine Network Driver for Microsoft Device Emulator at this address.
I suggest to do the setup with Visual Studio 2005 and the emulator turned off.
2. From the Network Settings select the Local Area Connection, right click and select Properties, check the box near Virtual Machine Network Services
3. In Visual Studio open Tools -> Options
4. Open the Device Tools -> Devices node
5. Select Pocket PC 2003 Emulator and click Properties
6. From the Transport section select the TCP Connect Transport
7. Click the Configure button and select Obtain an IP address automatically using ActiveSync, then close the dialog box
8. Click Emulator Options..., tab Network, check the box Enable NE2000 PCMIA network adapter and bind to: and from the drop down list select your network card
9. Close all the dialog boxes, run your application, in the emulator open then File -> Configure dialog box
10. Check the box or verify the state of the Enable NE2000 PCMIA network adapter and bind to: box, it must be checked

Now from your software you can use the code to connect to internet, databases servers and so on.

Alone in the dark - mutex use for single instance of application

2009-02-03T09:17:00.003+02:00

Drawback is a denial of service approach


static class Program
{
 [STAThread]
 static void Main()
 {
  bool onlyInstance = false;
  string mutexName = AssemblyGuid;
  // if you want your app to be limited to a single instance across ALL SESSIONS (multiple users & terminal services), then use the following line instead:
  // string mutexName = String.Format("Global\\{0}", AssemblyGuid);
  Mutex mutex = new Mutex(true, mutexName, out onlyInstance);
  if (!onlyInstance) {
   IntPtr hwndFirstInstance = WinApi.FindWindow(null, applicationName); // For FindWindow to work, applicationName must be the same as the title (the Text property) of your MainForm.
   WinApi.PostMessage(
    hwndFirstInstance,
    WinApi.WM_SHOWFIRSTINSTANCE,
    IntPtr.Zero,
    IntPtr.Zero);
   return;
  }
  Application.Run(new MainForm);
  GC.KeepAlive(mutex);
 }
 const string applicationName = "YourApplicationNameGoesHere";
 static public string ApplicationName
 {
  get { return applicationName; } // You could use an Assembly Attribute Accessor instead of a variable, but it involves a bit more code.
 }
 static public string AssemblyGuid
 {
  get
  {
   object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(System.Runtime.InteropServices.GuidAttribute), false);
   if (attributes.Length == 0) {
    return String.Empty;
   }
   return ((System.Runtime.InteropServices.GuidAttribute)attributes[0]).Value;
  }
 } 
}

public class WinApi
{
 public static readonly int WM_SHOWFIRSTINSTANCE = RegisterWindowMessage("WM_SHOWFIRSTINSTANCE");

 [DllImport("user32")]
 public static extern bool PostMessage(IntPtr hwnd, int msg, IntPtr wparam, IntPtr lparam);
 
 [DllImport("user32")]
 public static extern int RegisterWindowMessage(string message);
 
 [DllImport("user32.dll")]
 public static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
 
 [DllImport("user32.dll")]
 public static extern bool SetForegroundWindow(IntPtr hWnd);
 
 [DllImport("user32.dll")]
 public static extern IntPtr FindWindow (string lpClassName, string lpWindowName);

 public static void ShowToFront(string windowName)
 {
  IntPtr window = FindWindow(null, windowName);
  ShowWindow(window, 1);
  SetForegroundWindow(window);
 }
}

public partial class MainForm : System.Windows.Forms.Form
{
        bool minimizedToTray;

 public MainForm()
 {
  InitializeComponent();
  this.Text = Program.ApplicationName;
 }
        private void btnMinToTray_Click(object sender, EventArgs e)
        {
  MinimizeToTray();
        } 
        void MinimizeToTray()
        {
  notifyIcon = new NotifyIcon();
  notifyIcon.Click += new EventHandler(NotifyIconClick);
  notifyIcon.Icon = this.Icon;
  notifyIcon.Text = Program.ApplicationName;
  notifyIcon.Visible = true;
  this.ShowInTaskbar = false;
  this.Hide();
  minimizedToTray = true;
        }
        public void ShowWindow()
        {
  if (minimizedToTray) {
   notifyIcon.Visible = false;
   this.ShowInTaskbar = true;
   this.Show();
   minimizedToTray = false;
  } else {
   WinApi.ShowToFront(this.Text);
  }
        }
        void NotifyIconOpen(Object sender, System.EventArgs e)
        {
  ShowWindow();
        }
 protected override void WndProc(ref Message message)
 {
  if (message.Msg == WinApi.WM_SHOWFIRSTINSTANCE) {
   ShowWindow();
  }
  base.WndProc(ref message);
 }
}

SQL Server triggers used to prevent users to modify data

2009-01-29T16:42:00.001+02:00

IF EXISTS (SELECT * FROM sys.triggers WHERE object_id = OBJECT_ID(N'[InterzicereModificari]'))
DROP TRIGGER [InterzicereModificari]
GO

CREATE TRIGGER dbo.DenyWrite_ViramenteAntet
ON [dbo].[Viramente - antet]
AFTER INSERT,DELETE,UPDATE
AS
BEGIN
RAISERROR ('Nu mai aveti dreptul de a modifica din acest program', 16, 1);
END
GO

MemoryDictionaryCache reminder

2009-01-16T11:55:00.005+02:00


        public interface ICache
        {
            void Reset();
            void Load();
            string LoadMessage { get; set; }
        }

        public class MemoryDictionaryCache<T, Z> : ICache 
        {
            public MemoryDictionaryCache(Func<Dictionary<T, Z>> loadCache, string loadMessage, Func<Dictionary<T,Z>, T, Z> retrieveValue)
            {
                _load = loadCache;
                LoadMessage = loadMessage;
                _retrieveValue = retrieveValue;
            }

            private Func<Dictionary<T, Z>> _load;
            Func<Dictionary<T, Z>, T, Z> _retrieveValue;
            public string LoadMessage { get; set; }

            private Dictionary<T, Z> _cache = null;
            private Dictionary<T, Z> Cache
            {
                get
                {
                    if (_cache == null)
                        Load();
                    return _cache;
                }
            }

            public void Reset()
            {
                _cache = null;
            }

            public void Load()
            {
                using (var waitWindow = new WaitWindow(LoadMessage ?? "Asteptati incarcarea datelor"))
                {
                    _cache = _load();
                }
            }

            public Z GetValue(T forKey)
            {
                return _retrieveValue(Cache, forKey);
            }
        }

        private Dictionary<Type, ICache> _caches = new Dictionary<Type, ICache>();

        private void Initialize()
        {
            _caches.Add(typeof(ContractID), new MemoryDictionaryCache<ContractID, ContractEntity>(
                ()=>new Dictionary<ContractID, ContractEntity>(),
                "Incarc contractele",
                (dic, contractID)=>dic.GetValue(contractID)));
        }

        public ContractEntity GetContractul(ContractID contractID)
        {
            return ((MemoryDictionaryCache<ContractID, ContractEntity>)_caches[typeof(ContractID)]).GetValue(contractID);
        }

Toys for boys

2008-12-12T10:53:00.002+02:00

I can't wait for grab something like this toy for programmers
Some of the specs:

* 80MHz
* 512K flash storage
* 32K RAM
* 3 pushbuttons
* 5 LEDs
* 5V voltage regulator
* Terminal emulator command interface
* USB bootloader
* SMD resistor pads for every I/O pin

Lambda expressions closure fix

2008-12-10T10:13:00.002+02:00

Is quite a time from my last post. My wife and I were blessed with a baby boy, and the time frozen for me, between the child needs and the job.

Today i had read an article very interesting about closure fix in Enumerator context.
http://geekswithblogs.net/jolson/archive/2008/06/13/lambdas---know-your-closures.aspx
below is a copy paste of it in case that page disappear:

Lambdas - Know Your Closures

In this post I want to discuss with you the importance of realizing how lambdas work (and why you should care). Let's dive right in with some code.

Given the following code snippet, what would you expect the output to be (no cheating :P)?

var actions = new List();

for (int i = 0; i < 10; i++)
{
actions.Add(() => Console.WriteLine(i));
}

foreach (var action in actions)
{
action();
}

Would you believe me if I told you this is the output you get?

10
10
10
10
10
10
10
10
10
10

At first glance, one might expect this output:

0
1
2
3
4
5
6
7
8
9

But all tens are output instead. Why does this happen? Let's crank open Reflector and find out why...

The first thing you'll notice is that the compiler has created a helper class to enable the closure we have. This helper class created by the compiler contains a local variable that we use to iterate over and a method that our delegate is contained within. This helper class is especially interesting because it is where the magic happens.

[CompilerGenerated]
private sealed class <>c__DisplayClass2
{
// Fields
public int i;

// Methods
public void

b__0()
{
Console.WriteLine(this.i);
}
}

Rather than diving into MSIL, let's look at some pseudo-code of what the compiler _actually_ executes with the original code above (based on the generated MSIL):

var actions = new List();

<>c__DisplayClass2 localFrame = new <>c__DisplayClass2();
for (localFrame.i = 0; localFrame.i < 10; localFrame.i++)
{
actions.Add(localFrame.

b__0);
}

foreach (var action in actions)
{
action();
}

Perhaps now you can see where the problem is. The "problem" in our original code exists because of the scope that our closures are defined. The local index from our for loop is now stored in our helper class <>c__DisplayClass2. And the code that is executed by the action is contained within the compiler generated

b__0() method now. So the Console.WriteLine() method now uses the local variable from <>c__DisplayClass2 when it is executed.

So while we are looping through building all our actions, we are also incrementing the property i in localFrame (an instance of <>c__DisplayClass2). Then at the end when we are actually executing the actions, the

b__0() is called and uses the local i property (which by this time, has already been incremented to 10 from our loop). And that's why every action we execute prints "10" instead of the 0 through 9 like we expected.

So, why do you need to know how these work? Take the following code that outputs items from an array of strings:

var actions = new List();
string[] urls =
{
"http://www.url.com",
"http://www.someurl.com",
"http://www.someotherurl.com",
"http://www.yetanotherurl.com"
};

for (int i = 0; i < urls.Length; i++)
{
actions.Add(() => Console.WriteLine(urls[i]));
}

foreach (var action in actions)
{
action();
}

This code looks pretty innocuous. Our bounds are protected, and we just index into our array to output a string. But, is that what we're really doing? Remember how closures work from above. The actual thing that happens when I run this code is this:

Confusing

Interesting. Even though our index variable should only even be less than the length of our url array, an exception is thrown because the index variable is actually equal to the length of our url array (and hence outside of the bounds thanks to 0-based indices).

Well, that wasn't what we were probably expecting. But now that we are having this "problem", what is the easiest way to resolve it? Remember that the problem is happening because of the scope of the variable within our closure. So to fix this, we can essentially declare a temporary variable that is unique in scope to this specific iteration through our array:

for (int i = 0; i < urls.Length; i++)
{
string localUrl = urls[i];
actions.Add(() => Console.WriteLine(localUrl));
}

And now the code is fixed.

Understanding how lambdas work is especially important when you start developing with a library that leverages lambdas heavily like LINQ does, or Parallel Extensions to the .NET Framework. And don't worry, even those people that know how lambdas work occasionally get bitten by this behavior.

A good laugh speech recognition in Vista

2008-07-22T10:11:00.002+03:00

I know how hard is to make such a tool, but I can't stop to lol about outcome

MRSD how to change default port for host projects

2008-05-22T21:16:00.004+03:00

[MRSD(Microsoft Robotics Developer Studio) installation folder]\tools\Templates\CSharp\ contains a zip file named CS_Hosting_2.0.730.3.zip that contains a template for a c# host project. Change the program.cs in that archive to use the new ports instead of defaults 50000 and 50001.

A critic over your shoulder

2008-05-22T09:45:00.010+03:00

Pex could be the critic you need for your code. If you don't have a friend to criticize when you make a mistake or to laugh his ass off, then you should find one. Pex is a testing engine, that make code analysis and generate unit tests accordingly. The final scope is to increase the quality of your unit tests by raising your test code coverage.

Smat tags in runtime Windows.Forms

2008-05-21T17:05:00.004+03:00

A very interesting topic aboutSmart tags in runtime on Windows.Forms. I just made a copy:

You have to create a DesignerOptions with UseSmartTags property set to true, add the DesignerOptions to DesignerOptionService, after which add this service to the DesignerSurface, I write the following sample which host a TextBox and a DataGridView control on the designer surface.

Code Snippet

namespace Sample25

{

public partial class Form2 : Form

{

public Form2()

{

InitializeComponent();

}

private void Form2_Load(object sender, EventArgs e)

{

myDesignSurface surface = new myDesignSurface();

IDesignerHost host = surface.GetService(typeof(IDesignerHost)) as IDesignerHost;

UserControl root = host.CreateComponent(typeof(UserControl)) as UserControl;

root.Width = this.panel1.Width - 30;

root.Height = this.panel1.Height - 30;

TextBox textbox = host.CreateComponent(typeof(TextBox)) as TextBox;

textbox.Location = new Point(100, 90);

textbox.Text = "textbox";

root.Controls.Add(textbox);

DataGridView dgv = host.CreateComponent(typeof(DataGridView)) as DataGridView;

dgv.Location = new Point(100, 130);

dgv.Text = "DataGridView";

root.Controls.Add(dgv);

Control c = surface.View as Control;

c.Dock = DockStyle.Fill;

c.BackColor = Color.White;

c.Parent = this.panel1;

}

}

class myDesignSurface : DesignSurface

{

public myDesignSurface()

{

MyDesignerOptionService optionService = new MyDesignerOptionService();

this.ServiceContainer.AddService(typeof(DesignerOptionService), optionService);

}

}

class MyDesignerOptionService : DesignerOptionService

{

protected override void PopulateOptionCollection(DesignerOptionCollection options)

{

if (options.Parent == null)

{

DesignerOptionCollection doc =
this.CreateOptionCollection(options, "WindowsFormsDesigner", null);

DesignerOptions doptions = new DesignerOptions();

doptions.UseSmartTags = true;

this.CreateOptionCollection(doc, "General", doptions);

}

}

}

}

Changing learning curve ... is developer's learning effort

2008-05-21T11:37:00.008+03:00

How easy is to change the learning curve for the users of your programs? The answer lays on your response to What is ergonomics?

Example of not to do: to name Arbiter.Choise<>() (is suggesting a decision to make by using a predicate ) instead of Arbiter.TakeFirstArrivingFrom<>() (more clear for the reader) or Arbiter.FirstReceivedFrom() or even Arbiter.Any<>() sounds better.

I polluted my mind with Implementing a Simple 2D Object Tracker. I'm sorry right now, because i want to make my own system of recognition, or at least to take the time to think the best approach. After that to see other programmer's solutions.

Nature is fighting back - the suicide ants

2008-05-20T10:15:00.003+03:00

NASA moves to save computers from swarming ants.
I'm remember Ants a great animation movie and the Ants and The Day of the ants by Webber great sci-fi books all in category must see and read

Falling in the pit of success

2008-05-20T08:47:00.013+03:00

First service that control a robot. Is very simple in his nature, but is the first little big step.

Prepare yourself for staring at amazing movie - great work Boston Dynamics

At this time I'm a PHSC

SpamAssasin with the Traffic control tool a good news.

Some steganography (let the user to hide data in plain view) tools Hide in Picture, PDF's, HTML files or bitmaps, mp3stego
To hide a folder, just rename it to Alt+255, change the icon representation to a blank icon.

Mouse gesture in C#, to think of some usage in the future solutions.

Starting is hard sometimes

2008-05-18T09:42:00.013+03:00

I just watched the architecture getting started video for Microsoft Robotics Studio (MSRS) and decided to play with Visual Programming Language for MSRS. Is very intuitive and I made a hello world application in 30 seconds. But when tried to run I got:

A valid transport port was not specified.

This setback is easy to resolve by using

netstat -a -o

and see if the ports are used already by your system and make a decision if you want to terminate the program that is using the ports or to use other ports. To change what ports to use is fairly simple. From the Run menu choose Port Settings and enter the desired unused port numbers (let say 55004 and 55504).
Running again I got other error:

DsspForwarder:CreateRequestFrowarder. System.ArgumentOutOfRangeException: Specified argument was out of the range of valid values. Parameter name: Transport not found in local ServiceEnvironment instance, for scheme:http

ouch. Error that is hiding other error in other service:

Cannot create a TCP Listener.

Error was raised because my operating system was Vista, and UAC (User Account Control) is on. The right solution for this is to use httpreserve, not to disable the UAC. I run DSS Command Prompt from the menu group Microsoft Robotics Developer Studio as administrator and executed the command httpreserve /port:55004 /user:me ( 55004 is the http port and me is current vista user logged in). After this application run smoothly and a hello appear.

Social integration

2008-05-16T09:58:00.004+03:00

Google http://translate.google.com/translate_t now allow me to translate text from English in Romanian. Is not perfect, but what is?

A very funny toy http://phun.cs.umu.se/wiki/Download to learn physics.

http://www.FlazX.com is a very nice site, it makes me to want to live forever.

Future is now

2008-05-15T11:20:00.004+03:00

Microsoft TouchWall is very impressive and is more practical then Surface table.

Sharping the axe before cutting the tree

2008-05-15T00:47:00.004+03:00

LinqPad from http://www.linqpad.net is a nice learning tool. It comes with a challenge. I will subscribe to it.

It seems that saving(inserting) bulk in SQL Server is much more efficient. So our framework will gain a new functionality. There are scenarios when allot of calculated records will get home by this new bus.

I'm disappointed by Entities Framework I hope that will evolve in a real tool in the near future.

It seems that the day is getting smaller for me, even the light period is increasing.