DOT NET TRICKS

Enterprise Architectural Patterns

2024-11-04T10:16:00.003+05:30

An architectural pattern is a common standard for an architecture and solution to a problem. Unlike Design Patterns, an architectural pattern has a broader scope and can address big problems. The architectural pattern address various issues of software engineering, such as computer hardware performance limitations, high availability and minimizing business risk.

According to Martin Fowler, there Enterprise Architectural Patterns are broadly categorized into

Domain Logic Patterns

Transaction Script
Domain Model
Table Module
Service Layer

2. Data Source Architectural Patterns

Table Data Gateway
Row Data Gateway
Active Record
Data Mapper

3. Object Relational Behavioral Patterns

Unit of Work
Identity Map
Lazy Load

4. Object Relational Structural Patterns

Identity Field
Foreign Key Mapping
Association Table Mapping
Dependent Mapping
Embedded Value
Serialized LOB
Single Table Inheritance
Class Table Inheritance
Concrete Table Inheritance
Inheritance Mappers

5. Object Relational Metadata Mapping Patterns

Metadata Mapping
Query Object
Repository

6. Web Presentation Patterns

Model View Controller
Page Controller
Front Controller
Template View
Transform View
Two-step View
Application Controller

7. Distribution Patterns

Remote Facade
Data Transfer Object

8. Offline Concurrency Patterns

Optimistic Offline Lock
Pessimistic Offline Lock
Coarse Grained Lock
Implicit Lock

9. Session State Patterns

Client Session State
Server Session State
Database session State

10. Base Patterns

Geteway
Mapper
Layer Supertype
Separated Interface
Registry
Value Object
Money
Special Case
Plugin
Service Stub
Record Set

I would edit this article with all the links when I am complete in writing implementation of each of those. If you have contributed anyone of these patterns, please go ahead and put the links.

Software Patterns & Practices

2024-11-04T10:12:00.001+05:30

The article describes how to deal with Design patterns and practices while developing your application. This article is basically a pointer to all the design patterns associated with the series. Please bookmark this to get links updated for all other articles that are added to the series. Click on a link below to read a pattern.

Introduction

Software patterns are there and widely followed in the industry for a long time. In Software engineering, a pattern is a generalized solution to a common problem, a software design or an architecture for a given problem. This is the widely used solution to a problem specific to an industry, a person or a goal. A Software pattern can never be identified as a silver bullet to a problem but rather it is widely accepted a solution to a problem. There could be always a notion of adjustment to a pattern to adjust the specific need of the project that is worked on by the developers.

Patterns are essentially formalisms and naming of nice idioms of coding. It is a way to give experience to programmers. It is a nice way to know that both the developers are talking about the same thing while discussing a problem.

Software patterns are first introduced in 1995 by "gang of four": Design Patterns by Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides. In this book, it is first discussed capabilities and pitfalls of Object oriented programming, and later on, it discusses the classic Design Patterns on OOPS. They introduced the first requirement of a software pattern while developing a piece of software in the industry. Better organizing a code is a lifelong learning experience for every developer and it is hard to follow when some functionality is needed to be implemented by a programmer. A software pattern just gives a sense of guidance to a developer while implementing a code or functionality for a problem.

Software Patterns are generally categorised into

Design Patterns

Enterprise Architectural Patterns

Software Principles

Conclusion

Patterns are the widely accepted solution to problems. It is important to at least know the patterns of creating some kind of architecture that suits your needs. There is always an element of improvement in this industry. Let's hope as this wiki grows and we can add more and more content to it. There would be much more talks in the betterment of the software industry.

C# 6.0: Language features and its internals Part 2

2015-03-11T03:12:00.000+05:30

As discussed in my last article on C# 6.0 features we have discussed some of the interesting features like : Auto property initialization, Expression bodied functions, Static class uses and string interpolation method. In this post, we will take the discussion ahead with more language features introduced with the new language.

The features will be covered with basic introduction to internals are :

5. Null Conditional operators
6. Exception filters
7. nameof operator
8. Dictionary initializers
9. await in try / finally.
10. Parameterless constructor for struct

Feature 5 : Null conditional operators

Getting into NullReferenceException or "Object reference not set to instance of an object" is one of the most common exception that every developer must see while working with the langauge. It has been a common problem where developers need to give extra stress to check the null value before calling any member functions. Null for compiler is unknown, and hence if you call a method on null, it will point nowhere and hence throws NullReferenceException and exists the stack.

To handle nulls Microsoft had introduced few language constructs already like Null coalesce operator (??) or Conditional operators. But with the new feature introduced in C# 6.0, the language team has introduced another operator which checks for null.

Null Conditional operator is a new construct that gives away a shortcut to condition the null check before calling its members.

string zipcode = (address == null? null : address.zipcode);

string zipcode = (person == null? null : (person.address == null ? null : person.address.zipcode))

Here in the above two lines you can see how the complexity rises when there are multiple number of null checking on an expression. In the first statement the address is checked with null and when it has address, it will only then evaluate the zipcode. On the second statement, the person object is checked with null, then its address and then finally the zipcode is evaluated.

With null conditional operator the code would look like :

string zipcode = address?.zipcode;

string zipcode = person?.address?.zipcode;

Here the code is reduced greatly even though the actual expression logic remains the same. The ? mark is used for null conditioning. Null conditional operators does not exists as well, it is the same representation as that of the previous conditional operators. If you try to look into reflector, you will see it like :

You can see the null conditional operators are replaced by the compiler with normal conditional statements.

Feature 6 : Exception Filters

Now after so many syntactic sugar introduced with latest version of C#, this is the only new feature that directly relates to IL (Intermediate Language). From the very inception, the exception filters were there in CLR but was not exposed to the C# language. With C# 6.0, the exception filters finally came into existence and finally as a C# developer you can make use of it.

In C# the exception block contains try/catch/finally with multiple catch blocks supported. Based on type of the exception that has been encountered during runtime, the runtime chooses the appropriate catch block to execute. Exception filters allows you to filter out the catch blocks to ensure which catch block can handle the exception. With exception filters in place, there could be multiple catch blocks with same type where the type determines which filter it will call first.

Let us take a look at the code :

public class ExceptionFilters
    {
        public static bool LogException(Exception ex)
        {
            //Log
            return false;
        }
        public static bool LogAgainException(Exception ex)
        {
            //Log
            return true;
        }
        public void CallMe()
        {
            try
            {
                throw new ArgumentException("Exception");
            }
            catch (Exception ex) when (LogException(ex))
            {
                //Keep exception stack intact
            }
            catch(Exception ex) when (LogAgainException(ex))
            {
                // Calling the catch
            }
            
        }
    }

Here the ArgumentException is thrown when CallMe is invoked. The Exception filters are specified using when keyword just like in VB.NET. So the execution is like, it will call LogException method, executes the code and see whether the return statement is true or false. If it is true, it executes the catch block and exit, or otherwise it move and call LogAgainException method.

The exception filter expects a boolean value, hence the call to LogException should be a method returning bool or otherwise we need a comparison operator to always evaluate the when statement to boolean. Exception filters allows the developer to run arbitary code between the exception and the catch block execution without interfering the original stack trace of the exception object.

I have already told you that exception filters is a CLR concept. The IL is laid out as :

 .try --- to --- filter --- handler --- to ---

This tells the compiler to execute try block from line no --- to line ----. It will then call filter line and then call the handler which executes some bunch of lines. Cool ? Yes.

One small addition that I would want to add, if an exception filter encounters an exception and is left unhandled, the compiler handles it for you and automatically skip the exception block and moves to the next catch block. For instance if LogException in the code above throws an exception, it will call LogAgainException without modifying the Stack for ex.

Feature 7 : nameof Operator

nameof is a new addition to operator list supported by C#. This new operator is nothing but a compiler trick, where the compiler determines the name of a Property, Function or an Extension method and writes it directly in compiled output. For instance,

string name1 = nameof(this.MyProp); // evaluates MyProp
string name2 = nameof(DateTime.Now);//evaluates Now
string name3 = nameof(Console.WriteLine); //evaluates WriteLine
string name4 = nameof(new List<string>().FirstOrDefault); // Evaluates FirstOrDefault

string name5 = nameof(name4);//Evaluates name4

The nameof operator works on any type where the type has a name. In case you specify a variable, the nameof operator will evaluate to the name of the variable.

Feature 8 : Dictionary initializers

Dictionary is one of the common array object which used often to send data between objects. Unlike arrays, Dictionaries form an array of KeyValuePair. In modern days, Dictionary is used interchangeably with arrays because of its flexibility of defining key value set.

var list = new List<string>();
list.Add("Abhishek");
list.Add("Abhijit");

//Access
var first = list[0];
var second = list[1];

Here you can see a list is used to store string data, where index giving you the reference to individual objects. If I write the same with dictionary, it will look like :

var dict = new Dictionary<int,string>();
dict.Add(0, "Abhishek");
dict.Add(1, "Abhijit");

//Access
var first = dict[0];
var second = dict[1];

Even though the basics remain the same, the developers are increasingly inclined to use the later as it gives a flexibility to assign any index. You can define "Abhishek" to 10 and "Abhijit" to 20 without the limitation of fixed incremental index usage of dictionary.

As more and more people are going to Dictionary, language team thought about giving easier constructs to define Dictionary. Even though we can go without it, but it is a nice to have feature. In C# 6.0, you can define dictionary using the following syntax :

var dict = new Dictionary<int,string>
{
   [10] = "Abhishek",
   [20] = "Abhijit"
};

//Access
var first = dict[10];
var second = dict[20];

Or even if the key is declared as string, you can also use like:

var dict = new Dictionary<string,string>
{
   ["first"] = "Abhishek",
   ["second"] = "Abhijit"
};

//Access
var first = dict["first"];
var second = dict["second"];

This way it is very easier to declare and use dictionaries. The last two syntaxes were introduced in C# 6.0.

Now if you think of the actual implementation, there is nothing as such. If you try to sneak peek on the compiled code, you will be seeing the same code with object being initialized inside the constructor.

Here even though the new construct is used, the dictionary object is actually initialized in constructor itself. The code is re-written by the compiler.

Feature 9: Await in catch and finally

If you are not using async / await stuffs too often you might have already overlooked that you cannot specify await in catch or finally block before the latest version of C#. Microsoft has initially thought that it wont be possible to allow awaits in catch/finally because the compiler creates a state machine which slices each and every await statements into a sequence of calls which can pause and resume the function upon request. But as try/catch/finally are handled by CLR, allowing such thing will indicate every errors in the state machine is properly handled and also each of try/catch/finally would need their individual state machines each.

Based on the complexity, microsoft haven't provided the feature in previous version, but as everything is handled by the compiler itself, it is a very important feature to have as a programmers perspective hence in latest version of C# 6.0, the feature have been revised and await in catch/finally is allowed.

 public async Task<string> DownloadUrl(string url)
        {
            WebClient client = new WebClient();
            client.BaseAddress = "www.abhisheksur.com";
            try
            {
                return await client.DownloadStringTaskAsync(url);
            }
            catch
            {
                return await client.DownloadStringTaskAsync("mvp");
            }
            finally
            {
                //Await is also allowed.
            }
        }

Hence you can successfully compile the code above where the await works during the catch execution.

If you try looking at the code in reflector it will look very ugly with so many of StateMachine declarations and so many of goto statements to properly navigate to lines inside the state machine on failure. It would be nice if you can look into it personally, but if there is any problem understanding the implementation, feel free to ask me in discussions.

But as a benefit, you get this feature ready.

Feature 10: Parameterless constructor for struct

If you are unaware, there was no parameterless constructors in struct. This is because of the fact that ValueTypes has a unique behavior where it will be automatically assigned a default memory when declared.

For instance,

int x;

Here int is a struct (System.Int32) and the value of x would be automatically 0. You can even declare array of a struct. For instance,

struct MyStruct
{
  public int Property1{get;set;}
  public string Property2 {get; set;}
}

MyStruct[] array = new MyStruct[10];

Now the Struct MyStruct will automatically get the default(MyStruct) in the array even though its not explicitly constructed. If you want to know more why struct does not support default constructor, feel free to read the article I posted.

In C# 6.0 the parameterless constructor is allowed. This is also a trick made by the compiler. It actually replaces the default constructor with the parameterless constructor passed in when the new operator is used to construct the object.

So if you say,

MyStruct s = new MyStruct();

The .NET will call the parameterless constructor for you.

Conclusion

There are lot more things coming with the new framework, new concepts, technologies etc. which I will cover one after another. Here is everything that are coming with C# 6.0 which is expected soon.

Let me know your thoughts.

Happy coding.

C# 6.0: Language features and its internals Part 1

2015-03-08T21:55:00.000+05:30

C# have been one of the most evolving language in recent times. It was not more than a couple of years when some of the coolest features were introduced with C# 5.0 and today we have announced the next version of C#. In this post we will try to look deep into these features and try to see what exactly is coming in the new version. I would go deeper than just demonstrating the feature so that you are well acquainted on what exactly you would be getting from these features.

1. Auto Property Initializer
2. Expression bodied Function
3. Static Class Uses
4. String Interpolation

More in Part 2 of the post.

Feature 1 : Auto Property Initializer

Auto properties are not new to C#. It was there since C# 3.0. The auto properties does not require a backing field to be defined which was done automatically during compilation. So as a coder, you can get a ready-made property without writing much of code. As auto properties does not have backing field exposed, you cannot initialize the backing field during object initialization, rather you have to initialize explicitly in constructors.

    public class AutoPropertyInitialier
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }

        public string FullName { get; set; }

        public AutoPropertyInitialier()
        {
            this.FirstName = "Abhishek";
            this.LastName = "Sur";

            this.FullName = this.FirstName + " " + this.LastName;
        }
    }

You can see in the above code block, the FirstName and LastName were Auto - Implemented properties, and both of them were initialized during constructor call, as the backing fields are not exposed for them. Think of a situation when your class is pretty big and you want to introduce a new property, you need to again initialize it inside constructor. This is the pain of the developer.

