Of course, there is never a good time to leave, but I feel satisfied with my tenure at GoodCore. I recently accomplished an enterprise educational content management system that involved all the latest .NET 4 flavors: WPF, Silverlight and ASP.NET were used for user interface, WCF for communication, Entity Framework for data access and SQL Server for storage. I was involved as the lead architect and gained a lot of experience and knowledge while working on the project.

Apart from handling some .NET projects at GoodCore, I also looked after few business intelligence and data warehousing projects. I utilized SQL reporting services and highly complex TSQL queries for dashboards and analytical reports, SQL Integration services for data extraction, transformation, loading, aggregation, integration and migration, and SQL Analysis services for building multidimensional structures, cubes and analytic solutions.

In this post, I would like to thank all the great folks at GoodCore for their support, cooperation and guidance. I hope the company will continue to have a positive reputation in the software industry.

Now I look forward to a new venture at DevEnhanced that brings forth new challenges and will add more diverse experience to my career. Please do remember me in your prayers and best wishes.

public static void SetDefaults(object obj)
{
    DateTime defaultDate = new DateTime(1753, 1, 1);
    PropertyInfo[] infos = obj.GetType().GetProperties();
    foreach (PropertyInfo info in infos)
    {
        if (info.CanWrite)
        {
            //numeric fields (int, double etc) are already defaulted to 0
 
            //string
            if (info.PropertyType == typeof(string)) 
                info.SetValue(obj, string.Empty, null);
            
            //date fields
            else if (info.PropertyType == typeof(DateTime))
                info.SetValue(obj, defaultDate, null);

            //timestamps
            else if (info.PropertyType == typeof(byte[]))
                info.SetValue(obj, new byte[1], null);
        }
    }
}

The above method needs to be called from the partial implementation of OnCreated for our generated data classes. However, things will still not work normally as there’s still a small point left: The Required attribute on string fields does not allow empty string. To tackle this, we need to decorate all our string fields in the metadata class (located in server project) with [Required(AllowEmptyString = true)]. That’s all.

<ListBox ItemsSource="{Binding MyList}" >
    <ListBox.ItemTemplate>
        <DataTemplate>
            <TextBox Text="{Binding}" Background="LightYellow"  />
        </DataTemplate>
    </ListBox.ItemTemplate>
</ListBox>

Here’s the output for the above XAML:

A quick thought would be to assign HorizontalContentAlignment property to Stretch for the TextBox but this wont work. We need to specify this property for the ListBoxItem that encapsulates our DataTemplate. Here’s a quick syntax for doing this using a style:

<Grid>
    <Grid.Resources>
        <Style x:Key="ListBoxItemStyle" TargetType="ListBoxItem">
            <Setter Property="HorizontalContentAlignment" Value="Stretch"/>
        </Style>
    </Grid.Resources>
    <ListBox Margin="100" ItemsSource="{Binding MyList}" 
                ItemContainerStyle="{StaticResource ListBoxItemStyle}"
                >
        <ListBox.ItemTemplate>
            <DataTemplate>
                <TextBox Text="{Binding}" Background="LightYellow"  />
            </DataTemplate>
        </ListBox.ItemTemplate>
    </ListBox>
</Grid>

And here’s the output:

This should be fine in most case but sometimes we also need to wrap the text as highlighted using red arrows in the above image. Now setting TextWrapping property will have no effect as the TextBox thinks it can take all the horizontal space. This can be solved by disabling the horizontal scroll bar for the ListBox:

<Grid>
    <Grid.Resources>
        <Style x:Key="ListBoxItemStyle" TargetType="ListBoxItem">
            <Setter Property="HorizontalContentAlignment" Value="Stretch"/>
        </Style>
    </Grid.Resources>
    <ListBox Margin="100" ItemsSource="{Binding MyList}" 
                ItemContainerStyle="{StaticResource ListBoxItemStyle}"
                ScrollViewer.HorizontalScrollBarVisibility="Disabled"
                >
        <ListBox.ItemTemplate>
            <DataTemplate>
                <TextBox Text="{Binding}" 
                    Background="LightYellow"
                    TextWrapping="Wrap" />
            </DataTemplate>
        </ListBox.ItemTemplate>
    </ListBox>
</Grid>

Here’s the final output:

Nice learning for me!

public class SomeClass
{
    List<int> someList;

    //property
    public string Item { get; set; }
        
    //indexer
    public int this[int index]
    {
        get { return someList[index]; }
        set { someList[index] = value; }
    }
}

Nothing special? But when I tried to compile, it complained saying:

The type 'MyNamespace.DataClasses.SomeClass' already contains a definition for 'Item'.

