DOT NET TRICKS

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.
Some software and training licences (not yet decided)

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.

31 Tips for the month on Threading, WPF, MEF, ASP.NET

2011-09-01T01:49:00.000+05:30

Daily .NET Tips is aiming to sharing useful coding tips and tricks 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. This month we have wide range of tips including Threading, MEF, WPF and MVC. In this post I am quickly listing down all the tips which are published over the month August 2011. And the most important point to mention, among those 31 tips that has been posted on DailyDotnettips this month 22 is coming from me.

To get regular updates visit http://dailydotnettips.com and follow @dailydotnettips at Twitter.

I hope you would like the posts. Stay tune for more.

Monday Mornings : Extensibility in .NET 4.0

2011-08-28T14:20:00.000+05:30

It is my great pleasure to speak at Microsoft Moday's last Monday on 22nd August 2011. I have introduced a way to develop a plugin based application with and without MEF. I have also touched some of the interfaces which Visual Studio uses for Extensibility. It has been a very good session and I have learned a lot from it.

If you are a part of the session, please get the Power Point Presentation and the updated source code.

Extensibility in application

View more presentations from Abhishek Sur.

You can download the source code from here.

For further references on MEF you can read :

http://tinyurl.com/MEFWorld

http://tinyurl.com/MEFSource

http://tinyurl.com/MEFGuide

http://tinyurl.com/MEFBlogs

http://tinyurl.com/MEFDiscussions

http://tinyurl.com/PluginMEF

Thanks for attending my session.

Keep in touch.

Steps to write a plugin based application with MEF

2011-08-27T23:38:00.000+05:30

I have already written a blog on Managed Extensibility Framework few days ago, and you must wonder why I am writing again. Well actually today I have been creating an application that could be easily plugged into a host application. In this blog lets show you in steps how you could easily create your own plugin based application and later change itself easily using MEF.

Steps to create a Plugin based application :

Before we proceed lets look how the User Interface for the application that I am building looks like :
The UI contains two Panels, one to show the UI loader control, ideally will list a Button, and another container which will load the actual UI for the application. I have used normal windows based application to make you understand better. Initially it will show you a button, and when you click on the button, it will load the actual usercontrol.
To start creating a plugin based application, we need to create a contract that lies between the Modules and the Host. The contract restricts the Plugins to be loaded on the Host.
Lets add a Class Library to the project and name it as PluginContract. We add 3 interfaces.
```
public interface IProcessRunner
{
    void Process();
}
```
The IProcess interface includes some portion of code that you need to execute when the application is getting loaded. This interface acts as a process which the plugin needs to execute whenever the object is loaded. The idea is to separate the actual process code from the User Interface.

Next we define IPlugin interface which maps the actual User Interface of the Module. The definition of the IPlugin interface looks like :

public interface IPlugin
{
    UserControl GreeterControl { get; set; }

    bool IsPluginCreated { get; set; }
    void CreatePlugin();
    UserControl GetPlugin();

}

The final Interface represents the Interface attacher when connects the plugin with the application and also giving a special interface to run the plugin and run custom code. The interface looks like :

public interface IInterfaceAttacher
{
    Control InterfaceControl { get; set; }
    IProcessRunner Runner { get; set; }
    Control GetInterfaceObject();
    IPlugin Plugin { get; set; }
    Control Container { get; set; }
}

Once you are done, you can add a new Class Library and add one UserControl in it. We call it as GreetControl. Add reference to the Contract library and add the implementation of the interfaces.
IProcess is the most simple interface that I have added to the system. It implements only Process method. The idea is to invoke a sequence of steps in the Process to generate the UserControl. For simplicity we put a messageBox in it.

The IPlugin interface on the other hand actually used to create an object of my plugin and return back the object. The implementation looks like :

public class Plugin : IPlugin
{
    public UserControl GreeterControl { get; set; }

    public bool IsPluginCreated { get; set; }
    public void CreatePlugin()
    {
        if (this.GreeterControl == null)
            this.GreeterControl = new ucGreetMessage();

        //Initialize

        this.IsPluginCreated = true;
    }

    public UserControl GetPlugin()
    {
        if (!this.IsPluginCreated)
            this.CreatePlugin();

        return this.GreeterControl;
    }
}

Here we create the object of GreeterControl and return the object of it when the GetPlugin is called. This contract element should be used from the Host to load the interface.

