DotNetStyling

Be aware of deep copy with Collection(IList)

admin — Thu, 19 Mar 2009 08:36:05 GMT

Usually when I need to create a copy of some primitive type collection based on List<T> usually I use overload constructor of List class such as List<T>(IEnumerable<T>). It basically creates a new List<T> collection and populates the items based on IEnumerable<T> input parameter. Copied version is isolated from the original one which means changes made in copied version will not effect the original one. Recently I had the same task but instead of List<T> I had...(read more)

C# 3.0 Features. Part IV: Anonymous Types

Armen Ayvazyan — Thu, 21 Aug 2008 09:06:00 GMT

Previous materials of C# 3.0 Feature series: Part 1 - C# 3.0 Features. Part I: Auto Property Part 2 - C# 3.0 Features. Part II: Object and Collection Initialization Part 3 - C# 3.0 Features. Part III: The var keyword "Dynamic" Classes Anonymous Type is basically the C# way how we can dynamically create, populate and use a class without type declaration. If for some reason we need temporary classes as data carrier without any business logic implementation then Anonymous Types could be the perfect...(read more)

C# 3.0 Features. Part III: The var keyword

Armen Ayvazyan — Thu, 07 Aug 2008 11:58:00 GMT

Previous materials of C# 3.0 Feature series: Part 1 - C# 3.0 Features. Part I: Auto Property Part 2 - C# 3.0 Features. Part II: Object and Collection Initialization “var” keyword During the local variable declaration we have to explicitly specify the type even if the variable doesn’t have any value yet. The “var” expression brings as ability do not specify the type during local variable declaration. The compiler will get it from the initializer. Let’s declare two local variables of the same type...(read more)

C# 3.0 Features. Part II: Object and Collection Initialization

Armen Ayvazyan — Mon, 04 Aug 2008 08:28:00 GMT

Previous materials of C# 3.0 Feature series: Part 1 - C# 3.0 Features. Part I: Auto Property Object Initialization New object initialization technique gives us ability to define and fill the public property of the object on the fly. This expression was created to support LINQ but it can be used anywhere. This expression helps to fill values during the initialization and keep constructor empty. 1: public enum Sex { Male, Female } 2: 3: public class User 4: { 5: public int UserId { get; private...(read more)

C# 3.0 Features. Part I: Auto Property

Armen Ayvazyan — Thu, 31 Jul 2008 09:47:00 GMT

I would like to continue my blogging experience with a series of blog posts related to C# 3.0 features. Although there are already a lot of materials regarding this subject in .Net community my impression is so strong that it forces me write about it. I decided to post simple blog per feature. The first one in the list is “Auto Property” Redundancy in Property Declaration Usually, we use properties as data carrier which do not contain any business logic inside. This especially visible...(read more)

How to Create Plugin for Windows Live Writer? Simple Content Source.

Armen Ayvazyan — Thu, 29 Nov 2007 10:16:00 GMT

Windows Live Writer gives capability to extend functionality by creating new plug-ins. What I will demonstrate here is how to create content source plug-in which inserts custom formatted content. There are two types of content sources available in writer: Simple Content Source Smart Content Source Simple Content Source: Enables to insert custom HTML code to the post. Smart Content Source: Enables to insert custom HTML content with "smart" editing capabilities, such as include atomic selection, two-way...(read more)

Abstract Factory Design Pattern

Armen Ayvazyan — Sun, 25 Nov 2007 21:28:00 GMT

Abstract Factory provides interface for creating set of objects without specifying concrete implementation. Abstract Factory uses abstract classes and decouples concrete implementation from the system. It brings flexibility to easily...(read more)

Passing Parameter by Value and by Reference ("ref"). CLR Internals

Armen Ayvazyan — Thu, 22 Nov 2007 20:35:00 GMT

What is the difference between passing parameter by reference (using "ref" keyword) and by value (without using "ref" keyword)? This is really nice and advance question which demonstrates understanding of .Net internals, especially relationship between Stack and Heap. Reference Type Let's make some demonstration and examine behavior and difference between passing reference type object by value and by reference. First let's create some custom class which we will use in demonstration. public class...(read more)