Strange!! and the location of the error as pointed by Visual Studio was my indexer:

Well, the reason is that internally, C# converts the indexer to a property name ‘Item’ to be able to support other languages that don’t directly support indexers. Since I had already defined a property name Item, so a conflict was created. Luckily, this can be solved by forcing the compiler to use a custom name other than ‘Item’ by using the IndexerNameAttribute. So, here’s a quick fix for such situation:

[IndexerName("Indexer")]
public int this[int index]
{
    get { return someList[index]; }
    set { someList[index] = value; }
}

Enjoy!!!

The entity ' StoredProcedure_Result' in DomainService 'MyDomainService' does not have a key defined. Entities exposed by DomainService operations must have at least one public property marked with the KeyAttribute.

What to do? Adding attributes to EF designer generated classes is a bad idea; Also, we cannot use partial classes to add attributes to an already defined property. However, luckily, WCF RIA Services uses metadata classes in conjunction with the entity model classes and hence we can always create a meta data class for our complex type and decorate one of the fields with a [Key] attribute. E.g., If our stored procedure is returning StoredProcedure_Result, then we may just need to add the following in our DomainService.metadata.cs file:

[MetadataTypeAttribute(typeof(StoredProcedure_Result.StoredProcedure_Result_Metadata))]
public partial class StoredProcedure_Result
{
    internal sealed class StoredProcedure_Result_Metadata
    {
        // Metadata classes are not meant to be instantiated, so mark constructor as private
        private StoredProcedure_Result_Metadata()
        { }
 
        [Key]
        public string SomeUniqueColumn { get; set; }
    }
}

1. Dealing with inheritance hierarchies
2. Dealing with circular references

1. Dealing with inheritance hierarchies
Suppose we have a Fruit class with derived classes Orange and Apple. Now, we need to return a list of fruits from a WCF service method like this:

public List<Fruit> GetSomeFruits()
{
  List<Fruit> list = new List<Fruit>;
  list.Add( new Orange() };
  list.Add( new Apple() };
  list.Add( new Mango() };
  return list;
}

If we try to call the above method from a client, it will throw a communication exception. Using the test method described in this post, we can see that the DataContractSerializer was unable to serialize the result throwing a System.Runtime.Serialization.SerializationException:

Type 'WebApplication1.CustomBO.Orange' with data contract name 'Orange:http://schemas.datacontract.org/2004/07/WebApplication1.CustomBO' is not expected. Consider using a DataContractResolver or add any types not known statically to the list of known types - for example, by using the KnownTypeAttribute attribute or by adding them to the list of known types passed to DataContractSerializer.

So the serializer does not know how to serialize a derived object (Orange) as a base object (Fruit). The exception message is quite detailed and presents us a few ways to tackle such situation. Here’s a quick list:

1. Add KnownTypeAttribute to the Fruit class
2. Add ServiceKnownTypeAttribute to the WCF method
3. Add KnownType entries to web.config
4. Create a DataContractResolver and associate it using a custom service host.

These methods are very well described in this, and this post by Youssef, as well as this post by Sowmy. Checkout the links for some detailed analysis.

2. Dealing with circular references
Assume we have a FruitBasket class that contains a collection of Fruit objects. If such relation is bi-directional (like the navigational properties Entity Framework creates), we will have a List property in our FruitBasket class and a FruitBasket property in our Fruit class:

public class FruitBasket
{
  List<Fruit> fruitCollection;
  public List<Fruit> FruitCollection
  {
    get { return this.fruitCollection; }
    set { this.fruitCollection = value; }
  }
}

public class Fruit
{
  FruitBasket basketContainer;
  public FruitBasket BasketContainer
  {
    get { return this.basketContainer; }
    set { this.basketContainer = value; }
  }
}

When we try to send such bi-directionally related objects with multiple Fruit objects containing a reference to the same FruitBasket object, we will get a SerializationException:

Object graph for type 'WebApplication1.CustomBO.Orange' contains cycles and cannot be serialized if reference tracking is disabled.

To solve this, we need to explicitly tell the DataContractSerializer that a single FruitBasket can be referenced by multiple Fruit objects. This can be done by decorating FruitBasket object with [DataContract(IsReference=true)]. For some more details, check out this MSDN document and this blog post by Zulfiqar. If our data classes share some base class (which is always a good idea), then we may simply decorate the top-level base class with such attribute and enjoy the beauty of referential serialization.

System.ServiceModel.CommunicationException: The underlying connection was closed: The connection was closed unexpectedly.