InterfaceAttacher is created to aggregate all the elements into a single object. It creates an object of IPlugin, an object of IProcess, so it is the main contract for the whole plugin. Lets see how I implement the interface :

public class InterfaceAttacher : IInterfaceAttacher, IDisposable
{

    private void Initialize()
    {
        this.InterfaceControl.Text = "Load Greeter";
    }

    public Control InterfaceControl { get; set; }
    public IProcessRunner Runner { get; set; }
    public IPlugin Plugin { get; set; }

    public Control Container { get; set; }

    public Control GetInterfaceObject()
    {
        if (this.InterfaceControl == null)
        {
            this.InterfaceControl = new Button();
            this.InterfaceControl.Click += new EventHandler(InterfaceControl_Click);
        }
        this.Initialize();

        return this.InterfaceControl;
    }

    void InterfaceControl_Click(object sender, EventArgs e)
    {
        if (this.Container == null)
            throw new ApplicationException("You cannot load a module without specifying the container");

        if (this.Runner == null)
            this.Runner = new Processor();

        this.Runner.Process();

        //Load Plugin
        if (this.Plugin == null)
            this.Plugin = new Plugin();

        this.Container.Controls.Add(this.Plugin.GetPlugin());
    }

    #region IDisposable Members

    public void Dispose()
    {
        if (this.InterfaceControl != null)
            this.InterfaceControl.Dispose();
    }

    #endregion
}

Here the InterfaceControl is an individual control which will be loaded on the system and used to invoke a load operation of the Plugin. Here for simplicity I have used a Button to load the plugin, but ideally it should be a menu item. Thus when the object is Clicked, it will invoke certain events to call the Process of IProcess and load the IPlugin to the Container which is provided by the Host.

Certainly, you might be thinking why I am showing this crappy unusable code to you. Actually I have written this code long ago, may be at least 2 years ago when I was actually creating plugin based application for the first time. Here is to show you how I have actually developed the system, and how easy is to modify it to use MEF.

Creating the Host

Finally lets create the Host for this Plugin. The plugin host will host two container (in our case) one to load all the buttons that are coming for each individual plugin which loads the actual plugin to the system, and another is to host the actual plugin interface. Lets take two panels in the Form and name it pnlLoadControls for the panel which loads the InterfaceLoader (Button) and pnlContainer which loads the actual UserControl coming from plugin.

Once the interface is created we need to write some code to actually load all the interface elements when form is loaded and upon user interaction, the actual UserInterface is loaded. Hence we write like this :

private void Form1_Load(object sender, EventArgs e)
{
    foreach (string fpath in Directory.GetFiles("plugins", "*.dll"))
    {
        this.LoadAssembly(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, fpath));
    }
}

private void LoadAssembly(string filepath)
{
    Assembly asm = Assembly.LoadFile(filepath);
    var items = asm.GetTypes().Where(t => typeof(IInterfaceAttacher).IsAssignableFrom(t));

            

    foreach (var item in items)
    {
        IInterfaceAttacher attacher = Activator.CreateInstance(item) as IInterfaceAttacher;
        attacher.Container = this.pnlContainer;
        this.pnlLoadControls.Controls.Add(attacher.GetInterfaceObject());
    }
}

Hmm, looks quite complex to you, isnt it ? Its just a code that loads the assemblies from the plugins directory and GetInterfaceObject from all the IInterfaceAttacher type that is found within the plugin. Hence the code will place the button called Load in the interface. You can see, that we pass the Container to load the actual interface when the InterfaceControl is clicked.

So this is all we need to create our first plugin based application.

Limitations of this approach:

This approach is very tightly coupled with the host. The Plugin needs to follow exactly what the rules that is created by the Host.
The plugins are not flexible enough to create interdependencies. That means, you cannot have interdependent plugins so that one plugin can easily host a component coming from another plugin.
The approach requires some sort of standardization so that once a plugin is created it can be re used in another host.
The approach forms a strict rule that a Plugin cannot spread itself in multiple dlls. I mean the IPlugin should always reside within the Plugin attacher.

To address these situations we use MEF.

Lets introduce MEF to the System

If you are new to MEF, please feel free to read my previous blog about MEF to get the idea. MEF is actually a IOC container that relate each Exports with Imports. The idea of MEF is to mark an interface with Export when it needs to be plugged in to a system, and Mark as Import when we need to host some sort of plugin that might be present in the system.

Export:

We mark all methods, properties, types as Export when we want to export the functionality to the external world.

Import

If you are a host of Plugin you need to Import the plugin. Hence Import is used to import a functionality to the system.