Append new line in StringBuilder: AppendLine, AppendFormatLine, JavaScriptBuilder

Armen Ayvazyan — Tue, 13 Nov 2007 09:57:00 GMT

It is a common technique in ASP.NET to generate JavaScript code from the web page's code behind file (.aspx.cs, .aspx.vb). Unfortunately it is a problem to read and sustain rendered JavaScript code because it usually renders all JavaScript code in one line. So, to have it readable developer tries to break those lines to have code a little bit more readable. But downside is more "mess" in code which builds JavaScript. Before I'll continue I hope you are familiar that the best and the fastest way how...(read more)

Issue of Rendering JavaScript in WebControls

Armen Ayvazyan — Mon, 05 Nov 2007 08:42:00 GMT

Originally I was not planning to post this subject until I spent hours for hunting some ghost JavaScript code. Problem was in generating custom JavaScript inside of WebControl. Basically this is not about "How" to generate JavaScript code but "When". Unfortunately I faced to this problem several times and all the time it was a cause for some JavaScript bug. Issue During WebControl implementation developers used to register all necessary JavaScript code inside of OnLoad method. For instance: private...(read more)

Explicit Interface Implementation

Armen Ayvazyan — Mon, 29 Oct 2007 00:03:00 GMT

Explicit interface implementation helps to ensure that user can use methods define by a given interface using by correct interface reference....(read more)

How fast StringBuilder is ?

admin — Sat, 27 Oct 2007 01:20:00 GMT

Blog post explains why different approaches of string building perform faster than others. There is a sample application which measures speed of those approaches. How specifying capacity of StringBuilder during its instantiation increase a performance?...(read more)

Optimal String Comparison

admin — Thu, 04 Oct 2007 08:08:00 GMT

There are several ways how to compare two strings in .Net but not all of them have similar performance impact. The blog post describes why certain methods work slowly and which comparison tool is the optimal to use in .Net....(read more)

Decorator Pattern

admin — Thu, 27 Sep 2007 07:08:00 GMT

One of the beautiful patterns in GOF's (Gang Of Four) bucket is a Decorator Pattern. The purpose of Decorator pattern is to add extended functionality to the class without making any change in it. The blog describes architecture and has sample which shows pattern in work. ...(read more)

Custom Type Conversion

admin — Fri, 14 Sep 2007 09:22:00 GMT

Blog post shows how to create Explicit and Implicit conversion (not casting) for two different classes....(read more)

Nullable value type variables.

admin — Fri, 03 Aug 2007 14:31:00 GMT

.Net Framework 2.0 brought us ability of having nullable value type variables. Maybe it sounds unusually but there are cases where we could use this feature. To make it happen we have to put "?" mark operator after the type, like this:

bool? booleanvalue = null;

int? integervalue = null;

short? GetShortValue()

{

return null;

}

Now variables booleanvalue and integervalue have null value. And of course we can set null value in any part of code.
For example I could use this feature to create public property with lazy load initialization:

private int? _field;

public int? Property

{

get

{

if (_field != null)

_field = 10; //Default value

return _field;

}

set { _field = value; }

}

We cannot set nullable type of variable to non nullable. We will get compile-time error.

int? integervalue = 3;
int standardInteger = integervalue; //This is wrong implementation

To achieve that we have to use new "??" operator.

int? integervalue = null;

int y = integervalue ?? 3;

In case when integervalue will have null value y variable will set to 3 otherwise to integervalue.

Commerce Server 2007

admin — Fri, 03 Aug 2007 10:29:05 GMT

Commerce Server 2007 is a huge and powerful application but it is a problem to find documentation or material about it. Including the fact that there are not so many people working on Commerce Server 2007, it is a new product and there is no book, it should be a problem to start implementation.

Nikola Malovic has a couple of awesome posts on his blog site blog.vuscode.com about Commerce Server 2007. Follow the link and check them out.

How to Sort objects in collection. IComparer, IComparable

admin — Thu, 02 Aug 2007 22:43:00 GMT