Silverlight guys should be able to recall the famous NotFound exception that was thrown every time anything was wrong. Well, the above communication exception is typically raised when something was wrong at server and it was forced to terminate the service request. The best way to debug such exceptions is to enable WCF Tracing. This is dead simple and requires the following addition to web.config under configuation section:

<system.diagnostics>
   <sources>
         <source name="System.ServiceModel"
                 switchValue="Information, ActivityTracing"
                 propagateActivity="true">
         <listeners>
            <add name="traceListener"
                type="System.Diagnostics.XmlWriterTraceListener"
                initializeData="wcf_service_traces.svclog" />
         </listeners>
      </source>
   </sources>
</system.diagnostics>

Now we will get a file named: wcf_service_traces.svclog that can be opened via SvcTraceViewer.exe (included with Visual Studio installation). Typically we don’t need to worry about locating the file as .svclog extension will automatically be associated with that utility. In the utility, look out for error rows highlighted in red:

For my case, most of the errors were related to DataContractSerializer that was unable to serialize my business entities. So I wrote a quick method to test if an object can be serialized or not. Here’s the method that was called from each of my unit tests.

public static void TestSerialization<T>(T objectToSerialize)
{
    DataContractSerializer serializer = new DataContractSerializer(typeof(T));
    using (MemoryStream stream = new MemoryStream())
    {
        //will throw an exception if cant serialize
        serializer.WriteObject(stream, objectToSerialize);
    }
}

The above method will throw an exception if the entries cannot be serialized and we can look into the exception details to find the actual error. I hope you will find this method and post useful.

Remote report processing requires Microsoft SQL Server 2008 Reporting Services or later.

Strange!! Typically software are backward compatible and new versions support all previous versions but Report Viewer wont. So be careful when choosing your version of Report Viewer. Finally, if you need directions on how to use Report Viewer version 9 with VS2010, here’s an stack overflow question that may be helpful: http://stackoverflow.com/questions/3013135/using-reportviewer-9-control-in-vs-2010.

• Calculating overrideable attributes
• Combining results from Full Outer Join
• String concatenation

Calculating overrideable attributes
Perhaps the best usage of coalesce function is when we need to pick up some value that can be declared at various levels, and each level can have different priorities. E.g. in one of our scenarios, the rate of a resource can be assigned on the task he/she worked, or on the project the task belongs to, or on the department the project belongs to, or on the resource itself. Here’s a quick query for such situation:

;With TimesheetWithAllRates as
(
  Select
    ResourceID
    ,HoursWorked
    ,RateFromTask = ( Select Top(1) Rate from TaskRate tr where tr.TaskID = ts.TaskID and tr.ResourceID = ts.ResourceID )
    ,RateFromProject = ( Select Top(1) Rate from ProjectRate pr where pr.ProjectID = ts.ProjectID and pr.ResourceID = ts.ResourceID )
    ,RateFromDept = ( Select Top(1) Rate from DepartmentRate dr where dr.DeptID = ts.DeptID and dr.ResourceID = ts.ResourceID )
    ,RateFromResource = ( Select Top(1) Rate from Resource r where r.ResourceID = ts.ResourceID )
    ...
  From Timesheet ts
)
,TimesheetWithApplicableRate as
(
  Select ResourceID
    ,HoursWorked
    ,Rate = Coalesce(RateFromTask, RateFromProject, RateFromDept, RateFromResource) --starting from left, pickup the first non-null value
    ...
  From TimesheetWithAllRates
)

Notice that we build all the possible rate combinations in the first CTE and then picked the appropriate one according to desired priority.

Combining results from Full Outer Join
Another interesting scenario for the usage of coalesce is when we need to combine values from two result sets. Suppose we have two tables/CTEs: ProjectAmountsUsingMethod1 and ProjectAmountsUsingMethod2 having similar columns and we want to see the row-by-row comparison of both the tables per Project. Here’s a result set assumption:

ProjectAmountsUsingMethod1  as
(
   Select ProjectID, Sum(Amount), ...
   From ... (method1)
)
,ProjectAmountsUsingMethod2 as
(
  Select ProjectID, Sum(Amount), ...
  From ... (method2)
)

Assume that both methods do not yield same result and we need to compare them. Also, there can exists some Project rows using method1 that are missing when we use method2 and vice verca. So we may need to join both the result set using a full outer join. Here’s how the coalesce function can build a better output set for comparison (although for this very example, we can also use IsNull since there are only two parameters but this concept can be extended further as well):

Select coalesce(m1.ProjectID, m2.ProjectID), m1.Amount as M1Amount, m2.Amount as M2Amount
From ProjectAmountsUsingMethod1 m1
Full Outer Join ProjectAmountsUsingMethod2 m2 on m1.ProjectID = m2.ProjectID

