Un-recursive - part 1

I decided to write a cycle of posts about avoiding recursive calls in your algorythms. Recursion is the thing i hate to implement - it's hard to debug, it cost too much and so on. In this cycle i'm going to start with a common task - Tree Painting in depth - a task that could easyly solved with recursive calls - and show two ways to achieve the goal without recursive calls. After that i ll build parallels between this task and "common" recursive-solved task. Than i will implement quick sort and merge sort. Show/Hide

Tree Painting in Depth is a common task that could easyly be solved with recursive calls. Suppose we have a root node of a tree and a collection of children. Recursive method should paint root node and than calls itself for each child node. Pseudo-code for such method will look like Method(node root) { root.Paint(); for i = 1 to childern.Count { Method(children[i]); } } To avoid recursive calls in this algorythm we can use a stack of nodes to call Paint(). After painting a node we add its children at the beginning of the stack. Look at the implementation of this: We have a class Node

1:  class Node  
2:       {  
3:            public int Number { get; set; }  
4:            public Node[] Children { get; set; }  
5:            public void Paint()  
6:            {  
7:                 Console.WriteLine(Number + " was painted");  
8:            }  
9:       }  

Property Number at line 3 is just a name for node and Children is a collection of child nodes. Class Painter will paint a tree, accepting a root node building a stack of nodes which expect to be be called:

1:       class Painter  
2:       {  
3:            public void PaintWithStack(Node root)  
4:            {  
5:                 List<Node> stack = new List<Node>();  
6:                 stack.Add(root);  
7:                 while (stack.Count > 0)  
8:                 {  
9:                      var node = stack[0];  
10:                      node.Paint();  
11:                      stack.RemoveAt(0);  
12:                      if (node.Children != null)  
13:                      {  
14:                           for (int i = node.Children.Length - 1; i >= 0; i--)  
15:                           {  
16:                                stack.Insert(0, node.Children[i]);  
17:                           }  
18:                      }  
19:                 }  
20:            }  
21:       }  

A code to test algorytm is provided below. Lines 3-59 just instantiate a tree to paint. We call painter at line 61 to perform the task.

1:  static void Main(string[] args)  
2:            {  
3:                 var tree = new Node  
4:                 {  
5:                      Number = 1,  
6:                      Children = new[] {  
7:                           new Node  
8:                           {  
9:                                Number = 2,  
10:                                Children = new[] {  
11:                                     new Node  
12:                                     {  
13:                                          Number = 5,  
14:                                     },  
15:                                     new Node  
16:                                     {  
17:                                          Number = 6  
18:                                     }  
19:                                }  
20:                           },  
21:                           new Node  
22:                           {  
23:                                Number = 3,  
24:                                Children = new[] {  
25:                                     new Node  
26:                                     {  
27:                                          Number = 7  
28:                                     }  
29:                                }  
30:                           },  
31:                           new Node  
32:                           {  
33:                                Number = 4,  
34:                                Children = new [] {  
35:                                     new Node  
36:                                     {   
37:                                          Number = 8  
38:                                     },  
39:                                     new Node  
40:                                     {  
41:                                          Number = 9,  
42:                                          Children = new []{  
43:                                               new Node  
44:                                               {  
45:                                                    Number = 11  
46:                                               },  
47:                                               new Node  
48:                                               {  
49:                                                    Number = 12  
50:                                               }  
51:                                          }  
52:                                     },  
53:                                     new Node  
54:                                     {  
55:                                          Number = 10  
56:                                     }  
57:                                }  
58:                           }}  
59:                 };  
60:                 Painter p = new Painter();  
61:                 p.PaintWithStack(tree);  
62:                 Console.ReadKey();  
63:            }  

Output of this code will

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

which corresponds to the expected output.

Randomized Quick-sort

Quick-sort is another type of comparison sorting algorythm. It's much better than other comparing algorythms cause it doesn't require additional space for its work (unlike merge sort for example). It also has a good time of work in average case - O(n lgn) - that is best time for every comparing algorytm as you know. It's also has asymptotic n^2 time of work in worst case, that occurs rarely. Using randomization at the each step of algorytm helps to avoid receiving "pre-defined worst case", when our solution gives us worst time on a particular sequence. Here is an implementation of randomized qucik-sort: Show/Hide