With C# 6.0, the initialization of auto-implemented properties is damn easy. Take a look into the code below :

    public class AutoPropertyInitializer
    {
        public string FirstName { get; set; } =  "Abhishek";
        public string LastName { get; } = "Sur";

        //public string FullName { get; } = this.FirstName + this.LastName;

        public string FullName { get; }

        public AutoPropertyInitializer()
        {
            this.FullName = this.FirstName + " " + this.LastName;
        }
    }

Here the properties FirstName and LastName were initialized directly after the declaration. You can notice the LastName were intentionally made readonly by not mentioning the setter. The backing field produced for a readonly property is also a readonly variable.

The FullName though is initialized inside constructor as the object initialization works before the constructor call, and hence initialization cannot evaluate "this".

In the above image, the C# representation of actual IL is shown which clearly indicates that the properties do have their backing fields. You can also notice the backing fields for property LastName is defined as readonly. The auto-property initialization is handled very cautiously during compilation and is abstract to you and relieves some of the pain points on writing un-necessary code.

Feature 2 : Expression bodies functions

Similar to Auto property initialization, C# 6.0 also comes up with expression bodies functions a long awaited feature. Expression bodied function is also a syntactic sugar implemented in the language which adds the flexibility on how you define member functions.

Lambda expressions are not new to the language, but you might already know you cannot assign a lambda to a member function if the member function is not defined with a delegate. But if you read my internals to Lamba expression, you already know that for each lambda declaration the compiler creates a backing function body, but that function body cannot be exposed to class level. C# 6.0 enhances the language to allow you to define a member function with lanbda expressions.

    public class ExpressionBodiedFunction
    {
       
        public string WelcomeMsg(string name) => string.Format("Welcome {0}", name);

        public string HelloMsg => "Abhishek";

        public void Print() => Console.WriteLine(this.HelloMsg);

    }

In the above code block the WelcomeMsg is a member function that takes a string argument and returns a string. As per lambda rules, a lambda which has a return statement does not require a return keyword, hence the WelcomeMsg returns the expression with string.Format.

The second property is HelloMsg which is a property like method where the getter of the property HelloMsg will return the string "Abhishek". Remember, as property is also auto-implemented, the get keyword is also automatically evaluated by the compiler.

The last method "Print" is a void method and hence require a non-returning expression. The Console.WriteLine calls the property HelloMsg to print "Abhishek".

Now how does the compiler handles the lambda now without an explicit declaration of delegates ? Well, the answer is simple. The compiler re-writes the lambda into a full functional method body.

Here the WelcomeMsg, HelloMsg and Print after compilation is just a class level methods. The compiler entirely re-written the class into a strongly typed method bodies.

Feature 3 : Static class uses

The C# language teams identified the developers pain points very well, and implemented the Static class uses in the language. If you are using Static types it is always a nice to have feature in the language such that we can omit the repetitive static method call.

For instance, say I want to print a number of lines on screen, using Console.WriteLine. How about if we don't need to mention Console each line when we call WriteLine ? Static class uses does the same thing. Static class uses also recognize extension methods, hence if say a static class defines extension methods, if you add it, it will automatically recognize the extension methods as well.

    using static System.Console;
    using static System.Linq.Enumerable;

    public class UseStatic
    {
        public void CallMe()
        {

            WriteLine("Hi");

            var range = Range(10, 10);
            var check = range.Where(e => e > 13);
            // Static extension method can 
            // only be called with fulll representation
        }
    }

In the above code the WriteLine is automatically detected as we added the head using static statement. The Range is also declared inside System.Linq.Enumerable which is automatically determined and Where is an extension function. The static uses automatically recognized the extension methods as well.

If you look at the internals of the static uses, the compiler rewrites the static type calls on every occurrences of its method call.

In the actual IL, you can see, the WriteLine is padded with its appropriate type Console and Range is also associated with Enumerable. The re-writing is done by the compiler.

Feature 4 : String Interpolation

String interpolation is another interesting feature introduced with recent version of C# 6.0. Interpolation is not new with strings. We can do string interpolation using string.Format before, but the problem is the code looks really ugly when using interpolation constructs.

For instance,

string myString = "FullName :" + p.First + " " + p.Last;
string myString = string.Format("FullName : {0} {1}", p.First, p.Last);

Here the first instance, is normal string concatenation. This creates an issue with multiple memory allocation if not string interned. The second statement uses string.Format to format a given string and replaces the {} arguments with the proper arguments as parameter to the method. Now while dealing with multiple occurrences of these kind of string placeholders might look very ugly and unmaintainable and error prone.

C# 6.0 comes with a new technique where the string interpolation can take place in between the strings, or rather than putting numeric placeholders, you can use the actual values.

string myString = $"FullName : {p.First, 5} {p.Last, 20}";
Console.WriteLine(myString);

string my2ndString = $"FullName from EBF = {this.EBF.FullName}";
Console.WriteLine(my2ndString);

Here the string need to be started with a $ sign which indicates that the new kind of string interpolation to occur. The {p.First, 5} will be replaced with the value of p.First aligned to 5 characters.

Now what does the compiler do when these kind of interpolation is encountered. Well, you might be surprised to see, that the string is actually replaced by a call of String.Format during compilation.

So here you can see the actual statement after compilation is nothing but a string.Format call. So string interpolation is also a compiler trick.

Conclusion

So whatever we have seen in this post are few compiler trick introduced to enhance the language C# 6.0. There are few more features introduced which I will discuss in coming article.

I hope this post comes helpful.

Happy Coding.

Also check Part 2 of this post.

.NET Book : Visual Studio 2013 Expert Development Cookbook

2014-11-09T13:56:00.000+05:30

Friends, It gives me immense pleasure to tell you that my new book "Visual Studio 2013 and .NET 4.5 Expert Development Cookbook" has been released few days back. It is the continuation to my previous book "Visual Studio 2012 and .NET 4.5 Expert Development Cookbook" which has released last year. In this post, I will discuss some of the interesting parts of the book and help you understand what exactly you are expected to learn from this book. It has been tremendous effort for last 1 year which let me release this book for you. I hope this book will stand out to your expectation.

After tremendous success on my first book, presenting the next version of the book. Visual Studio 2013 enables you to develop and manage consumer-focused and business-oriented apps. It provides best-in-class tools that propel developers to create new apps or evolve existing ones. In conjunction, .NET 4.5 provides expansive capabilities for developers to work on all forms of apps and services, from client to mobile and from web to cloud, enabling them to focus solely on business logic rather than architecture.

This practical guide teaches you how to work with new changes in technology under the arena of .NET. It provides in-depth analysis and expert advice on various elements of .NET, applying them in code using detailed practical examples, and helping you understand the entire technology in easy, small steps. This book provides solutions to common development problems that you as a developer often face, thereby helping you to adapt the latest technologies as well as get grips on modern app development using .NET 4.5.

What you will learn from this book

Get to grips with Visual Studio 2013 IDE and its various components utilizing its tools to debug your code better
Get to grips with Visual Studio 2013 IDE and its various components utilizing its tools to debug your code better
Understand the Windows Phone 8 development environment and gain practical experience on app development on the platform
Create service-oriented applications using WCF and study advanced use cases on implementing a RESTful service with WCF
Test your application inside Visual Studio 2013 IDE and advanced use case scenarios to handle testing issues
Effectively utilize the various components of Team Foundation Server for better management of code
Extend Visual Studio 2013 IDE to add your own custom changes enhancing your experience
Discover the advanced usage of cloud computing with Windows Azure and its various components

To summarise each chapters :

Chapter 1, A Guide to Debugging with Visual Studio, focuses on giving you a basic understanding of the different environments set up inside Visual Studio and deals with all the necessary tools present inside Visual Studio to help in debugging a source. This chapter clarifies the debugging procedures in detail, followed by quick and easy sample code to help find bugs.

Chapter 2, Enhancements to WCF 4.5, deals with the Service Oriented Architecture using WCF. This chapter gives you knowledge on common problems that a developer needs to know and provides you with sample recipes to deal with the most common problems. This chapter also gives a clear understanding on all the new features that came along with new releases.

Chapter 3, Building Touch-sensitive Device Applications Using Windows Phone 8.1,

provides a quick introduction on device application development with the Windows Phone environment. This chapter provides simple solutions to some of the common problems of developing a Windows Phone application.

Chapter 4, Working with Team Foundation Server, deals with the source control functionality using Visual Studio ALM. The chapter provides detailed, step-by-step recipes to deal with development issues using a Team Foundation Server with the configuration and easy implementation of a successful TFS Server.

Chapter 5, Testing Applications Using Visual Studio 2013, provides a deeper insight on testing a full-fledged application. This chapter provides all the relevant information that you need to know about testing inside Visual Studio, enabling you to write tests quickly in easy steps and a clear understanding of what is going on under the hood.

Chapter 6, Extending Visual Studio IDE, focuses on presenting interesting facts related to adding more functionality in Visual Studio. The need to customize Visual Studio itself is sometimes necessary to allow a developer to customize the tools inside the integrated environment. This chapter shows you points that will help in dealing with extensions on Visual Studio IDE in easy steps.

Chapter 7, Windows Azure and Cloud Computing, demonstrates the Microsoft implementation of cloud computing, enabling you to quickly adapt Azure in your own solution in easy steps. This chapter gives recipes to help a developer port their existing on-premise applications to the cloud.

What you can get ?

First of all, don't forget to read through the first chapter, which is given for free :

Sample Chapter

Or you can Purchase the book from :

Purchase this book online

If you are interested to purchase it online, you can get it from the following links :

Write a review and get this book for free :

Just like my previous book, if you are writing a review on the book, please do let me know, I can provide you a free copy of the book from my publisher. The process is :

1. Write a review in your blog, dzone with a link to my book and send it to me.
2. Share the blog in Twitter and / or facebook.
3. Like us on Facebook to get more updates on the book.

Best of Luck. Have fun.

I am sure you will like this book. Do let me know your feedback on it. Write to me at contact@abhisheksur.com on any problem you face while reading this book.

Happy Programming !!!

Advanced Usage of Grouping in CollectionView with ItemsPresenter

2013-07-09T09:49:00.000+05:30

CollectionView is an object that we generally use while dealing with a collection in WPF. It is an object structure that supports a collection as well some of the inherent features which a user might always need while dealing with a collection. Some of the features like Sorting, Grouping, Filtering are automatically implemented in a CollectionView. I have written one article on how to deal with CollectionView way back in Aug 2010 which explains almost everything you need to do while dealing with collection in WPF. But it does not give the entire story.

Controls that can show a Collection in WPF is somehow derived from ItemsPresenter. The ItemsPresenter has a property called ItemsSource which takes an object of ICollectionView, and hence it is one of the important interfaces considered so far.

There are some advanced scenarios where the general Grouping or sorting does not makes sense. Here in this article I am going to deal with such advanced scenarios which might be worth mentioning.

Advanced Grouping with CollectionView

Groping in ICollectionView is done by adding GroupDescription. Let us consider the case with some code:

ListCollectionView collectionView = new ListCollectionView(this.MyCollection);
collectionView.GroupDescriptions.Add(new PropertyGroupDescription("GroupProperty"));
return collectionView;

The ListCollectionView is an implementation of ICollectionView which allows you specify a GroupDescription on a Collection. Here in the above code, the MyCollection is an ObservableCollection that adds a GroupDescription on GroupProperty.

public class GroupedObjects
{
   // Other properties
    public string GroupProperty { get; set; }
}

Here the GroupedObject represents each object in the collection. The GroupProperty is of type string and hence when two object has same GroupProperty value, it will be treated on the same group in the collection.

this.MyCollection.Add(new GroupedObjects { GroupProperty = "A" });
this.MyCollection.Add(new GroupedObjects { GroupProperty = "A" });

For instance, the first two objects belong to the same group.

Now when showing the Group on the ItemsPresenter, you need to show the GroupProperty in the header by defining the GroupStyle.

<ListView.GroupStyle>
    <GroupStyle>
        <GroupStyle.HeaderTemplate>
            <DataTemplate>
                <TextBlock Text="{Binding Name}" />
            </DataTemplate>
        </GroupStyle.HeaderTemplate>
    </GroupStyle>
</ListView.GroupStyle>

Here the Name property is automatically assigned to the GroupProperty value for each Group while the elements are getting added. Thus while defining GroupStyle, if you specify Binding on Name, it will show the Group header.

Now think of a situation, where you need multiple data for a Group. The Name supports objects and hence you can specify a whole object for Name. Lets change our class a little bit.

public class MyCustomGroup
{
      public string Type { get; set; }
      public string DisplayText {get; set;}
}
public class GroupedObjects
{
     public string Item {get; set;}
     public MyCustomGroup {get;set;}
}

Here the MyCustomGroup defines the group of GroupedObjects. Hence if you specify MyCustomGroup in properties, it will assign the whole MyCustomGroup to the Name property of the Style. You can easily define the GroupStyle like this :

<ListView.GroupStyle>
    <GroupStyle>
        <GroupStyle.HeaderTemplate>
            <DataTemplate>
<StackPanel Orientation="Horizonta">
                     <TextBlock Text="{Binding Name.Type}" />
                     <TextBlock Text="{Binding Name.DisplayText" />
               </StackPanel>
            </DataTemplate>
        </GroupStyle.HeaderTemplate>
    </GroupStyle>
</ListView.GroupStyle>

Here the Name holds the entire object and the properties can be evaluated. But how does it then determine the equality of the Groups ? Well, the PropertyGroupDescription calls the Equals method on Group each time the item is evaluated. So if you override equals and return boolean based on the actual group, it can easily determine the group.

public class MyCustomGroup
{
      public string Type { get; set; }
      public string DisplayText {get; set;}
      public override bool Equals(object obj)
      {
         var groupdata = obj as MyCustomGroup;
        return this.Type.Equals(groupData.Type);

}
}

Here the Equals is called to determine the equality of two MyCustomGroup objects. Implementing this will do the job.

Moving the Group Equality to another method than Equals

Sometimes, in advanced scenarios, you might also wonder how to deal the equality of Group in a separate method when the actual Equals method is used somewhere else in your framework. You could do that by inheriting the PropertyGroupDescription class and create an own implementation.