String concatenation
This is a fairly common scenario described by various people. If we need to build a comma separated list of values from a certain column into a variable, then one method is to use coalesce(or IsNull) as:

Declare @myVariable varchar(max) 

Select @myVariable = coalesce(@myVariable + ',', '') + MyColumn
From MyTable

That’s all. I hope this post helped you in determining how and when to use the coalesce function. Please share your thoughts by leaving a comment in case you have experienced any other interesting usage of coalesce.

Consider the following scenario having a many to many relationship between Student and Course:

The generated Entity Model will look something like:

However, if the junction table contains any other field other than the two foreign keys, then EF will create a separate entity for it. E.g. lets assume that the StudentCourseEnrollment table has its own ID and some fields like EnrolledFrom and EnrolledTo, like:

The generated Entity Model for the above tables will look like:

Now, we will see how to write some typical LINQ queries involving the two tables participating in many to many relationship for both cases (with and without the junction table exposed in EF model):

Get students enrolled in a particular course

• For case 1, when there is no junction table, and we have the required CourseID to look for, we may write:

dc.Students.Where(s => s.Courses.Any(c => c.CourseID == courseID))

//or without the Any method
from s in dc.Students
from c in s.Courses
where c.CourseID == courseID
select s;

• For case 2, when the junction table is included in the entity model, we may need to write:

dc.Students.Where(s => s.StudentCourseEnrollments.Any(e => e.Course.CourseID == courseID)

//or without the any method
from s in dc.Students
from e in s.StudentCourseEnrollments
where e.Course.CourseID == courseID
select s;

If the foreign keys are also included in the model (applicable only for EF4), we can also directly refer to the CourseID property in the StudentCourseEnrollment table, like:

dc.Students.Where(s => s.StudentCourseEnrollments.Any(e => e.CourseID == courseID)

//or without the any method
from s in dc.Students
from e in s.StudentCourseEnrollments
where e.CourseID == courseID
select s;

In the above situations, the Any() method is translated to where exists() expression while the other SelectMany methods are translated to join expression.

However, an interesting twist for such queries is to start our query with the junction table and use navigational properties for filtering and selecting. This leaves us with a more compact query:

dc.StudentCourseEnrollments.Where(e => e.Course.CourseID == courseID).Select(e=>e.Student);

//the verbose query 
from e in s.StudentCourseEnrollments
where e.Course.CourseID == courseID
select e.Student;

Get students enrolled in any course from a list of courses

Notice that such query will use the Contains methodology that is only available with Entity Framework 4. For similar queries with EF1 (EF3.5) we can use the BuildContainsExpression() extension method described here.

• For case 1, when the bridge table is abstracted by EF, this can be written as:

int[,] courseIDs = new int[,] { 1,2,3 };
var students =
 from s in dc.Students
 from c in s.Courses
 where courseIDs.Contains(c.CourseID)
 select s;

//similarly, such query can be written with the any method
var students =
 from s in dc.Students
 where (
   from c in s.Courses
   where courseIDs.Contains(c.CourseID)
   select c
   ).Any()
 select s;

• For case 2, when the bridge table is included in the entity model, we may write:

int[,] courseIDs = new int[,] { 1,2,3 };
var students =
 from s in dc.Students
 from e in s.StudentCourseEnrollments
 where courseIDs.Contains(e.Course.CourseID)
 select s;

//starting with the bridge table
var students =
 from e in dc.StudentCourseEnrollments
 where courseIDs.Contains(e.Course.CourseID)
 select e.Student;

//with the any method
var students =
 from s in dc.Students
 where (
   from e in s.StudentCourseEnrollments
   where courseIDs.Contains(e.Course.CourseID)
   select e
   ).Any()
 select s;

Get students enrolled in ALL courses from a list of courses

• For case 1, when the bridge table is abstracted by EF, we can write the query as:

int[,] courseIDs = new int[,] { 1,2,3 };
var students =
 from s in dc.Students
 where
  (
   from c in s.Courses
   where courseIDs.Contains(c.CourseID)
   select c
  ).Count() == courseIDs.Count
 select s;

• For case 2, when the bridge table is included in the entity model, we may query as:

int[,] courseIDs = new int[,] { 1,2,3 };
var students =
 from s in dc.Students
 where
  (
   from e in s.StudentCourseEnrollments
   where courseIDs.Contains(e.Course.CourseID)
   select e
  ).Count() == courseIDs.Count
 select s;

Thats’s all. I will include some more queries in case I find interesting. Notice that same queries can be written for LINQ To SQL also. The only difference is that the bridge table is always included in the model, so always we need to refer to case 2 from this discussion.