http://abhijitjana.net/2011/10/06/bundling-and-minification-in-asp-net-4-5/

Having read this, I was just thinking about these elements/classes under the System.Web.Optimization namespace are all stitched together to implement the bundling and minification functionality.There were some design level questions as well like is the bundled content cached once created at server side or the bundling is done for every request?.

I went through the object model using the Visual Studio 11 Developer Preview and found the following key classes:

• BundleResponse – This class represents a resource bundle which contains the response after the resources are bundled and minified.
• IBundleTransform – This is the interface, defining the contract for transformation i.e. Bundling + Minification
• JSMinify – This is default implementation of IBundleTransform provided by the framework for javascript resources.
• Bundle – This class represents a resource bundle with a list of files or directory from where resources needs to be read. This class accepts the type of transformer in the constructor as shown below:

public Bundle(string virtualPath, System.Type transformType)

NOTE:

• Not quite sure why this signature accepts a System.Type rather than accepting an instance of IBundleTransform.
• The IBundleTransform.Process method should accept a Bundle as input and return BundleResponse as output not a void return type with BundleResponse as input. This does not seem to be a good API design to me.

So I can understand logically that

• A Bundle is defined by providing resource (js/css files & folders) locations
• A class implementing IBundleTransform interface converts this to a minified and merged content and puts them in BundleResponse.

But how IBundleTranform.Process method is invoked? Is there any caching happening?

I implemented a small custom transform class which throws an Exception.

public class MyJSTransform:IBundleTransform
{
    public void Process(BundleResponse bundle)
    {
        throw new ApplicationException("...");

    }
}

The stacktrace captured is as shown below:

[ApplicationException: ...]
BundingDemo.MyJSTransform.Process(BundleResponse bundle) in d:\Demos\BundingDemo\BundingDemo\MyJSTransform.cs:12
System.Web.Optimization.Bundle.GenerateBundleResponse(HttpContextBase context, String bundleVirtualPath) +99
System.Web.Optimization.Bundle.GetBundleResponse(HttpContextBase context, String bundleVirtualPath) +37
System.Web.Optimization.Bundle.ProcessRequest(HttpContextBase context) +25
System.Web.Optimization.BundleHandler.ProcessRequest(HttpContext context) +62
   System.Web.CallHandlerExecutionStep.System.Web.HttpApplication.IExecutionStep.Execute() +116
System.Web.HttpApplication.ExecuteStep(IExecutionStep step, Boolean& completedSynchronously)

There are many methods which seems to be internal methods and classes, not visible through object browser. So a decompiler is the only resort. From the decompiled code we get some insight into the three critical method:

• BundleHandler
  • This is an IHttpHandler implementation handling the JS & CSS resource requests
  • The ProcessRequestmethod
    • Get the Bundle from the Singleton class BundleTable.
    • Invokes Bundle.ProcessRequest  method
• Bundle.ProcessRequest
  • This method retrieves the bundle url first
  • Invokes the GetBundleResponse method
• Bundle.GetBundleResponse
  • Perform the cache lookup (normal ASP.NET cache with bundle url as key)
  • If there is a cache miss it calls GenerateBundleResponse
• Bundle.GenerateBundleResponse
  • Create an instances of BundleResponse class
  • Set the files to be processed in correct order
  • Invokes IBundleTransform.Process

The storage of the JS content in Cache can be easily viewed using Quick Watch window as shown below:

The entire flow can be summarized as:

a) Whether the class has any instance fields or properties

b) Whether class is a singleton i.e having a private constructor

Let’s consider the following singleton class:

public class Test 
    { 
        private static Test instance = null; 
        private int i = 0; 
        private int J { get; set; } 
        private Test() 
        {

        } 
        public static Test GetInstance() 
        { 
            lock(typeof(Test)) 
            { 
                if(instance==null) 
                { 
                    instance = new Test(); 
                } 
            } 
            return instance; 
        } 
        public void M1() { } 
        public void M2() { } 
    }

Here there are three static variables but we will not consider one field or property with type Test. As this is essential for the basic Singleton implementation. We will use the following rules:

• If the class is static then Singleton check is not required.
• If class has any constructor which is not private then it’s not a valid singleton class.
• If all the methods are static then the code will issue an warning to mark it as static
• If there instance variables of type other than the type of Singleton class then it’ll flag an error
• If there are more than one instance variable to type of Singleton class then it’ll flag an error

public class SingletonClassChecker 
{ 
     private bool isStatic = false; 
     private List<string> propertyFieldTypes = new List<string>();

     private List<string> methodStaticNonStatic = new List<string>(); 
     private int nonPrivateCnstrCounter = 0; 
     
     public void CheckSingletonClass(ClassDeclarationSyntax cds) 
     { 
         
         CollectData(cds); 
         AnalyzeData(cds);

     }