1:  using System;  
2:  using System.Collections.Generic;  
3:  using System.Linq;  
4:  using System.Text;  
5:  namespace QuickSort  
6:  {  
7:       public class SortManager  
8:       {  
9:            public int[] Sort(int[] data)  
10:            {  
11:                 try  
12:                 {  
13:                      SortRange(data, 0, data.Length - 1);  
14:                 }  
15:                 catch (Exception ex)  
16:                 {  
17:                      int a = 1;  
18:                 }  
19:                 return data;  
20:            }  
21:            public void SortRange(int[] data, int startIndex, int endIndex)  
22:            {  
23:                 if (startIndex >= endIndex) return;  
24:                 int rangeLen = endIndex - startIndex + 1;  
25:                 Random rnd = new Random();  
26:                 int randomIndex = rnd.Next(rangeLen - 1) + startIndex;  
27:                 int val = data[randomIndex];  
28:                 data[randomIndex] = data[endIndex];  
29:                 data[endIndex] = val;  
30:                 int temp = 0;  
31:                 int j = startIndex;  
32:                 bool isRangeEqual = true;  
33:                 for (int i = startIndex; i <= endIndex; i++)  
34:                 {  
35:                      if (data[i] != val) isRangeEqual = false;  
36:                      if (data[i] < val)  
37:                      {  
38:                           temp = data[j];  
39:                           data[j] = data[i];  
40:                           data[i] = temp;  
41:                           j++;  
42:                      }  
43:                 }  
44:                 if (isRangeEqual) return;  
45:                 SortRange(data, startIndex, j - 1);  
46:                 SortRange(data, j, endIndex);  
47:            }  
48:       }  
49:  }  

Lines 35 and 44 are a small cheat cause i can't understand how it should behaves when all items in the input are equal. I alse add some test to view how it works

1:  using System;  
2:  using System.Text;  
3:  using System.Collections.Generic;  
4:  using System.Linq;  
5:  using NUnit;  
6:  using NUnit.Framework;  
7:  using Karn.PerfomanceLibrary;  
8:  namespace QuickSort.Fixture  
9:  {  
10:       /// <summary>  
11:       /// Summary description for UnitTest1  
12:       /// </summary>  
13:       public class SortManagerTest  
14:       {  
15:            private Observer watches = new Observer();  
16:            public SortManagerTest()  
17:            {  
18:                 //  
19:                 // TODO: Add constructor logic here  
20:                 //  
21:            }  
22:            [Test]  
23:            public void SortCommonOrder()  
24:            {  
25:                 //  
26:                 // TODO: Add test logic     here  
27:                 //  
28:                 var manager = new SortManager();  
29:                 watches.Start("SortCommonOrder");  
30:                 var input = new[] { 9, 13, 2, 6, 19, 8, 24, 49, 3, 33, 27, 16, 11 };  
31:                 int[] data = manager.Sort(input);  
32:                 watches.Stop("SortCommonOrder");  
33:                 Assert.IsTrue(watches["SortCommonOrder"].ElapsedMilliseconds < 100);  
34:                 Assert.IsTrue(input.Length == data.Length);  
35:                 Assert.IsTrue(checkDataSorted(data));  
36:            }  
37:            [Test]  
38:            public void SortEqualOrder()  
39:            {  
40:                 var manager = new SortManager();  
41:                 watches.Start("SortEqualOrder");  
42:                 var input = new[] { 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 };  
43:                 int[] data = manager.Sort(input);  
44:                 watches.Stop("SortEqualOrder");  
45:                 Assert.IsTrue(watches["SortEqualOrder"].ElapsedMilliseconds < 100);  
46:                 Assert.IsTrue(input.Length == data.Length);  
47:                 Assert.IsTrue(checkDataSorted(data));  
48:            }  
49:            [Test]  
50:            public void SortSorted()  
51:            {  
52:                 var manager = new SortManager();  
53:                 watches.Start("SortSorted");  
54:                 var input = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 };  
55:                 int[] data = manager.Sort(input);  
56:                 watches.Stop("SortSorted");  
57:                 Assert.IsTrue(watches["SortSorted"].ElapsedMilliseconds < 100);  
58:                 Assert.IsTrue(input.Length == data.Length);  
59:                 Assert.IsTrue(checkDataSorted(data));  
60:            }  
61:            [Test]  
62:            public void SortUnsorted()  
63:            {  
64:                 var manager = new SortManager();  
65:                 watches.Start("SortUnsorted");  
66:                 var input = new[] { 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };  
67:                 int[] data = manager.Sort(input);  
68:                 watches.Stop("SortUnsorted");  
69:                 Assert.IsTrue(watches["SortUnsorted"].ElapsedMilliseconds < 100);  
70:                 Assert.IsTrue(input.Length == data.Length);  
71:                 Assert.IsTrue(checkDataSorted(data));  
72:            }  
73:            bool checkDataSorted(int[] data)  
74:            {  
75:                 if (data.Length <= 1) return true;  
76:                 for (int i = 1; i < data.Length; i++)  
77:                 {  
78:                      if (data[i] < data[i - 1]) return false;  
79:                 }  
80:                 return true;  
81:            }  
82:       }  
83:  }  