public class MyCustomGroup
{
      public string Type { get; set; }
      public string DisplayText {get; set;}
     public override bool Equals(object obj)
      {
         var groupdata = obj as MyCustomGroup;
        return this.DisplayText.Equals(groupData.DisplayText);
      }
      public bool GroupEquals(object obj)
      {
         var groupdata = obj as MyCustomGroup;
        return this.Type.Equals(groupData.Type);
      }
}

Consider the class MyCustomGroup, it already have an Equals operator implemented which equates DisplayText. There is a separate method called GroupEquals which needed to be used while equating groups. Here is what you need to do :

   public class MyGroupDescription : PropertyGroupDescription
    {
        public MyGroupDescription(string groupName) : base(groupName) { }
        public override bool NamesMatch(object thisgroup, object othergroup)
        {
            var groupdata = thisgroup as MyCustomGroup;
            return groupdata.GroupEquals(othergroup);
        }
    }

Here we have derived the PropertyGroupDescription and overridden the NamesMatch which in turn calls the Equals operator on the object. We rather redirected the same to GroupEquals instead. You can even inherit from abstract type GroupDescription while in that case, you will have responsibility to override GroupNameForItem as well. The GroupNameForItem has responsibility to determine the Group object for an item.

Conclusion

Generally, Grouping an ICollectionView is rather very easy to implement, until when I struck into a situation where I needed to implement grouping all myself. I tried to search over internet and found no good link which explains the entire story. I hope in case of need for advanced grouping, you can still make use of ICollectionView in WPF rather than moving in wrong direction. I hope you will find this post handy.

Thank you for reading.

Happy programming.

Windows Phone 7.5 and F# - A book in the market

2013-06-24T04:30:00.003+05:30

Hi Friends,

I am excited to announce that one of my friend cum MVP (Lohith) has written a pretty nice book on Windows Phone 7.5 using F# recently. I have given an honor to read the book from PacktPub and wanted to write a review of the same today.

Chapter wise review :

1. Setting Up Windows Phone Development with F#.

This chapter gives an insight on Windows Phone and gives you an introduction on how to setup Windows Phone Development using F#.

2. F# Windows Phone Project Overview

This chapter demonstrates about Windows Phone Projects and creates a simple project using the Project templates.

3. Working with Windows Phone Controls

This chapter gives insights on some of the common controls that you might use while developing day to day applications in Windows Phone. It also makes you familiar with F# language syntaxes as you go ahead and create the applications yourself.

4. Windows Phone Screen Orientations

Screen orientations is a feature of any smart devices nowadays. This chapter gives an introduction on how screen orientation works in Windows Phone and creates applications that respond to Orientation changes.

5. Windows Phone Gesture Events

A number of gestures discussed which are commonly used and created an application that responds to gestures.

6. Windows Phone Navigation

Navigation between different pages in Windows Phone is tricky. This chapter discusses some of the good ways of navigation between pages inside an app. The chapter clearly demonstrates the navigation techniques with the help of sample applications in this chapter.

7. Windows Phone and Data Access

Isolated Storage is one of the basic storage in Windows Phone. This chapter demonstrates how to use Isolated storage to store data inside an app. The author guides you with a simple application that can store and then retrieve the data stored in Isolated storage.

8. Launchers and Choosers

The chapter demonstrates various Launchers and Choosers in the application and gives sample code on how to use each of them.

9. Windows Phone Sensors

Any Windows Phone device you own will have multiple sensors associated with it. The Chapter demonstrates how to use Windows Phone Sensors inside your application with Sample code.

Conclusion

Overall, I like this book. Even though the book is for beginners, but it hits all the major parts and parcels of the code. It does not target to make you understand F# as a language, but it will get you through with building applications using F#. I would recommend this book if you want to build Windows Phone Applications using F#.

Links

Thank you.

Want a copy of Visual Studio 2012 and .NET 4.5 Expert Cookbook for free in simple steps?

2013-05-06T01:37:00.000+05:30

Visual Studio 2012 and .NET 4.5 Expert Development cookbook is your ready-made reference to all the problems we face while working with Visual Studio and .NET 4.5. It gives you explicit references to some of the interesting topics that as a developer you always wanted to master or want to collect and store securely so that it is available to you just the time when needed. It has been my honor to put up such important things into one book and make you understand development better.

To give you some instances :

Internals of .NET Memory Management and Garbage Collection Techniques.
Solution to 10 common mistakes made by developers while writing code
Securing code from reverse engineering using Obfuscation
Writing Multi-threaded application more quickly and easily.
Working with Performance boosters in ASP.NET Web Applications.
HTML5 and CSS3
Write enhanced application in MVVM model.
Building Applications using WinJS and XAML in Windows 8
Enable Push notification to update Tiles, Toast, Batch notifications of your Windows 8 Applications
And many more like this ...

I am overwhelmed to receive great responses for my articles on "Internals of .NET" on my blog but I wrote this book in such a way so that you can take most out of the under the hood items of Language and CLR and use those skills while writing or architecting your own application. This is reference book only for developers and experts with more emphasis given on practicals rather than the theory. To know more about the book you can go to the publisher site using this link . Moreover, I remember of putting up a draft about the book as well on my blog which you can try for more knowledge.

I want to win a free copy!

As you know I am very much active in the community and love to share my knowledge with the .NET community, it is my pleasure to announce that you can win a copy of this book for free. There are 3 copies of the book to be won from here. All you have to do is :

Leave a comment down below with the reason why you should be the lucky winner. Write on the topic "why you would like to win this book".
Share this post on Facebook and Twitter with a mention to @abhi2434 (my twitter handle) so that I can have a count on them, the more is the count, the more will be your chances.
Like us on Facebook to get more updates on the book.

The best motivation wins and the winner will be notified through email. So be sure to leave any reference of your contact (like facebook url, twitter or anything you feel safe, so that we can contact you).

Thats it ... Good Luck to you all !!!.

The Contest ends on 1st June 2013 ( 6 AM PST) and winners will be contacted and published within 3 days from that.

So hurry up!! Don't miss the opportunity.

What else to win from the same contest?

Well, as a matter of fact, we have decided to give away some additional things with the Book. Here is some of the additional gifts that we are going to provide to the winners.

One T-Shirt for every winner
One USB Flash drive.
One big poster with .NET architecture printed for reference.
One Pen + Pad which suits your desktop.
1 free license to either .NET Reflector, SmartAssembly or ANTS Memory Profiler from

So Hurry !!! Don't miss this opportunity.

Who is this book for ?

This book is aimed at Visual Studio 2012 and .Net developers who want to gain advanced understanding and sharpen their existing skill sets and adapt to new .NET technologies. Basic understanding of .NET and C# is assumed. The purpose of this book is to give under the hood expertise in .NET and help you to face common problems on latest technologies.

Visual Studio 2012 and .NET 4.5 Expert Development Cookbook is a step-by-step tutorial providing Visual Studio 2012 and .Net developers with useful techniques to develop the latest .NET technologies using Visual Studio 2012.

This book covers all the essential areas of Visual Studio 2012 IDE and delves into step-by-step instructions that highlights various techniques to build, design, asynchronous better multithreaded applications using recent updates on .NET 4.5 and learn better ways to create secure ASP.NET web based applications in .NET 4.5 using JQuery and HTML5.

I can't wait and want to buy a copy now !

Well, thank you so much for your support. Below are the links that would help you buy this book.

You can also try Ebook version in PDF, Mobi, EPub formats. Thank you.

.NET Book : Visual Studio 2012 and .NET 4.5 Expert Development Cookbook (Must Read)

2013-04-21T04:08:00.000+05:30

Friends,

It is my great honor to tell you that my book has finally been released this week. If you have ever liked any of my blogs or internals, you would like this book for sure. There are lot of things to learn from the book and I can assure you that you wont be upset with this book if you buy it.

The "Visual Studio 2012 and .NET 4.5 Expert Development Cookbook" is a book that guides you through steps to ensure you enrich the best experience with the latest technology in the best amount of time possible. The book focusses to give you under the hood expertise in .NET technologies it tends to cover and adapts you the best to face common problems of these technologies. The book is divided in forms of recipes. Each of these recipes gives you clear insight of the problem and step by step process to solve the issue practically. It also addresses the advanced features associated with each of those recipes that gives you additional advantage on getting precise knowledge about the problem and its associated issues.

What you will learn from this book

Basic usage of Visual Studio 2012 IDE and its various components and better utilization of the tool while writing code
Understand memory management techniques to build better applications
Understand the .NET infrastructure with in-depth analysis of its internals
Architect solutions that leverage the full power of .NET language gems, understanding when to use what
Implement multithreaded / asynchronous applications using recent updates on .NET 4.5 and compare the past approaches
Create secure ASP.NET web based applications in .NET 4.5 with use of JQuery and HTML5 for rapid application development
Architect advanced .NET client applications using MVVM with WPF 4.5
Understand touch sensitive devices and leverage skills to develop multi-touch applications inside Windows 8

To summarise each chapters :

Chapter 1 : Introduction to Visual Studio IDE Features (Download this chapter for free)

It starts with a basic introduction to Visual Studio IDE and gives the developer insights into how to increase productivity of development using a common set of tools and features present inside the IDE

Chapter 2 : Basics of .NET Programs and Memory Management

This chapter introduces the intersection of a .NET program and its core components. It dives deep in demonstrating the .NET infrastructure with detailed explanation of memory management and related techniques. It also covers the internals of .NET and understand some of the few great features that you might never came across.

Chapter 3 : Asynchronous Programming in .NET

The chapter focuses on introducing all existing techniques to deal with threading in .NET followed by the newer patterns that takes over the existing working principles with in-depth explanation on their working principles.

Chapter 4 : Enhancements to ASP.NET

The chapter gives you an introduction to latest enhancements of ASP.NET 4.5 with HTML5 and jQuery. It also introduces some of the performance boosters available in .NET 4.5 and Visual Studio 2012 with ASP.NET.

Chapter 5 : Enhancements to WPF
It introduces the enhancements to WPF 4.5 and the major components of WPF. It gives a practical implementation of MVVM based WPF application covering all the facets required to program in WPF environment.

Chapter 6 : Building Touch-sensitive Device Applications in Windows 8
The chapter introduces the new programming model for developing Windows 8 style tiles application. It gives a step-by-step introduction in how to program using HTML5 and JavaScript as well as WPF and C# for developing Windows 8 applications.

Chapter 7 : Communication and Sharing Using Windows 8
It focuses on how to implement network-enabled applications in Windows 8 with step by step implementation on how sharing and searching works inside the Windows 8 environment.

Appendix : .NET languages and its Construct

It focuses on giving insights on how languages work in the .NET framework and C# with details explanation with examples of various features of C# language.

You can download this Appendix from http://www.packtpub.com/sites/default/files/downloads/6709EN_Appendix_NET_Languages_and_its_Construct.pdf

Working with a varied set of upcoming technologies is a challenge. Visual Studio 2012 is all about enabling you to develop and manage these consumer-focused and business-focused apps. It provides best-in-class tools that propel developers to create new apps or evolve existing ones, and it enables individuals and teams to deliver continuous value and agility. In conjunction, .NET 4.5 provides expansive capabilities for developers to work on all forms of apps and services, from client to mobile to web to cloud, enabling them to get to the market fast. This book shows you exactly how to do this, and much more. It focuses on giving expertise on upcoming technologies through complete architectural insights of .NET infrastructure and hands on examples.

"Visual Studio 2012 and .NET 4.5 Expert Development Cookbook" is a step-by-step practical guide that teaches you how to work with new changes on technology under .NET. It provides in-depth analysis and expert advice on various elements of .NET, applying them in code using detailed practical examples. The book provides solutions to common development problems and helps you adapt to the latest technologies and get to grips with modern app development for the .NET 4.5 platform.

This cookbook gets you started on Visual Studio 2012 IDE and its various tooling capabilities. It provides expert knowledge on .NET infrastructure, internals of assemblies, and a basic introduction of Intermediate language. Common C# concepts and ideas are demonstrated through an example-driven approach.

The recipes provide an overall view of ASP.NET Web applications and introduce the new performance boosters in .NET 4.5. It also gives a basic introduction to HTML 5 and JQuery library to enhance Web applications. It provides a complete introduction to Client applications using WPF and MVVM patterns and looks at some of the major enhancements on WPF 4.5. It shows you how to write applications for Windows 8 and provides expert advice on how to write applications in WinRT, either using XAML and C# or HTML/JavaScript.

"Visual Studio 2012 and .NET 4.5 Expert Development Cookbook" gives you better understanding of overall .NET infrastructure using the latest technology updates, providing a broad guide for a basic developer to become an expert on .NET.

Finally, I have written this book to give you clear insights on the ongoing problems and changing technologies. People liked me before when I was presenting problems in my blog, I have kept the same approach on this book and I am sure as a reader I can justice your time from this book.

Purchase this book online

If you are interested to purchase it online, you can get it from the following links :

I am sure you will like this book. Do let me know your feedback on it. Write to me at contact@abhisheksur.com on any problem you face while reading this book.

Happy Programming !!!

A new book on Kinect by Abhijit Jana - A must read

2013-02-17T22:50:00.000+05:30

Kinect is one of the revolutionary device that were introduced lately in Microsoft ecosystem. The use of Kinect devices has increased in great extend in recent times and people are using it more and more in their day to day life. The use of Kinect is not only limited only with the gaming world, but its use is now widely spread over commercial applications too. Microsoft has released the Kinect SDK that can interact with the hardware and program on them. It is a kind of Fun working with Kinect and also writing small applications for it.

Recently I have read a book on "Kinect for Windows SDK Programming Guide" by Abhijit Jana. It is a book with great details about Kinect SDK and the Hardware. I enjoyed reading this book and thought of sharing my experiences with you such that if you are new in Kinect and want to write code on it, you might find this review helpful.

Kinect for Windows SDK Programming Guide by Abhijit Jana

Chapter 1