Compose

The CompositionContainer is a IOC container that maps individual Export with its appropriate Import.

You can read about them from my article here.

Steps to change the existing application to use MEF

Add System.CompositionModel.Composition to your Plugins and add Export attribute to the IInterfaceAttacher.

Adding Export(typeofIInterfaceAttacher) will enable that the Interface object will be viable to export from the system to some external agent which wants to import it.
In the Actual Host we add a new class which creates a property of IInterfaceAttacher and Import the object. The class looks like :
```
public class InterfaceBuilder
{
    [ImportMany(typeof(IInterfaceAttacher))]
    public IEnumerable<IInterfaceAttacher> Attachers { get; set; }
}
```
We use ImportMany as we can have multiple plugin in the dlls. So the property Attachers will list all the plugins into a single IEnumerable.
In the Form, lets remove all the code that I have written to invoke the Type from assembly and change it to something like this :

private void Form1_Load(object sender, EventArgs e)
{
    DirectoryCatalog catalog = new DirectoryCatalog("plugins");
           
    InterfaceBuilder builder = new InterfaceBuilder();
    CompositionContainer container = new CompositionContainer(catalog);
    container.ComposeParts(builder);


    foreach (IInterfaceAttacher attacher in builder.Attachers)
    {
        this.pnlLoadControls.Controls.Add(attacher.GetInterfaceObject());
        attacher.Container = this.pnlContainer;
    }
}

Now if you run the code, it runs just fine.

Thus you can see that the Exported plugin is actually created automatically using CompositionContainer and works as we have implemented earlier.

Benefits ?

Yes. There are lots of benefits of using MEF.

As it forms a standard, the same dll can plugin to any system that imports something that the plugin is going to export.
As we do not create dlls manually and rely completely on CompositionContainer, it is quite capable of handling errors, and reporting critical errors.
Interdependency can also be achieved in this approach. The plugins can spread into multiple dlls easily. Lets look how :

We made the Runner and Plugin in InterfaceAttacher as Import capable and removed the object creation from InterfaceControl_Click event handler. And Export the actual classes. Even you can do the same for the UserControl too.

Simple huh ?
Yes now you can spread the types into assemblies, even your plugins can import types from outside the assemblies, even from the host

You can download the sample

I hope this post comes to you handy. Even though you should change it in your practical plugin based application, but this will help you to start.

Thank you.

.NET Tips : List of my short tips

2011-08-15T01:13:00.002+05:30

Hi Friends,

As I have already told you that I have been publishing short tips in DailyDotnetTips regularly, it is time to share the links with you to keep you updated. Please read these short tips from me and give your feedback.

So here are my last 20 short tips posted on DailyDotnetTips.

I hope you will like these tips. For full list of all the tips and the latest updates, check this link.

Happy Coding.

Thanks.

Internals of Dependency Property in WPF

2011-07-31T05:35:00.000+05:30

WPF introduces new property system to us. Every WPF objects that is inherited from DependencyObject inherently supports Dependency property containers within it. That means you can define your own dependency property in your code which can take part in some of the interesting features of WPF like Binding, Styles, Triggers, Animation, Property Inheritence etc. Today I will concentrate on how Dependency Property system is actually built and what are the benefits we get instead of using CLR property system.

Note : If you are really new in WPF and don't know about Dependency Property, it would be nice to read my post on Dependency Property or you can also try WPF Tutorial series to start on.

So lets start on using the most basic code of creating your own Dependency Property.

public static readonly DependencyProperty DescriptionProperty = 
    DependencyProperty.Register("Description", typeof(string), typeof(DependencyHoster));

public string Description
{
    // Will not be called each time property is retrieved. Only be called when 
    //you explicitely call it through ur code.
    get
    {
        return (string)this.GetValue(DescriptionProperty); 
    }
    set
    {
        this.SetValue(DescriptionProperty, value);
    }

}

So here we define a property called Description to our DependencyObject named DependencyHoster of type string. According to the rule specified on DependencyProperty System, it is stated that you should always create a static reference of DependencyProperty and call Register to register a property to the Property System. It is also to the rule, that you should define a CLR property Stub which will call GetValue and SetValue in its getter and setter which is defined in DependencyObject to get or set the actual value defined for the instance. The Dependency property reference should be named with property name with "property" suffix. (in our case property name is Description and with suffix Property, it is named as DependencyProperty).