Count sort - yehhaaa!

Count sort is very good to sort sequence of integer which has small range of values (in comparison with sequence length). Due to two assumptions - our sequence contains only integers and its values range is much less than amount of items in sequence, it's linear in time to the amount of items in input. It's much better than classic algorythms based on comparison, cause it doesn't use comparison in its work, so it overcomes traditional for comparing algorythms O(nlogn). Here is an implementation: Show/Hide

 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
 using System.Text;  
 namespace CountSort  
 {  
     public class SortManager  
     {  
         public int[] Sort(int[] data)  
         {  
             int max = 0;  
             int min = 0;  
             // get min and max elements of input array to get borders of counting array  
             GetMaxMin(data, out min, out max);  
             // declare sorting array  
             int[] metaCount = new int[max + 1 - min];  
             // count amount of each item in iput  
             foreach (int d in data)  
             {  
                 metaCount[d - min]++;  
             }  
             // rebuild sorting array to get end position of each item in sorted output  
             for (int i = 1; i < metaCount.Length; i++)  
             {  
                 metaCount[i] += metaCount[i - 1];  
             }  
             int[] returnValue = new int[data.Length];  
             // just fill output array  
             int currentInsertPosition = 0;  
             for (int i = 0; i < metaCount.Length; i++)  
             {  
                 for (; currentInsertPosition < metaCount[i]; currentInsertPosition++)  
                 {  
                     returnValue[currentInsertPosition] = i + min;  
                 }  
             }  
             return returnValue;  
         }  
         void GetMaxMin(int[] data, out int min, out int max)  
         {  
             if (data.Length == 1)  
             {  
                 min = data[0];  
                 max = data[0];  
                 return;  
             }  
             decimal mediana = data.Length / 2;  
             int[] left = new int[(int)Math.Floor(mediana)];  
             int[] right = new int[data.Length - left.Length];  
             for (int i = 0; i < left.Length; i++)  
             {  
                 left[i] = data[i];  
             }  
             for (int i = 0; i < right.Length; i++)  
             {  
                 right[i] = data[i + left.Length];  
             }  
             int leftMin = 0;  
             int leftMax = 0;  
             int rightMin = 0;  
             int rightMax = 0;  
             GetMaxMin(left, out leftMin, out leftMax);  
             GetMaxMin(right, out rightMin, out rightMax);  
             min = leftMin < rightMin ? leftMin : rightMin;  
             max = leftMax > rightMax ? leftMax : rightMax;  
         }  
     }  
 }  