The book starts with the basic introduction to the evolution of the device, introduction of Natural User Interface and the differences of the Kinect device and Xbox platform. It then take us further introducing each and every component of the device and makes the hardware introduction ready. It is always good to know about the hardware components before going further with the SDK and programming interfaces. It seems this book has taken care of these details correctly.

Chapter 2

As we are kind of already get a basic introduction of Hardware, the book goes on to do the same with the software components and the Kinect SDK. In this chapter the author clearly introduces how to use the SDK, what are the components we need to install to correctly communicate windows with the hardware. I should also mention, this chapter also introduces some other software tools which might come handy while doing the development. The chapter also introduces the features of Kinect device in short paragraphs to get things really started.

Chapter 3

The real start of writing something is here. I like this chapter because it introduces the SDK by explaining each and every step correctly, such that if you are a beginner, you can start along to build this Infobox. Even Kinect SDK is so simple laid out, it is really fun and simple to create application using it. BTW, it uses WPF to design the sample, that might sometimes challenging. Well, if you want to learn WPF, I will encourage to read this.

Chapter 4

This chapter introduces Kinect Camera. It introduces how to retrieve color stream and processing it into a ImageControl. Here you will understand how you can stream the RGB set on the canvas and also save pictures form it. It also introduces how to change the elevation of Camera, putting effects on stream, inverting color and everything about camera elegantly. Overall this chapter will give you a good insight on the Camera API.

Chapter 5

This chapter is about depth mapping. The Kinect sensor provides Depthstream channels which can be utilized to create responding apps. This chapter gives an insight on how to utilize depth camera to determine the position of an object. The application looks cool to me.

Depth masking is one of the most interesting thing in Kinect. The chapter proves to be good one to introduce the various tricks to handle the depth of an object projected on camera.

Chapter 6

Well, probably now as we know everything in Kinect, it comes with something really constructive. This chapter introduces Skeleton Tracking. I must thank Microsoft to have SkeletonStream inbuilt on the SDK and also the Author to introduce and present it beautifully.

Again, this chapter creates a simple application to detect each section of the skeleton. I really enjoyed to track certain Joints on the skeleton while building this application and playing around with JointCollection in real time with the device.

Chapter 7

Well Chapter 7 is regarding the Microphone present in Kinect device. This is more like basic application development to explore sound API on Kinect device.

Chapter 8

As Chapter 7 being more on introductory level, I got really excited when I read Chapter 8. This chapter introduces Speech Recognisation. I know I did some speech recognisation applications before, but using Kinect, it is unique and exciting. Speech Recognisation works well with Kinect and built a solid application using this chapter is fun.

Chapter 9

Gesture recognition. Well, Its another interesting chapter where I learnt how to detect various gesture of a man, like clapping, moving hand etc. Funda is quite simple, you need to play around with the distance between joints. The idea will be much more clear if you can read this chapter. The chapter also builds up a gesture detection engine, which is what really interesting here, in this chapter.

Chapter 10

Finally it is time to interact with multiple kinect devices. I am yet to read this chapter, but as per I saw, it detects all the devices connected with a machine and combines the streams of all of them into a single application.

Chapter 11

Chapter 11 is one of the most interesting chapter where client server interaction is shown. It works with Augmented reality, Face tracking system etc.

That's all. Now after reading the whole book, I am very confident to start writing my own real world application using Kinect device. I will share more of Kinect when I build one myself.

After you read this book, probably you would be more inclined towards utilizing what you have learned from here. The trends currently show we are moving towards more touch/gesture sensitive UI in future. Kinect is the future of modern UI.

My Review

The book really kept its promises. It has a lot of examples to deal with so that you could utilize the SDK in real time and also describes every bits and pieces of the API as a whole. I would really recommend this book to all who have interest on Kinect API. The book starts from beginners level and so it does not depend how much experienced you are it would definitely be useful.

Download the Sample Chapter from here

If you are interested to purchase it online, you can get that from the publisher packtpub site as well as from amazon or flipkart too. Here are the links to get quick details of the book and link to purchase it online

Hope you will like this book and Happy coding.

NotifyIcon with WPF applications

2012-08-23T05:28:00.002+05:30

NotifyIcon is an utility form System.Windows.Forms which can be used by any application to invoke the default notification from the system tray. As per my latest requirement, I have to create an application that runs on system tray and occationally shows notification using the system tray default notifications. While working with it, I have wasted a considerable amount of time, and thought it would be worth mentioning the same in a blog.

Steps :

1. Start a WPF Application and add Reference to System.Windows.Forms and System.Drawing to the project.
2. Create an instance of NotifyIcon on the Code behind of the WPF application.
3. Specify the Icon property for the NotifyIcon.
Remember, you should specify the Icon property as it is a mandatory before you can show notifyIcons from the application.
4. Make the NotifyIcon visible.
5. Call ShowBallonTip after minimizing the window to System Tray.

In my sample application, I have just created one button on the Window and when it is clicked, I show up a notifyIcon on the system tray.

<Window x:Class="NotifyIconSample.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525">
    <Grid>
        <Button Click="Button_Click" Content="Click to Open" />
    </Grid>
</Window>

Code :

 NotifyIcon nIcon = new NotifyIcon();
        public MainWindow()
        {
            InitializeComponent();
        }
 
        private void Button_Click(object sender, RoutedEventArgs e)
        {
            this.WindowState = System.Windows.WindowState.Minimized;
            this.nIcon.Icon = new Icon(@"../../Cartman-General.ico");
            this.nIcon.ShowBalloonTip(5000, "Hi", "This is a BallonTip from Windows Notification", ToolTipIcon.Info);
            
        }

Note : I have wasted lot of time just to ensure that the Icon property is mandatory for the NotifyIcon to work on. So it is important to note that you must specify it before using it.

Microsoft TechEd 2012 on the Go.. Are you attending?

2012-03-18T19:51:00.001+05:30

Well, Microsoft is going Big with their event TechEd 2012 which will be held just in 2 days from now. Everyone is excited to visit Bangaluru for this awesome event and learn lot of technology. I am going to visit Bangalore soon. If you are going, just text me at contact@abhisheksur.com and come and say hi to me during the event.

Visit the link below to know more about the event
Microsoft TechEd India 2012 -> Go Big

Now if you cannot join us in Bangaluru for this event, you can still see the event live. Register yourself immediately.

Catch TechEd Online for FREE!!!

Click to Read Details!

I hope to see you all around.

Inter-Process Communication using MemoryMappingFile

2012-02-27T04:58:00.000+05:30

In an operating system, a Memory Mapping file are virtual storage place which has direct byte to byte correlation between the Virtual Address Space and the corresponding physical storage. So when we access the Virtual Address space via a memory mapping file we are directly communicating with the kernel space where the file is actually loaded. The portion of calculation between the physical storage and logical storage is hence avoided.

Memory Mapping files allows application to access files in the same way as memory. Generally as address between the physical storage and virtual memory address space, we cannot access the physical address directly. But using Memory Mapping Files, the process loads a specific range of address within the process address space with which the storage of memory into the file can be done by just assigning value to a dereferenced pointers. The IO operation on a MemoryMapping file is so fast that from the programmers point of view it seems to be like accessing the memory rather than actual physical storage. To increase performance memory mapping files are not actually stored to the disk file as well, but rather it will be stored automatically in background when FlushViewOfFile is executed or paging file is written. To Read more about memory mapping files, read here.

Memory Mapping file inside .NET Framework

.NET introduces a separate namespace to handle Memory Mapping files. Previously, we needed to do this using unmanaged Api's but with the introduction of managed API into the .NET framework library, it becomes very easy to handle MemoryMapping file directly from .NET library.

As memory mapping files are loaded into memory on a separate range of address space, two process can easily share the same page file instance and thus interprocess communication can be made with fast access to memory. It is recommended to back data with an actual disk file when large data is loaded into memory, so that there is no memory leak on the system when there is large memory pressure.

MemoryMapping with backup Paging file (For large data communication)

We generally use backed up memory file in the hard disk when the memory that needs to be shared between the process goes out of physical memory available on the pc or when you think that the data that needs to be loaded can be very expensive and sensitive to remain only in memory.

const string FILENAME = "LargeFile.dat";
private MemoryMappedFile GetMemoryMapFile(FileMode mode)
{
   string path = Path.Combine(defaultPath, FILENAME);
   var mmf = MemoryMappedFile.CreateFromFile(path, mode, "INTERPROC", this.length, MemoryMappedFileAccess.ReadWriteExecute);
  return mmf;
}

The code above gets the reference of MemoryMappedFile using a disk backup paging file. The CreateFromFile static method of MemoryMappedFile exposes an option to specify path of the actual file location where the memory mapping file content needs to be mapped. By opening the file you can load the views of memory mapping file as you are accessing the file content from memory. You can also use OpenExisting or CreateNew methods if you are sure of the specific requirement of usage.

In the above code, you can see I have specified the length of the file as well as a fixed name "INTERPROC" which indicates the name of the shared memory location which other process can call to access. The length of the file needs to be a multiple of 1024 always, hence if you are not using the content of the file, the paging location will still be occupied with null content. This ensures the mapping file always remains in same context as the loaded memory. The file based Memory Mapping files are not loaded totally when you try to access, but rather it provides views in terms of what data you are currently accessing.

Once the file is opened, you can read the content of it using :

var mf = this.GetMemoryMapFile(FileMode.OpenOrCreate);
   using(mf)
   {
        int dsize = Marshal.SizeOf(typeof(T));
        T dData;
        int offset = dsize * index;
        using (var accessor = mf.CreateViewAccessor(0, length))
         {
             accessor.Read(offset, out dData);
             return dData;
         }
  }

Here once the MemoryMappedFile is loaded into memory, you can use CreateViewAccessor to create a separate view to see the content of the data. Here I have loaded the entire data at a time, but it is better to create View content as soon as you want to read its content. Once the data is loaded you can use Read method to get data from the memory.

var mf = this.GetMemoryMapFile(FileMode.OpenOrCreate);
using (mf)
{
int dsize = Marshal.SizeOf(typeof(T));
int offset = dsize * index;
using (var accessor = mf.CreateViewAccessor(0, length))
{
    accessor.Write(offset, ref dData);
}
}

Almost identical to it, you can use write method to write content into the memory.

Remember
One thing that you need to remember, when you Dispose the memory content from one process that means all the content that are loaded into view needs to be rewritten to the disk file, such that the other process needs to reopen and recreate the view again. If you want to access some specific view without writing to the page file often after using it, tweak the behavior by not disposing the MemoryMappedFile (removing the using block from here) and the operating system will automatically manage the destruction of View.

MemoryMapping without backup Paging file (For small data communication)

When the load of memory file is small, it would not be always good to have a large paging file created in background and wasting large amount of memory of the system. Sometimes we need to share content only between the process and when no process is accessing the shared memory, the operating system needs to dispose the content. Regards to this requirement, you can use MemoryMappedFiles to be stored only into memory and be called using the name of Memory created.

private MemoryMappedFile GetMemoryMapFile()
{

    var security = new MemoryMappedFileSecurity();
    security.SetAccessRule(
        new System.Security.AccessControl.AccessRule<MemoryMappedFileRights>("EVERYONE",
            MemoryMappedFileRights.ReadWriteExecute, System.Security.AccessControl.AccessControlType.Allow));

    var mmf = MemoryMappedFile.CreateOrOpen("InterPROC",
                    this.length,
                    MemoryMappedFileAccess.ReadWriteExecute,
                    MemoryMappedFileOptions.None,
                    security,
                    HandleInheritability.Inheritable);

    return mmf;

}

In the code above, I have created a MemoryMappedFile using CreateOrOpen and named the actual memory being created as "InterProc". Now this will create a file into the memory without any reference to it into disk file. The HandleInheritability states that the child processes can also access the memory file.

You can also specify security on the memory using MemoryMappedFileSecurity and add Access rule to the security blocks.

public T ReadEntry<T>(int index) where T : struct
{
    var mf = this.GetMemoryMapFile();

    int dsize = Marshal.SizeOf(typeof(T));
    T dData;
    int offset = dsize * index;
    using (var accessor = mf.CreateViewAccessor(0, length))
    {
        accessor.Read(offset, out dData);
        return dData;
    }
}

public void WriteEntry<T>(T dData, int index) where T : struct
{
    var mf = this.GetMemoryMapFile();
    int dsize = Marshal.SizeOf(typeof(T));
    int offset = dsize * index;
    using (var accessor = mf.CreateViewAccessor(0, this.length))
    {
        accessor.Write(offset, ref dData);
    }
}

You can read from and write to the file in the same way as you did for the file based shared memory, but one thing you need to remember again, you cannot close/dispose the MemoryMappedFile as this will erase all the content that you write into the View.

Here you can see, I didnt use using block or even wrote the Dispose of MemoryMappedFile as it is important.

Download the Source code

Using the code

In the sample application that I have provided with this article, there is an interface that you can use to handle both Large and small Communicators. Ideally these classes needs to be used based on the requirement on real world .

 public interface ICommunicator
    {
        T ReadEntry<T>(int index) where T : struct;
        void WriteEntry<T>(T dData, int index) where T : struct;
    }

int index = 0;
ICommunicator lcom = new SmallCommunicator();//new LargeCommunicator("D:\\");

// My Try
while (true)
{
    DummyData dData = lcom.ReadEntry<DummyData>(index);
    Console.WriteLine("Existing Data at 0 position : {0}", dData);

    Console.WriteLine("Write Data Id");
    dData.Id = Convert.ToInt32(Console.ReadLine());
    Console.WriteLine("Write new Data");
    dData.Data = Convert.ToInt32(Console.ReadLine());

    lcom.WriteEntry<DummyData>(dData, index);

    Console.ReadKey(true);
}

Thus it will open a SmallCommunicator (or LargeCommunicator) and read/Write data into it.

Hope that helps!

Happy Coding.

Optimizing INPC Objects against memory leaks using WeakEvents

2012-02-04T05:25:00.000+05:30

Working with WPF has always been a fun. Dealing with animation and richness in UI to its optimum level often gives you an edge to present something to your client and to ensure that your client shouts with a "WOW!". The Wow factor of applications can give you high rank in the first place, but increases expectation from the software. It is practically very hard to maintain with this expectation as time progresses. The survival of the fittest chooses one which best suits to the problem.