Now lets see what exactly happens inside when you Register a DependencyProperty. I would use our favorite tool Reflector to get deep into it.

So if you look into the Register method you will see something like this :

Now lets concentrate on the lines highlighted in the image. The First creates an object of FromNameKey, which is created with name that we pass in Register and the Type in which the key is associated with. This class is just a repository of a single key element with the type associated with it.

Next, it is checked inside a HashTable named PropertyFromName. Well, I don't know why it is used as HashTable rather than Dictionary, may be because both Key and Value of the object is Reference Types and does not need boxing/unboxing.

Another important line that actually assigns the new object of DependencyProperty to the HashTable.

So basically from the above three lines, you can deduce some of the interesting facts on DependencyProperty System as of now :

A DependencyProperty maintains a static reference of all the DependencyProperty you register in WPF object hierarchy. It maintains a HashTable named PropertyFromName which it uses internally to get the DependencyProperty object. So in other word, each dependencyProperty object is registered in a global HashTable.

Now lets check the object DependencyProperty as a whole and what it is capable of. Remember that each DependencyProperty object is created once for every DependencyProperty you define in your property system and not on every instance of object you create. Hence according to what we just seen, all TextBox will have only one TextProperty dependency property that go inside the field PropertyFromName.

Therefore the object DependencyProperty just holds the name, ownerType and its metadata. Metadata can be the Callbacks the DependencyPropertyKey element etc.

Where the value gets stored exactly ?

Well this might have come already in your mind. As I have already seen the DependencyProperty and it seems nowhere until now, a provision of value to be stored, yet a DependencyProperty has a method called GetDefaultValue for a specific type which will return the default value, but what if I assign something to a Type, where does it get stored ?

To clear this confusion, lets look into DependencyObject instance a bit and try to see what exactly written inside GetValue, SetValue and ClearValue method.

1. GetValue

GetValue is used to get the current value of an instance of a control. Remember, DependencyProperty supports a number of levels in which the effective values could be retrieved. Lets look in detail on the source of GetValue.

The code snippet that I have specified,clearly says that every DependencyObject instance actually maintains a collection of objects (EffectiveValues) which will be set only when the instance stores / modifies the value of the DependencyProperty. The code gets either from the own collection or gets it from a method GetEffectiveValue based on whether the Request is fully resolved or not. the GetEffectiveValue identifies whether the current value is in animation mode (DependencyProperty supports animation) or is in Expression.

Finally it checks whether the dependencyProperty DefaultValue is changed or not. If it isn't it gets you the default value of the property.

2. SetValue

SetValue on the other hand actually sets a value of a DependencyProperty on the instance from which it is called. As we have already seen every DependencyObject actually maintains a collection of EffectiveValueEntry which holds the value of instance object we specify with some index value.

So the first thing that you notice is inside the SetValue is actually a feature. If you pass DependencyProperty.UnsetValue as value, it will actually call ClearValue for you. Hence SetValue(DP, DependencyProperty.UnsetValue) equals ClearValue(DP).

The rest of the code looks quite simple. It checks whether the entry exists in the current object, if so it resets the value or it create a new EffectiveValueEntry and store it and update the index.

Impact of Styles

If you look into styles, it just maintains a collection of Setter. A setter on the other hand maintains a combination of DependencyProperty and the Value of the dependency property. Hence when a style is applied on an instance, it will get the value from it.

The Style is actually a DependencyProperty defined inside FrameworkElement class. So in object hierarchy, it gets the value of the Style. Once the style is set for a control, it first clears all the object instances that the object already applies to and then apply the setters to each of them.

Thus the CreateInstanceData is used to apply a new style for a type.

Remember, styles are overridden by the object values during runtime.

Summary

To summarize,

Dependency Property System holds a collection of all DependencyProperty with its corresponding ownerType.
Each instance of a DependencyObject holds a collection of all individual DependencyProperty that has been changed either through animation or programmatically.
Styles produce a separate entity that holds a Key Value collection of a DependencyProperty and its value, once it is applied to a FrameworkElement, it modifies the default DependencyProperties with the ones that is defined inside styles.
Separating DependencyProperty from the object instance saves lots of space, as Reference Types will not create object instances when each instance is created, but will use up the existing instance every time. The separation of property system also allows to have a Property to be used as attached to its children.

Conclusion

There are lots of things to be learned and lots of things to be talked about in this regard. It is just the beginning.

Feel free to comment. I would love to see if I missed out something or if anything that you didnt like.

Read more about internals from my Internals Series.