Probably you know about the IComparer and IComparable interfaces which bring us ability to sort items inside of the collection. I would like to talk about them as I know a lot of developers getting confused during implementation sorting functionality.

One dimensional sorting, IComparable.

IComparable interface allow object to be sorted in collection based on some key. By inheriting object from IComparable interface we are making object "comparable" to its type in collection. How it works?

IComparable interface contains one public method CompareTo(object obj) which we have to implement in our class. Let's say we have some class named Employee which contains information about company employee and looks like this :

using System;

namespace SortingObjectsInCollecton
{
    public class Employee
    {
        private int _id;
        public int Id
        {
            get{ return _id;}
        }

        private string _employeeName;
        public string EmployeeName
        {
            get { return _employeeName; }
        }

        private DateTime _dateOfHire;
        public DateTime DateOfHire
        {
            get { return _dateOfHire; }
        }
    
        public Employee(int id, string name, DateTime dateOfHire)
        {
            _id = id;
            _employeeName = name;
            _dateOfHire = dateOfHire;
        }    
    }
}

We have a simple class which contains three properties with different types: integer, string and datetime. Now let's us to make it "comparable" to have ability to sort it after. To achieve that we will inherit our class from IComparable interface.

using System;

namespace SortingObjectsInCollecton
{
    public class Employee : IComparable
    {
        private int _id;
        public int Id
        {
            get{ return _id;}
        }

        private string _employeeName;
        public string EmployeeName
        {
            get { return _employeeName; }
        }

        private DateTime _dateOfHire;
        public DateTime DateOfHire
        {
            get { return _dateOfHire; }
        }
    
        public Employee(int id, string name, DateTime dateOfHire)
        {
            _id = id;
            _employeeName = name;
            _dateOfHire = dateOfHire;
        }

        /// <summary>
        /// Implementation of IComparble interface's compare method.
        /// </summary>
        /// <param name="obj">Object which should be compared 
        /// with the current one.</param>
        /// <returns>Returns the value which shows position of 
        /// object compare to current.</returns>
        public int CompareTo(object obj)
        {
            Employee temp = (Employee) obj;

            if(this.Id>temp.Id)
                return 1;
            else if(this.Id<temp.Id)
                return -1;
            else 
                return 0;
        }
    }
}

As you can see, we implemented public CompareTo (object obj) method where input parameter obj will be compared with the current type where returned value represents order compare to passed object, whether it should be positioned before or after. Let's try it. In our Main method of our console application project we will create a collection, fill it by some Employee objects and then sort it.

using System;

namespace SortingObjectsInCollecton
{
    class Program
    {
        static void Main(string[] args)
        {
            Employee[] employees =new Employee[5];

            employees[0] = new Employee(5, "Jhon", new DateTime(2006, 7, 10));
            employees[1] = new Employee(2, "David", new DateTime(2006, 11, 23));
            employees[2] = new Employee(1, "Alex", new DateTime(2004, 5, 4));
            employees[3] = new Employee(10, "Ann", new DateTime(2005, 4, 9));
            employees[4] = new Employee(4, "Todd", new DateTime(2003, 2, 18));

            Array.Sort(employees);

            foreach (Employee employee in employees)
            {
                Console.WriteLine("Id={0} : Name={1} : DateOfHire={2}",
                                  employee.Id,
                                  employee.EmployeeName,
                                  employee.DateOfHire.ToShortDateString());
            }

            Console.Read();
        }
    }
}

As you can see we added 5 Employee objects into the collection and before writing them out we used static Sort() method of Array class and passed there our collection like input parameter. Thanks that our class was inherited from IComparable Sort method run CompareTo method of Employee class with our implementation.

And as you can see the result output have been sorted by Id of Employee even we added object with mixed order. This is called as one dimensional sorting as it is sorting just by Id property and with Ascending order. But what if we want to change the order of sorting or to change the property which should be used for compare. Now it is a time to look into the IComparer interface.

Multidimensional sorting, IComparer.

