This is going to be my last blog post here. I have resigned from Microsoft and am moving on to seek my future else where. I never thought this day would come and am myself quite surprised.

My experience with Microsoft was amazing. I am always going to remember this company as "The Company". However, I would like to add that there is definitely certain things that I expect to change in Microsoft IT, Hyderabad.

I would look forward to coming back to Microsoft some day, perhaps in a different role or capacity in a different division. And so I will not say Goodbye. I will just say "Bye for now" and hope to return some day. Until then I will continue to blog at https://www.dasboard.in/nilotpal.

3 hours earlier:

I wanted to create a sequence diagram from the code I have already written. Visual Studio 2010 comes with the sequence diagram feature. I decided heck why not use it. It creates some really cool sequence diagrams. I opened the same project in Visual Studio 2010, created the sequence diagram, closed the project. Went for a smoke.

30 minutes earlier:

My test cases won’t run. the error I get is  “Error loading xxx.vsmdi: D:\Projects\xxx\xxx.vsmdi” looked here, looked there looked everywhere. But didn’t look in the place I should have been looking.

10 minutes earlier:

I built the test project. I got an error. “Project file contains ToolsVersion="4.0", which is not supported by this version of MSBuild. Treating the project as if it had ToolsVersion="3.5".”

Well I should have been looking at this 30 minutes ago. I went to the test projects Properties, went to TargetFramework and checked. it was not selected at all. I selected Framework 3.5.

After this all I had to do was close the project and open it and then run all my tests in the solution.

They were all still green. Love it when that happens…!!

I felt an urge to argue, but I resisted. I thought I would investigate before I waste time. I came up with some articles pretty quickly.

1. Left Outer Join in LINQ
2. Left Outer Join using Inverse Navigation Property
3. DefiningQuery Element
4. Left Outer Join in LINQ to SQL
5. LINQ to Entities with Multiple Left Outer Joins

I am sure these should resolve all questions related to Left Outer Joins.

Now about the performance and the question about how the data is brought, I am pretty sure we can prove that LINQ Queries all support deferred execution. But we can always prove that using the SQL Query Profiler.

Hope this helps.

Well generally we write a generic method that gets all the records for a generic object. it looks like this:

This will only query into the database. So if you have just recently inserted some records, but haven't yet committed them, they won’t appear in the results.

However, if we provide another method (an overload perhaps) that handles local objects, this would be possible. When I say local objects, I mean objects that have been inserted into the Object Context and yet not been persisted into the database. this method would look something like this:

This way we give the option to the user of the API to choose which kind of select he wants to fire. A local one or one on the database.

I am not sure if this makes any sense or not, but hey, I am a software program writer not a network administrator. So please excuse my jargon. Anyway, when I actually logged on to the domain with my brand new operating system the next day, a new profile had to be created for the domain. Now since there was a folder already with my alias name in “C:\Users” the brand new operating system create a brand new profile with in the format <alias.domain> so now there was a “.” in my profile directory name.

What happens is this “.” sometimes creates problems in installing certain software. I got the error message saying “There is an invalid character in the directory path of My Documents”. I checked the path and could find only one anomaly. And no points (“.”) for guessing what.

So I decided I will rename the profile directory. I straight away went to the directory and though I would rename it to something else. of course it wouldn’t let you. So I thought I would log on as a local administrator and then do it. Also I made sure that I start windows in safe mode.

After Logging on I backup my documents, and delete the profile and assume that the next time I log on, it will automatically create the new directory for me. Guess what… Not that easy…

So after a long research I found out that there are registry entries out of which windows reads the location of the profile directory. So if it doesn’t find the directory at the specified location, it creates a temporary directory and logs you on with a temporary profile. And after the log on is complete, it gives you that message.

So here is what you do to save your life. Please do this only if you have already deleted your profile and did not take backup. If you are doing your research before you have messed with your machine, please skip these steps and refer below.

