.Net 2.0-3.5

Using XML to perform database operations rather than parameterized query?

Bigyan Rajbhandari — Sun, 24 Aug 2008 18:55:16 GMT

There's no doubt that today xml is becoming more and more prevalent as platform-independent data format. Starting SQL server 2005, Microsoft also added tons of support for xml and a new native data type XML, since then I have started to see lots of applications that utilize this data type to run very complex solutions. A new trend is starting to emerge, as one of my colleagues calls it a "paradigm shift", where applications use xml serialized objects (that map to tables) to perform inserts/updates to table rather than having to pass each parameter independently. However, the question remains if this approach is necessarily better than previous?

For example consider the following scenario:
In middle-Tier (.Net Code) my object looks like the following

My serialized xml looks like below:
<Customer customerID="12" customerName="Bigyan" address="123 Redmond Way" phone="123-123-3434"/>

And my call to database stored proc like:
exec Customer_UpdateInformation @customerXml

In parameterized query I would have done something like this:
exec Customer_UpdateInformation @customerID, @customerName, @addresss, @phone

There are both pros and cons to this approach, which I'll explain next. But I also want to clarify that I am NOT advocating one approach vs other, but actually want your opinion on this approach.

Pros:

Instead of passing 4 parameters, I need to pass only 1. Thus my signature for the database contract is much more succinct.
If I need to add or modify field, I have less code to deal with and do NOT need to change my signature
If I am just performing updates on certain fields (not all), I might be able to pass only updated fields and reduce my message size
Serialization and Deserialization on my .Net objects can be automated, thus reducing effort to map those fields with database fields.
If I wanted to perform bulk updates, then I have ability to pass multiple elements in my xml; this greatly reduces chatting between .Net and Sql Server.

Cons:

First and foremost, I'll lose type safety on the parameters passed.
Xml parsing is little expensive (not a whole lot), compared to primitive data types. Bulk process might make up ground in this area.
Data contract I am exposing through the stored procedure is not self explanatory. Just looking at the parameter, no one will know what to pass.

Best practice and effective way of using DataContext in Linq to SQL?

Bigyan Rajbhandari — Wed, 19 Mar 2008 01:51:33 GMT

NOTE: See my follow up post here for more info.

At work, Jeff and I have been throwing around ideas to find a best way to implement DataContext in Linq so that we can integrate it into the base class in our framework while achieving following goals.

Implementation should be easy and non-redundant, so that we do not need to do new DataContext(), every time we have to use one.
Portability of the DataContext should be such that we do not need to pass it around as parameters from one tier to another.
"Unit of work" pattern should be well represented and "very" transparent.
Context should not be persisted without intent, or be open to manipulation from other methods, such that "unit of work" is compromised or a transaction is ill-represented

These seem like simple goals given the features and flexibility of LINQ, however, in reality this has become much more difficult and annoying to achieve than we previously thought. Here are several ideas we have been kicking around, and problem it presents. I would like to hear from people who have effectively used LINQ Datacontext in these scenarios or in a pattern that's most effective.

1. Creating and disposing LINQ as required.

DbDataContext myContext = new DbDataContext();

//your code goes here

myContext.SubmitChanges();

Problems with this pattern:

Creating datacontext everytime we need to use is cumbersome and in my opinion just verbose.
If you have to use datacontext in any of the method this code calls, you'll have to pass the datacontext with it. This is one- too many parameters to pass around

2. Creating a static DataContext and using it throughout the application.

DataLayer.DataContext.Current

Problems with this pattern:

Creating static object isn't always a good thing. In this case, the context is available for manipulation at any level. And unit of work quickly becomes very hard to maintain
If manipulated by other threads or methods context isn't clean anymore and cannot be trusted

3. Ambient DataContext (Currently using this)

The idea behind ambient datacontext is that context is created for a particular thread or a httpcontext(in asp.net) as soon as there is a first call for the DataContext. Then the same context is used for that thread or request unless it is disposed manually. This is done by storing the context in the request/thread data store. The approach to this pattern is similar to static DataContext, however, separation is provided for each thread and requests. This works really well in Asp.Net, however, is again plagued by some of the problems of static context.

Problems with this pattern:

The context is available for manipulation at any level. And quickly becomes very hard to maintain unit of work
Portability across thread is very hard
Unit of work pattern is not transparent enough

4. Finally, the last idea we've been trying to come up with is concept similar to TransactionScope.

In this pattern, you would used using{ } block to initialize your context and represent a "Datacontext Scope". Any method below that will automatically be able to figure out the proper context, through thread/request datastore. Then just before the dispose happens, you manually call the SubmitChanges() method. This is the one I like so far, however, has few practical problems.

Problems with this pattern:

If sub method needs to implement a new context, we need to figure out how to exclude it from the parent context's using block. If allowing multiple contexts in multiple using blocks, how do you determine which context to use in sub-sub methods?

Please do comment on what you think is the best approach to solving this problem.