Thanks for reading.

Writing a Reusable Custom Control in WPF

2011-07-24T22:19:00.002+05:30

In my previous post, I have already defined how you can inherit from an existing control and define your own reusable chunk. The reusable XAML code that I have defined there is actually a composition of one of more existing elements in a common design surface. But sometimes you must define a new behaviour for your reusable component which does not belong to any of the already existing behaviors. Custom controls can help you in this. You can define a new behaviour for your Custom control which can have a default look and feel defined for it, and obviously which can be changed using Template for the user who is using the control. In this post I am going to provide you step by step approach on defining a Custom Control for your application.

Note: If you are really new to WPF, please read my WPF Tutorial before going further.

Steps to Create a new Custom Control

Creating a custom control is very simple. Just in your project right click and add a new Item. In the dialog box that appears, choose Custom Control template and Name it. I call it here as SimpleControl.

Once you have added the control, it adds up a new class to your project which inherits from Control. The Template also provides you with some initial help to define your own control. Lets remove all the comments for now and start building a control.

Download Sample Code

In this control, I will show you all the components that you need for a Control so that it would help you guide each of the components individually.

Components that comprises a Custom Control

There are a number of components that you need to use inside your custom control which represents the behaviour for your control. Lets define each of them one by one before creating a Control.

1. Property : Properties are one of the most important component for a control. In WPF, we use properties to define certain characteristics of a control. You can use either CLR properties or a Dependency Property. As you must know already a dependency property is a new Property System introduced with WPF, which holds a container of all the properties you define for a single instance of your control and which supports Property Value Inheritence, Animation, Templates, Styles, etc. To read more about Dependency Property check my article.

Example :

public static readonly DependencyProperty ColorProperty = DependencyProperty.Register("Color", 
    typeof(Color), 
    typeof(SimpleControl), 
    new PropertyMetadata(Colors.Green));

public Color Color
{
    get
    {
        return (Color)this.GetValue(ColorProperty);
    }
    set
    {
        this.SetValue(ColorProperty, value);
    }
}

Here we have defined a new dependency Property called color, which will represent the initial BackColor of the control. The Default value for the Property is defined as Green.

2. Commands : It is important to define a command for your Control rather than using a method. Commands lets you use CommandBinding on a control just like your Button Class. The Command generally invoke certain set of action defined using ICommand interface. It also creates an Inversion of Control to invoke some user code as well, during the event.

Example :

static SimpleControl()
        {
            CommandManager.RegisterClassCommandBinding(typeof(SimpleControl), 
                new CommandBinding(SimpleControl.CustomCommand, OnCustomCommand));
        }

        static void OnCustomCommand(object sender, ExecutedRoutedEventArgs e)
        {
            //Need to first retrieve the control
            SimpleControl invoker = sender as SimpleControl;

            //Do whatever you need
        }

        public static readonly ICommand CustomCommand = new RoutedUICommand("CustomCommand", "CustomCommand",
                                                        typeof(SimpleControl),
                                                        new InputGestureCollection(
                                                            new InputGesture[] { 
                                                                new KeyGesture(Key.Enter), 
                                                                new MouseGesture(MouseAction.LeftClick) }
                                                                )
                                                          );

Here I have defined a Command called CustomCommand. As you can notice I have used Static Constructor to register my command and static eventHandler so that it is more efficient. You can easily retrieve the actual object easily from sender.

3. RoutedEvents : Events are another most important thing for a control. You can define your own event for the control, but it should be RoutedEvent to ensure that WPF model supports them internally. RoutedEvent supports event routing, that the event can bubble or tunnel to the complete Visual Tree, when the event is raised. The FrameworkElement has a complete set of methods to use in defining a RoutedEvent.

Example :

public static readonly RoutedEvent InvertCallEvent = EventManager.RegisterRoutedEvent("InvertCall",
    RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(SimpleControl));

public event RoutedEventHandler InvertCall
{
    add { AddHandler(InvertCallEvent, value); }
    remove { RemoveHandler(InvertCallEvent, value); }
}

private void OnInvertCall()
{
    RoutedEventArgs args = new RoutedEventArgs(InvertCallEvent);
    RaiseEvent(args);
}

Just like dependency property system, WPF event system also holds a collection of Events which appropriately raises the event for a particular control when some specific operation is executed. The WPF event system can take part on EventSetters, Triggers etc. You have noticed that you can use Addhandler and RemoveHandler from the Event Accessor to add or remove an event for a particular control. The RaiseEvent is used to raise an event for a particular control.