and of course some test for you:

 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
 using System.Text;  
 using NUnit;  
 using NUnit.Framework;  
 namespace CountSort.Fixture  
 {  
     public class SortManagerTest  
     {  
         [Test]  
         public void TestFromZero()  
         {  
             SortManager manager = new SortManager();  
             int[] data = new[] { 1, 3, 0, 2, 1, 4, 3, 0, 2, 4, 2, 4, 3, 2, 1, 0 };  
             int[] sorted = manager.Sort(data);  
             checkSort(data, sorted);  
         }  
         [Test]  
         public void TestFromLessZero()  
         {  
             SortManager manager = new SortManager();  
             int[] data = new[] { 1, 3, 0, -1, 2, 1, 4, 3, 0, -1, -2 ,2, 4, 2, 4, -2, 3, -1, 2, 1, 0 };  
             int[] sorted = manager.Sort(data);  
             checkSort(data, sorted);  
         }  
         [Test]  
         public void TestFromGreatZero()  
         {  
             SortManager manager = new SortManager();  
             int[] data = new[] { 1, 3, 5, 1, 2, 1, 4, 3, 5, 11, 2, 2, 4, 2, 4, 2, 3, 1, 2, 1, 6 };  
             int[] sorted = manager.Sort(data);  
             checkSort(data, sorted);  
         }  
         [Test]  
         public void TestWithSpaces()  
         {  
             SortManager manager = new SortManager();  
             int[] data = new[] { 3, 3, 1, 1, 3, 5, 3, 1, 5, 6, 3, 1 };  
             int[] sorted = manager.Sort(data);  
             checkSort(data, sorted);  
         }  
         void checkSort(int[] input, int[] output)  
         {  
             // check both arrays have equal amount of items  
             Assert.AreEqual(output.Length, input.Length);  
             // check for sort  
             for (int i = 1; i < output.Length; i++)  
             {  
                 Assert.IsTrue(output[i - 1] <= output[i]);  
             }  
             // check no new items in output  
             for (int i = 0; i < output.Length; i++)  
             {  
                 bool isInInput = false;  
                 foreach (int inp in input)  
                 {  
                     if (output[i] == inp)  
                     {  
                         isInInput = true;  
                         break;  
                     }  
                 }  
                 Assert.IsTrue(isInInput);  
             }  
             // check no items lost  
             for (int i = 0; i < input.Length; i++)  
             {  
                 bool isInOutput = false;  
                 foreach (int outp in output)  
                 {  
                     if (input[i] == outp)  
                     {  
                         isInOutput = true;  
                         break;  
                     }  
                 }  
                 Assert.IsTrue(isInOutput);  
             }  
             // check sum  
             int sumInput = 0;  
             for (int i = 0; i < input.Length; i++)  
             {  
                 sumInput += input[i];  
             }  
             int sumOutput = 0;  
             for (int i = 0; i < output.Length; i++)  
             {  
                 sumOutput += output[i];  
             }  
             Assert.AreEqual(sumInput, sumOutput);  
         }  
     }  
 }  

Merge implementation with predicate

I study algorythms carefully during last two weeks and as you probably know, many algorythm tasks require implementation of sorting procedure. There is a huge amount of various sorting algorythms, such as Quick Sort, Heap Sort and so on. But one of the easiest to implement is a Merge Sort. You can find its description somewhere. I implemented it several times - for ascending sorting, for descending sorting and so on, so finally i take time to implement it with any predicate you like. Here is an implementation:

There is one class SortManager with method Sort, that calls itself recursively on input parts:

 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
 using System.Text;  
 namespace MergePredicate  
 {  
      public class SortManager  
      {  
           public int[] Sort(int[] data, Func<int, int, bool> predicate)  
           {  
                if (data.Length <= 1) return data;  
                decimal mediana = data.Length / 2;  
                // left part of our input for first recursion call  
                int[] leftPart = new int[(int)Math.Floor(mediana)];  
                // right part  
                int[] rightPart = new int[data.Length - (int)Math.Floor(mediana)];  
                // fill left part with data  
                for (int i = 0; i < leftPart.Length; i++)  
                {  
                     leftPart[i] = data[i];  
                }  
                // fill right part  
                for (int i = leftPart.Length; i < data.Length; i++)  
                {  
                     rightPart[i - leftPart.Length] = data[i];  
                }  
                // sort both parts  
                int[] leftSorted = Sort(leftPart, predicate);  
                int[] rightSorted = Sort(rightPart, predicate);  
                return MergeByPredicate(leftSorted, rightSorted, predicate);  
           }  
           /// <summary>  
           /// Main procedure - merge both sorted arrays in one  
           /// </summary>  
           /// <param name="leftSorted"></param>  
           /// <param name="rightSorted"></param>  
           /// <param name="predicate"></param>  
           /// <returns></returns>  
           public int[] MergeByPredicate(int[] leftSorted, int[] rightSorted, Func<int, int, bool> predicate)  
           {  
                // returned merged array  
                int[] data = new int[leftSorted.Length + rightSorted.Length];  
                // cursors over both parts  
                int i = 0;  
                int j = 0;  
                while (i + j < data.Length)  
                {  
                     // we are in the end of right part  
                     if (j == rightSorted.Length)  
                     {  
                          while (i < leftSorted.Length)  
                          {  
                               data[i + j] = leftSorted[i];  
                               i++;  
                          }  
                     }  
                     // or in the end of left part  
                     if (i == leftSorted.Length)  
                     {  
                          if (j < rightSorted.Length)  
                          {  
                               data[i + j] = rightSorted[j];  
                               j++;  
                          }  
                     }  
                     // left part of both conditions we need not to get out of the bound of data  
                     while (i < leftSorted.Length && predicate(leftSorted[i], rightSorted[j]))  
                     {  
                          data[i + j] = leftSorted[i];  
                          i++;  
                     }  
                     while (j < rightSorted.Length && i < leftSorted.Length && predicate(rightSorted[j], leftSorted[i]))  
                     {  
                          data[i + j] = rightSorted[j];  
                          j++;  
                     }  
                }  
                return data;  
           }  
      }  
 }  

I also added some tests if you want to see it's working. I use NUnit as Test Tool cause i have no Visual Studio Testing tool at home. Last note: be carefull about predicate to compare values. It should work as if predicate(a, b) == false then predicate(b, a) == true so dont pass predicate like (a, b) => a < b cause it won't pass condition if a = b (cause a < b == false and b < a == false) instead use (a, b) => a <= b The third test method provides a predicate to separate array on odd and non-odd numbers, for you to evaluate the power of predicate merge ;-)

 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
 using System.Text;  
 using NUnit;  
 using NUnit.Framework;  
 using MergePredicate;  
 namespace MergePredicate.Fixture  
 {  
      public class MergePredicateTest  
      {  
           [Test]  
           public void TestDescendingSort()  
           {  
                SortManager manager = new SortManager();  
                var data = new [] { 3, 12, 6, 9, 43, 1, 33, 23, 12, 38, 7, 19 };  
                Func<int, int, bool> predicate = (a, b) => a <= b;  
                var output = manager.Sort(data, predicate);  
                checkSorting(data, output, predicate);  
           }  
           [Test]  
           public void TestAscendingSort()  
           {  
                SortManager manager = new SortManager();  
                var data = new[] { 3, 12, 6, 9, 43, 1, 33, 23, 12, 38, 7, 19 };  
                Func<int, int, bool> predicate = (a, b) => a >= b;  
                var output = manager.Sort(data, predicate);  
                checkSorting(data, output, predicate);  
           }  
           [Test]  
           public void TestOddnessSort()  
           {  
                SortManager manager = new SortManager();  
                var data = new[] { 3, 12, 6, 9, 43, 1, 33, 23, 12, 38, 7, 19 };  
                Func<int, int, bool> predicate =  
                     (a, b) =>  
                     {  
                          if (a % 2 != 0 && b % 2 == 0) return false;  
                          return true;  
                     };  
                var output = manager.Sort(data, predicate);  
                checkSorting(data, output, predicate);  
           }  
           void checkSorting(int[] data, int[] sortedData, Func<int, int, bool> predicate)  
           {  
                Assert.AreEqual(data.Length, sortedData.Length);  
                if (sortedData.Length > 1)  
                {  
                     for (int i = 1; i < sortedData.Length; i++)  
                     {  
                          Assert.IsTrue(predicate(sortedData[i - 1], sortedData[i]));  
                     }  
                }  
                foreach (int sorted in sortedData)  
                {  
                     bool sortedIsInInitial = false;  
                     foreach (int initial in data)  
                     {  
                          if (sorted == initial)  
                          {  
                               sortedIsInInitial = true;  
                               break;  
                          }  
                     }  
                     Assert.IsTrue(sortedIsInInitial);  
                }  
           }  
      }  
 }  