To achieve the goal we have to implement class with ICompare interface. Usually, ICompare is not implemented on a class which should be sorted but on external helper class. So, it is the time to create our own comparer class:

namespace SortingObjectsInCollecton
{
    public class EmployeeComparer : System.Collections.IComparer
    {
        public int Compare(object x, object y)
        {
            Employee tempx = (Employee) x;
            Employee tempy = (Employee) y;

            return tempx.Id.CompareTo(tempy.Id);
        }
    }
}

As you can see we created EmployeeComparer class inherited from IComparer and what we just need to implement Compare() method brought by interface. By the way ICompare is part of System.Collections namespace. In current implementation compare class will bring us the same result as the previous example with IComparable implementation. How to use it? Basically with the same way:

using System;

namespace SortingObjectsInCollecton
{
    class Program
    {
        static void Main(string[] args)
        {
            Employee[] employees =new Employee[5];

            employees[0] = new Employee(5, "Jhon", new DateTime(2006, 7, 10));
            employees[1] = new Employee(2, "David", new DateTime(2006, 11, 23));
            employees[2] = new Employee(1, "Alex", new DateTime(2004, 5, 4));
            employees[3] = new Employee(10, "Ann", new DateTime(2005, 4, 9));
            employees[4] = new Employee(4, "Todd", new DateTime(2003, 2, 18));

            Array.Sort(employees, new EmployeeComparer());

            foreach (Employee employee in employees)
            {
                Console.WriteLine("Id={0} : Name={1} : DateOfHire={2}",
                                  employee.Id,
                                  employee.EmployeeName,
                                  employee.DateOfHire.ToShortDateString());
            }

            Console.Read();
        }
    }
}

In Sort method along with collection parameter we are passing comparer object.

As you can see we have the same result as in the with the IComparable:

But now all our attention should switch to EmployeeComparer implementation. Lets add two public enumerations and two public properties which will hold the enumeration value into the comparer class:

namespace SortingObjectsInCollecton
{
    public class EmployeeComparer : System.Collections.IComparer
    {
        public enum SortDirection
        {
            /// <summary>
            /// Ascending
            /// </summary>
            Asc,
            /// <summary>
            /// Descending
            /// </summary>
            Desc
        }

        public enum SortingProperty
        {
            /// <summary>
            /// EmployeeId
            /// </summary>
            id,
            /// <summary>
            /// Employee name
            /// </summary>
            name,
            /// <summary>
            /// Date when employee was hired.
            /// </summary>
            date
        }

        private SortDirection _sortOrder = SortDirection.Asc;
        public SortDirection SortOrder
        {
            get { return _sortOrder; }
            set { _sortOrder = value;}
        }

        private SortingProperty _sortBy = SortingProperty.id;
        public SortingProperty SortBy
        {
            get { return  _sortBy; }
            set { _sortBy = value; }
        }
    

        public int Compare(object x, object y)
        {
            int compareValue = 0;

            Employee tempx = (Employee) x;
            Employee tempy = (Employee) y;

            switch(_sortBy)
            {
                case SortingProperty.id :
                    {
                        if (_sortOrder == SortDirection.Asc)
                            compareValue = tempx.Id.CompareTo(tempy.Id);
                        else
                            compareValue = tempy.Id.CompareTo(tempx.Id);    
                        break;
                    }
                case SortingProperty.name :
                    {
                        if (_sortOrder == SortDirection.Asc)
                            compareValue = tempx.EmployeeName.CompareTo(tempy.EmployeeName);
                        else
                            compareValue = tempy.EmployeeName.CompareTo(tempx.EmployeeName);

                        break;
                    }
                case SortingProperty.date:
                    {
                        if (_sortOrder == SortDirection.Asc)
                            compareValue = tempx.DateOfHire.CompareTo(tempy.DateOfHire);
                        else
                            compareValue = tempy.DateOfHire.CompareTo(tempx.DateOfHire);

                        break;
                    }

            }

            return compareValue; 
        }
    }
}

As you see, we have now implemented object compare by all three properties and in both orders (ASC, DESC). Let's now use them:

using System;