     private void CollectData(ClassDeclarationSyntax cds) 
     { 
         PropertyDeclarationSyntax prop = null; 
         FieldDeclarationSyntax field = null; 
         MethodDeclarationSyntax meth = null; 
         var hasPrivateConstructor = false; 
         var isStatic = false; 
         foreach (var md in cds.Modifiers) 
         { 
             if (md.GetText().Equals("static")) 
             { 
                 isStatic = true; 
                 break; 
             } 
         } 
         if (!isStatic) 
         { 
             foreach (var m in cds.Members) 
             { 
                 prop = m as PropertyDeclarationSyntax; 
                 field = m as FieldDeclarationSyntax; 
                 meth = m as MethodDeclarationSyntax; 
                 if (prop != null) 
                 { 
                     propertyFieldTypes.Add(prop.Type.PlainName); 
                 } 
                 if (field != null) 
                 { 
                     propertyFieldTypes.Add(field.Declaration.Type.PlainName); 
                 } 
                 if (m is ConstructorDeclarationSyntax) 
                 { 
                     hasPrivateConstructor = false; 
                     foreach (var cmd in (m as ConstructorDeclarationSyntax).Modifiers) 
                     { 
                         if (cmd.GetText().Equals("private")) 
                         { 
                             hasPrivateConstructor = true; 
                         } 
                     } 
                     if (!hasPrivateConstructor) nonPrivateCnstrCounter = nonPrivateCnstrCounter + 1; 
                 } 
                 if (meth!=null) 
                 { 
                     isStatic = false; 
                     foreach (var mm in meth.Modifiers) 
                     { 
                         if (mm.GetText().Equals("static")) isStatic = true; 
                     } 
                     if (isStatic == true) methodStaticNonStatic.Add("Static"); else methodStaticNonStatic.Add("Non Static"); 
                     

                 } 
             } 
         } 
     } 
     private void AnalyzeData(ClassDeclarationSyntax cds) 
     { 
         Console.WriteLine("Analyzing Class::" + cds.Identifier); 
         //If class is static then Singleton check is not required 
         if (isStatic) 
         { 
             Console.WriteLine("Static Class.Singleton check is not required"); 
         } 
         else 
         { 
             // If Class has non private constructor then it's not a singleton 
             if (nonPrivateCnstrCounter > 0) 
             { 
                 Console.WriteLine("Has non private constructor.Not a valid singleton.Singleton check is not required"); 
             } 
             else 
             { 
                 var count = methodStaticNonStatic.Count(p => p.Equals("static")); 
                 //If all methods are static then the class need not be a singleton 
                 if (count == methodStaticNonStatic.Count) 
                 { 
                     Console.WriteLine("Warning::All methods are static.Mark the class as static.Singleton not required."); 
                 } 
                 else 
                 { 
                     // If class contains instance variables other than singleton instance then there is an error 
                     if(propertyFieldTypes.Count(p=>!p.Equals(cds.Identifier.GetText()))>0) 
                     { 
                         Console.WriteLine("Error:: Singleton class with instance variables"); 
                     }// If class contains instance variables of same type but more than one then there is an error. 
                     else if (propertyFieldTypes.Count(p => p.Equals(cds.Identifier.GetText())) > 1) 
                     { 
                         Console.WriteLine("Error:: Singleton class with instance variables"); 
                     } 
                 } 
             }

         } 
     }
} 

This method is invoked as shown below:

static void Main(string[] args)
    {
        SyntaxTree tree = SyntaxTree.ParseCompilationUnit(@"namespace RoslynCTPDemo
                        {
                        public class Test
                        {
                            private static Test instance = null;
                            private int i = 0;
                            private int J { get; set; }
                            private Test()
                            {

                            }
                            public static Test GetInstance()
                            {
                                lock(typeof(Test))
                                {
                                    if(instance==null)
                                    {
                                        instance = new Test();
                                    }
                                }
                                return instance;
                            }
                            public void M1() { }
                            public void M2() { }
                        }
                    }");
        SingletonClassChecker sc = new SingletonClassChecker();
        var root = (CompilationUnitSyntax)tree.Root;
        foreach (var n in root.Members)
        {
            if (n is NamespaceDeclarationSyntax)
            {
                //Find Classes if inside namespace
                foreach (var c in (n as NamespaceDeclarationSyntax).Members)
                {
                    if (c is ClassDeclarationSyntax) sc.CheckSingletonClass(c as ClassDeclarationSyntax);
                }
            } // For classes with namespace declaration
            else if (n is ClassDeclarationSyntax)
            {
                sc.CheckSingletonClass(n as ClassDeclarationSyntax);
            }
        }
        Console.Read();
    }

The output is:

This example demonstrates the beauty, simplicity yet the power of Roslyn Syntax API. This small code snippet is converted to a suitable Visual Studio plug-in can serve the purpose of source code checker the way Resharper does that now.

The major components of a syntax tree are shown below:

A sample node in a code fragment is shown in the figure below:

In this post we will develop a small sample syntax tree walker to start with. But before that let’s take a quick look how the Roslyn Syntax API is structured for SyntaxNodes.

We will develop a  syntax walker which will traverse the different declaration syntax nodes and print their text contents.

static void Main(string[] args) 
{ 
     SyntaxTree tree = SyntaxTree.ParseCompilationUnit( 
                 @" 
                 using System; 
                 using System.Collections; 
                 using System.Linq; 
                 using System.Text; 
  
                 namespace HelloWorld 
                 { 
                     class Program 
                     { 
                         
                         static void Main(string[] args) 
                         { 
                             var a = 10; 
                             Console.WriteLine(""Hello, World!""); 
                         } 
                         public int i {get;set;} 
                         var i = 11; 
                     } 
                 }"); 
    
     var root = (CompilationUnitSyntax)tree.Root; 
     foreach (var n in root.Members) 
     { 
         if (n is NamespaceDeclarationSyntax) 
         { 
             foreach (var t in (n as NamespaceDeclarationSyntax).Members) 
             { 
                 if (t is ClassDeclarationSyntax) 
                 { 
                     foreach (var m in (t as ClassDeclarationSyntax).Members) 
                     { 
                         if (m is PropertyDeclarationSyntax) 
                         { 
                             Console.WriteLine("Property::" + m.GetText()); 
                         } 
                         if (m is MethodDeclarationSyntax) 
                         { 
                             Console.WriteLine("Method::" + m.GetText()); 
                         } 
                         if (m is FieldDeclarationSyntax) 
                         { 
                             Console.WriteLine("Variable::" + m.GetText()); 
                         }  
                     } 
                 } 
             } 
         } 
    } 
     Console.Read();

} 

The programs does the following:

• Invokes SyntaxTree.ParseCompilationUnit method with source code as input to generate SyntaxTree.
• Loops through all the members of the root node
• Checks the type of each member to determine the type of declaration syntax node and prints the contained text of that node.

The output is as shown below:

Now we will take a look into the different tokens of the method declaration. Every method has modifiers, return type, identifier and parameter list as shown below:

The code below shown how Roslyn Syntax API can be used to explore and walkthrough the same:

if (m is MethodDeclarationSyntax) 
{ 
    var meth = (m as MethodDeclarationSyntax); 
    foreach (var mt in (m as MethodDeclarationSyntax).Modifiers) 
    { 
        Console.WriteLine("Modifier::" + mt.GetText()); 
    } 
    Console.WriteLine("Identifier::" + meth.ReturnType); 
    Console.WriteLine("Identifier::" + meth.Identifier); 
    foreach (var p in meth.ParameterList.Parameters) 
    { 
        Console.WriteLine("Parameter Type::" + p.TypeOpt.PlainName + "::" + p.TypeOpt.Kind ); 
        Console.WriteLine("Parameter Identifier::" + p.Identifier); 
    }

} 

The output now changes to:

In the next post we will how we can use Syntax API in source code analysis and checking.

public static class MyExtensions 
    { 
        public static Int32 AddExt(this Int32 i, Int32 j) 
        { 
            return i + j; 
        } 
    }

We can invoke it as

10.AddExt(12)

In this post we will look at what’s happening inside extension method.

To understand the difference I am adding one more static method of exactly same signature.

public static class MyExtensions 
    { 
        public static Int32 AddExt(this Int32 i, Int32 j) 
        { 
            return i + j; 
        } 
        public static Int32 AddStatic(Int32 i, Int32 j) 
        { 
            return i + j; 
        } 
    }

The two methods are invoked as:

static void Main(string[] args) 
        { 
            Console.WriteLine(10.AddExt(12)); 
            Console.WriteLine(MyExtensions.AddStatic(10,12)); 
            Console.Read(); 
        }

Let’s take a look into the IL code of the two method calls.

The IL code of the two method calls are exactly same and they are just static method calls. Only in case of AddExt the object on which it is invoked in C# code is passed as first parameter value.

So what’s going on ? We have to go to the IL for method definitions:

Only visible difference is the extension method has an attribute called ExtensionAttribute injected on the IL code. Let’s add this attribute to the other static method and see what happens?

This leads to a compiler error “Do not use ‘System.Runtime.CompilerServices.ExtensionAttribute’. Use the ‘this’ keyword instead.”

So Mr. compiler is not allowing us to hack around with his magic wand of syntactic sugar.

However we can summarize as:

• When we write an extension method using “this” keyword in the first parameter compiler injects a ExtensionMethodAttribute to the IL code of the method.
• The invoking code for an extension is replaced as <Static Class Name>.<ExtensionMethodName>(<Object Instance on which method is invoked>,…….)

Hang on.. What if there are two classes with same extension method name on same class e.g. if we add something like:

public static class MyOtherExtensions 
    { 
        public static Int32 AddExt(this Int32 i, Int32 j) 
        { 
            return i + j; 
        } 
        public static Int32 AddStatic(Int32 i, Int32 j) 
        { 
            return i + j; 
        } 
    }

We immediately get a compiler error “The call is ambiguous between the following methods or properties: ‘ExtensionMethods.MyExtensions.AddExt(int, int)’ and ‘ExtensionMethods.MyOtherExtensions.AddExt(int, int)”

If I define the extension method on a dynamic type as

public static Int32 AddExt(this dynamic i, Int32 j) 
{ 
            return i + j; 
}

Again compiler stops us from so with a message “The first parameter of an extension method cannot be of type ‘dynamic’”

We will go for a generic parameter now.

public static Int32 AddExt<T>(this T i, Int32 j) 
        { 
            return ++j; 
        }

This one compiles. But which will be invoked? MyExtensions.AddExt or MyOtherExtensions.AddExt.

static void Main(string[] args) 
       { 
           Console.WriteLine(10.AddExt(12)); 
           Console.WriteLine(new Object().AddExt(12));

           Console.WriteLine(MyExtensions.AddStatic(10, 12)); 
           Console.Read(); 
       } 


public static class MyExtensions 
    { 
        public static Int32 AddExt<T>(this T i, Int32 j) 
        { 
            return ++j; 
        } 
        public static Int32 AddStatic(Int32 i, Int32 j) 
        { 
            return i + j; 
        } 
    } 
    public static class MyOtherExtensions 
    { 
        public static Int32 AddExt(this Int32 i, Int32 j) 
        { 
            return i + j; 
        } 
        public static Int32 AddStatic(Int32 i, Int32 j) 
        { 
            return i + j; 
        } 
    }

It is MyOtherExtensions.AddExt that is compiler finds the closest match while generating the IL Code.

So Extension methods are nothing but static calls accepting the object instance on which it is invoked (as if instance method) as the first parameter.

The last question we they can only be added in static classes. I think that’s good design decision.

• Extension methods are supposed to act & designed like instance method on some other classes
• We can’t add global methods without classes in C# every method needs a class container
• But extension methods are not supposed be aware of instance properties of the class they belong to as that is a mere container for them.
• So best way is to enforce through the complier that extension methods are within static classes

When we add an Entity Data Model (*.edmx) a default connection string gets added to the solution as shown below:

As indicated in the figure above the two critical components, one is metadata (model) and another is provider (datasource). The datasource part is quite obvious and easy to understand so let’s concentrate on the metadata part of it.

The entity data model (*.edmx) contains three xml based sections:

• Storage Model define in Storage Schema Definition Language (SSDL)
• Conceptual Model (Class Model) defined in Conceptual Schema Definition Language(CSDL)
• Mapping defined in Mapping Specification Language(MSL)

By default settings, when the code is compiled these three xml blocks get embedded into the assembly as resources. So in the metadata connection string we need to specify name of the SSDL/MSDL/CSDL and from which assembly we need to download them. This is shown in the figure below:

If we can change the Metadata location to output directory as shown below then SSDL/MSDL/CSDL files will be separately generated in the output (bin) folder

The files will be be generated as shown below:

The connection string gets modified as shown below:

So far so good. Though in most of the cases it seems to me that embedding inside the assembly makes much more sense but some of the configuration crazy crowd might think otherwise as well.So how we can manipulate this programmatically through the API.It’s time to go back to the EntityConnection class.

The EntityConnection class has a constructor which accepts a connection string as shown above containing both database and metadata information.But in case there are many metadata files this will be extremely cumbersome & long.

So to do similar stuff using API we need to see metadata information is exposed through classes.

EntityConnection holds a reference to System.Data.Common.DbConnection & System.Data.Metadata.Edm.MetadataWorkspace as shown in the figure below

MetadataWorkspace is the class representing the metadata and it has the following constructor which accepts list of paths and assemblies.

• public MetadataWorkspace(IEnumerable<string> paths,IEnumerable<Assembly> assembliesToConsider)

The following code block shows how we can use this constructor to read the metadata from file system: Here I have passed null in the second parameter as we are not extracting metadata from assembly here.

This leads to the following ArgumentNullException exception.

{“Value cannot be null.\r\nParameter name: assembliesToConsider”}

However passing a empty list works

static void Main(string[] args)
        {
            DbConnection dbc = new SqlConnection(@"data source=.\SQLEXPRESS;initial catalog=AdventureWorksLT2008;
                                                integrated security=True;multipleactiveresultsets=True;");

            MetadataWorkspace mdw = new MetadataWorkspace(new List<String>()
                                                                {
                                                                    @"D:\Demos\EFSample\AdventureWorks.Sales\bin\Debug\SalesModel.csdl",
                                                                    @"D:\Demos\EFSample\AdventureWorks.Sales\bin\Debug\SalesModel.ssdl",
                                                                    @"D:\Demos\EFSample\AdventureWorks.Sales\bin\Debug\SalesModel.msl"
                                                                }
                                                                ,new List<Assembly>());
            AdventureWorksLT2008Entities a = null;

            try
            {
                a = new AdventureWorksLT2008Entities(new EntityConnection(mdw, dbc));
                Console.WriteLine(a.ProductCategories.First().Name);
            }
            finally
            {
                (a as IDisposable).Dispose();
            }
           
            Console.Read();
        }

http://sankarsan.wordpress.com/2008/10/28/wcf-web-model-poxjson-support/

This limitation drew my attention. However there was a solution to the problem.We can always extend the WebHttpBehavior and override the WebHttpBehavior.GetReplyDispatchFormatter method to return our own custom implementation of System.ServiceModel.Dispatcher.IDispatchFormatter. A similar implementation can be found in the post below:

http://damianblog.com/2008/10/31/wcf-rest-dynamic-response/

Wait …..

This kind of an implementation is actually now part of the .NET 4.0. This is controlled by the automaticFormatSelectionEnabled property of the WebHttpBehavior. This property when set to true then the response format of the operation is governed by the Accept , Content-Type header of the request. This feature is called Automatic Format Selection. This is what we will discuss in this post.

I have a simple service with a Add operation as shown below:

[OperationContract] 
[WebGet] 
public int  Add(int i , int j) 
{ 
   // Add your operation implementation here 
   return i+j; 
} 

HttpWebRequest request = HttpWebRequest.Create("http://localhost:5072/TestService.svc/Add?i=1&j=1") as HttpWebRequest; 
request.AuthenticationLevel = System.Net.Security.AuthenticationLevel.None; 
request.Method = "GET"; 
request.ContentType = "text/xml"; 
request.Accept = "text/xml"; 
HttpWebResponse response = (HttpWebResponse)request.GetResponse(); 
using (StreamReader rdr = new StreamReader(response.GetResponseStream())) 
{ 
    Console.WriteLine(rdr.ReadToEnd()); 
}

The response is in JSON format as shown below:

{"d":2}

Now I will turn on auto format selection as shown below using config.

Now the output is XML as shown below:

<AddResponse xmlns="http://sankarsanbose.com/test"><AddResult>2</AddResult></Add 
Response>

Now I will change the Accept header to JSON.

request.ContentType = "text/xml"; 
request.Accept = "text/json";

The response is now again in JSON format as shown below:

{"d":2}

NOTE: If both Accept and Content-Type are specified then Accept takes the higher priority.

What happens if I set the response format in WebGetAttribute? Say I make it Json as shown below:

[OperationContract] 
        [WebGet(ResponseFormat=WebMessageFormat.Json)] 
        public int  Add(int i , int j) 
        { 
            // Add your operation implementation here 
            return i+j; 
        }

The output is driven by Accept Header and is in XML format

<AddResponse xmlns="http://sankarsanbose.com/test"><AddResult>2</AddResult></Add 
Response> 

If I change the headers to JSON obviously the output is JSON.

Now I am changing the ResponseFormat to XML as shown below:

[WebGet(ResponseFormat=WebMessageFormat.Xml)] 

The request headers are set as shown below:

request.ContentType = "text/json"; 
request.Accept = "text/json"; 

The output surprisingly is just 2 neither JSON nor XML.

The request headers are changed back to XML

request.ContentType = "text/xml";
request.Accept = "text/xml";

Now the output is XML is as shown below:

 
<int xmlns="http://schemas.microsoft.com/2003/10/Serialization/">2</int>

This is clearly different from structure of the XML generated earlier. Seems to be using the different serializer.

I was not able to articulate the reason for the above two anomalies very clearly. But I think when auto format selection is enabled then providing the ResponseFormat does not make much sense.

WCF uses the System.Runtime.Serialization.DataContractSerializer class for this purpose.The code snippet below uses DataContractSerializer to serialize Plain CLR Object.

class Program 
    { 
        static void Main(string[] args) 
        { 
            Customer c = new Customer() { FirstName = "Sankarsan", LastName = "Bose", Address = "404/6 NSC BOSE ROAD" }; 
            DataContractSerializer ds = new DataContractSerializer(typeof(Customer)); 
            using(var m = new MemoryStream()) 
            { 
                ds.WriteObject(m,c); 
                m.Seek(0,SeekOrigin.Begin); 
                using (var sr = new StreamReader(m)) 
                { 
                    Console.WriteLine(sr.ReadToEnd()); 
                } 
                
            } 
                   Console.Read(); 
        } 
    } 
    public class Customer 
    { 
        public String FirstName { get; set; } 
        public String LastName { get; set; } 
        public String Address { get; set; }

    }

The output will be the following XML string.

<Customer xmlns="http://schemas.datacontract.org/2004/07/SerializationDemo" xmlns:i="'>http://www.w3.org/2001/XMLSchema-instance">

<Address>404/6 NSC BOSE ROAD</Address>

<FirstName>Sankarsan</FirstName>

<LastName>Bose</LastName>

</Customer>

We need to note the following points:

a) The output is XML format

b) A Plain CLR object(POCO) without any additional decoration(attributes) is serialized with Type Name and Properties as XML Elements (This is called inferred data contracts)

c) The xmlns attribute by default is http://schemas.datacontract.org/2004/07/<<CLR Namespace Name>>