One of the major problems that developers face today is the memory leaks in an applications. Often the software that is built looks great but does not follow basic guidelines to ensure that the application is not memory hungry or even there are no existing memory leaks.

Note : By memory leak we mean, some portion of memory is not reclaimed by the garbage collector even though the object is not in use.

By this way, the memory usage of the application increases at a certain extent and finally crashes with the OutOfMemoryException. To detect a memory leak there exists a large number of tools of which some are free while others are used as commercial purposes. Most of these problems can be fixed by either using Disposable pattern ( IDisposable interface) or manually de - referencing each and every object that are not in use. Sometimes, this can be also done in destructor / finalizers in .net too (but remember using destructors lose GC cycle).

GC algorithm actually tries to find all reachable objects in the entire heap and creates a map. It then puts the reachable objects one by one into the heap releasing memory of all unreachable objects. This is called Heap Compaction. By reachable objects we mean those objects to which the application still has strong reference, and the items which can be called in future. Thus it is important to release any strong reference of a memory when it is not in use, so that GC can collect it.

Even though Garbage Collector separates all the reachable objects with non-reachables, there is one exception to this. .NET framework exposes WeakReference as a special type in the system, which can hold objects that are reachable but still it will be collected by the garbage collector. You can look into it in detail in my post : Garbage Collection Algorithm with the use of WeakReference

The Problem

Now coming back to the application, sometimes it is even difficult to identify a memory leak when it exists inside of its framework. One of such scenario is when a large portion of memory is held by the EventHandler where the source has an EventHandler which is connected with a strong reference of the target which has the event. Let me explain it more :

Object A holding strong reference of Object B through the use of EventHandler

In the above figure, let say Object A is an object that exposes one Event. Suppose Object A is an INPC container and exposes PropertyChanged Event from it. Object B on the other hand consumes Object A and adds an EventHandler inside B. Now it invokes statement to add this handler to the Object A using the code below :

A a1 = new A();
a1.PropertyChanged += new PropertyChangedEventHandler(this.A_PropertyChanged);

So now object A can call A_PropertyChanged event handler defined inside Object B directly.
At a certain point, lets say Object A is no longer in use and is de-referenced from B by doing :

a1 = null;

Here the de-referencing works good, but you are missing the fact that a1 still holds reference of B through the Event PropertyChanged, and will not be GCed until B is de-referenced as well. Here is the problem of memory leak. If B is a Static object and creates lots of A throughout the program, this problem can really leak lots of memory and eventually can load the process to crash.

The Solution

To deal with such a problem, we need a Co-ordinator for the Event such that the event raised by the object does not go directly to the Object B, rather it calls an intermediate listener which routes the event to the handler of Object B.

The Object A is not communicating directly with Object B, rather it connects with a WeakListener which exposes one WeakReference object to hold B

In the above figure, we can see, the Listener co-ordinates the event with the EventHandler thus de-referencing Object A and Listener from Object B will remove all the references from it. Lets implement this approach using code.

interface IPropertyChanged
    {
        void OnPropertyChanged(object sender, PropertyChangedEventArgs e);
    }

    public class WeakEventListener : IDisposable
    {
        readonly object locker = new object();
        WeakReference weakListener;
        INotifyPropertyChanged target;
        IPropertyChanged source;

        public WeakEventListener(IPropertyChanged source, INotifyPropertyChanged target)
        {
            this.source = source;
            this.target = target;
            if (this.target != null)
                this.target.PropertyChanged += new PropertyChangedEventHandler(target_PropertyChanged);
            this.weakListener = new WeakReference(source);
        }

        void target_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            object source = null;
            lock (locker)
            {
                if (weakListener != null)
                {
                    source = weakListener.Target;
                }
                if (source == null)
                {
                    ReleaseListener();
                    return;
                }
            }
            IPropertyChanged notifier = source as IPropertyChanged;
            notifier.OnPropertyChanged(sender, e);

        }

        private void ReleaseListener()
        {
            if (target != null)
            {
                target.PropertyChanged -= new PropertyChangedEventHandler(target_PropertyChanged);
                target = null;
                weakListener = null;
            }
        }
        #region IDisposable Members

        public void Dispose()
        {
            lock (locker)
            {
                this.ReleaseListener();
            }
        }

        #endregion
    }

So here I have implemented one dummy implementation of WeakEventListener. Here the IPropertyChanged interface is used to reference the object inside the Listener for simplicity.

In the above implementation, you can see, I have used two object. Preferably consider object A in figure with INotifyPropertyChanged object target and IPropertyChanged as object B such that object B creates reference to both INotifyPropertyChanged as well as WeakEventListener. Now if B is derived from interface IPropertyChanged and define the eventhandler inside it, the WeakEventListener can invoke it without holding a strong reference of it.

public class A : INotifyPropertyChanged
{
    string myProperty;
    public string MyProperty
    {
        get { return myProperty; }
        set
        {
            this.myProperty = value;
            if (this.PropertyChanged != null)
                this.PropertyChanged(this, new PropertyChangedEventArgs("MyProperty"));
        }
    }

    #region INotifyPropertyChanged Members

    public event PropertyChangedEventHandler PropertyChanged;

    #endregion
}

public class B : IPropertyChanged
{
    A a1;
    WeakEventListener wlistener;

    public B(A a1)
    {
        this.a1 = a1;
        wlistener = new WeakEventListener(this, a1);
    }

    #region IPropertyChanged Members

    public void OnPropertyChanged(object sender, PropertyChangedEventArgs e)
    {
        MessageBox.Show(string.Format("Property {0}, has been changed", e.PropertyName));
    }

    #endregion


    public void ReleaseA()
    {
        if (this.wlistener != null)
            this.wlistener.Dispose();
        this.wlistener = null;
        this.a1 = null;
    }

}

Now here class A implements INotifyPropertyChanged and invokes it when any of its property is changed. Class B, on the other hand implements IPropertyChanged and provides a eventhandler of PropertyChanged. But as it is using WeakEventListener you can call ReleaseA to release any strong reference of a1 from it and also dispose the listener object. Therefore you can keep on using the object B irrespective of any memory leak been created.

Alternatives inside Framework

WPF has a framework alternative to do the same thing. A number of class are available on the framework which help in implementing the same thing. Lets see how to do this using framework interfaces :

1. Create a class and derive it from WeakEventManager.
2. Implement IWeakEventListener interface to define listener.
3. Use AddListener and RemoveListener to add and remove the objects.

Lets see how I implement the same thing.

class A : INotifyPropertyChanged
{
       
    string myProperty;
    public string MyProperty
    {
        get { return myProperty; }
        set
        {
            this.myProperty = value;
            if (this.PropertyChanged != null)
                this.PropertyChanged(this, new PropertyChangedEventArgs("MyProperty"));
        }
    }
    //code to raise the event
    public event PropertyChangedEventHandler PropertyChanged;
}
class B : IWeakEventListener
{
    A a1;

    public B(A a1)
    {
        this.a1 = a1;
        PropertyChangedEventManager.AddListener(a1, this, "MyProperty");
            
    }
    public bool ReceiveWeakEvent(Type managerType, object sender, EventArgs e)
    {
        PropertyChangedEventArgs pe = e as PropertyChangedEventArgs;

        MessageBox.Show(string.Format("Property {0}, has been changed", pe.PropertyName));

        return true;
    }
    public void ReleaseA()
    {
        PropertyChangedEventManager.RemoveListener(this.a1, this, "MyProperty");
        this.a1 = null;
    }

}

Here the PropertyChangedEventManager is a special class derived from Dispatcher object deals with INPC objects by holding a collection of all those INPC in the whole process and calling appropriate objects when event is raised. Thus ReceiveWeakEvent will be called, just like what we did earlier in B when A raises the event provided you implement IWeakEventListener interface on it.

The ReleaseA is used to release the object A from memory without any strong reference been held.

There is also a CollectionChangedEventManager to deal with ObservableCollection events or even you can build your own by deriving from WeakEventManager.

I hope the post will help you. Please let me know your thoughts.

Thanks for reading.

I am reviewing Microsoft's 70-515 C# exam PrepKit from UCertify

2012-01-04T01:05:00.003+05:30

I have got a offer from uCertify to review their PrepKit and I have accepted that challenge and now I am reviewing 70-515 Exam .NET 4.0 PrepKit from uCertify. Initially it looks like a simple tool that has a number of practice sets listed on the initial screen to try out few tests. The home screen also contains few links that points to Study Materials related to the exam that you are registered for. Lets take a look how the initial screen looks like :

The menu contains different links to Tests, Quiz, Notes, Articles, Reports etc for easy navigation.

As soon as I am done with the full review I will post it for you all.

If you are looking for a Certification, you can buy it from them :
http://www.ucertify.com/

Thanks and stay tune.

Awarded Microsoft MVP in a row

2012-01-02T02:24:00.002+05:30

Its new years eve. I was struck in traffic to join a Birthday party of one of my friend. Its all of a sudden I realized that it is my MVP renewal date too. I forgot it totally.

I opened my Mobile, browsed to my account and saw, I have got a mail from MVP Award Team.

"Dear Abhishek Sur,

Congratulations! We are pleased to present you with the 2012 Microsoft® MVP Award! This award is given to exceptional technical community leaders who actively share their high quality, real world expertise with others. We appreciate your outstanding contributions in Client App Dev technical communities during the past year.

The Microsoft MVP Award provides us the unique opportunity to celebrate and honor your significant contributions and say "Thank you for your technical leadership."

Nestor Portillo
Director
Community & Online Support"

I am really passionate about this award and I am really happy to receive this award for yet another time in Client App Dev category. This came to me as a New Years Gift. Thank you so much Microsoft for considering my activities and I want to personally thank Mr. Abhishek Kant, as my MVP Lead, Abhijit Jana, Kunal Chowdhury, Amit Bansal, Dhananjay Kumar, Pinal Dave, Anoop Madhusudanan and last but not the least my own Community KolkataGeeks all of whom inspired me so much on my community activities. I would also like to thank the whole Microsoft Team for providing us such an opportunity to be in touch with this elite group.

And finally thank you to all my blog readers. I feel truly honored to receive such an award.

Happy New Year to all of you. Its time to party..... .

:)

Daily DotNet Tips 1 year and onwards

2011-12-27T08:53:00.000+05:30

Friends,

We are excited to celebrate 1st Anniversary of our site DailyDotnetTips today. It aims to share useful programming tips for .net developers.This site completely design for sharing Tips and Tricks, useful Code Snippet which anyone use in daily development work and targeted anything related with .NET.

Here is some of the statistics :

Founded : 27th December 2010
No of Posts : 250
No facebook likes : 502
No of participants : 7
No of Twitter followers : 348

We are still a long way to go. Follow us and be a part of it.

www.dailydotnettips.com

DEVCON – Kolkata, A New Beginning on 12th November, 2011

2011-11-10T21:31:00.001+05:30

November 12th , we are getting together for a big event Developer Conference 2011 Organized by Microsoft User Group Kolkata (KolkataGeeks) . Developer Conference is the premier technical event for technology professionals at Kolkata interested in learning, connecting and exploring latest Microsoft technologies. This is also going to be community Launch event for Office 365. So be there and enjoy the flavor of cutting edge Microsoft technologies.

This is a full day event and you can attend this event in person at Bharatiya Bhasha Parisad 36A, Shakespeare Sarani, 4th Floor Kolkata – 700017. Overall there are 7 different sessions which primarily focused on latest Microsoft Technologies. . Check the Dev Con Web Site for more information.

I’ll be presenting on “Windows 8 Metro Style Application“. In this session I will talk about latest Windows release and how you can get best out of it through your Metro Style applications. There will be lots of demo in this session.

Check out session details and agenda from here http://kolkatageeks.com/DevCon2011.aspx . You can register for this event over here http://kolkatageeks.com/DevCon2011/Register.aspx

See you there !

Layout adjustments Snapping and OrientationChanges in Metro Applications

2011-10-31T06:06:00.001+05:30

If you have read my first article on Windows 8 metro styled application, you might already know about the working principle of it. I have talked about the capabilities for an application and settings which end user can configure for an application. In this post I will take a look at the basic layout structure that one needs to follow while creating an application in WinRT Metro styles so that it is best suited to perform well.

Layout is the most important part of any application. The best design for an application gets more credit and love from the users than applications that are designed bad. Metro style applications runs in full screen. Your application does not include a Title Bar, status bar or anything. Microsoft gave us some of the basic layout guidelines that one needs to follow. Lets talk about them here to make you understand how you should layout your application in Metro Applications to utilize maximum flexibility of it.

Lets start defining a layout and explain each section.

<UserControl x:Class="LayoutSample.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Loaded="UserControl_Loaded"
    d:DesignHeight="768" d:DesignWidth="1366">
    
    <Grid x:Name="LayoutRoot" Background="#FF0C0C0C">
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="Auto"/>
            <ColumnDefinition Width="320"/> 
            <ColumnDefinition Width="*" />
        </Grid.ColumnDefinitions>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*" />
        </Grid.RowDefinitions>
        <Rectangle x:Name="rctSpacerLeft" Width="120" />
        <Border x:Name="brdHeader" Height="140" Grid.ColumnSpan="2" Grid.Column="1">
            <TextBlock HorizontalAlignment="Left" VerticalAlignment="Center" Text="My Basic Layout"
                       FontSize="40"/>
        </Border>

        <ListBox x:Name="lstBasicItems" Grid.Row="1"
                 Grid.Column="1">
            <ListBox.ItemTemplate>
                <DataTemplate>
                    <StackPanel Orientation="Vertical" >
                        <TextBlock Text="{Binding Name}" HorizontalAlignment="Center"/>
                        <TextBlock Text="{Binding Description}" HorizontalAlignment="Left"/>
                    </StackPanel>
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>
        <Grid x:Name="grdLayoutRight" Grid.Row="1" Grid.Column="2" DataContext="{Binding ElementName=lstBasicItems, Path=SelectedItem}">
            <Grid.RowDefinitions>
                <RowDefinition Height="Auto" />
                <RowDefinition Height="*"/>
            </Grid.RowDefinitions>
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="Auto" />
                <ColumnDefinition Width="*" />
            </Grid.ColumnDefinitions>
            <TextBlock Text="Name" FontSize="14" />
            <TextBox Text="{Binding Name}" Grid.Column="1" />
            <TextBlock Text="Description" FontSize="14" Grid.Row="1" />
            <TextBox Text="{Binding Description}" Grid.Column="1" Grid.Row="1" />
        </Grid>
    </Grid>
    