namespace SortingObjectsInCollecton
{
    class Program
    {
        static void Main(string[] args)
        {
            Employee[] employees =new Employee[5];

            employees[0] = new Employee(5, "Jhon", new DateTime(2006, 7, 10));
            employees[1] = new Employee(2, "David", new DateTime(2006, 11, 23));
            employees[2] = new Employee(1, "Alex", new DateTime(2004, 5, 4));
            employees[3] = new Employee(10, "Ann", new DateTime(2005, 4, 9));
            employees[4] = new Employee(4, "Todd", new DateTime(2003, 2, 18));

            EmployeeComparer ec = new EmployeeComparer();
            ec.SortBy = EmployeeComparer.SortingProperty.name;
            ec.SortOrder = EmployeeComparer.SortDirection.Desc;

            Array.Sort(employees, ec);

            foreach (Employee employee in employees)
            {
                Console.WriteLine("Id={0} : Name={1} : DateOfHire={2}",
                                  employee.Id,
                                  employee.EmployeeName,
                                  employee.DateOfHire.ToShortDateString());
            }

            Console.Read();
        }
    }
}

Before sorting we created new instance of EmployeeCompare object and set the sorting order and property to appropriate values.

Try to change sorting criteria and you will see the appropriate result on a screen. Well, basically that's it. :) As you see nothing special in it.

Ok, but what about having custom collection based on ArrayList class. Do we need to sort it throw Array.Sort() method ? Let's see. First we will create collection class.

using System.Collections;

namespace SortingObjectsInCollecton
{
    public class EmployeeCollection : ArrayList
    {
        public void Add(Employee employee)
        {
            base.Add(employee);
        }

        public void Sort(EmployeeComparer.SortingProperty sp,
            EmployeeComparer.SortDirection sd)
        {
            EmployeeComparer ec = new EmployeeComparer();
            ec.SortBy = sp;
            ec.SortOrder = sd;

            base.Sort(ec);
        }
    }
}

Now we will replace the code in the Main method to have EmployeeCollection instead of Employee array.

using System;

namespace SortingObjectsInCollecton
{
    class Program
    {
        static void Main(string[] args)
        {
            EmployeeCollection employees = new EmployeeCollection();
            employees.Add(new Employee(5, "Jhon", new DateTime(2006, 7, 10)));
            employees.Add(new Employee(2, "David", new DateTime(2006, 11, 23)));
            employees.Add(new Employee(1, "Alex", new DateTime(2004, 5, 4)));
            employees.Add(new Employee(10, "Ann", new DateTime(2005, 4, 9)));
            employees.Add(new Employee(4, "Todd", new DateTime(2003, 2, 18)));

            employees.Sort(EmployeeComparer.SortingProperty.name,
                           EmployeeComparer.SortDirection.Desc);

            foreach (Employee employee in employees)
            {
                Console.WriteLine("Id={0} : Name={1} : DateOfHire={2}",
                                  employee.Id,
                                  employee.EmployeeName,
                                  employee.DateOfHire.ToShortDateString());
            }

            Console.Read();
        }
    }
}

And us you can see the result is the same but with different implementation.

Than's it.

Basically that's it. As you can see nothing special. Really easy. I'll try in a future to make some blog about sorting of Generic objects. Hopefully this blog will help you to implement "Sorting" functionality.

Visual Studio 2008 Beta 2

admin — Fri, 27 Jul 2007 09:03:38 GMT

Visual Studio 2008 Beta 2 is now available on MSDN web site :). Follow the link, pick the edition and download it.

Download Visual Studio 2008 Beta 2

Family.Show 2.0

admin — Sun, 22 Jul 2007 20:58:12 GMT

Version 2.0 of Family.Show application which is an incredible example of WPF technology now available. You can download it at Vertigo website http://www.vertigo.com/familyshow.aspx

There are a couple of new features added to application:

· New “Family Data View” with filtering, sorting, and in-place editing

· Family Analytics including last name tag cloud, age distribution historgram and birthday list.

· Enhanced story editing with support for font name, size, alignment, bullets, and numerical lists