d) The ordering of the properties/fields is alphabetically sorted.

e) The XML output does not contain any additional information CLR Datatypes.This is the reason we need to provide the type information while we instantiate the Serializer.

Now if we need to have more fine grained over the serialization output we need to have some mechanism to provide additional inputs to the serializer regarding how we can want to customize our output. The System.Runtime.Serialization.DataContractAttribute and System.Runtime.Serialization.DataMemberAttribute provides the same.

We have used these attributes in the Customer class as shown below:

[DataContract(Name="customer",Namespace="http://sankarsanbose.com/Customer")] 
    public class Customer 
    { 
        [DataMember(Name="firstname",Order=1)] 
        public String FirstName { get; set; } 
        [DataMember(Name = "lastname", Order = 2)] 
        public String LastName { get; set; } 
        [DataMember(Name = "address", Order = 3)] 
        public String Address { get; set; }

    }

The XML output produced is as shown below:

<customer xmlns="http://sankarsanbose.com/Customer" xmlns:i="'>http://www.w3.org/2001/XMLSchema-instance">

<firstname>Sankarsan</firstname>

<lastname>Bose</lastname>

<address>404/6 NSC BOSE ROAD</address>

</customer>

Here we have altered the name of the XML Elements, Namespace and ordering of the elements.

We will play around a little bit with this attributes and let’s remove DataMemberAttribute from one of the properties and make another one private.