</UserControl>

This is a basic layout of an application which shows a list of data in the left hand side in a ListBox and the Right hand side shows few textboxes to edit the data. Following the convension, each application should have a left margin of 120 px. In this layout the First Column of the LayoutRoot grid is specified Auto. Auto indicates that the portion of the screen will be sized to content. In this section I specified a Rectangle with width 120px.
Again the Application needs to have a Heading. I have specified the heading in the First Row of the Grid. The ListBox is taken as 320px, this is because when the application is snapped, it takes 320px of size based on the design resolution. The Grid is *(star) Sized, hence it will adjust the size based on the available space.

Now if you run this code, you will see something like this :

Here the ListBox takes 320 px of size and the Grid takes the rest of the available space. Now if you snap the application with another application, it will not adjust the size automatically. Lets write code so that it does.

public MainPage()
{
    InitializeComponent();
    var currentView = ApplicationLayout.GetForCurrentView();
    currentView.LayoutChanged += new TypedEventHandler<ApplicationLayout, ApplicationLayoutChangedEventArgs>(currentView_LayoutChanged);
}

void currentView_LayoutChanged(ApplicationLayout sender, ApplicationLayoutChangedEventArgs args)
{
    switch (args.Layout)
    {
        case ApplicationLayoutState.Filled:
        case ApplicationLayoutState.FullScreen:
            this.rctSpacerLeft.Visibility = Windows.UI.Xaml.Visibility.Visible;
            this.brdHeader.Visibility = Windows.UI.Xaml.Visibility.Visible;
            break;
        case ApplicationLayoutState.Snapped:
                this.rctSpacerLeft.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
                this.brdHeader.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
            break;
    }
}

So here you can see I have made the rctSpacerLeft and brdHeader visible only when the state of the application is Filled (that means when some other application is snapped with the application) or when the application is FullScreen (that means when the whole application is showed up). But these elements need to be Collapsed whenever the application is in Snapped mode(when the current application is snapped).

You should already know, basically applications has 3 states. One when the size of the application is 320px long (called snapped ), when the application is filled most of the space just leaving 320px of the entire screen for some other application or when the application is full screen.

In the above image, I have just snapped the Tweet@rama that comes preinstalled with Windows 8. You can see the Grid is sized smaller than the previous one sharing the the 320 px of the entire screen to the other application. Here the Margin is kept intact.

But when the current application is snapped state, we need to show the entire thing in 320px. So the application needs to adjust itself to be meaningful to the User.

When I snap the current application with Tweet@rama, you can see, it removes the header, the spacer margin and the Grid that is auto sized.

Responding to Rotation

Responding to Ration of the device is another important consideration that you should always keep in mind while designing a Metro styled application. To know the Native Orientation of the device when the application gets started, you can use the DisplayProperties.CurrentOrientation property.

Lets modify the code to show the Orientation of current device in header. By default the orientation is Landscape.

The above image shows up the current Orientation of the device. Lets edit the xaml a bit to introduce it.

<Border x:Name="brdHeader" Height="140" Grid.ColumnSpan="2" Grid.Column="1">
      <TextBlock HorizontalAlignment="Left" VerticalAlignment="Center"
                 FontSize="40">
          <Run Text="My Basic Layout" />
          <Run x:Name="runOrientation" />
      </TextBlock>
</Border>

I have added a couple of Run statement to allow changing the Orientation text in one particular Run block inside the TextBlock. Now lets handle the OrientationChanged Event of DisplayProperties to get the current Orientation. To do this lets add this code :

public MainPage()
{
    InitializeComponent();
    var currentView = ApplicationLayout.GetForCurrentView();

    currentView.LayoutChanged += new TypedEventHandler<ApplicationLayout, ApplicationLayoutChangedEventArgs>(currentView_LayoutChanged);

    DisplayProperties.OrientationChanged += new DisplayPropertiesEventHandler(DisplayProperties_OrientationChanged);
}

void DisplayProperties_OrientationChanged(object sender)
{
    this.WriteOrientation();
}
void WriteOrientation()
{
    this.runOrientation.Text = string.Format(" ({0})", DisplayProperties.CurrentOrientation);
}

Here we initialize the new event handler for OrientationChanged in constructor of MainPage, which will call the event whenever the orientation of the device is changed. DisplayProperties also lists many other display related properties like ColorProfileChanged, LogicalDpiChanged etc but they are rarely needed. You can read them from here.

Download Sample Project

Conclusion

To write a general purpose application, it is very important that your application maintains proper layout when the device changes its size or shape. The objective of the post is to get you through understanding how you could form a good layout for your application. I hope you have already got the basics of how to layout the application in Metro Environments.

I hope this post helped you.

Thank you for reading.

Understanding basic WinRT Metro Applications and Application Capabilities

2011-10-30T06:47:00.000+05:30

Just about a month ago, WinRT was introduced with all new style of application development that can work better with Multi Touch Enabled devices. We call it as Metro Applications. In this post, I will discuss how to develop your first metro applications and how to work with its layout changes.

How to Start

Before we start talking directly about Metro Style application, let us see how to install it first. I refer to use OracleVM which you can find for free from this link, and install. This will install a Virtual Machine in which you can install the Developer Preview of Windows 8.

After your Virtual Machine is ready download Windows 8 Developer Preview from this link. Remember you need to install Windows Developer Preview with Developer Tools 64 Bit which is 4.8GB in size if you are willing to develop Metro Style Application. If you have something else, you do not have option than install it again. ( I have lost several hours trying on other windows previews). If you are having problems while installing Windows 8 in your Virtual Box, please follow the steps mentioned here.

After you install Windows 8 in your virtual machine please make sure you change the resolution to something above 1152. It is important because anything below this will turn of certain things. You cannot open Metro Apps or you cannot apply Partial fill settings of your application when the resolution is below this range.

Another Important consideration

You must remember, Metro application does not support closing the application, at least now. Hence if you start a new application the other application will keep on running in background. You can switch back to that by hovering the left hand side of the screen and dragging back to the working area. Shortcut to do this is Windows + Tab. The only way to close is either using an explicit close button from the application itself, or using Alt + F4 key from the keyboard.

The Desktop Tile
Metro application is designed in such a way that the tiles are capable of update itself and it is easier to work with them using your hand. But like me most of the people might want the desktop on which we are all familiar of in windows. Yes Metro has a Tile called Desktop Tile that can present you with the very old Desktop with applications that are meant to run in desktop. You can move back and forth to this Desktop tile when you want.

So the one that is marked represents the Desktop Tile. You can also see Visual Studio and other developer tools appear in the same picture as Tile. The Visual Studio Express will help you build your first metro applications.

Application Store

Application store is another important point to note for Metro style application. After you package a metro style application you need to publish it and upload it to Application Store with all the important information of it clearly. The user that needs the application should connect to the application store and download the same. This way the user is always aware of what he is downloading and what the application does.

Now as you know much about Metro applications, lets start writing one metro application.

What are Capabilities?

Just like Silverlight or Windows Phone, Metro applications run in a very constrained mode. That means when you install the metro application you should provide the entire rules which the application should follow. That is to say if you do not specify that the application needs internet access to run the application, you would not get it from the application either. Hence Capabilities are defined set of rules that govern the application to access certain functionalities that application needs.

When you create a blank application in Visual Studio, you will see a appmanifest file that exists for each application. It is nothing but an XML file where you need to specify capabilities, Application related metadata etc. You can easily open that file in XML editor and add Capabilities like below :

<Capabilities>    
    <Capability Name="internetClient" />
</Capabilities>

But you dont need to. If you double click on the File Package.appmanifest, you can edit to add Capabilities from a list of Capabilities that are commonly used. For instance Internet is checked by default. Lets add Location in this list. Location will allow you to get Latitude/Longitude information of the device.

When you run an application, it deploys the application automatically to metro application without the need of Application store. Hence you dont need to wait until the application store approves your application to run. This is called as side loading which the end user cannot do as it is explicitly restricted to Visual Studio. Now if you run your application, you will see a blank black screen appear after the initial flash screen.

Lets run the project and swipe the application by hand to see some settings. You can also hover over the left hand bottom of your application to open the same settings or use Windows + I.

Here you can see some standard settings that appear on the bottom of the sidebar. The Application information is also specified in the top of the side bar. And a special link which indicates the application capabilities. Lets click on it to see which capabilities are there for me.

I have asked for Location, Proximity and Internet access, and hence it shows up in this list. You can see there is one additional settings called Location listed as Off above the list.

Certain features needs explicit access by the user when the application request it. Location is taken as sensitive capability, and hence it will again ask the user to enable it when you first call it and the user has the option to block this too.

Now lets write some code to access the Location and see what happens to the application.

We add some basic XAML to the application which adds one TextBlock and one Button. So when the Button is clicked the Textblock updates the current location of the device.

Lets see how xaml looks like:

<UserControl x:Class="Metro1SimpleApp.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Loaded="UserControl_Loaded"
    d:DesignHeight="768" d:DesignWidth="1366">

    <Grid x:Name="LayoutRoot" Background="#FF0C0C0C">
        <Grid.RowDefinitions >
            <RowDefinition Height="120" />
            <RowDefinition Height="*" />
        </Grid.RowDefinitions>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="120"/>
            <ColumnDefinition Width="*"/>
        </Grid.ColumnDefinitions>
        <StackPanel Orientation="Vertical"  Grid.Row="1" Grid.Column="1">
            <TextBlock x:Name="txtLocation" Text="Your Current Location is : "/>
            <Button Click="Button_Click" Content="Update Location" />
         </StackPanel>

    </Grid>

</UserControl>

Here the code adds one TextBlock and a Button that acts just like regular controls. If you try to know from inside these controls are wrappers to WinRT controls. Now the Button has a Click Handler defined and the UserControl also defines the Loaded event handler.

Now lets write code for those handlers :

private async void Button_Click(object sender, RoutedEventArgs e)
{
    await UpdateGeoLocationAsync();
}

private async void UserControl_Loaded(object sender, RoutedEventArgs e)
{
    await UpdateGeoLocationAsync();
}

private async Task UpdateGeoLocationAsync()
{
    Geolocator location = new Geolocator();
    Geoposition position = await location.GetGeopositionAsync();

    this.txtLocation.Text = string.Format("Your current position is :({0}, {1} ", position.Coordinate.Latitude, position.Coordinate.Longitude);
}

Geolocator is an WinRT API that calls for a GeoPosition either by using satellite position (if appropriate sensor is found in the device) or using internet address of the IP. Now this is slow API and hence WinRT allows you to only invoke asynchoronous call to this api. We use the new async support here to call the API.

If you dont know about async, please read my article.

We add the contextual await to call from both the UserControl.Loaded and Button.Click event handlers.

When I run the application, it will first ask to unblock the Location API. I have already told you, the location API is taken as sensitive and hence you as an user for the application have the settings to block and unblock. You will see something like below :

Thus it asks to turn on location service. If you allow then only the application can get Location data. Lets allow it, you will see the location is updated.

If you are moving, you can click on the Button on the application to update your location when needed.

Now after you unblock the location API for the first time, if you go to settings, you will see the Location capability is now enabled for you. You can turn on or off whenever you want.

To run on or off, you can drag the button to the right or left.

You can download the sample from here.

Even though for a developer coming from normal Windows application it may seem to you as weird to have such kind of security enabled for your application, but world is moving towards it and this will benefit the end user to have clear knowledge about what the application is capable of. Hence it adds up security to the whole system.

Conclusion

This is still very early stage of WinRT to talk about. There may be some amount of changes in final release of it. But yet it is good to learn about it. I hope you like my post. I will update with more posts on WinRT metro application in near future.

Thanks for reading.

Regular Expressions with Timeout in .NET 4.5

2011-10-21T06:31:00.000+05:30

.NET 4.5 Developer preview is out with Visual Studio 2011. I was already thinking to try out what's new in .NET 4.5 myself and share what exactly been changed.

Lets start by the new Regex Api introduced with the framework. The improvement that has been made is minor yet handy at certain cases. The Regex class of .NET 4.5 supports Timeout. Lets take a look how to work with it.

Lets try to write a simplest RegEx validator to look into it.

try
{
    Regex regexpr = new Regex("[A-Z ]{10}", RegexOptions.Singleline, TimeSpan.FromMilliseconds(1));
    Match mch = regexpr.Match("ABHISHEK SUR");
    if (mch.Success)
        Console.WriteLine("Match found");
    else
        Console.WriteLine("Not matched");

}
catch (RegexMatchTimeoutException ex)
{
    Console.WriteLine("Regex Timeout for {1} after {2} elapsed. Tried pattern {0}", ex.Pattern, ex.Message, ex.MatchTimeout);
}
catch (ArgumentOutOfRangeException ex)
{
    Console.WriteLine(ex.ToString());
}
finally
{
    Console.ReadKey(true);
}

Here in the code you can see I simply check a string with a Regular expression. It eventually finds success as Pattern matches the string. Now this code is little different than what we have been doing for last few years. The constructor overload of Regex now supports a Timespan seed, which indicates the timeout value after which the Regular expression validator would automatically generate a RegexMatchTimeoutException. The Match defined within the Regex class can generate timeout after a certain time exceeds.

You can specify Regex.InfiniteMatchTimeout to specify that the timeout does not occur. The value of InfiniteMatchTimeout is -1ms internally and you can also use Timespan.Frommilliseconds(-1) as value for timespan which will indicate that the Regular expression will never timeout which being the default behavior of our normal Regex class. Regex also supports AppDomain to get default value of the Timeout. You can set timeout value for "REGEX_DEFAULT_MATCH_TIMEOUT" in AppDomain to set it all the way through the Regular expressions being used in the same AppDomain. Lets take a look how it works.