· Filtering and sorting the Family List view, in the main window

· More cowbell!

· Skinnable user interface with two skins: black and silver

· Improved Windsor family sample data file with stories and images.

· Source code migrated to CodePlex

ReSharper 3.0 has been released

admin — Fri, 22 Jun 2007 07:59:56 GMT

JetBrains released next version of its awesome application ReSharper 3.0.

ReSharper is an add-in for Visual Studio which contains many features for .Net application development. It helps simplify the process of writing a code. Ones I stared to use ReSharper I cannot imagine working without it after. It has many features but the best from my point of view is static code analyzer which brings you errors or warnings on the fly without compilation. Another excellent feature is searching the objects inside of solution which is much powerful and has much better interface for doing that.

With the new version ReSharper supports XAML and XML, offers C# code suggestion on the fly and much much more.

Just follow the link to check out all the features exist in ReSharper 3.0

http://www.jetbrains.com/resharper/features/index.html

To download a 30 days free trial version click here

WPF in life

admin — Tue, 19 Jun 2007 09:01:40 GMT

This is a simple application which shows a power of Window Presentation Foundation. Just follow the link, download "ClickOnes" installation and have a fun. You gonna love it. :)

http://www.vertigo.com/familyshow.aspx

The most important part is that you can download the source code and investigate application structure.

Incredible future in IT world

admin — Thu, 31 May 2007 15:31:01 GMT

This is awesome. This is an incredible future of computer hardware. It's beeter to see than to talk about :)

Microsoft Surface

How to create an Add-in for Visual Studio?

admin — Mon, 23 Apr 2007 17:03:36 GMT

If you are planning to create your own Add-in for Visual Studio, I found a very good source written by Jon Rista - Writing a Visual Studio 2005 Add-in.
Follow the link below and you'll see explanation and will have ability to download source code (C#).

http://www.codeproject.com/useritems/LineCounterAddin.asp

ASP.NET: Monitoring of web page life cycle

admin — Sat, 14 Apr 2007 20:47:00 GMT

I wrote simple code which is showing order of execution of events and protected methods related to the page life cycle.

I simply added output messages into the each event and protected method of Page and Control (UserControl which is located on that page). This is an example of how I did it:

...

protected void Page_Init(object sender, EventArgs e)
{
Container.messageCollection.Add("P: Page_Init");
}

...

protected override void OnInit(EventArgs e)
{
    Container.messageCollection.Add("P: Before base.OnInit");
    base.OnInit(e);
    Container.messageCollection.Add("P: After base.OnInit");
}

etc.

After filling a collection I just write messages out in order how they were added.

And this is an output result:

1: P: Before base.OnPreInit

2: P: Page_PreInit

3: P: After base.OnPreInit

4: C: Before base.OnInit

5: C: Page_Init

6: C: After base.OnInit

7: P: Before base.OnInit

8: P: Page_Init

9: P: After base.OnInit

10: P: Before base.OnInitComplete

11: P: Page_InitComplete

12: P: After base.OnInitComplete

13: P: Before base.OnPreLoad

14: P: Page_PreLoad

15: P: After base.OnPreLoad

16: P: Before base.OnLoad

17: P: Page_Load

18: P: After base.OnLoad

19: C: Before base.OnLoad

20: C: Page_Load

21: C: After base.OnLoad

22: P: Before base.OnLoadComplete

23: P: Page_LoadComplete

24: P: After base.OnLoadComplete

25: P: Before base.OnPreRender

26: P: Page_PreRender

27: P: After base.OnPreRender

28: C: Before base.OnPreRender

29: C: Page_PreRender

30: C: After base.OnPreRender

31: P: Before base.OnPreRenderComplete

32: P: After base.OnPreRenderComplete

33: C: Before base.OnUnload

34: C: Page_Unload

35: C: After base.OnUnload

36: P: Before base.OnUnload

37: P: Page_Unload

38: P: After base.OnUnload

First "C" letter or red color are messages from UserControl side. Messages with "P" letter or blue color represent page level.

So, now you can see an order how events in page and contol occur during page life cycle.