[DataContract(Name="customer",Namespace="http://sankarsanbose.com/Customer")] 
public class Customer 
{ 
    [DataMember(Name="firstname",Order=1)] 
    public String FirstName { get; set; } 
    [DataMember(Name = "lastname", Order = 2)] 
    private String LastName { get; set; } 
    public String Address { get; set; }

} 

As the xml output below shows the property(Address) without the DataMemberAttribute is not serialized and the private attribute is serialized with a default NULL value.

<customer xmlns="http://sankarsanbose.com/Customer" xmlns:i="'>http://www.w3.org/2001/XMLSchema-instance">
<firstname>Sankarsan</firstname>
<lastname i:nil="true"/>
</customer>

The default value can be controlled through the EmitDefaultValue parameter of the DataMember attribute.This is true by default and can be turned off as shown below:

[DataContract(Name="customer",Namespace="http://sankarsanbose.com/Customer")]
public class Customer
{
    [DataMember(Name="firstname",Order=1)]
    public String FirstName { get; set; }
    [DataMember(Name = "lastname", Order = 2,EmitDefaultValue=false)]
    private String LastName { get; set; }
    public String Address { get; set; }

}

So the serialized data now no longer emits the lastname with Null value:

<customer xmlns="http://sankarsanbose.com/Customer" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
<firstname>Sankarsan</firstname>
</customer>