4. Handling an Event : Sometimes your control might require to handle an Event that already comes from Control. For instance, the Button class handles an event called MouseDown to create an event Click to it. In such a scenario you can use RegisterClassHandler method to handle an event.

Example :

static SimpleControl()
{
    EventManager.RegisterClassHandler(typeof(SimpleControl), Mouse.MouseDownEvent, new MouseButtonEventHandler(OnMouseDown));
}

static void OnMouseDown(object sender, MouseButtonEventArgs e)
{
    SimpleControl invoker = sender as SimpleControl;
    //Do handle event

    //Raise your event
    invoker.OnInvertCall();

    //Do Rest
}

Now here I have used RegisterClassHandler to handle the event. This will handle the MouseDown event for the control and invoke InvertCall event defined as RoutedEvent.

5. TemplatePart : For every control you should specify the rules how the UI for the control should look like. Template allows the user of your control to modify the look and feel, but using TemplatePart you can define the part of a control which you can change behaviour from within the control. Say for instance, if your control has a border, and your control wants to change its color when Mouse is hovered over the control, you can call the part attribute to apply this change which will be shown for any Template your user define later on, provided it should name the same part name.

Note: Currently PartNames are not actually checked for Templates, so you can omit a part
Example :

[TemplatePart(Name="PART_MainBorder", Type=typeof(Border))]
[TemplatePart(Name="PART_body", Type= typeof(ContentControl))]
public class SimpleControl : Control
{

    Border MainBorder;
    ContentControl Body;

