My last communique has always been quite important for me in all my previous organizations. And I had thought that I would say something profound in my last email when I leave. But I could not think of anything and so no email. I still can't think of anything that would be super interesting so I guess I will keep it simple 

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 http://www.dasboard.in/nilotpal.

This evening I heard someone say that Left Outer Joins are not possible in Entity Framework or perhaps Left Outer Joins are possible, but they bring in all the data and then filter out the right table.

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.

This is not a problem that I feel you would encounter on a regular basis. I think I had a unique problem because of which I encountered this one. When you install an operating system it allows you to create a profile. Now I installed the machine at home. Which means I was not on the corpnet of Microsoft which means I could not log on to the domain. So when I created a profile named after my alias, it was considered as a local profile and not a domain profile. And a folder was created under “C:\Users” with my alias name.

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.

Look around the web. You will find no Update method in the repository patterns for entity framework implementations published. There are different flavors of retrieves, mark for insertions an deletions but no update implementation. And curiously this is the most painful. There are 2 options that you have. But to explain both, I will start off with the repository design. We can get into a discussion about the pattern in case anyone is interested, all you have to do is instigate me by posting a comment.

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.

Why do Entity Framework Function Imports do not have eager loading? Because when you use Entity SQL or regular Object context to retrieve data, it is a live connection. So whenever you say eager loading enabled, it gets the data from the database using the live connection. But if you want to do it using Function Import, EF doesn’t know where to get the data from, since the stored procedure that the function import maps to, doesn’t get that data. Perhaps in the later versions of EF, the team might add the feature which can mix and match the object context and the stored procedure to get the required data. But as of now it is not possible.

So you are serious about your code quality huh... well StyleCop is a fantastic tool to ensure that. The best part is, it integrates with Studio 2008. It is simple.

1. Go to This Location, click on downloads and download the latest version of StyleCop. As of now it is the version 4.3
2. Install StyleCop. It asks you information about integration. Let it integrate with Studio for the moment.
3. Fire up Visual Studio
4. Click on Tools and say Run StyleCop and look at the 1001 warnings that StyleCop gives.

Now when you use StyleCop, most of the warnings are not what you really want to work upon. Like Documentation, for instance, who cares whether there is a blank space line above a comment or not...? So you can go to Solutions Explorer and click on Style Cop Settings. This will bring up the "Microsoft StyleCop Project Settings" Dialogue box which will allow you to customize your rules set. Allow you to enable / disable rules as per your own special requirements / whims / fancies / moods... :)

It is a fun little tool and I could have written more about it but then I decided that I won't spoil the fun. You guys go ahead and explore.

So what's this new buzz word... everyone has been talking about it...

Essentially what we are doing is taking our applications and putting them in a cloud. Cloud meaning highly available servers which are provided by huge service providers such as Microsoft, Amazon, etc. Now since I strongly believe that it is business that drives technology, it is the business side that we need to understand first. why do we need it. I have my servers in house, I deploy my apps on my servers, I control and maintain them then why would I want it to be on servers that others control? It is like the analogy that my valuables are in my house, how can it be a better idea to go and put them somewhere else. Well the answer to that question is another question. Do you put all your money under your mattress in your house? Or is it a better idea to go and put them in the bank?

There are many benefits in building the applications from the cloud. Let's take cost for example. The cost of hosting an application on the cloud is just a fraction of what you will have to incur in deploying the application on one of your in-house servers. Along with it comes the maintenance cost. Employing people to maintain the Servers, business continuity planning, and so on and so forth. The list goes on. The Cloud providers on the other hand can provide you all the same services at a fraction of the cost. They work on much much larger scales. So it makes sense for them too.

Another interesting perspective is that, let's say you are an application vendor. You go and talk to a customer to sell your app. Let's say you convince the customer in buying the app. That means you have convinced one person. The person who takes the decisions. Let's say he consults a team before he takes the decision. Even in that case you have convinced that team. And most usually, the people who make the decisions are not the people who end up using your app. And there is no way for them, yet, to find out whether or not the app is good enough for them in their context. So then you go ahead and deploy the app and then start using it. Then the users, find out how much the application was worth in their context and they may or may not like it. Although this is the model we have been working on all these years, it doesn't look like a very effective model does it?

Let's change the scenario. Same application vendor, but this time, he has his application as a software as a service, deployed on the cloud. He just has to go and say, "Well you don't have to guess, I don't have to convince you. Why don't you use the application yourself for a few days and find out?" The users use the app, they like it fine; if they don't, well they don't have to buy it. And of course there is the "pay as you go" model in Software as a service. Just stop paying when you stop using the software.

And the best part is you don't have to go fight it out with your IT for deployment. It's all there in the cloud...!!

I am working on this really smart, smart client application installer. Which smartly installs other pieces of another smart client application as and when required.

It makes sure that only those bits are downloaded that are not already installed. So it takes care of upgrades on its own. So basically we are writing our own "ClickOnce" functionality.

Why are we not using ClickOnce out of the box? Well that would require another post, but let's say we require much more granularity than what "ClickOnce" provides us, on this "Installation Manager", and put it at that.

Anyways, I am doing some book keeping using SQL Server CE on the client machine to maintain account of upgrades and installations. For this I am querying the SQL Server CE database and in the process and I encounter an error that says:

"The ntext and image data types cannot be used in WHERE, HAVING, GROUP BY, ON, or IN clauses, except when these data types are used with the LIKE or IS NULL predicates."

I am not even working on ntext data type. The select query goes something like this:

IQueryable <FileInfo> files = entities.FileInfo.Where(fileInfo => fileInfo.FileName.Equals(fileName));

And "FileName" is not an ntext datatype in the entity "fileInfo". It is an nvarchar.

Interestingly, if you fire the same query on the Management Studio (SQL Version of the query of course), it works fine. It only breaks when you use LINQ to SQL or EF.

After a little research I find out that there is a bug in SQL Server 3.5 RTM which was incidentally not resolved even in the "SQL Server Compact 3.5 SP1 English". And later there was an out of the bag release that was made to resolve this issue. So the Hotfix, cannot be installed directly. You need to uninstall "Microsoft SQL Server Compact 3.5 SP1 English" from Add Remove Programs before you install this hotfix.

Once the Hotfix is installed, your query will just work...!

In case if you are wondering whether you need to re-install "Microsoft SQL Server Compact 3.5 SP1 English"? Well, installing it back will remove the hotfix. So DO NOT DO THAT.