try
{
    AppDomain.CurrentDomain.SetData("REGEX_DEFAULT_MATCH_TIMEOUT", TimeSpan.FromMilliseconds(2));

    Regex regexpr = new Regex("[A-Z ]{10}", RegexOptions.Singleline);
    Match mch = regexpr.Match("ABHISHEK SUR");
    if (mch.Success)
        Console.WriteLine("Match found");
    else
        Console.WriteLine("Not matched");

}
catch (RegexMatchTimeoutException ex)
{
    Console.WriteLine("Regex Timeout for {1} after {2} elapsed. Tried pattern {0}", ex.Pattern, ex.Message, ex.MatchTimeout);
}
catch (ArgumentOutOfRangeException ex)
{
    Console.WriteLine(ex.ToString());
}
finally
{
    Console.ReadKey(true);
}

Now this works exactly the same as the previous one. Here the Regex constructor automatically checks the AppDomain value and applies it as default. If it is not present, it will take -1 as default which is Infinite TImeout and also if explicitely timeout is specified after the default value from AppDomain, the Regex class is smart enough to use the explicitly set value only to itself for which it is specified. The Regex Constructor generates a TypeInitializationException if appdomain value of Timespan is invalid. Lets check the internal structure.

This is the actual code that runs in background and generates the timeouts. Infact while scanning the string with the pattern, there is a call to CheckTimeout which checks whether the time specified is elapsed for the object. The CheckTimeout throws the exception from itself.

The Constructor sets DefaultMatchTimeout when the object is created taking it from AppDomain data elements.

If you read MSDN thoroughly, it suggests to use Timeouts when specifying the Regular expressions. If the pattern is supplied from external or you are not sure about the pattern that needs to be applied to the string, it is always recommended to use Timeouts. Basically you should also specify a rational limit of AppDomain regex default to ensure no regular expression can ever hang your application.

This is a small tip on the new Regex enhancements introduced with .NET 4.5 recently. I hope you like it. More to come shortly, stay tune.

Thank you for reading

Generic Types and Static Members

2011-10-07T05:34:00.001+05:30

One of my friend recently asked me a question that I think I should share with you. Say you have a Static Implementation of a Type T which you pass as Open Type in your Generic Class. Now the problem is how to get reference to the Static Members or invoke a method that is Static to the Type from the Open Type T. In this post, I will demonstrate few implementations that help you getting the Static implementation.

First of all, According to C# documentation, any type allocates its static members once per Type rather than once per Open Type. Now lets define this using the code below :

public class MyType<T> where T : class
{
    public static int Counter;
    static MyType()
    {
        Counter = 0;
    }
    public MyType()
    {
        Counter++;
    }
}

Here this is actually a Generic Type that keeps track of the count of objects that per type creates. The Type instance here MyType<T> is called Open Type and can take form of any Type. Now lets create object of MyType.

MyType<string> ss = new MyType<string>();
ss = new MyType<string>();
ss = new MyType<string>();
MyType<object> oo = new MyType<object>();
oo = new MyType<object>();
oo = new MyType<object>();

Console.WriteLine(MyType<string>.Counter);

Console.ReadKey(true);

Now we create 3 instance of string and 3 of Object. Thus the Console.WriteLine should show 6, right? .... Wrong.. Actually we here create two types using Generic Type MyType, one is MyType<string> and another is MyType<object>. So here MyType generates its own closed type and each of the type creates its Type interface when first instance of the object is called for, or rather when the Static constructor is called.

Thus if I call MyType<X>.Counter it will show 0 and will create a new Type and call the Static constructor immediately.

Now this is very easy here to call static members of a Generic type, but what if we want to call Static member of the Type we pass into as Generic Argument. Lets see...

public class MyType
{
    public static void Try2CalMe()
    {
        Console.WriteLine("Wow. You finally called me!");
    }

    public void CallMe()
    {
        Console.WriteLine("Called CallMe");
    }
}

Lets say I have a class defined with one static method and one instance method. As I have already told you that Generic Static members create its memory when it creates it first object, the same is true for non generic types. Hence when an instance of MyType is passed within a Generic Type as Type argument, you would already have the memory allocated for the Type. Now let us consider using this Type for our Generic Class.

public class MyGenericClass<T> 
{
    T MyTObject { get; set; }
    public void InstanceMethod()
    {
        if (this.MyTObject != null)
            this.MyTObject.CallMe();
    }
}

Well the line which calls CallMe leads to a problem, because the Generic Type does not have any idea about what Type it is going to take. Say for instance if I pass int variable as T it will take that also. Well to fix this problem we can put a constraint to Type T with a Where clause. But that doesnt solve our problem either. Even though we can call CallMe we cannot call Try2CallMe. There are few approaches that you can take to solve this problem.

Working with your friend Reflection :

Reflection API can call any method from a Type. You can check whether the static Method is there in the type that is passed during Runtime and if exists you can call it. Lets try to call the method using Reflection :

public class MyGenericClass<T> where T : MyType
{
    public T MyTObject { get; set; }
    public void InstanceMethod()
    {
        if (this.MyTObject != null)
        {
            this.MyTObject.CallMe();

            //Calling static member using Reflection

            Type currentType = typeof(T);
            var method = currentType.GetMethod("Try2CalMe", BindingFlags.Static | BindingFlags.Public);
            if(method != null) // Method exists
                method.Invoke(null, null); //We pass null as object for static member

        }
    }
}

So here we first pass MyType as constraint (even though it makes the type strict to inherited members of MyType) and calling the member using Reflection. Yes, it can call it absolutely.

Putting it in intermediate Abstract base class:

Another option, or probably better approach is to create an intermediate abstract base class for all your types and call it. It is another option for you and probably a better one but remember, all of your members share the same static member here.

public abstract class MyAType
{
    public static void Try2CalMe()
    {
        Console.WriteLine("Wow. You finally called me!");
    }
    public virtual void CallMe()
    {
        Console.WriteLine("Called CallMe");
    }
}
public class MyGenericClass<T> where T : MyAType
{
    public T MyTObject { get; set; }
    public void InstanceMethod()
    {
        if (this.MyTObject != null)
        {
            this.MyTObject.CallMe();

            //Calling static member Directly here
            MyAType.Try2CalMe();
               

        }
    }
}

Here we create an abstract base class for MyType and we pass it as generic constraint. So any class that inherits from this base class can go as a Type for the class MyGenericClass and which in turn can call its static member directly.

There might be some other option available and known to you. I would like you to share that with me.

I hope you like this post.

Thanks.

Internals of .NET Objects and Use of SOS

2011-09-26T14:53:00.000+05:30

Well, now getting deeper into the facts, lets talk about how objects are created in .NET and how type system is laid out in memory for this post in my Internals Series. As this is going to be very deep dive post, I would recommend to read this only if you want to kill your time to know the internal details of .NET runtime and also you have considerable working experience with the CLR types and type system.

Recently I have been talking with somebody regarding the actual difference between the C++ type system and managed C# type system. I fact the CLR Type system is different from the former as any object (not a value type) is in memory contains a baggage of information when laid out in memory. This makes CLR objects considerable different from traditional C++ programs.

Classification of Types

In .NET there are mainly two kind of Types.

Value Types (derived from System.ValueType)
Reference Type (derived directly from System.Object)

Even though ValueTypes are internally inherited from System.Object in its core, but CLR treats them very differently. Indeed from your own perception the Value Types are actually allocated in stacks (occationally) while reference types are allocated in Heaps. This is to reduce the additional contension of GC heaps for Heap allocation, GC cycles, occasional call to OS for additional memory needs etc. The object that is allocated in managed Heap is called Managed Object and the pointer that is allocated in stack to refer to the actual object in heap is called Object Reference (which is sometimes called as Managed Pointer).

Additional to this basic difference a Value Type is treated completely different from CLR point of view. CLR treats any object that is derived from System.ValueType differently in respect of any other object derived from System.Object directly. The memory of a ValueType contains just the value of its fields and the size of the Value Type is just the addition to its content, while for reference types the size is completely different. Let us consider looking at the memory layout of both the types.

In case of Value Types, the Managed Pointer holds reference to the initial location of the actual Memory.Thus in this case, the Managed pointer holds reference to 0x0000 which is the address location of Field 1. Hence CLR needs to do pointer arithmetic to find Fields ... N. Thus we can easily use Sizeof operator on ValueTypes to get the actual size of the object.

The reference Types on the other hand holds some complex informations in its header.Lets define the individual blocks that comprises one object using a diagram.

In the diagram, I have depicted the entire layout of memory for a reference type. The initial Managed Pointer here for reference types holds the address of Reference to RTTI address (Run Time Type Information). The initial 4 bytes of the memory is allocated for Synchronization Block. In CLR every object holds its own lock information by itself using this storage. There is another important consideration that you need to think of, is every CLR object holds its Type information inside it. This ensures that every object can explain its own type from itself without any dependency from outside. Hence the reference types are Self Explanatory types and programs can use these information while casting, polymorphism, dynamic binding, reflection etc. Even though the Method Table structure reside outside the actual object, the RTTI Address holds the initial address of the Method Table runtime object which holds all the informations regarding the Type of the object. We query the information of the Runtime Type using the GetType method from any reference Type. The .NET runtime creates a special object of Type which helps to find out the actual type information.

On the other hand, the ValueTypes are simply a chunk of memory without any clue of what it acutally contains. This is the major difference between the two types.