Useful Utility functions in .Net a.k.a ‘Hidden Treasures’

Bigyan Rajbhandari — Wed, 17 Oct 2007 23:03:21 GMT

It's no secret that Microsoft's is releasing the source for some of its core .Net classes in upcoming visual studio 2008. Before that arrives, the option to look at some of core classes is probably the .Net Reflector. Every now and then, when I want to find out how Microsoft implemented some of the functionalities in core classes, or if I want to learn better way to program, I use the reflector to dig through the core components. During these adventures, I have bumped into various classes and functions, that I thought were just too cool, and also unfortunate that most were internal only. One of my favorites is the VirtualPath class. However, during this quest I have also found that in some way or other the framework team did expose some great utility functions. Most developers aren't aware of this, including myself and make the mistake of rewriting it. Thus, here's a shot at exposing some of the cool Utility Classes and Functions (I have been using) that every .Net developer should know. (I hope to keep adding to this list, if anyone has other suggestions please feel free to add.)

ASP.NET
System.Web.HttpUtility System.Web.HttpServerUtility	Provides helper methods for processing web requests like HTMLEncode, UrlEncode, HTMLDecode Accessible through 'Server' object in asp.net
System.Web.VirtualPathUtility	Provides utility methods for common virtual path operations. Members: GetDirectory(), GetExtension()
System.Web.Compilation.BuildManager .CreateInstanceFromVirtualPath()	One of my favorites, allows you to create instance of pages/controls just by passing a virtual path.
System.Web.Security.UrlAuthorizationModule .CheckUrlAccessForPrincipal()	Another great utility in asp.net that allows you to check permission on the file even before you use it. Usage? ex: loading sitemap based on the permission set on each file rather than specifying roles in the node.
System.Web.Hosting.HostingEnvironment	Various methods/properties related to hostingenvironment
System.Web.Hosting.HostingEnvironment .VirtualPathProvider	Retrieves virtual path provider for the application

.NET
System.IO.Path	Provides helper methods for file/directory strings Members: ChangeExtension(), GetFileName, Combine…
Int? DateTime?	These are nullable classes of primitive types.
Int.TryParse	Equivalent to IsNumeric() function in VB.

NOTE: There are tons of other classes & static functions in .NET, it's a best practice to use those. If you can't find one exposed but is internal/private, I would suggest creating one similar to it.

Using MailDefinition object to send templated emails in ASP.Net 2.0

Bigyan Rajbhandari — Wed, 26 Jul 2006 03:26:00 GMT

Sending emails using Asp.Net has never been as easier and manageable than with introduction of System.Net.Mail in ASP.Net 2.0. Though it always has been relatively easy to create a MailMessage and send it through SMTP, I have seen myself and lots of other developers struggle with decisions like if one should create the body for the message in code, put it in config file/database/ flat file. Depending on the project requirement and developer’s intuition, text could go anywhere. And time required to put something together were comparable.

One of my favorite choices is putting the template in a text file. Later, merging it with custom fields during runtime.

Ex: Template.txt

This code was generated at <%DATETIME%> from <%WEBSITE%>

Ex: Code Substitution

This code was generated at 12:45:00 PM from DOTNETLOG.com

This method decouples the message from code and is easier to manager, however, in .Net 1.1 this meant writing code to open file and also writing the substitution method. In 2.0, System.Web.UI.WebControls.MailDefinition object makes life a lot easier. Below is an example where I use MailDefinition and ListDictionary substitution collection to dynamically generate the mail message. This gives me flexibility, if I want to change the template later on.

using

System.Web.UI.WebControls;
using System.Mail.Net;
using System.Collections.Specialized;

//----------------------------------------------

//Create MailDefinition
MailDefinition md = new MailDefinition();

//specify the location of template
md.BodyFileName = @"c:\template.txt";//Build replacement collection to replace fields in template
ListDictionary replacements = new System.Collections.Specialized.ListDictionary();
replacements.Add("<%DATETIME%>", DateTime.Now.ToShortDateString());
replacements.Add("<%WEBSITE%>", "DOTNETLOG.com");//now create mail message using the mail definition object

// the CreateMailMessage object takes a source control object as the last parameter, if the object you are working with is webcontrol then you can just pass "this", otherwise create a dummy control as below.

MailMessage msg = md.CreateMailMessage(emailTo, replacements,

msg.Subject =

msg.From =

new System.Web.UI.WebControls.Panel());"Test Message";
msg.To = "test@dotnetlog.com";"admin@dotnetlog.com";//this uses SmtpClient in 2.0 to send email, this can be configured in web.config file. See example

SmtpClient smtp =

Ex: Web.Config

system.net>
   <mailSettings>
      <smtp deliveryMethod=" Network" from="admin@dotnetlog.com">
         <network host=" mail.dotnetlog.com" port= "25" userName="test" password= "test"/>
      </smtp>
   </mailSettings>
</system.net>new SmtpClient();
smtp.Send(msg);