    public override void OnApplyTemplate()
    {
        base.OnApplyTemplate();

        if (this.Template != null)
        {
            Border mainBorder = this.Template.FindName("PART_MainBorder", this) as Border;
            if (mainBorder != MainBorder)
            {
                //First unhook existing handler
                if (MainBorder != null)
                {
                    MainBorder.MouseEnter -= new MouseEventHandler(MainBorder_MouseEnter);
                    MainBorder.MouseLeave -= new MouseEventHandler(MainBorder_MouseLeave);
                }
                MainBorder = mainBorder;
                if (MainBorder != null)
                {
                    MainBorder.MouseEnter += new MouseEventHandler(MainBorder_MouseEnter);
                    MainBorder.MouseLeave += new MouseEventHandler(MainBorder_MouseLeave);
                }
            }

            Body = this.Template.FindName("PART_body", this) as ContentControl;

        }
    }

void MainBorder_MouseLeave(object sender, MouseEventArgs e)
{
    Border thisBorder = sender as Border;
    if (thisBorder != null)
    {
        thisBorder.Background = new SolidColorBrush(Colors.Red);
        if (Body != null)
        {
            Run r = new Run("Mouse Left!");
            r.Foreground = new SolidColorBrush(Colors.White);
            Body.Content = r;
        }
    }
}

void MainBorder_MouseEnter(object sender, MouseEventArgs e)
{
    Border thisBorder = sender as Border;
    if (thisBorder != null)
    {
        thisBorder.Background = new SolidColorBrush(Colors.Blue);
        if (Body != null)
        {
            Run r = new Run("Mouse Entered!");
            r.Foreground = new SolidColorBrush(Colors.White);
            Body.Content = r;
        }
    }
}

So here I have created two TemplatePart one named PART_MainBorder and another PART_body. In your Generic template you must define this TemplateParts so that the default control acts perfectly. The User can also redefine the template and once the user redefines it, it can also use these Part names to call a specific control inside, so that your control can apply something inside of it. In this example I have used a border, which will change its color to Red when Mouse is entered inside of it, and to Blue when it is left. You should note that I have used Template.FindName and passed the current instance of the control. This is important because Templates are generally shared by more than one instance.

When a Template is applied to a control it calls OnApplyTemplate. Make sure you are tolerant enough to handle bad templates, as you can see, I have checked every time if the object is available before doing anything with it as WPF ignores bad templates and your control might end up with a bad NullReferenceException somewhere if you dont gracefully eliminate the same.

Now in your actual Window, you should declare the template for the Control and define each of the PartNames you specify here.

6. Themes : Yes your control should define a default Theme at least to make sure it at least appears when an object is created. At the basic level, when you add a new Custom Control to your project, you should add a style for Generic.XAML that is added up on the Themes folder. The AseemblyInfo also adds up a assembly level attribute which identifies where the default Theme template resides.

The Theme folder will by default hold a Generic.xaml. Lets add a default Style for our control.

<Style TargetType="{x:Type local:SimpleControl}">
    <Setter Property="HorizontalAlignment" Value="Center" />
    <Setter Property="VerticalAlignment" Value="Center" />
    <Setter Property="Template">
        <Setter.Value>
            <ControlTemplate TargetType="local:SimpleControl">
                <Border x:Name="PART_MainBorder" Width="{TemplateBinding Width}" Height="{TemplateBinding Height}">
                    <ContentControl x:Name="PART_body" 
                                    HorizontalAlignment="{TemplateBinding HorizontalAlignment}" 
                                    VerticalAlignment="{TemplateBinding VerticalAlignment}" >
                    </ContentControl>
                </Border>
            </ControlTemplate>
        </Setter.Value>
    </Setter>
</Style>

Now as you can see this is a simple Style that will be applied to each control we instantiate in our application.

Creating the Sample

Now as we have already created our control lets add this control in MainWindow.

<Window x:Class="CustomControlExample.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="clr-namespace:CustomControlExample"
        Title="MainWindow" Height="350" Width="525">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition/>
            <RowDefinition />
        </Grid.RowDefinitions>
        <local:SimpleControl Width="90" Height="90" >
        </local:SimpleControl>
        <local:SimpleControl Width="90" Height="90" Grid.Row="1" Color="Crimson">
            <local:SimpleControl.Template>
                <ControlTemplate>
                    <Border x:Name="PART_MainBorder">
                        <Button x:Name="PART_body" HorizontalAlignment="Center" VerticalAlignment="Center" Background="Black"></Button>
                    </Border>
                </ControlTemplate>
            </local:SimpleControl.Template>
        </local:SimpleControl>
    </Grid>
</Window>

So here basically I add two controls in two rows of a Grid. The first one taking up the Default Template it provides, and the second one creates its own template. You can specify the Template Part in your own template as shown in the declaration which interact with the control itself.

Now if you run the sample it shows two rectangular box, one with all default values and another with custom template.

Bit Further

There are also few things that deals with Design Support of Visual Studio and Expression Blend for a control. You can either build separate dlls for design time support for your control with .design.dll or within the same assembly. The design time support can add custom Adorners which can help in layout the control in Visual Designer or Expression Blend. To build a design time support for a control you need to inherit from IRegisterMetaData and build an AttributeTableMetaData, which will work for the Designer. I will talk about it later in a separate post.

Download the Sample Code

Conclusion

You should remember, creating a Custom control does require a lot of effort. So if you looking for just look and feel, you can get a workaround to this using custom template or inheriting from other existing Controls. But if you are building your own Custom behaviour or a library of control, then you should go for Custom Control. Also remember, custom control is Themable, Templatable and also supports inheritence, so you should always consider writing your control gracefully and hitting every possible aspect that your control might come across.

I hope this sample code will help you. If you want, you can read my WPF Tutorial too from here and subscribe to my blog too.

Thank you for reading.

Writing a Reusable WPF Control with Design Support

2011-07-23T22:47:00.002+05:30

Code reusablity is one of the major concern to many of us. When dealing with large projects, modularizing your project is one of the primary thing that you should look for. I have talked about many of the approaches that you can use to deal with modularizing your code, eg, Prism. In this post our intent is not to talk hard on some pattern, rather I will discuss how your WPF application supports code reusability. There are a number of approaches that WPF supports to deal with reusable component. We can use Resources to define a Resource or even use CodeBehind to write our reusable component or even load the XAML from a file using XAML Loader. Each of the approaches has its own pros and cons. Today I will show you another cool technique to write a reusable XAML for your project which will allow you to easily use Visual Studio design surface to design the component.

Note : It is a very basic article, if you want to know about details on WPF, please read my tutorial on it.

Steps to Create your Reusable Component

Lets create a series of steps to create a reusable component for your application to make it easier for you to write one yourself.

Step 1 : Start Visual Studio and Create a new WPF project.
Step 2 : Add a new Page to the application and call it as GreetPanel. Just like the figure below.

Once you are done lets change the code for the Page.

Step 3 : Change the root element of the page to Grid to make it a Reusable grid.

Note : Currently there is no Visual Studio File Template for writing a loose XAML component, hence I have used Page to do the same.

Step 4: After doing this, you also need to go to the Code -behind for the Page and change it to inherit from Grid. Now you have a complete reusable component (UserControl) which can use the design surface too, to define its components.

Now lets define the control with most basic code :

<Grid x:Class="WritingLooseXAML.GreetPanel"
      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <Grid.RowDefinitions>
        <RowDefinition />
        <RowDefinition />
    </Grid.RowDefinitions>
    <Grid.ColumnDefinitions>
        <ColumnDefinition />
        <ColumnDefinition />
    </Grid.ColumnDefinitions>
    <Label Grid.Row="0" Grid.Column="0" >
        Write Name
    </Label>
    <TextBox Grid.Column="1" x:Name="txtName" />
    <Button Content="Greet Me" Click="Button_Click" Grid.Row="1" Grid.Column="0" />
    <TextBlock x:Name="tbResult" Grid.Row="1" Grid.Column="1"/>
    
</Grid>

Here I define a TextBox and a Button which has a click Handler too. You can define the ClickHandler in the codebehind for the GridPanel too. The Button will display a message in a textblock called tbResult.

The Codebehind looks like :

public partial class GreetPanel : Grid
{
    public GreetPanel()
    {
        InitializeComponent();
    }