During instantiation, a valuetype automatically calls its default constructor when it is declared. You cannot define default constructor for a ValueType. But language (like C#) puts additional restriction to ensure that the valuetype is initialized before it is used to save additional constructor calls.

ReferenceType on the other hand must have an object assigned to it using new operator. The new operator first allocates memory of its fields with default values and then calls the constructor.

Caveats of CLR Variables

Value Type variable directly represents memory of a Stack.
Reference Type represents a pointer (or probably we should call it as Reference) that refer to the start location of the object produced in Heap. The reference points to RTTI address location.
CPU registers can hold managed pointers as well as managed objects. Hence in certain cases, you can either store your value type or a reference to a Object in CPU registers depending on your need.
AppDomain wide managed Table contains all the references pointing to the managed object references that are marked by GC. It also holds static ValueTypes and static Reference Types.

Implicit Object Reference (this)

There is nothing new with "this". Any instance member have access to this pointer even though they are Value Type or a Reference. The method generally pass the object from which it is called as "this" as first argument of the call. Hence it is available inside any method. "this" pointer for ValueType points to the first instance field address location while the "this" pointer for the Reference Type points to the address of Method Table information.

How CLR Methods are called ?

There are two types of method being called in CLR. One with invoking call IL instruction which needs the current object to be loaded in stack before any other argument passed as parameters; and other by using CallVirt which is almost similar to call, but produces an additional instruction to validate the object reference. The call statement does not produce NullReferenceException to a call to the method, but passes null as "this" pointer. But eventually if there is any instruction that requires access to its field or any other method call, it will produce NullReferenceException. CallVirt directly produces NullReferenceException prior to the call to the method when the object does not assign anything.

When using Interface based methods, the ValueType generally needs to be boxed to produce Method Table information so that the Virtual Methods could be called by CLR. The Reference type does not bother to invoke callvirt which actually translates it based on the type of the runtime object rather than the original type it is called from (interface reference).

Delegates on the other hand is a special type that holds reference of methods. MSIL has two opcodes to deal with them, ldvirtftn that load virtually a method, and ldftn. The ldftn loads the method address into stack. The type of the method token loaded by this IL instruction can be searched to MethodTable of the type to get the actual address of the method. Delegates generally pass the object on which the member needs to be executed as Target and the method address stored in delegate instance to invoke the method. In case of Static method call the target is apssed as null. The process of retrieving an storing address to a delegate is expensive and is called delegate binding.

Delegates are derived from a special type called System.Delegate in .NET CLR. A delegate can hold multiple methods in a chain. You can add more methods of same signature to a delegate which will be invoked sequentially by calling the last method added to it first and thereby calling the first method that is added as the final method in delegate chain. The return statement of the final method call is actually passed to the caller.

Trying out some basic debugging with Son of Strike(SOS)

Before we start SOS debugging with Visual Studio, you should recollect that there are three important data structure that you need to keep in mind.

MethodTable : Stores all information about a Type. Holds information regarding static data, table of method descriptors, pointers to EEClass, pointers to other Methods from other VTable and pointers to Constructors.
EEClass : This is almost same structure as of Method Table, but holds more static data information.
MethodDesc : Information regarding a particular method such as IL or JIT'ed informations.

Now let us consider a dummy class to start debugging.

public class MyClass
{
    public static int RefCounter;
    private int age;
    public MyClass(string name, int age)
    {
        this.Name = name;
        this.Age = age;
        MyClass.RefCounter++;
    }
    private string name;
    public string Name
    {
        get
        {
            return name;
        }
        set
        {
            name = value;
        }
    }
    public int Age
    {
        get
        {
            return age;
        }
        set
        {
            age = value;
        }
    }
    public void GetNext(int age)
    {
        Console.WriteLine("Getting next at age" + age);
    }
}

Here I have defined one static field, two member fields, a parameterized constructor and one instance method to start testing. We will use SOS to test instance of this code.

So as we know already when an object is created, the memory contains an object reference to the actual object placed in heap. Hence lets create an object of it in Main.

static void Main(string[] args)
{
    MyClass obj = new MyClass("Abhishek", 28);
    obj.GetNext(20);
}

To start debugging you need to enable native debugging. To do this, Right Click on project => Debug => Enable unmanaged code debugging. Now put a breakpoint on the first line and step into the constructor. Lets say I go until one instance field is loaded. Now open Intermediate Window and type .load C:\WINDOWS\Microsoft.NET\Framework\v4.0.30319\sos.dll. Please replace the exact location if folder structure differs.

Now once the extension is loaded we can examine the instance of MyClass.

We call !DumpStackObjects to dump the object that is loaded in memory. We see something like below :

These are the managed objects that are loaded into memory. Our concern is to see instance of MyClass. So copy the object reference handle of the corresponding Object of MyClass ( in our case it is 00c2c1d0). Now lets use !DumpObj 00c2c1d0

The instruction actually dumped the entire object with the address to MethodTable, EEClass and size of the object in bytes. You can see the size of the object in heap is 16 bytes. This is because the Objects in CLR holds more than the fields and members (like sync headers, method pointers etc.) It also lists the fields currently in memory. You can see Value for name has an address as we execute this after the instruction line name in constructor but before age. Now if I pass through all the lines of constructor it will show the memory address of all the members. You can use !DumpObject to play around the addresses of Name (00c2c1b0) or age or any instance member from here onwards.

Now lets try few more commands to get interesting behaviors. There are few commands that you can try. !CLRSTACK dumps the managed code on the stack on the CurrentThread. !DumpStack on the other hand dumps both managed and native stack. Lets try !CLRStack now, the output will be like this :

Here I have moved to the call to GetNext method. Hence you can see the GetNext and Main in stack for the command !CLRStack. With additional argument like -p -l produces the result with better output listing all the parameters passes to the method. You can see this represents the first parameter for the method GetNext, as I have told you which holds the object obj (in our case).

Similarly you can use !DumpStack to dump both the native and managed objects and !EEStack to execute !DumpStack on all threads.

To conclude,

This post is just the starting point of your understanding. There are lots of depth in this topic. You can try an excellent article on MSDN magazine here, which talks more on CLR object creation. If you want to know more on internals of .NET, you can also try my Internal Series here.

Thank you for reading, give your feedback.

Stay tune for more.

Internals of Interface and its Implementation

2011-09-24T14:14:00.000+05:30

As many of my followers requested me to write few things that I missed out from the Internals Series, I should continue with it. In this post, I will cover the internals of Interface implementation and mostly talk about explicit interface implementation, as most of the developers seems to be in confusion with it. I hope you will like the post.

Beginning from the basics, Interfaces are the most important part of any application. Interfaces are language construct that does not implement anything but declares a few members upfront. Generally we use interfaces to create a contract between the two or more communication agents. Another important thing that everyone would be knowing already, Interfaces are meant to be implemented. That means whenever you are creating a class, all the members that were there in the interface are meant to be implemented completely. .NET (or probable any other standard language) disallows the creation of objects on types that are not fully defined. Hence abstract classes also coming into play here. They are classes that have few members undefined or abstract. Once you don't have concrete implementation, you cannot create an instance of a type. Notably, you can say "Interface is a types that does not belong to the System.Object or implement it when it reside inside an assembly". But ironically you could also says that once the type is implemented, it would probably inherit from System.object by default.

Another important OOPS feature is that you can hold reference of any concrete type to any of its base implementations. By this what I mean, if say class X derived from Y and implements Z (where Z is an interface) you can say either Y y1 = new X() or Z z1 = new X().

Now lets define an interface and start some tweaks some of its behaviors.

public interface IA
{
    void GetX();
}

Let us suppose we have an interface IA which has a method GetX(). Now you should remember, it is not allowed to use access specifier for members of an interface as that mean the implementers of this interface needs to specify access specifiers for its members and it would appear to all implemtors that these members are public. Now lets see one implementation of it.

public class A : IA
{
    public void GetX()
    {
        Console.WriteLine("Here is X: Normal");
    }
    void IA.GetX()
    {
        Console.WriteLine("Here is X: Explicitely");
    }
}

A is a class which implements IA, and hence need to declare one member GetX. Now you can see here we have defined two implementation of the same method GetX. The other one is Explicit implementation of IA. The explicit declaration of a method can only be done for Interfaces (not allowed for normal classes) and allows you to differentiate the calls to GetX to its explicit implementation when interface is used rather than a normal derived reference is used. Hence if I call :

A a1 = new A();
a1.GetX(); // prints Here is X: Normal

IA a2 = a1;
a2.GetX(); //Prints Here is X: Explicitely

You can see here compiler replaces the call to some explicit implementation based on the reference itself.

There are few basic characteristics of Explictely implemented methods.

They are not overridable and cannot be made virtual.
They can only be called with appropriate interface name, as the methods in Vtable is not determined by its name but by the reference it calls for.
You cannot specify any access specifier for the implementation of Explicit method.}
They remain private and does not belong to a member of actual concrete class. For instance, if I remove the normal implementation of GetX and try calling the code below :
```
dynamic a1 = new A();
a1.GetX();
```
It produces an exception, as A does not contain the member GetX().
Now if we see the IL for the implementation :

So here you can see the explicit declaration defines two important attributes, viz, newslot, virtual and final.

newslot defines a new pointer in the VTable. Thus it is a completely new method created in vtable that can only be called by reference of the interface explicitely.

virtual : you must already know virtual means the object could be overridable at runtime.
final : means sealed.

Hence it is a sealed method with a new entry in VTable.
They are privately inherited and can be implemented only in the class where the Interface is actually implemented, not in any of its parent. For instance :
```
public interface IA
{
    void GetX();
}
abstract class A : IA
{
}
public class B : A
{
    public void GetX()
    {
        ((IA)this).GetX();
    }
    void IA.GetX()
    {
        Console.WriteLine("New Impleentation");
    }
}
```
The above code produces an exception
"Inconsistent accessibility: base class 'TestInterfaceApplication.A' is less accessible than class 'TestInterfaceApplication.B'"

Which means the GetX() method is private to B and cannot be implemented there.
But remember, interface inheritence is supported. Thus the code below compiles fine :
```
public interface IA
{
    void GetX();
}
public interface IB : IA
{
}
public class B : IB
{
    public void GetX()
    {
        ((IA)this).GetX();
    }
    void IA.GetX()
    {
        Console.WriteLine("New Impleentation");
    }
}
```
This is because interface implementation is not actually possible in CLR without marking both of them in concrete class so that the Types can be cast to any of the parent interfaces. So when you specify an Interface implementation, the two interfaces remains as individual types and when you implement the derived interface, it will actually implement the two interfaces for you. Its just a compiler trick. Lets see the IL.

So here you can see, if I implement a Derived interface IB from IA, the actual class actually implements both the interface explicitly.

Practical uses

Explicit interfaces are generally used when you need two implementation of same method or property to co-exist. We generally create Explicit interfaces to specify default behaviour of a class. As explicit methods are actually attached to the interface itself, so at any level of Inherited member, it can be cast easily to get the default implementation (which is in fact not overridable).

Even though there might be some further cases where it comes really handy, I would like to leave them for you. Post your comments regarding some other practical implementation or something you would like to address to me.

Thanks, I hope you find it interesting.

Happy programming.

Writing a Custom ConfigurationSection to handle a Collection

2011-09-12T05:04:00.001+05:30

Configuration is one of the major thing that you need to keep in mind while building any application. Either its an Windows Forms application or a Web site, configuration file is always needed. We write all the configuration that are needed to be changed after it is being deployed in confugration files. It is an XML File which lists all the configuration blocks itself and also allows you to define your own custom configuration sections yourself. Today I am building my own custom configuration section and show how easily you can build yourself.

While dealing with Configurations, there are two things that you need to address

ConfigurationSection
ConfigurationElement
ConfigurationElementCollection

For most of the simple configurations, it is pretty much common to use these two classes, but when you need more complex configuration block, like appsettings which actually puts a Collection of ConfigurationElements, you might need to use ConfigurationElementCollection to hold the collection of ConfigurationElement.

Here in the article I will build one Configuration similar to appsettings so that it would be easier to build one for your own application.

ConfgurationSection maps to the whole configuration, reading through the whole configuration you define in your config file. It has its own serialization and deserialization technique internally to open and close one specific ConfigurationSection when you want. For each Configuration file, it searches the Type of the ConfigSection, (in out case it is ConnectionSection which is within the assembly Configurationsettings). The name of the section indicates the Tag which you use for your ConfigurationSection.

ConfigurationElement maps with the individual element of the Section. It generally points to the entire XML configuration Tag that we use for the configuration. It is the serialized object with all the information about your configuration. When used as a Collection (as in our case) the ConfigurationElement maps to individual configuration blocks (in our case it is Element).

ConfigurationElementCollection : Each ConfigurationSection can have a collection of ConfigurationElement. In our case Servers represents the collection of Element.

Now lets see how we code to retrieve data from this Configuration.

Implementation of ConfigurationElement

On the lowest level, each Configuration block in the collection represents one .NET object. Lets think that the enter tag here is converted to a .NET object and vice-versa. So how your .NET object would look like ?

public class Element : ConfigurationElement
{
    [ConfigurationProperty("name", DefaultValue = "", IsKey = true, IsRequired = true)]
    public string name
    {
        get { return (string)base["name"]; }
        set { base["name"] = value; }
    }
    [ConfigurationProperty("servername", DefaultValue = "", IsKey = false, IsRequired = true)]
    public string servername
    {
        get { return (string)base["servername"]; }
        set { base["servername"] = value; }
    }

    [ConfigurationProperty("isactive", DefaultValue = "true", IsKey = false, IsRequired = false)]
    public bool isactive
    {
        get { return (bool)base["isactive"]; }
        set { base["isactive"] = value; }
    }

    [ConfigurationProperty("userid", DefaultValue = "abhi", IsKey = false, IsRequired = false)]
    public string userid
    {
        get { return (string)base["userid"]; }
        set { base["userid"] = value; }
    }

    [ConfigurationProperty("password", DefaultValue = "password", IsKey = false, IsRequired = false)]
    public string password
    {
        get { return (string)base["password"]; }
        set { base["password"] = value; }
    }
}

Here the class Element represents exactly as we define our Configuration element in the collection. Our Element in configuration looks like :

<Element name="RemoteServer"
                    servername="68.240.22.19"
                    userid="abhijit"
                    password="passcode"
                    isactive="true" />

So our idea to create a type that maps to this. Remember XML is case - sensitive.
Hence we create a class. We map the individual Properties with ConfigurationProperty. You can see each individual property has few attributes that you can define. Such as, DefaultValue would be used whenever the attribute is not present in actual configuration; IsRequired indicate that the property is mandatory etc.

You should always consider one of the property of the ConfigurationElement as Key field. Key field represents the unique identifier for the object.

Implementation of ConfigurationElementCollection

Now as we have a collection of Element in our configuration block, we need to wrap the individual Element inside a ConfigurationElementCollection. This class is an abstract implementation of a ConfigCollection. It has few members that we need to address. Lets see how do we implement it.

[ConfigurationCollection(typeof(Element))]
public class ServerAppearanceCollection : ConfigurationElementCollection
{
    internal const string PropertyName = "Element";

    public override ConfigurationElementCollectionType CollectionType
    {
        get
        {
            return ConfigurationElementCollectionType.BasicMapAlternate;
        }
    }
    protected override string ElementName
    {
        get
        {
            return PropertyName;
        }
    }

    protected override bool IsElementName(string elementName)
    {
        return elementName.Equals(PropertyName, StringComparison.InvariantCultureIgnoreCase);
    }


    public override bool IsReadOnly()
    {
        return false;
    }


    protected override ConfigurationElement CreateNewElement()
    {
        return new Element();
    }

    protected override object GetElementKey(ConfigurationElement element)
    {
        return ((Element)(element)).name;
    }

    public Element this[int idx]
    {
        get
        {
            return (Element)BaseGet(idx);
        }
    }
}

First and foremost, we need to annotate the class using ConfigurationCollection attribute. Generally, each configurationSection is read by the .NET configuration reader using Reflection. It chooses appropriate classes based on the Attribute. Hence it is important to define this for each configuration.

Here the first thing that you notice is we define an Indexer for the class and return BaseGet(index). The BaseGet actually reads the configuration collection and use Reflection to create object of the ConfigurationElement.

Another important thing that you need to address in this implementation is CreateNewElement. You need to return the actual implementation of your ConfigurationElement here. The ElementName represents the name of the Tag that you use in Config file.

Implementation of ConfigurationSection

Finally we need to actually map the collection to a single ConfigurationSection. Lets see the implementation first :

public class ConnectionSection  : ConfigurationSection
{
    [ConfigurationProperty("Servers")]
    public ServerAppearanceCollection ServerElement
    {
        get { return ((ServerAppearanceCollection)(base["Servers"])); }
        set { base["Servers"] = value; }
    }
}

Here basically we create an object of our Collection and return the whole XML block using base["name of the block"]. You must notice that we wrapped the whole configuration inside one XML tag called Servers. We use this to indicate the whole collection.

As a Side Note

Yes, of course you can read configuration directly without using existing APIs available. This article demonstrates how to handle complex configuration blocks for your application.

If you are looking for something simplier than this, check the following links :
3 Easy steps to create Configuration

In much simple scenario you dont need to use ConfigurationSectionCollection rather you can simply use ConfigurationSection itself to handle your entire configuration.

To Get information about Configuration

To retrieve the information of the configuration lets define a class and enumerate all the Element objects that can be found from Configuration.

public class ConfigSettings
{
    public ConnectionSection ServerAppearanceConfiguration
    {
        get
        {
            return (ConnectionSection)ConfigurationManager.GetSection("serverSection");
        }
    }

    public ServerAppearanceCollection ServerApperances
    {
        get
        {
            return this.ServerAppearanceConfiguration.ServerElement;
        }
    }

    public IEnumerable<Element> ServerElements
    {
        get
        {
            foreach (Element selement in this.ServerApperances)
            {
                if (selement != null)
                    yield return selement;
            }
        }
    }
}

Here we use GetSection to get the specific section that we have created, and we can easily cast the object returned by GetSection to ConnectionSection. The GetSection automatically creates the instance of the class (if everything is alright) . Now as our section also contains a Collection of custom settings, we have yield the elements from ServerAppearanceCollection.

Download Source application

Conclusion

Use of Custom Section for app.config is generally very handy. The System.Configuration api exposes a number of good classes that can handle configuration for you. Here I have shown how to create a section that might act similar to AppSettings or any collection oriented settings.

I hope this will come handy.

Thanks for reading.