1. Log on with local administrator account, preferably in safe mode. To boot the machine in safe mode, Click F8 during boot.
2. Click Start + Run and type in regedit and then Enter.
3. Open HKEY_LOCAL_MACHINE
4. Open Software
5. Open Microsoft
6. Open Windows NT
7. Open Current Version
8. Open ProfileList
9. Here you will see keys that belong to each profile. To find your problematic profile navigate to each key and refer to the ProfileImagePath entry on the right hand side.
10. Once you find your problematic profile, just delete the key. This means delete the folder on the left hand side tree view that contains your alias in the ProfileImagePath entry.
11. Restart machine.

There is another way you can actually backup your profile and create a new one.

Click on “Start”, Right click “Computer” and go to “properties”

Click on “Change Settings”

Go to the “Advanced” tab and click on User Profiles “Settings” button

“Change type” will allow you to change your profile type between Roaming and Local Profiles

“Delete” will delete that profile. Including the registry entries and everything.

“Copy To” will back up your profile. It is always advisable to backup your profile from here rather than from anywhere else. Your profile contains more than you can see. Hidden Files, System Files, etc. This takes care of everything in a safe manner.

Hope this helps.

So now your IRepository here has some generic functions :

---

    /// <summary>
    /// Return all instances of type T.
    /// </summary>
    /// <returns></returns>
    IEnumerable<T> All();

    /// <summary>
    /// Return all instances of type T that match the expression exp.
    /// </summary>
    /// <param name="exp"></param>
    /// <returns></returns>
    IEnumerable<T> FindAll(Func<T, bool> exp);

    /// <summary>Returns the single entity matching the expression. Throws an exception if there is not exactly one such entity.</summary>
    /// <param name="exp"></param><returns></returns>
    T Single(Func<T, bool> exp);

    /// <summary>Returns the first element satisfying the condition.</summary>
    /// <param name="exp"></param><returns></returns>
    T First(Func<T, bool> exp);

    /// <summary>
    /// Mark an entity to be deleted when the context is saved.
    /// </summary>
    /// <param name="entity"></param>
    void MarkForDeletion(T entity);

    /// <summary>
    /// Create a new instance of type T.
    /// </summary>
    /// <returns></returns>
    T CreateInstance();

    /// <summary>Persist the data context.</summary>
    void SaveAll();

---

These generic functions, if you notice, does not contain an update function. Now the 2 options that you have that I have talked about, are

Option 1: Do not take care of your updates in the provider. Now this is simple. Do all the updates in the logical layer that calls the data provider. Something like

---

                    Events dbEvent = null;
                    IEnumerable<Events> dbEvents = this.DataProvider.All<Events>(eve => eve.EventID.Equals(communityEvent.EventID));
                    if (dbEvents != null && dbEvents.Count() == 1)
                    {
                        dbEvent = dbEvents.SingleOrDefault();
                    }
                    else
                    {
                        throw new ApplicationException(MADConstants.GENERIC_DATA_ERROR);
                    }
                    dbEvent.DateModified = communityEvent.DateModified;
                    dbEvent.Description = communityEvent.Description;
                    dbEvent.EventEndDate = communityEvent.EventEndDate;
                    dbEvent.EventName = communityEvent.EventName;
                    dbEvent.EventStartDate = communityEvent.EventStartDate;
                    dbEvent.IsApproved = communityEvent.IsApproved;
                    dbEvent.LastModifiedBy = communityEvent.LastModifiedBy;
                    dbEvent.NoOfRatings = communityEvent.NoOfRatings;
                    dbEvent.Organizer = communityEvent.Organizer;
                    dbEvent.ParticipatedBy = communityEvent.ParticipatedBy;
                    dbEvent.RatedBy = communityEvent.RatedBy;
                    dbEvent.Rating = communityEvent.Rating;
                    dbEvent.Sessions = communityEvent.Sessions;
                    this.DataProvider.SaveAllChanges();

---

The second option which i feel is most elegant is this:

---

/// <summary>
        /// Updates
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entityName"></param>
        /// <param name="entity"></param>
        public void Update<T>(string entityName, T entity)
        {           
            this.context.AttachTo(entityName, entity);
        }

---

So all you have to do now is to call the functions like this

---

DataProvider.Update<Customer>(“Customer”, customer);

DataProvider.SaveAllchanges();

---

The third option is a little complex. Please refer to the diagram above, the task repositories that you will implement must contain the update function like this:

public void Update(Customer customer)

{
    context.Attach(customer); //Custom extensor method
    context.SaveChanges();
}

This means you have all your Task Repositories that know the type of your entity. So a CustomerRepository would know that it is handling Customer Types and hence will take Customer as a parameter to the Update Method. This is because Attach method requires an argument that is of type System.Data.Objects.DataClasses.IEntityWithKey. Which means it will not accept type T because this does not have the entity key or the primary key on the basis of which it will know which entity / row to update in the database.

The purpose of the third option is that all interaction with the database that is specific to a particular entity can be handled in the Task Repositories.

The answer is given aptly by Martin Fowler as, “A system with a complex domain model often benefits from a layer, such as the one provided by Data Mapper (165), that isolates domain objects from details of the database access code. In such systems it can be worthwhile to build another layer of abstraction over the mapping layer where query construction code is concentrated. This becomes more important when there are a large number of domain classes or heavy querying. In these cases particularly, adding this layer helps minimize duplicate query logic.

A Repository mediates between the domain and data mapping layers, acting like an in-memory domain object collection. Client objects construct query specifications declaratively and submit them to Repository for satisfaction. Objects can be added to and removed from the Repository, as they can from a simple collection of objects, and the mapping code encapsulated by the Repository will carry out the appropriate operations behind the scenes. Conceptually, a Repository encapsulates the set of objects persisted in a data store and the operations performed over them, providing a more object-oriented view of the persistence layer. Repository also supports the objective of achieving a clean separation and one-way dependency between the domain and data mapping layers.”

This has a no. of benefits. Simplifying complexity, removing redundant querying, making code more testable, etc. Let’s say you want to test your code without going into the database and destroying it completely. unless you use DBUnit, This pattern helps you a lot. All you need to do is change your SaveChanges() function from

---

        /// <summary>
        /// Saves all changes in the current context.
        /// </summary>
        public virtual int SaveAllChanges()
        {
            try
            {
                ((ObjectContext)this.Context).SaveChanges();
                return 0;
            }
            catch
            {
                return -1;
            }
        }

---

to

---

        /// <summary>
        /// Saves all changes in the current context.
        /// </summary>
        public virtual int SaveAllChanges()
        {
                return 0;
        }

---

On doing this, your changes are not populated to the database and you can do all your testing in-memory. Now is it a good idea to change your code to just make it testable? Well that’s a good question that needs discussing at length. Maybe in another post…

How do you design an application that uses Entity Framework as a data access strategy? There are a no. of things to consider. The apparent answer all over the Internet is the Repository Pattern (ref: https://blogs.infosupport.com/blogs/willemm/archive/2008/08/18/Using-ADO.NET-Entity-framework-with-the-repository-pattern.aspx, https://blogs.microsoft.co.il/blogs/kim/archive/2008/11/12/data-access-with-the-entity-framework.aspx, https://www.simonsegal.net/blog/2009/01/13/entity-framework-repository-specifications-and-fetching-strategies/). The purpose of the repository pattern is "A system with a complex domain model often benefits from a layer, such as the one provided by Data Mapper (165), that isolates domain objects from details of the database access code." All said and done, we write the repository to abstract the CRUD from the Application Layer. This way, simply put, we don't need to write separate routines to do CRUD behaviour on every entity type. The functions look something like this:

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Now if you see, we have one function retrieve all types of entity objects. Now let's get to the actual topic in hand. Eager loading and lazy loading. I cannot opt for any of the mentioned patterns, because I do not have the type of the pattern that I am going to return at design time. I have already postponed that by using Generics. Just last night I learnt from Daniel Simmons that Framework 4.0 they are planning to add a property to Context object in order to opt in implicit lazy loading.

While I am still trying to figure out a good way of working around eager loading and lazy loading, as of now (before 4.0 arrives) I am firing separate queries to get all types of related objects. And interestingly, once I fire the queries for the related objects and enumerate them, the principal object at hand gets populated with related objects. So next time you want to reference the related objects, just go ahead and use the beautiful sentence completion features such as this: "txtAddressLine1.Text = employee.EmployeeAddress.First().Address.AddressLine1;"