    private void Button_Click(object sender, RoutedEventArgs e)
    {
        this.tbResult.Text = string.Format("Hello {0}, Welcome!", this.txtName.Text);
    }
}

Step 5 : Now once you are done defining your GridPanel, you can use it in any Window. Just use xmlns to declare the namespace for the control, here I used the local namespace, and define the controls.

<Window x:Class="WritingLooseXAML.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="clr-namespace:WritingLooseXAML"
        Title="MainWindow" Height="350" Width="525">
    <WrapPanel Orientation="Horizontal">
        <local:GreetPanel x:Name="gPanel1" />
        <local:GreetPanel x:Name="gPanel2" />
        <local:GreetPanel x:Name="gPanel3" />
    </WrapPanel>
</Window>

You can access each properties of the Grid from your GreetPanel as it is derived from Grid. Now compile your code and run, you will see your greetpanel working.

Adding a RoutedEvent on the control

As you know RoutedEvent is one of the base for events in WPF application, lets see how you can add one on the panel just declared. Now as you might already know that RoutedEvent can be of three types, one that Bubbles, one Tunnels and one Direct. To declare a RoutedEvent, you need to use EventManager.RegisterRoutedEvent. This command will register the event to the XAML and hence allows you to use Event in EventSetters, styles etc.

In our previous code, lets add an event which will fire when the Result box is altered. To do this, lets add this to the code page of GreetPanel.

static readonly RoutedEvent ResutlAlteredEvent = 
    EventManager.RegisterRoutedEvent("ResultAltered", 
    RoutingStrategy.Bubble, 
    typeof(RoutedEventHandler), 
    typeof(GreetPanel));

public event RoutedEventHandler ResultAltered
{
    add { AddHandler(ResutlAlteredEvent, value); }
    remove { RemoveHandler(ResutlAlteredEvent, value); }
}

// This method raises the ResultAltered event
void RaiseResultAlteredEvent()
{
    RoutedEventArgs newEventArgs = new RoutedEventArgs(GreetPanel.ResutlAlteredEvent);
    RaiseEvent(newEventArgs);
}

private void Button_Click(object sender, RoutedEventArgs e)
{
    this.tbResult.Text = string.Format("Hello {0}, Welcome!", this.txtName.Text);
    this.RaiseResultAlteredEvent();
}

Now from the MainWindow.xaml (where you add this control you can find the ResultAltered event directly.

<WrapPanel Orientation="Horizontal">
        <local:GreetPanel x:Name="gPanel1" ResultAltered="gPanel_ResultAltered" />
        <local:GreetPanel x:Name="gPanel2" ResultAltered="gPanel_ResultAltered" />
        <local:GreetPanel x:Name="gPanel3" ResultAltered="gPanel_ResultAltered" />
    </WrapPanel>

And in the code-behind we added the eventhandler as :

private void gPanel_ResultAltered(object sender, RoutedEventArgs e)
{
    GreetPanel panel = sender as GreetPanel;

    MessageBox.Show(string.Format("You have altered result of {0}", panel.Name));
}

Thus when the button is clicked on the Control it shows up a messagebox shows up.

Conclusion

By this way you can derive any control directly from an existing control. But if you are likely to build a completely new control you can use UserControl as its base, which will ensure that the UI has nothing. This is very easy. In my next post I will talk about Custom Controls.

I hope this tutorial helps you.

Thank you for reading.