This post covers the basics and in the next post we will take a deeper look into the DataContractSerializer class.

We will use a Groovy script to read from this properties file as shown in the snippet below:

package com.test

import java.util.Properties

class Start {

    static main(args) { 
        def p = new Properties() 
        new File("test.properties").withInputStream { 
          stream -> p.load(stream) 
        } 
        println "gfv3.admin.url=" + p["gfv3.admin.url"] 
  
    }

}

This is a very simple piece of code which makes use of the java.util.Properties class and load the properties file using java.io.File and it’s associated InputStream class.Here the properties are accessed as  a map of name/value pairs. This code can be tweaked bit using the ConfigSlurper class and the values can be accessed as object properties as shown below:

package com.test

import java.util.Properties

class Start {

    static main(args) { 
        def p = new Properties() 
        new File("test.properties").withInputStream { 
          stream -> p.load(stream) 
        } 
        def cfg = new ConfigSlurper().parse(p) 
        println "gfv3.admin.url=" + cfg.gfv3.admin.url 
    
    }

}

We can write a similar ConfigSlurper in C# using the System.Dynamic.ExpandoObject which allows us to add and remove properties to this object at runtime.ExpandoObject implement a IDictionary and IDynamicMetaObjectProvider interfaces as shown in the definition below:

public sealed class ExpandoObject : IDynamicMetaObjectProvider,IDictionary<string, Object>, ICollection<KeyValuePair<string, Object>>, IEnumerable<KeyValuePair<string, Object>>, IEnumerable, INotifyPropertyChanged