Hide button test

I want to test hot to hide text here Show/Hide

This is Hidden Text

extract dll from GAC

Do you know that you can view GAC as "usual" folder if you unregister shfusion.dll? regsvr32 /u C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\shfusion.dll You can browse it and copy any folder you like. Just not to forget register shfusion.dll back.

your javascript and validators' javascript

I was creating a small web-page the day before. There was a button like this:

I wanted confirmation box appeared before button would postback the page to the server so in Page_load i added such row:

btnComplete.Attributes.Add("OnClick", "return confirm('" + ConfirmTextWarning + "');");

After that, everything was working fine. A bit later i added RequiredFieldValidator to validate a textbox on the page. The button's "Causes validation" button was set to true, but there was no validation on click of the button. The confirmation box was shown but if i click yes - page was send to the server without any validation. When i checked the page source in browser, i found there this element:

<input type="submit" name="btnComplete" value="Complete" onclick="return confirm('some text');WebForm_DoPostBackWithOptions(new WebForm_PostBackOptions("btnComplete", "", true, "", "", false, false))" id="btnComplete" />

As you can see, call of the validator's javascript function is added to the onclick event of the button, but it was not call due the return keyword in confirmation box call. I changed row in the Page_load method to

btnComplete.Attributes.Add("OnClick", "confirm('" + ConfirmTextWarning + "');");

and output became

<input type="submit" name="btnComplete" value="Complete" onclick="confirm('some text');WebForm_DoPostBackWithOptions(new WebForm_PostBackOptions("btnComplete", "", true, "", "", false, false))" id="btnComplete" />

And it worked fine:) Thank you if you read it, it was my last post before vacations.

Never return!

Never return in the middle of the function.
Never return in the middle of the function.
Never return in the middle of the function.
Never return in the middle of the function.
Never return in the middle of the function.

If you don't want code behind return to be executed, rever conditions of return

Instead of
if(returnCondition) return yourValue;
/// some code

write
if(!returnCondition)
{
//// some code
}
return yourValue;

Never return in the middle of the function.

Test yourself.

Just a small task for you, try not to cheat and you ll get a pie :)
Show/Hide

You have a Provider class, pretty simple:

public class Provider
{
public delegate void NotifyDelegate(string message);

public event NotifyDelegate Notify;
}

And class Consumer a bit more difficult:

public class Consumer
{
public int Id { get; set; }

~Consumer()
{
Console.WriteLine("Consumer " + Id + " finalized...");
}

public void Consumer_Notify(string message)
{
}
}

And finally here is favourable ;) static void Main:

static void Main()
{
var provider = new Provider();

var topLevelConsumers = new List();

for (var i = 0; i < 5; i++)
{
var consumer = new Consumer { Id = i };
provider.Notify += consumer.Consumer_Notify;
}

for (var i = 5; i < 10; i++)
{
var consumer = new Consumer { Id = i };
provider.Notify += consumer.Consumer_Notify;
topLevelConsumers.Add(consumer);
}

Console.WriteLine("Step 1. Collect garbage");

GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();

Console.WriteLine("Step 2. Dispose provider");

provider = null;

GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();

Console.WriteLine("Step 3. Close app");
Console.ReadKey();
}





Try to predict output of such main function (don't pay attention to the Id's order in output)?

just-in-mind: resharper doesn't look into false preprocessor directives

Suddenly noticed resharper doesn't look into preprocessor directives if they are false. For example, it counts such code as good:

var debugVariable = 0;
Console.WriteLine("This use the variable in output, " + debugVariable);
Console.WriteLine("And this is not");

Now, switch to "Release" configuration and add some preprocessor directives, to get a code like this:

var debugVariable = 0;
#if DEBUG
Console.WriteLine("This use the variable in output, " + debugVariable);
#else
Console.WriteLine("And this is not");
#endif

Resharper doesn't like it and it shows that variable debugVariable is never used.

