From .NET Geek's Desk

APTCA and Sandboxing

sankarsan — Fri, 10 Apr 2009 10:51:00 GMT

In .NET Framework any code which does not have the FullTrust cannot make calls to a strong named assembly.The strong naming of assemblies is again a requirement to register the same in GAC to be shared by multiple applications.Most of the third party...(read more)

.NET Memory Management and GCHandle

sankarsan — Sun, 01 Mar 2009 07:56:00 GMT

GC Handle provides facilities to explicitly control and monitor the lifetime of an object in heap.Whenever an appdomain loads it creates a GC Handle table which maintains a list of pointers and corresponding GC Handle type.The GC Handle can be obtained...(read more)

Physical Layout of Data - StructLayout

sankarsan — Sun, 22 Feb 2009 06:48:00 GMT

This week I was taking a close look into various InterOp related stuff for a code review purpose.While doing so the way CLR controls the physical layout of a data structure in memory caught my attention.This is what I intend to discuss here. When we are...(read more)

Functional Construction in LINQ To XML

sankarsan — Sat, 31 Jan 2009 07:51:00 GMT

In this post we describe how we can create XML documents using LINQ to XML.Here we will discuss about functional construction of a XML tree in which we can construct a XML document using a single statement.Before getting into examples let us take a look...(read more)

LINQ To XML Overview

sankarsan — Sat, 24 Jan 2009 08:40:00 GMT

In this post I will discuss about how we can use the concepts of LINQ in parsing an xml document using the classes provided in the System.Xml.Linq namespace.We can think of any xml document as a collection of nodes where a node can be element,attribute,processing...(read more)

Anonymous Types and LINQ

sankarsan — Sat, 17 Jan 2009 06:42:00 GMT

Anonymous types, introduced in C# provides the facility to encapsulate a set of properties into a type without specifically naming the type in source code as shown below: var prod = new { Name="xyz",Price=12.00}; In this case compiler internally...(read more)

Dependency Injection

sankarsan — Sun, 04 Jan 2009 13:29:00 GMT

As the concept of TDD(Test Driven Development) is growing popular day by day the Dependency Injection (DI) and Inversion of Control (IoC) patterns are also becoming increasingly popular and much discussed about topic.In this post I will share my thoughts...(read more)

Lambda Expressions

sankarsan — Sun, 28 Dec 2008 12:30:00 GMT

Before getting details of Lambda expressions let us quickly take a look into how we work with delegates and a named method since the days of .NET 1.1.Let us consider the following code sample //Delegate declaration public delegate void Test(string s);...(read more)

String Interning in C#

sankarsan — Thu, 25 Dec 2008 06:39:00 GMT

We all know that string objects are immutable in C# i.e we can only create a new instance of the object we cannot alter or modify them.Let us take a quick look into the following lines of code: static void Main(string[] args) { string s1 = "sankarsan";...(read more)

Object Equality

sankarsan — Thu, 25 Dec 2008 05:28:00 GMT

In this post I will discuss about the very basic concepts related to object equality.Object equality can be of two types Value Equality - Two objects having same value for all the fields Reference Equality - Two instance variables pointing to same reference...(read more)

Upcasting and Downcasting in C#

sankarsan — Mon, 22 Dec 2008 21:26:00 GMT

While reviewing code and discussing with developers I have seen in several occasions that people are not very clear or conscious about upcasting and downcasting.In this post I would like to note down the differences between the two.

Upcasting means casting an object of any type to another type which is above it in the inheritance hierarchy.

Downcasting means casting an object of any type to another type which is below it in the inheritance hierarchy.

For sake of simplicity let us consider the two classes as shown below:

public class Base
    {
        public int i;
        public Base()
        {
            i = 10;
        }
    }
    public class Derived:Base
    {
        public int j;
        public Derived()
        {
            j = 10;
        }
    }

Following is the code for upcasting:

Derived d = new Derived();

Base b = (Base)d;

The corresponding IL code will be as follows:

//Create new object of type
IL_0001: newobj instance void TypeConversionDemo.Derived::.ctor()
//Store the reference in first variable
IL_0006: stloc.0
//Load the value from first variable
IL_0007: ldloc.0
//store the value in second variable
IL_0008: stloc.1

Following is the code for downcasting:

object d = new Derived();

Base b = (Base)d;

The corresponding IL code will be as follows:

IL_0001: newobj instance void TypeConversionDemo.Derived::.ctor()
IL_0006: stloc.0
IL_0007: ldloc.0
IL_0008: castclass TypeConversionDemo.Base
IL_000d: stloc.1

The major difference in the two is presence of the castclass operator.This operator performs a runtime type checking and the types are not compatible then throws a InvalidCastException.For upcasting runtime checking is not required as "derived" is always a type of "base" so question of incompatibility at runtime does not arise.But for downcasting it is not possible to determine at compile time whether two types are compatible.

Let us consider another class:

public class Test
   {
       public int k;
   }

The following code will compile without any error:

object d = new Derived();

Test b = (Test)d;

But will throw runtime InvalidCastException.

{"Unable to cast object of type 'TypeConversionDemo.Derived' to type 'TypeConversionDemo.Test'."}

For this runtime check downcasting is always more costly than upcasting in terms of performance.