We can use the IDictionary implementation to attach properties at runtime as shown below in the ConfigSlurper class.

public static class ConfigSlurper 
{ 
    public static ExpandoObject  Parse(System.Collections.Specialized.NameValueCollection settings) 
    { 
        var config = new ExpandoObject(); 
        var dictConfig = (config as IDictionary<String, object>); 
        foreach (var k in settings.AllKeys) 
        { 
            dictConfig[k] = settings[k]; 
        } 
        return config; 
    } 
} 

The config settings are defined as shown below:

<appSettings> 
  <add key="gfv3AdminUrl" value="http\://localhost\:4848"/> 
  <add key="gfv3Root" value="D\:\\Program Files\\glassfish-3.0.1\\glassfish"/> 
  <add key="gfv3Port" value="4848"/> 
  <add key="gfv3Host" value="localhost"/> 
  <add key="gfv3Username" value="admin"/> 
  <add key="gfv3Url" value="http\://localhost\:8080"/> 
</appSettings> 

This config can be read using the ConfigSlurper class as:

static void Main(string[] args)
{
    dynamic config = ConfigSlurper.Parse(ConfigurationManager.AppSettings);
    Console.WriteLine(config.gfv3AdminUrl);
    Console.Read();
}

We will use the standard School data model to explain most of the stuff and take different examples in some of the special cases.The table diagram is shown below:

We will start with the very basics, i.e. I have POCO and I want to map it to a database table.I need to use the annotations TableAttribute and ColumnAttribute under System.ComponentModel.DataAnnotations as shown below

[Table("Course")] 
   public class Course 
   { 
       [Column("CourseID")] 
       public int CourseID { get; set; } 
       [Column("Title")] 
       public string Title { get; set; } 
       [Column("Credits")] 
       public int Credits { get; set; } 
       [Column("DepartmentID")] 
       public int DepartmentID { get; set; } 
              
   }

The TableAttribute also allows to specify the schema to which this table belongs to. Now the next thing is how to specify the primary key?. We have to use the KeyAttribute as shown below:

[Table("Course")] 
   public class Course 
   { 
       [Key] 
       [Column("CourseID")] 
       public int CourseID { get; set; } 
       [Column("Title")] 
       public string Title { get; set; } 
       [Column("Credits")] 
       public int Credits { get; set; } 
       [Column("DepartmentID")] 
       public int DepartmentID { get; set; } 
               
   }

In this table the Primary Key is an IDENTITY column automatically generated in the database. We need to use the DatabaseGeneratedAttribute to specify the same. There are three types of database generation strategy supported by the framework using the DatabaseGeneratedOption enumeration i.e

• None
• Identity
• Computed

The completed class definition is shown below:

[Table("Course")] 
   public class Course 
   { 
       [Key] 
       [DatabaseGenerated(System.ComponentModel.DataAnnotations.DatabaseGeneratedOption.Identity)] 
       [Column("CourseID")] 
       public int CourseID { get; set; } 
       [Column("Title")] 
       public string Title { get; set; } 
       [Column("Credits")] 
       public int Credits { get; set; } 
       [Column("DepartmentID")] 
       public int DepartmentID { get; set; } 
              
   } 

Next thing how we can define Composite Keys? In the table CourseInstructor we have both CourseID and InstructorID as Primary Key. This can be easily defined using the KeyAttribute as shown below:

[Table("CourseInstructor")]
    public class CourseInstructor
    {
        [Key]
        [Column("PersonID")]
        public int PersonID { get; set; }
        [Column("CourseID")]
        [Key]
        public int CourseID { get; set; }
    }

While executing query on this object we get the following exception

Unable to determine composite primary key ordering for type ‘EFAnnoations.CourseInstructor’. Use the ColumnAttribute or the HasKey method to specify an order for composite primary keys.

We will use the Order property of ColumnAttribute as shown below:

[Table("CourseInstructor")]
public class CourseInstructor
{
    [Key]
    [Column("PersonID",Order=0)]
    public int PersonID { get; set; }
    [Column("CourseID",Order=1)]
    [Key]
    public int CourseID { get; set; }
}

Next post onwards we will start exploring how we can establish the different types of relationship in our entity model.

I will start with the most simplest of all the techniques that is implementing the interface IComparable<T>. The IComparable<T> has the following methods:

• int CompareTo(T other) – This method compares one instance of object of type T with another which is passed as parameter.

The following class implements an IComparable<T> interface as shown below:

public class Member : IComparable<Member> 
    { 
        public int ID { get; set; } 
        public String FirstName { get; set; } 
        public String LastName { get; set; } 
        public DateTime DateOfJoining { get; set; }


        public int CompareTo(Member other) 
        { 
            return this.ID.CompareTo(other.ID); 
        } 
    }