Enterprise Library custom tracelistener to log to MS CRM

Hi to all. I hope this will be the first successfull entry in my blog.
It's devoted to a class i created recently in my current project. We plan to use Enterprise Library
in our projects and want our MS CRM users able to watch through the log entries via MS CRM. So my article describes
a process of creation custom listener for Enterprise Library that is able to write entries in MS CRM. I used
Enterpise library Beta 2 version, and it has poor documentation, so in several places i used a workaround code because
i failed to use all power of EL API for creating custom listener... So lets start!
Show/Hide

We start from declaring our class, it's inherited from CustomTraceListener class and marker with
ConfigurationElementType to mark configuration section we will use in our projects to configure our listener:
[ConfigurationElementType(typeof(CustomTraceListenerData))]
public class MSCRMTraceListener : CustomTraceListener
{
}

I skip description of connection to MS CRM webservice, just say that i have a property Servise that returns object of
CrmService type. Something like this:
private CrmService Service
{
get
{
}
}

We create property SeveritySetting to get appropriate severity level from the listener's configuration setting. This is my
cheat-workaround-code, because i failed to receive "native configuration"'s severity setting from config, so i was needed to use
attributes of the listener to keep appropriate severity. The property looks like:
private TraceEventType SeveritySetting
{
get
{
return GetSeverityFromSettings();
}
}

And GetSeverityFromSettings method contains attribute processing:
///

/// Receives maximum severity for logging from configuration settings.
/// If settings doesn't contain SeverityAttributeKey key, it returns Verbose.
/// If attribute contains integer value - we parse it to understand what range 1-2-4-8-16 it belongs to.
/// If attribute contains non-integer value - try to compare with enumeration members' names,
/// if fails - return Verbose.
///

/// Maximum severity we will message.
private TraceEventType GetSeverityFromSettings()
{
/// If settings doesn't contain SeverityAttributeKey key, it returns Verbose
if (!Attributes.ContainsKey(SeverityAttributeKey)) return TraceEventType.Verbose;
var severitySetting = Attributes[SeverityAttributeKey];

int severity;

/// If attribute contains integer value - we parse it to understand what range 1-2-4-8-16 it belongs to.
if (Int32.TryParse(severitySetting, out severity))
{
if (severity <= 1) return TraceEventType.Critical;
if (severity <= 2) return TraceEventType.Error;
if (severity <= 4) return TraceEventType.Warning;
return severity <= 8 ? TraceEventType.Information : TraceEventType.Verbose;
} /// If attribute contains non-integer value - try to compare with enumeration members' names /// if fails - return Verbose. switch (severitySetting.ToLower())
{
case "critical":
return TraceEventType.Critical;
case "error":
return TraceEventType.Error;
case "warning":
return TraceEventType.Warning;
case "information":
return TraceEventType.Error;
default:
return TraceEventType.Verbose;
}
}
We need to override TraceData and Write methods to log messages. TraceData processes incoming data object and if it's LogEntry object, it calls asynchroniously method to write it to MS CRM. I use asynchronious call because calling crm's webservice can take significant amount of time and i don't want external callers suffered from this. If data is not LogEntry object i just call simple writing, it calls asyncronious writing itself public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, object data)
{
if (data is LogEntry)
{
/// If data has insufficient severity level - just return
if ((data as LogEntry).Severity > SeveritySetting) return;
/// start asynchronious thread for logging
var traceThread = new Thread(WriteAsync);
traceThread.Start(data);
}
else
{
/// Severity of the message is not defined, we count it as a Verbose by default
if (TraceEventType.Verbose > SeveritySetting) return;
WriteLine(data.ToString());
}
}

Write and WriteLine methods are also pretty simple:
public override void Write(string message)
{
/// Severity of the message is not defined, we count it as a Verbose by default
if (TraceEventType.Verbose > SeveritySetting) return;
WriteAsync(message);
}

public override void WriteLine(string message)
{
/// Severity of the message is not defined, we count it as a Verbose by default
if (TraceEventType.Verbose > SeveritySetting) return;
Write(message);
}