Here the comparison is done based on the property ID of the member class. The following snippet is used to demonstrate the usage.

List<Member> ls = new List<Member>() 
                                { 
                                    new Member(){ID=1,FirstName="John",LastName="Doe"}, 
                                    new Member(){ID=3,FirstName="Allan",LastName="Jones"}, 
                                    new Member(){ID=2,FirstName="Martin",LastName="Moe"}, 
                                    new Member(){ID=4,FirstName="Ludwig",LastName="Issac"} 
                                }; 
ls.Sort(); 
ls.ForEach(m => Console.WriteLine("Member " + m.FirstName + ":" + m.LastName));

Here the output will be sorted by ID as shown below:

Member John:Doe
Member Martin:Moe
Member Allan:Jones
Member Ludwig:Issac

Now if we want to sort by other properties as well like FirstName, LastName etc. One crud approach is to create different subclasses as shown below:

public class MemberByFirstName : Member, IComparable<MemberByFirstName> 
    { 
        public int CompareTo(MemberByFirstName other) 
        { 
            return this.FirstName.CompareTo(other.FirstName); 
        } 
    }

Then when we need to sort by say FirstName we will use List of this sub class as shown below:

List<MemberByFirstName> ls = new List<MemberByFirstName>() 
{ 
            new MemberByFirstName(){ID=1,FirstName="John",LastName="Doe"}, 
            new MemberByFirstName(){ID=3,FirstName="Allan",LastName="Jones"}, 
            new MemberByFirstName(){ID=2,FirstName="Martin",LastName="Moe"}, 
            new MemberByFirstName(){ID=4,FirstName="Ludwig",LastName="Issac"} 
}; 
ls.Sort(); 
ls.ForEach(m => Console.WriteLine("Member " + m.FirstName + ":" + m.LastName));

The output will be alphabetically sorted by FirstName as shown below:

Member Allan:Jones
Member John:Doe
Member Ludwig:Issac
Member Martin:Moe

But this is a cumbersome and rigid approach.Similar stuff can be implemented in a much more cleaner way using the IComparer<T> interface.This interface defines the following method:

• int Compare(T x,T y) – This method takes two objects of type T and compares between them.

We can implement IComparer<T> as shown below:

public class MemberSorterByLastName : IComparer<Member> 
   {

       public int Compare(Member x, Member y) 
       { 
           return x.LastName.CompareTo(y.LastName); 
       } 
   } 
   public class MemberSorterByFirstName : IComparer<Member> 
   {

       public int Compare(Member x, Member y) 
       { 
           return x.FirstName.CompareTo(y.FirstName); 
       } 
   } 
  

We can use the method Sort(IComparer comparer) as shown below to sort the List of Member by FirstName and LastName respectively:

List<Member> ls = new List<Member>() 
                                { 
                                    new Member(){ID=1,FirstName="John",LastName="Doe"}, 
                                    new Member(){ID=3,FirstName="Allan",LastName="Jones"}, 
                                    new Member(){ID=2,FirstName="Martin",LastName="Moe"}, 
                                    new Member(){ID=4,FirstName="Ludwig",LastName="Issac"} 
                                };

ls.Sort(new MemberSorterByFirstName());

ls.ForEach(m => Console.WriteLine("Member " + m.FirstName + ":" + m.LastName));

ls.Sort(new MemberSorterByLastName());

ls.ForEach(m => Console.WriteLine("Member " + m.FirstName + ":" + m.LastName));

This approach is clean but has the overhead of creating separate classes for each different sort criteria.This can be achieved much more simply using the Comparison<T> delegate. The Comparison<T> delegate has the following signature:

• public delegate int Comparison<in T>(T x,T y) – This is used to compare two objects of generic type T.

We can use the Sort (Comparison<T> comparison) method as shown below:

List<Member> ls = new List<Member>() 
                    { 
                        new Member(){ID=1,FirstName="John",LastName="Doe"}, 
                        new Member(){ID=3,FirstName="Allan",LastName="Jones"}, 
                        new Member(){ID=2,FirstName="Martin",LastName="Moe"}, 
                        new Member(){ID=4,FirstName="Ludwig",LastName="Issac"} 
                    };

ls.Sort((x, y) => x.FirstName.CompareTo(y.FirstName)); 
ls.ForEach(m => Console.WriteLine("Member " + m.FirstName + ":" + m.LastName));

ls.Sort((x, y) => x.LastName.CompareTo(y.LastName)); 
ls.ForEach(m => Console.WriteLine("Member " + m.FirstName + ":" + m.LastName)); 

By far this approach is the most simplest one. In other languages like Java the first two options are there e.g. Java Comparer interface is similar to IComparable and Comparator interface is similar to IComparer in C# respectively. But Java is yet to have support for Closures so the third approach is still not possible.