WriteAsync method containts simple realization, that wraps input string into LogEntry object and
calls full implementation(asynchroniously as i promised):
private void WriteAsync(string message)
{
/// вызываем все ту же запись
var data = new LogEntry
{
AppDomainName = String.Empty,
EventId = 1,
MachineName = Environment.MachineName,
Message = message,
Title = string.Empty,
Priority = 1,
Severity = TraceEventType.Verbose,
TimeStamp = DateTime.Now,
Categories = new[] { "General" }
};

var traceThread = new Thread(WriteAsync);
traceThread.Start(data);
}

Before describe full implementation of WriteAsync method, i need to say a few words about corresponding object model
in MS CRM. We have new_logentry entity, which contains all LogEntry fields: appdomainname(new_appdomainname),
eventid(new_eventid) and so on. We also create new_logentrycategory entity to store possible entry's categories
and it's linked with new_logentry category by N:N relationship.
So WriteAsync method gets all existed categories from MS CRM (i won't write this simple CRM webservice call here),
and if new entry's categories aren't presented among them, it adds new categories to MS CRM. After that it calls
SaveLogEntry method to save the entry:
private void WriteAsync(object data)
{
var entry = data as LogEntry;
/// actually, at this time all our data objects are LogEntry
if (entry == null) return;

/// get all categories from MS CRM
var categories = GetAllCategories();

/// run througn entry categories
foreach (var dataCategory in entry.Categories)
{
/// skip if category exists in MS CRM
if (categories.ContainsKey(dataCategory)) continue;

/// otherwise - create it
var id = CreateNewLogEntryCategory(dataCategory);
categories.Add(dataCategory, id);
}

///сохраняем запись
SaveLogEntry(entry, categories);
}

Even though i don't think it's needed to present SaveLogEntry method here, i also write it to make your work simplier;)
private void SaveLogEntry(LogEntry data, IDictionary categories)
{
/// заполняем объект записи
var entry = new new_logentry
{
new_appdomainname = data.AppDomainName,
new_eventid = data.EventId.ToString(),
new_machinename = data.MachineName,
new_message = data.Message,
new_name = data.Title,
new_priority = new CrmNumber { Value = data.Priority },
new_severity = GetSeverity(data.Severity),
new_timestamp =
new CrmDateTime { Value = data.TimeStamp.ToString("u").Replace(" ", "T").Replace("Z", " Z") }
};

var target = new TargetCreateNew_logentry
{
New_logentry = entry
};

/// создаем запись
var response = (CreateResponse)Service.Execute(
new CreateRequest
{
Target = target
}
);

/// сохраняем связи между созданным объектом записи и категориями
foreach (var category in data.Categories)
{
if (categories.ContainsKey(category))
AddEntryCategoryLink(response.id, categories[category]);
}
}

GetSeverity method above just converts TraceEventType to appropriate Picklist value. AddEntryCategoryLink creates
N:N link between new_logentry and new_logentrycategory objects (if you feel yourself embarrassed here, look at
AssociateEntitiesRequest class in MS CRM documentation. There is also scaring line above:
new_timestamp = new CrmDateTime { Value = data.TimeStamp.ToString("u").Replace(" ", "T").Replace("Z", " Z") }
but it just converts DateTime to string presentation that CrmDateTime's Value can parse.

After that our class is completed and i hust want to say a few words about configuration part of the work. I won't
describe full logging section that EL Congigurator creates for you, i just show how "add" element, that adds
our listener to listeners collection, looks:


CrmServise and OrganizationName are attributes i used to create CrmService object (i skipped this code above). Severity is a value of
SeverityAttributeKey constant, it's used in GetSeverityFromSettings method. Name is used later to add listener to the sources. And don't
forget to add this listener to "Unprocessed Category" source, otherwise you will get an exception when trying to write entry with new category.

There is nothing more to add, i hope this sample was useful to you. Next post i'll describe one System.Net.Mail problem and way to solve it. C ya:)

back 2 business

Three years passed since i created this blog and finally i decided to start post here :) Even though my native language is Russian, i ll post in English cause
a) I want many-many readers of my blog:)
b) (i won't tell u now;))

So, sry 4 my english'n'c ya