.NET Tip of The Day.org

How to respond with code 404 (Not Found) in ASP.NET

Tue, 26 Aug 2008 20:46:47 GMT

Suppose you configured custom 404 page in web.config file in the customErrors section. So whenever user requests non-existent aspx page, ASP.NET run-time returns well formatted message to the user.

Also you have a page that shows articles from a database according to article ID passed in the url (for example: article.aspx?id=345). But if user passes article ID that doesn't exists the page must return code 404 (Not Found) and show the custom 404 page like in the previous situation.

Fortunately you don't need to parse the customErrors section to get name of the custom 404 page. Just throw HttpException:

    throw new HttpException(404, "Article not found");

ASP.NET run-time will catch the exception and will redirect to the custom 404.

Code snippets for some common operations with exceptions

Mon, 19 May 2008 08:47:41 GMT

Download and install these additional code snippets for common operations with exceptions. To use them type shortcut for the code snippet that you want to add to your code and then type Tab, Tab to invoke it.

thr - throw new
thrni - throw new NotImplementedException("");

Send an e-mail any time an unhandled exception occurs

Sat, 10 May 2008 14:06:58 GMT

Consider using built-in ASP.NET health monitoring to monitor your website. Especially if you are not monitoring it at all yet. ASP.NET health monitoring contains ready-to-use Web health-monitoring events classes (Web events) and health-monitoring providers (listeners). For example, you can easily configure it to send an email any time an error is detected.

News: .NET Tips & Tricks Community RSS

Sat, 10 May 2008 15:57:00 GMT

Those who prefer reading this site through RSS now can also subscribe for updates to .NET Tips & Tricks Community.

News: Why does new tips appear on this site so infrequently?

Thu, 08 May 2008 00:48:00 GMT

Hi guys. I know some of you are not satisfied with the frequency new tips appear on this site. The last comment I received was a proposal to rename the site to .NET Tip of The Month :) But I don't want to do this because I'm going to fix this problem. I'm working on the .NET Tips & Tricks Community section now. My tips that are too small to hit the front page were added to this section. It's the place where all of you can share your .NET tips and tricks.

It's clear that this section lacks for some features. And if anyone out of 2510 subscribers has a proposal, just drop me a line. My email is kostya.ly@gmail.com.

Thanks for you patience.
Kostya Ly

Turn off Session State if you're not using it

Thu, 01 May 2008 23:51:00 GMT

Since ASP.NET Session State is on by default, you pay the cost in memory even if you don't use it. If you're not using Session State, turn it off and save yourself the overhead. There are serveral ways to do this:

If you're not using Session State at all, turn it off completely via web.config file:

<system.web>

<sessionState mode="Off"></sessionState>

...
If you're using Session State, but it's required only for a few pages, then first turn it off for all pages:

<system.web>

<pages enableSessionState="false">

...

then enable it for a specific page:

<%@ Page ... EnableSessionState="true" %>

P.S. obviously such optimization makes sense only for high-traffic web sites.

How to debug Windows Service startup

Wed, 16 Apr 2008 22:05:00 GMT

Actually you can use this trick every time when:

You want to debug a process startup.
You can't run the process by hitting F5 in Visual Studio (for example, Windows Service).

So the problem is that you can't simply attach the Visual Studio debugger to the process as there isn't one to attach to until after you start the process. However, once you start the process if you have a bug such as an exception in the process's initialization you won't get the debugger attached to the process before it's too late.

Calling Debugger.Launch() or Debugger.Break() in your code allow you to debug such problems. This methods pop up the following screen asking you which instance of the debugger it should use to debug the application.

How to change HTML markup produced by ASP.NET controls

Wed, 09 Apr 2008 13:07:00 GMT

There are at least two ways of changing HTML markup produced by standard ASP.NET controls. The most obvious one is to derive a new class based on an existing ASP.NET control class and override the necessary rendering methods.

Another option that is worth considering is to write a small control adapter for the existing ASP.NET control. This is a little chunk of logic that you add to your web site to effectively "adapt" an ASP.NET control to render the HTML you prefer. This approach has the following two major advantages over custom controls:

You don't need to add the @Register directives to your pages.
The ASP.NET framework comes with a built-in means to apply the adapters to just certain browsers. When you build entirely new custom controls you have to write your own logic to handle browser detection to vary the response.

For example you can use ASP.NET 2.0 CSS Friendly Control Adapters package to generate CSS friendly markup from some of the more commonly used ASP.NET controls.

Label to a form input field

Tue, 01 Apr 2008 23:15:00 GMT

If you set a label to a form element set the AssociatedControlID property. This will force the label to render as <label> rather than <span>. A benefit of using the AssociatedControlID property is that clicking a label when this property is set automatically changes the form focus to the associated form input.

News: .NET Tips & Tricks Community (ALPHA)

Mon, 24 Mar 2008 00:16:00 GMT

Some of you have used "Add a tip" function and submitted one or more tips. Some of these tips are pretty interesting and I publish them on this site. But for someone other submitted tips could be interesting as well. So, from now on, everybody can check out all tips submitted by the visitors of the site in a new section - .NET Tips & Tricks Community (ALPHA). In fact this is not a real community yet (that's why you can see ALPHA in it's name). I'll add some common features soon. Let's see how it goes.

Add Windows Explorer to your Visual Studio tools menu

Mon, 17 Mar 2008 18:15:00 GMT

I often need to open Windows Explorer and browse to the current file, folder, or project that I am working on in Visual Studio. This tip allows you to achieve this by clicking "Windows Explorer" in the Tools menu, and is one of the most simple-yet-useful tips I know of.

To set it up, click Tools, then External Tools..., then click Add. Now enter the following data:
Title: Windows Explorer
Command: explorer.exe
Arguments: /select,"$(ItemPath)"

Leave Initial directoy blank, and click OK. Now when you click Tools, Windows Explorer, Windows Explorer will open with the current file you are editing selected.

submitted by Daniel Flower

Correct event invocation

Sat, 01 Mar 2008 18:18:00 GMT

Be aware that if there are no subscribers a .NET event will be null. Therefore when raising the event from C# test it for null first.

    public event EventHandler SelectedNodeChanged;
 
    protected virtual void OnSelectedNodeChanged(object sender, EventArgs e)
    {
        //Event will be null if there are no subscribers
        if (SelectedNodeChanged != null)
        {
            SelectedNodeChanged(this, e);
        }
    }

However in multithreaded application the last subscriber can unsubscribe immediately after the null check and before the event is raised. To avoid a null reference exception make a temporary copy of the event.

    public event EventHandler SelectedNodeChanged;
 
    protected virtual void OnSelectedNodeChanged(object sender, EventArgs e)
    {
        //Make a temporary copy of the event to avoid possibility of
        //a race condition if the last subscriber unsubscribes
        //immediately after the null check and before the event is raised.
        EventHandler handler = SelectedNodeChanged;
 
        //Event will be null if there are no subscribers
        if (handler != null)
        {
            handler(this, e);
        }
    }

submitted by Sergey P.

How to view code that is covered by the IntelliSense pop-up

Fri, 22 Feb 2008 12:56:00 GMT

When working in Visual Studio 2008 and the IntelliSense pop-up is visible, but you would like to view the code that is covered by it, press and hold the Ctrl key, and the pop-up becomes transparent so that you can view the code that is below the pop-up.

When returning DataReader from a function, specify CommandBehavior.CloseConnection

Sat, 16 Feb 2008 15:30:00 GMT

When you create an ADO.NET DataReader object, specify the CommandBehavior.CloseConnection enumeration in your call to ExecuteReader. This ensures that when you close the DataReader, the SQL connection is also closed. This is especially helpful when you return a DataReader from a function, and you do not have control over the calling code. If the caller forgets to close the connection but closes the reader, both are closed when the DataReader is created by using CommandBehavior.CloseConnection. This is shown in the following code fragment.

    public SqlDataReader CustomerRead(int CustomerID)
    {
        //... create connection and command, open connection
        return myCommand.ExecuteReader(CommandBehavior.CloseConnection);
    }
 
    //... client code
    SqlDataReader myReader = CustomerRead(10248);
    //... read some data
    myReader.Close(); // reader and connection are closed

Use explicit casting instead of DataBinder.Eval

Tue, 12 Feb 2008 21:42:00 GMT

The DataBinder.Eval method uses .NET reflection to evaluate the arguments that are passed in and to return the results. Consider limiting the use of DataBinder.Eval during data binding operations in order to improve ASP.NET page performance.

Consider the following ItemTemplate element within a Repeater control using DataBinder.Eval:

   <ItemTemplate>
       <tr>
           <td><%# DataBinder.Eval(Container.DataItem, "field1") %></td>
           <td><%# DataBinder.Eval(Container.DataItem, "field2") %></td>
       </tr>
   </ItemTemplate>

Using explicit casting offers better performance by avoiding the cost of .NET reflection. Cast the Container.DataItem as a DataRowView:

   <ItemTemplate>
       <tr>
           <td><%# ((DataRowView)Container.DataItem)["field1"] %></td>
           <td><%# ((DataRowView)Container.DataItem)["field2"] %></td>
       </tr>
   </ItemTemplate>

Consider using weak references for your custom caching solutions

Wed, 06 Feb 2008 21:51:00 GMT

Consider using weak references when you implement a custom caching solution, so that cached objects can be released by garbage collection when there is memory pressure. You should use weak references mostly for objects that are not small in size because the weak referencing itself involves some overhead. They are suitable for medium to large-sized objects stored in a collection.

Automatically insert attribute value quotes

Mon, 04 Feb 2008 20:50:00 GMT

Visual Studio HTML/ASPX editor can save you some time if you enable option Tools | Options... | Text Editor | HTML | Format | Insert attribute value quotes when typing. When this option is enabled, once you type a name of an attribute and following "=" symbol, Visual Studio automatically inserts a pair of quotes and invokes IntelliSense menu. After that you need only to select an attribute value from the menu and hit the Enter button. It's another nice timesaver.

Correct using of ASP.NET Cache

Wed, 30 Jan 2008 16:20:00 GMT

Often in ASP.NET application we see a code which looks like this one:

    if (Cache["SomeData"] != null)
    {
        string name = ((SomeClass)Cache["SomeData"]).Name;
        //.....
    }

This code is not safe enough and the second statement can generate a NullReferenceException sometimes. There is no guaranttee that a cached object will stay in the cache between two calls. After the first call it can be deleted either by garbage collector or by another thread to refresh cached data.

So to overcome this problem rewrite the code using as operator:

    SomeClass someClass = Cache["SomeData"] as SomeClass;
    if (someClass != null)
    {
        string name = someClass.Name;
        //.....
    }

via Dmytro Shteflyuk

Treat .NET Threads as a shared resource

Tue, 22 Jan 2008 01:21:00 GMT

Do not create .NET threads on a per-request basis because this can severely impact scalability. Creating new threads is also a fairly expensive operation that should be minimized. Treat threads as a shared resource and use the optimized .NET thread pool.

How to create fully qualified URLs

Fri, 18 Jan 2008 13:47:00 GMT

With ASP.NET it's quite easy to get absolute path to a page by calling the VirtualPathUtility.ToAbsolute method. Getting absolute URL is not that obvious but still quite easy. Just combine request url with absolute path to your ASP.NET page:

string absolutePath = VirtualPathUtility.ToAbsolute("http://dotnettipoftheday.org/test/MyWebForm.aspx");
Uri newUri = new Uri(Request.Url, absolutePath);

COALESCE function instead of long CASE WHEN ... ELSE (T-SQL)

Tue, 15 Jan 2008 22:00:00 GMT

Instead of using long "SELECT ... CASE WHEN ... ELSE ..." construction, you can use the COALESCE function when you need to find a value that is not NULL. Lets review the following T-SQL expression, in which we need to select an available "source":

SELECT TheSource =
   CASE
      WHEN localSource IS NOT NULL THEN localSource
      WHEN intranetSource IS NOT NULL THEN intranetSource
      WHEN internetSource IS NOT NULL THEN internetSource
      ELSE ''
   END
FROM ...

Now lets rewrite the code above using COALESCE function:

SELECT TheSource =
   COALESCE(localSource, intranetSource, internetSource, '')
FROM ...

The tip applies to MS SQL Server 2000/2005.

Cut a line into memory

Sun, 13 Jan 2008 12:13:00 GMT

While in Visual Studio.NET source code editor, press Ctrl+L to cut a line of code into memory. This is an easy way to move lines around your pages, or delete a set of lines quickly. Simple, yet useful!

submitted by Grant Merwitz, The X-Box Lounge

How to check email works without using SMTP

Tue, 08 Jan 2008 22:15:00 GMT

Testing code that sends email has always been a pain. You had to set up a SMTP service just to test that your .NET application sends the e-mail correctly.

However, there is a way to send e-mails with no SMTP server set up. Just configure your .NET application to drop e-mails into a specified folder instead of sending them via SMTP server:

<system.net>
   <mailSettings>
      <smtp deliveryMethod="SpecifiedPickupDirectory">
         <specifiedPickupDirectory pickupDirectoryLocation="c:\Test\" />
      </smtp>
   </mailSettings>
</system.net>

This will instruct SmtpClient class to generate mail message, save it as .eml file and drop it into c:\Test\ folder.

A simple method to validate an integer, double, date, and currency values entered into a textbox on ASP.NET page

Sat, 05 Jan 2008 23:59:00 GMT

Normally the CompareValidator is used to check one value against another on ASP.NET page. However it also can be used to ensure user has entered data in a correct format.

Here's how it works:

Set the ControlToValidate property to the ID of the TextBox.
Set the Operator property to DataTypeCheck.
Assign a ValidationDataType enumeration member to the Type property, which includes String, Integer, Double, Date, and Currency.

Note: this method is culturally sensitive. This means that if you change your browsers settings to en-UK, a date of 1-28-01 correctly fires the validator, while 28-1-01 is allowed through. This is because the date format is day-month-year in that region.

What is the difference between UriBuilder.ToString and UriBuilder.Uri.ToString

Wed, 26 Dec 2007 23:30:00 GMT

UriBuilder.ToString - the resulting string always contains Port, even if it is the default port for the Scheme. For example - http://localhost:80/tips.
UriBuilder.Uri.ToString - the resulting string only contains the port if it is not the default port for the scheme. For example - http://localhost/tips.

Therefore, in most of the cases UriBuilder.Uri.ToString should be used to omit redundant port specification.

Visual Studio Bookmarks

Fri, 21 Dec 2007 17:01:00 GMT

Bookmarks can be used to mark places in the code, like the code that you might want to jump back and forward. Bookmarks can be related to task list shortcuts, kind of the same functinality.

The bookmarks can be setup very easy, by pressing Ctrl+K, Ctrl+K to leave bookmark.

For navigation, you can press Ctrl+K, Ctrl+N to move to the next bookmark, or Ctrl+K, CTRL+P for the previous bookmark. It's easy, just try it now.

Generating compiler warnings for calls to an obsolete methods

Sat, 15 Dec 2007 01:17:00 GMT

Throughout the product development cycle, occasionally certain methods become obsolete. If you can't modify those methods, will need to write another implementation of the method using a slightly different name or signature. To maintain compatibility, you do not want to remove the old method and break your code. This is where the .NET Obsolete attribute comes in handy:

    [Obsolete("Use the new LogRequestEx instead.")]
    public static void LogRequest(string feedUrl, string referer)
    {
        ...

Setting the Obsolete attribute as above makes a warning message appear in the Visual Studio's Error List stating that the particular call to a method is obsolete. The warning message also includes your personalized message that you pass as the attribute's argument (such as, "Use the new LogRequestEx instead").

Big solutions can be organized using Solution Folders

Fri, 07 Dec 2007 19:55:00 GMT

Here is an example of a big Visual Studio.NET solution that contains numerous projects:

Such a big Visual Studio.NET solutions can be organized by grouping related projects into folders. Just right-click on the solution node and choose Add | New Solution Folder to add a Solution Folder. Then just Drag'n'Drop projects into this folder.

This also will allow you to do some operations on a group of projects. For example, unload all projects in a Solution Folder, collapse or hide entire Solution Folder so that you can work easily in Solution Explorer in Visual Studio.NET.

How to change the default view for Web pages and WinForms in Visual Studio

Wed, 05 Dec 2007 17:20:00 GMT

By default Visual Studio.NET initially displays Web pages and WinForms in a Design view. But if you prefer Source view, you can set it to be the default view.

For Web pages:

Go to Tools | Options... | HTML Designer and select Source View.
Click OK button.

For WinForms:

Right-click on a WinForm in the Solution Explorer and then click Open With.... Open With dialog opens.
Choose CSharp Editor in the list and then click Set as Default button.
Click OK button.

Use DebuggerBrowsable attribute to clean up class view in a debugger

Sun, 02 Dec 2007 23:11:00 GMT

The DebuggerBrowsable attribute determines if and how a field or property is displayed in the debugger variable windows. Let's review the following code example:

    public class VehicleSeries
    {
        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
 
        private List<string> _vehicles = new List<string>();
        public List<string> Vehicles
        {
            get { return _vehicles; }
            set { _vehicles = value; }
        }
    }

The resulting display within the debugger is shown below:

Now lets remove duplicate information and show constituent vehicles by adding a few DebuggerBrowsable attributes:

    public class VehicleSeries
    {
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
 
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private List<string> _vehicles = new List<string>();
        [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
        public List<string> Vehicles
        {
            get { return _vehicles; }
            set { _vehicles = value; }
        }
    }

This results in the following view in the debugger:

P.S. Also take a look at a tip "Use DebuggerDisplay attribute for a better debugger experience".

What is the difference between URL and URI?

Fri, 23 Nov 2007 21:46:00 GMT

A URL is the address of some resource on the web, which means that normally you type the address into a browser and you get something back. There are other type of resources than web pages, but that's the easiest conceptually. The browser goes out somewhere on the internet and accesses something.

A URI is just a unique string that uniquely identifies something, commonly a namespace. Sometimes they look like a URL that you could type into the address bar of your web browser, but it doesn't have to point to any physical resource on the web.

URI is the more generic term, and a URL is a particular type of URI in that a URL has to uniquely identify some resource on the web.

via Fedia.net

Don't generate unnecessary WinForm members for Label controls

Wed, 21 Nov 2007 20:54:00 GMT

To get rid of some auto-generated form level fields that point to a control that will never be referenced (for example, labels, panels, etc.), do the following:

In the Windows Forms Designer, select a control.
Set GenerateMember property for this control to false.

As a result a member of the form will not be generated for this control. It saves you 4 bytes per member and more importantly removes "clutter" from IntelliSense and any diagrams you autogenerate.

Simplify the usability of your generic methods with type parameter inference

Tue, 20 Nov 2007 17:54:00 GMT

When the parameter signature of a generic method includes a parameter that is of the same type as the type parameter for the method, it's not necessary to specify the type parameter when calling the method. Let's review an example:

    public class Class1
    {
        //both method type argument and parameter are of the same type
        public void SomeGenericMethod<T>(T sameAsTypeParameter)
        {
            ...
        }
    }
 
    public class Test
    {
        static void Main()
        {
            Class1 obj = new Class1();
            //It's not necessary to specify method type parameter
            //Instead of obj.SomeGenericMethod<int>(100) use
            obj.SomeGenericMethod(100);
        }
    }

As you can see in the example above, the syntax for calling generic method is identical to syntax of calling non-generic method. This ability is called generic type inference. To enable inference, the parameter signature of a generic method must include a parameter that is of the same type as the type parameter for the method.

Note: the compiler cannot infer the type based on the type of the returned value alone.

Two approaches to update database row if exists, insert if not

Sat, 17 Nov 2007 23:00:00 GMT

The biggest challenge with update/insert (so called upsert) is to minimize any kind of locks. Unfortunately there is no silver bullet for this yet. So let's review two the most commonly used methods:

1. Update, if @@ROWCOUNT = 0 then insert

    UPDATE Table1 SET Column1 = @newValue WHERE Id = @id
    IF @@ROWCOUNT = 0
    BEGIN
       INSERT INTO Table1 (Id, Column1) VALUES (@id, @newValue)
    END

This method is good if you know that in most of the cases a row will exist and update will be performed. Otherwise the second method should be used.

2. If row exists update, otherwise insert

    IF EXISTS(SELECT * FROM Table1 WHERE Id = @id)
    BEGIN
       UPDATE Table1 SET Column1 = @newValue WHERE Id = @id
    END
    ELSE
    BEGIN
       INSERT INTO Table1 (Id, Column1) VALUES (@id, @newValue)
    END

This one is good if you know that in most of the cases a row will not exist and insert will be performed. For such cases it executes SELECT statement followed by INSERT statement. That results in less expensive lock comparing to UPDATE + INSERT in previous method.

P.S. both methods should be used in transaction with isolation level Serializable.

Improve your code readability: make more sense to conditions

Thu, 15 Nov 2007 21:48:00 GMT

Instead of:

    if (!string.IsNullOrEmpty(state) && state.Length == 2)
    {
        ...
    }

do this:

    bool stateIsValid = !string.IsNullOrEmpty(state) && state.Length == 2;
    if (stateIsValid)
    {
        ...
    }

Speed up inserting records into database with SqlBulkCopy class

Wed, 14 Nov 2007 15:46:00 GMT

When you need to insert a great deal of rows into database (for example, when importing data from a flat file or when importing data from one database into another one), and you need to do it programmatically because it needs to be pre-processed on the fly, then you should use SqlBulkCopy class.

The class uses Tabular Data Stream for fast transmitting data from client to a database server (therefore you'll see a bunch of "strange" INSERT BULK statements in a SQL Profiler):

    DataTable dataTable = new DataTable();
    ...
 
    using (SqlBulkCopy bulkCopy = new SqlBulkCopy(connection))
    {
        bulkCopy.DestinationTableName = "dbo.DestinationTale";
        bulkCopy.WriteToServer(dataTable);
    }

Also try different values for SqlBulkCopy.BatchSize to adjust performance for your case.

P.S. the tip applies only to MS SQL Server.

Create elegant code with Action delegate and List.ForEach method

Sun, 11 Nov 2007 01:31:00 GMT

Let's review the following code which works with generic collection:

    List<Tip> tips = new List<Tip>();        //represents a list of Tips
    ...
 
    //create SiteMapNode from each Tip
    foreach (Tip tip in tips)
    {
        string url = string.Format("{0}/tips/{1}.aspx", appPath, tip.Id);
        SiteMapNode node = new SiteMapNode(this, url, url, tip.Title);
        node["lastmod"] = tip.PubDate.ToString("u");
        AddNode(node, rootNode);
    }

Although this code works well we can improve it using Action delegate and List.ForEach method. First we have to exctract code to create SiteMapNode into a method:

    private void AddSiteMapNode(Tip tip)
    {
        string url = string.Format("{0}/tips/{1}.aspx", appPath, tip.Id);
        SiteMapNode node = new SiteMapNode(this, url, url, tip.Title);
        node["lastmod"] = tip.PubDate.ToString("u");
        AddNode(node, rootNode);
    }

Separating it into a separate method has a few advantages, practically the ability to reuse the same logic for other uses. Now once we have this method creating SiteMapNode's from Tips collection would be:

    tips.ForEach(AddSiteMapNode);

P.S. this tip also can be used with Array.ForEach method.

Disable Submit button after it was clicked

Tue, 06 Nov 2007 13:42:00 GMT

While submitting the form data to a server to be handled by the Click event of Submit button, it would be a good practice to disable the button. Here is a small code sample to achieve this:

btnSubmit.OnClientClick = ClientScript.GetPostBackEventReference(btnSubmit, "") + "; this.value='Submitting...';this.disabled = true;";

Note: don't apply the tip to buttons which cause validation. Such buttons require more advanced onclick handler which checks client-side validation result.

submitted by Mustafa Basgun

News: Now you can comment on .NET tips

Tue, 06 Nov 2007 20:24:00 GMT

.NET Tip of The Day.org got a new feature – you can comment on tips. Click on Comments link to leave your comment.

Setting focus during a validation error

Thu, 01 Nov 2007 15:54:00 GMT

The validation controls now (starting with ASP.NET 2.0) allow you to easily set focus on a control in error using the SetFocusOnError property:

    <asp:RequiredFieldValidator
       SetFocusOnError="true"
       ErrorMessage="Enter something" ControlToValidate="TextBox1"
	
       runat="server" />

Which is better: Control or WebControl?

Tue, 30 Oct 2007 13:28:00 GMT

The System.Web.UI.Control class is the base class for all server controls. This provides the properties, methods, and events shared by all web controls. The System.Web.UI.WebControls.WebControl class derives from the Control class and adds style properties such as Font, Forecolor, and Backcolor.

Microsoft recommends:

if your custom control contains no user interface elements then derive from Control Class.
if your custom control provides a user interface, then derive from WebControl class.

submitted by Lohith Bandrehalli

Handling errors at the method level

Sun, 28 Oct 2007 15:17:00 GMT

If potential errors are recoverable in the routine
Use a combination of try…Catch blocks as a retry mechanism for error handling.
If useful information can be added to the exception
Create and throw a new exception with the added information.
If cleanup is required
Perform it in the finally block.
If potential errors are not recoverable in the routine
Recovery should be handled by the calling routine and its error-handling structure.

submitted by Lohith Bandrehalli

How to call a surrogate for Dispose() on StringBuilder objects

Fri, 26 Oct 2007 12:00:00 GMT

A typical use for the StringBuilder type looks like below:

    class Program
    {
        static string UseStringBuilder(string token)
        {
            StringBuilder sb = new StringBuilder();
            int i = 10;
            while (i-- > 0)
            {
                sb.Append(token + '\n');
            }
            string result = sb.ToString();
            return result;
        }
 
        static void Main(string[] args)
        {
            Console.WriteLine(UseStringBuilder("first"));
            Console.WriteLine(UseStringBuilder("second"));
        }
    }

The issue with this code is that when sb goes out of scope it is mark for garbage collection, but the memory stored in it lingers until the garbage collector invokes its finalizer. That could amount to a lot of unused memory and hence might cost you some unnecessary garbage collections by the CLR. Given this behavior it would only look natural to call something like Dispose to take care of the underline memory buffer used in the StringBuilder.

Unfortunately there is no Dispose method for this class, or any method to hint at freeing this unused memory in a deterministic way. The trick to get rid of this memory without invoking the finalizer is to set the Length to 0. The efficient code will become:

    class Program
    {
        static string UseStringBuilder(string token)
        {
            StringBuilder sb = new StringBuilder();
            int i = 10;
            while (i-- > 0)
            {
                sb.Append(token + '\n');
            }
            string result = sb.ToString();
            sb.Length = 0;        // this is the Dispose equivalent
            return result;
        }
 
        static void Main(string[] args)
        {
            Console.WriteLine(UseStringBuilder("first"));
            //no need to call System.GC.Collect() for the unreferenced StringBuilder object
            Console.WriteLine(UseStringBuilder("second"));
        }
    }

via Decebal Mihailescu

Update: use this trick with caution. There's no guarantee that future implementations of the runtime will act as described (tested only on .NET 2.0, 3.0 and 3.5). Only apply if you are working with big strings and have problems with memory/performance. Otherwise you will just complicate your code.
Thanks to Jeff Dean for pointing that out.

How to determine whether a property or a method is more appropriate for your needs

Thu, 18 Oct 2007 23:04:00 GMT

Use a method when:

The operation is a conversion, such as Object.ToString.
The operation is expensive enough that you want to communicate to the user that they should consider caching the result.
Obtaining a property value using the get accessor would have an observable side effect.
Calling the member twice in succession produces different results.
The order of execution is important. Note that a type's properties should be able to be set and retrieved in any order.
The member returns an array. Properties that return arrays can be very misleading. Usually it is necessary to return a copy of the internal array so that the user cannot change internal state. This, coupled with the fact that a user can easily assume it is an indexed property, leads to inefficient code.

P.S. this is not a comprehensive list of guidelines. See Design Guidelines for Class Library Developers for more.

Verbatim string literals

Wed, 17 Oct 2007 13:45:00 GMT

Verbatim string literal does not require the use of escape characters to define special characters. Instead, any information in the source code, including new lines, is included in the string. To define a string literal an @ symbol is placed before the opening quotation mark. Verbatim string literals are often used for specifying paths and multi-line strings:

    string path = @"C:\Program Files\My Program";        //verbatim literal
    string path2 = "C:\\Program Files\\My Program";      //regular literal
 
    string msg = @"Hello,
            This is a multi-line string";                //verbatim literal
 
    string msg2 = "Hello,\nThis is multi-line string";   //regular literal

P.S. the only character that requires a different action is the quotation mark itself, which must be entered twice to indicate a single character.

News: Maintenance

Mon, 15 Oct 2007 21:02:00 GMT

Hi everyone,

I'm Kostya Ly and I develop .NET Tip of The Day.org. I want to confess a horrible mistake I made: articles in this RSS channel appear in reverse order. As a result, when new people subscribe they see the last article first. My first thought was "You must commit harakiri".
But then a smarter idea visited my mind. I decided to fix the problem and republish RSS. As a result you might expresience some little problems with this RSS channel tomorrow. It is possible that old articles will appear as new one in your RSS reader (it depends on RSS reader you are using). But I have to do it. Sorry guys.

Thanks,
Kostya Ly

Speed up Visual Studio 2005

Wed, 10 Oct 2007 21:00:00 GMT

Make sure Visual Studio 2005 SP1 is installed.
Turn off animation.
Go to Tools | Options | Environment and uncheck Animate environment tools.
Disable Navigation Bar.
If you are using ReSharper, you don't need VS2005 to update the list of methods and fields at the top of the file (CTRL-F12 does this nicely). Go to Tools | Options | Text Editor | C# and uncheck Navigation bar.
Turn off Track Changes.
Go to Tools | Options | Text Editor and uncheck Track changes. This will reduce overhead and speeds up IDE response.
Turn off Track Active item.
This will turn off jumping in the explorer whenever you select different files in different projects. Go to Tools | Options | Projects and Solutions and uncheck Track Active Item in Solution Explorer. This will ensure that if you are moving across files in different projects, left pane will still be steady instead of jumping around.
Turn off AutoToolboxPopulate.
There is an option in VS 2005 that will cause VS to automatically populate the toolbox with any controls you compile as part of your solution. This is a useful feature when developing controls since it updates them when you build, but it can cause VS to end up taking a long time in some circumstances. To disable this option, select the Tools | Options | Windows Forms Designer and then set AutoToolboxPopulate to False.

Also make sure you read tip Optimize the launch of the Visual Studio 2005.

How to resolve relative url's without ResolveUrl

Mon, 08 Oct 2007 19:32:00 GMT

Sometimes you need to resolve relative url's without ResolveUrl. If the code is executing outside a Control, for example in an IHttpHandler or business layer code somewhere that has no reference to a Control, you can't call Control.ResolveUrl.

The System.Web.VirtualPathUtility class has some very useful method for converting from an app relative path to an absolute path:

    string absoluteUrl = VirtualPathUtility.ToAbsolute(relativeUrl);

How to maintain the position of the scrollbar on postbacks (across the entire site)

Thu, 04 Oct 2007 01:32:00 GMT

Tip/Trick: How to maintain the position of the scrollbar on postbacks. In addition, Joe Levi explains how to do this across the entire site:

If you would like to apply this behavior to your entire site simply modify the <pages /> entry of your <system.web /> section in your web.config file like so:

<pages maintainScrollPositionOnPostBack="true" />

via Joe Levi

Debugger variable $exception

Wed, 03 Oct 2007 02:07:00 GMT

If your catch block do nothing with caught exception you may declare block argument without name (to avoid warning message "CS0168: The variable 'ex' is declared but never used"):

    try
    {
        ...
    }
    catch (Exception)
    {
        // deliberately suppressing all exceptions
    }

But one day during debugging you may actually want to examine Exception. Since you don't have variable where exception is stored you can use debugger variable $exception provided by the Visual Studio.NET 2005 Debugger to examine the exception in a catch block. Just add it to Watch Window.

Explicitly suppress and restore compiler warnings using the #pragma warning directive

Sat, 29 Sep 2007 12:00:00 GMT

C# 2.0 allows you to explicitly suppress and restore compiler warnings using the #pragma warning directive:

// Disable "The private field 'MyClass._number' is never used" warning
#pragma warning disable 169
public class MyClass
{
    int _number;
}
#pragma warning restore 169

Disabling warnings should be generally discouraged in production code. It is intended only for analysis when trying to isolate a problem, or when you lay out the code and would like to get the initial code structure in place without having to polish it up first. In all other cases, avoid suppressing compiler warnings.

Validate integer value before casting it to an Enum type

Thu, 27 Sep 2007 19:27:00 GMT

There is one thing you should watch out for when using enumerations. You can cast any integer to an Enum type and you will not get an exception message. Therefore if the value comes from an external source (for example, from user input) check it against an enum before casting. The easiest way to do it is to use Enum.IsDefined method:

    int submitedValue = 123;
    if (Enum.IsDefined(typeof(MyEnum), submitedValue))
    {
        //do casting here
    }

Note: because Enum.IsDefined loads reflection it should be used with caution because of its performance penalty.

via M. Parreira

Return read-only collection if you want to control its modification

Wed, 26 Sep 2007 01:14:00 GMT

Let's review the following example:

public class Order
{
    private List<OrderItem> _orderItems = new List<OrderItem>();
 
    public ReadOnlyCollection<OrderItem> OrderItems
    {
        get { return _orderItems.AsReadOnly(); }
    }
 
    public void AddOrderItem(OrderItem orderItem)
    {
        ...
        _orderItems.Add(orderItem);
    }
}

The class has a public property of a collection type and I want to have "controlled access" to this collection. What I mean is, that a consumer of these classes should not be able to add an OrderItem to the collection directly, since some additional action(s) need to be executed. He should always use the AddOrderItem method if he wants to add an OrderItem to the Order.

In such cases keep the collection private, create the necessary methods to provide the necessary controlled access to the collection and create a public property which returns a read-only instance of the collection (by using List<T>.AsReadOnly method), so that you can iterate through the collection, change existing instances of objects within the collection, get the number of objects that are in the collection, etc.

Create elegant code with generic collections and Predicate delegate

Sat, 22 Sep 2007 12:30:00 GMT

Let's review the following code which works with generic collection:

    List<String> urls = new List<String>();    //represents a bunch of urls
    ...
 
    //Remove all urls that don't start with "http://"
    for (int i = urls.Count - 1; i >= 0; i--)
    {
        if (!urls[i].StartsWith("http://", StringComparison.OrdinalIgnoreCase))
        {
            urls.RemoveAt(i);
        }
    }

This works well but we can do a little better using Predicate (Predicate is essentially a delegate that allows us to filter based on a certain criteria). First, we have to define the method to be the predicate to validate that an url don't starts with an "http://". This would be:

    bool IsNonHttp(string url)
    {
        return !url.StartsWith("http://", StringComparison.OrdinalIgnoreCase);
    }

Which is essentially the same as the statement we had above. Separating it into a separate method has a few advantages, practically the ability to reuse the same logic for other uses. Now once we have this predicate removing all urls that don't start with an "http://" would be:

    urls.RemoveAll(IsNonHttp);

You can also write the whole thing in one line if you so choose by using an anonymous delegate this way:

    urls.RemoveAll(delegate(string url) {
        return !url.StartsWith("http://", StringComparison.OrdinalIgnoreCase);
    });

Other methods of List<T> which take a Predicate:

List.Exists - determines whether the List contains elements that match the conditions defined by the specified predicate.
List.Find - searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire List.
List.FindAll - retrieves the all the elements that match the conditions defined by the specified predicate.
List.FindIndex - searches for an element that matches the conditions defined by a specified predicate, and returns the zero-based index of the first occurrence within the List or a portion of it.
List.FindLast - searches for an element that matches the conditions defined by the specified predicate, and returns the last occurrence within the entire List.
List.FindLastIndex - searches for an element that matches the conditions defined by a specified predicate, and returns the zero-based index of the last occurrence within the List or a portion of it.
List.TrueForAll - determines whether every element in the List matches the conditions defined by the specified predicate.

Speed testing in .NET - System.Diagnostics.Stopwatch

Thu, 20 Sep 2007 15:57:00 GMT

System.Diagnostics.Stopwatch is a replacement for what most people probably do to identify the time spent on excecuting a method. The process usually goes something like: create a DateTime.Now value at the start and then subtract the ending DateTime.Now to get the TimeDuration value that elapsed.

As an alternative, the Stopwatch class was built using low-level API calls, with less overhead than other .NET methods. If the hardware and Windows version of the computer support a high-resolution performance counter, it will use this counter instead of the standard PC clock.

Here is a simple example:

System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
watch.Start();
 
//do my stuff
 ...
 
watch.Stop();
MessageBox.Show("Time spent: " + watch.Elapsed.ToString());

Use Tab twice to get the code snippets that are available within code editor

Sat, 15 Sep 2007 19:11:00 GMT

Take for example of foreach loop, just press 2 tabs after typing "fore"... that's it you got the code snippet as mentioned below:

Other useful code snippets are:

for - for loop
while - for while loop
equals - snippet for implementing Equals() according to quidelines
prop - for public property and backing field
tryf - for try finally
indexer - for indexer

For more information on code snippets that are included in Visual C# by default, see Default Code Snippets.

via Chakravarthy,
InteQ Solutions

?? operator (C#)

Thu, 13 Sep 2007 16:10:00 GMT

The ?? operator returns the left-hand operand if it is not null, or else it returns the right operand. For example:

    int? x = null;
    ...
    // y = x, unless x is null, in which case y = -1.
    int y = x ?? -1;

The ?? operator also works with reference types:

    //message = param, unless param is null
    //in which case message = "No message" 
    string message = param ?? "No message";

Optimize the launch of the Visual Studio 2005

Sun, 09 Sep 2007 16:22:00 GMT

Disable "Start Page".
1. Go to Tools | Options.
2. In Environment | Startup section, change At startup setting to Show empty environment.
Disable splash screen.
1. Open the properties of Visual Studio 2005 shortcut.
2. Add the parameter /nosplash to the target.
Close all unnecessary panels/tabs to prevent them from appearing when the IDE loads.

Conditional breakpoints in Visual Studio

Fri, 07 Sep 2007 00:00:00 GMT

You can specify a breakpoint condition which will be evaluated when a breakpoint is reached. The debugger will break only if the condition is satisfied.

To specify a condition:

In a source window, right-click a line containing a breakpoint glyph and choose Condition from Breakpoints in the shortcut menu.
In the Breakpoint Condition dialog box, define a boolean condition using the code in your local scope. For example, you can only break when _culture != "en-US".
Choose Is true if you want to break when the expression is satisfied or Has changed if you want to break when the value of the expression has changed.
Click OK.

Use Path.GetRandomFileName() or Path.GetTempFileName() when working with temp files

Wed, 05 Sep 2007 20:27:00 GMT

Do not reinvent function for generating unique name for temporary files. Use one of the existing methods:

System.IO.Path.GetTempFileName() - use this method if you want to create temporary file in user's temp folder.
System.IO.Path.GetRandomFileName() - use this method if you just want to generate unique file name.

Consider using System.IO.Path.Combine() instead of string concatenation

Mon, 03 Sep 2007 00:00:00 GMT

Let's review the following code for creating a file path:

    public string GetFullPath(string fileName)
    {
        string folder = ConfigurationManager.AppSettings["MyFolder"];
        return folder + fileName;
    }

This code is prone to error. For example, when you set the folder setting, you have to remember to make sure it ends with a slash. To avoid such problems use Path.Combine() method which will ensure that the folder has ending slash:

    public string GetFullPath(string filename)
    {
        string folder = ConfigurationManager.AppSettings["MyFolder"];
        return Path.Combine(folder, filename);
    }

Always check Page.IsValid in your button's EventHandler

Fri, 31 Aug 2007 23:23:00 GMT

Just because you are using ASP.NET validation controls, do not assume the page could not be submitted with invalid data.

Also, just because you hide a control, do not assume buttons/textboxes/etc on it are not submit-able. It is perfectly fine to hide a control that a user should not access, but with very little code (or using a third party tool) users can easily make an HttpPost with any data they choose.

Use DebuggerStepThrough attribute to save time when debugging

Thu, 30 Aug 2007 00:00:00 GMT

When debugging code, one of the annoying things is to step into an one-line method or property. Assume that you have the following property:

    private string word;
    public string Word
    {
        get { return word; }
        set { word = value; }
    }

And you have a code that uses that property when calling a method:

    DoSomething(obj.Word);

When you debug that line, and hit F11 to step into the method, you'll step into the get section of the property, and only then move on to the method.

By placing System.Diagnostics.DebuggerStepThrough attribute above get and set sections of the property you instruct the debugger to step through that property and not into it:

    public string Word
    {
        [System.Diagnostics.DebuggerStepThrough]
        get { return word; }
 
        [System.Diagnostics.DebuggerStepThrough]
        set { word = value; }
    }

This instruction will cause the debugger not to step into method (property) as normal, but you can always place a breakpoint in that method and stop there.

Speed up string comparison

Tue, 28 Aug 2007 12:23:00 GMT

The Compare method compares strings in a local-aware fashion, so it has to convert the Unicode code of each character into a numeric value that reflects its position in the current culture's alphabet. For example, the Compare method considers the "b" lowercase character to come immediately after the "A" uppercase char and before the "B" uppercase char, even though the "A" and "B" characters are contiguous in the Unicode character set. This conversion activity takes time and consume CPU cycles, so you'll find that VB.NET is less efficient than VB6 at comparing strings. Using the = operator and other comparison operators doesn't help at all, because they map to the Compare method behind the scenes, so these operators suffer from the same performance loss.

If you are only interested in checking whether two strings contain the same characters (in a case-sensitive comparison), you can speed up your code by using the CompareOrdinal shared method. This method is 3-4 times faster than the Compare method (or the = operator) because it just scans the two strings and compare the Unicode numeric code of each character.

Quickly move to matching brace in Visual Studio

Thu, 23 Aug 2007 22:50:00 GMT

Just press Ctrl+] and VS.NET will take you to the matching brace. It also will take you to the matching comment, region or quote depending on what is at the cursor now.

Linking a file in Visual Studio.NET

Wed, 22 Aug 2007 20:22:00 GMT

If in VS.NET you add to the current project an existing file that's located outside the current project's directory, the file is first copied in the project's directory, and then it's added to the project. However, you may want to share the same source file among multiple projects. As a trivially simple example, perhaps you get tired of specifying the same AssemblyCompany and AssemblyCopyright strings, over and over again, in all your projects? Wouldn't it be nice to have a little two-line C# file tucked away somewhere, and include it by reference in all your projects?

[assembly: System.Reflection.AssemblyCompany(".NET Tip of The Day.org")]
[assembly: System.Reflection.AssemblyCopyright("© 2007 All rights reserved.")]

To add a shared file, open the dialog to select an existing file with the Project | Add Existing Item… menu item and select the file you want to include. Then, instead of clicking the Open button, click the arrow on the left of that button, and click Link File from the list that drops down. This way you link to the original file, not to a local copy of it.

Don’t clear the stack trace when re-throwing an exception

Tue, 21 Aug 2007 23:15:00 GMT

Often, we need to put some exception handling on catch blocks (e.g., to rollback a transaction) and re-throw the exception. There are two ways of doing it. The wrong way:

    try
    {
        // Some code that throws an exception
    }
    catch (Exception ex)
    {
        // some code that handles the exception
        throw ex;
    }

Why is this wrong? Because, when you examine the stack trace, the point of the exception will be the line of the “throw ex;“, hiding the real error location. Instead of “throw ex;“, which will throw a new exception and clear the stack trace, simply use "throw;":

    try
    {
        // Some code that throws an exception
    }
    catch (Exception ex)
    {
        // some code that handles the exception
        throw;
    }

If you don’t specify the exception, the throw statement will simply rethrow the very same exception the catch statement caught. This will keep your stack trace intact, but still allows you to put code in your catch blocks.

Exceptions cause performance to suffer significantly

Mon, 20 Aug 2007 00:00:00 GMT

Do not rely on exceptions in your code and write code that avoids exceptions. Since exceptions cause performance to suffer significantly, you should never use them as a way to control normal program flow. If it is possible to detect in code a condition that would cause an exception, do so. Do not catch the exception itself before you handle that condition. Do not use exceptions to control logic. A database connection that fails to open is an exception but a user who mistypes his password is simply a condition that needs to be handled. Common scenarios include checking for null, assigning a value to a String that will be parsed into a numeric value, or checking for specific values before applying math operations.

//Unnecessary use of exception
try
{
    value = 100/number;
}
catch(Exception ex)
{
    value = 0;
}

Quickly locate where the exceptions are thrown

Fri, 17 Aug 2007 00:00:00 GMT

How many times has this happened to you? You're working on code that's not quite functioning correctly. You suspect there's an exception being thrown somewhere, but it's being caught and ignored. Maybe this was intentional, or maybe it was poorly written code. Either way, you need to locate the problem.

To do this, open the Exceptions dialog, either through the menu (Debug > Exceptions) or the keyboard shortcut (Ctrl+D, E).

Under the Thrown column, check the box next to the Common Language Runtime Exceptions. Now, when an exception is thrown, VS immediately breaks at the offending line of code.

Visual Studio Full Screen Mode

Thu, 16 Aug 2007 00:00:00 GMT

You can quickly toggle into Full Screen mode by pressing Shift+Alt+Enter.

Incremental search in Visual Studio

Wed, 15 Aug 2007 00:00:00 GMT

Press Ctrl+I.
Start typing the text you are searching for. Note: you'll see the cursor jump to the first match, highlighting the current search string.
Press Ctrl+I again to jump to the next occurrence of the search string.
To stop search, press Esc.

Advanced tip: Press Ctrl+Shift+I to search backwards.

Auto-complete the word in Visual Studio 2005

Fri, 10 Aug 2007 00:00:00 GMT

Type the first few characters of a control/variable/type name and hit Ctrl+Space or Alt+RightArrow to auto-complete the word. If there is more than one possibility Intellisense suggestions will pop up a window with available options.

Always set the "applicationName" property when configuring Membership and other Providers

Thu, 09 Aug 2007 00:00:00 GMT

Users created with the membership API will be associated with applicationName value specified in provider declaration in web.config file. This diagramm shows how user is associated with applicationName in database:

When no applicationName attribute is configured, ASP.NET uses the application vroot path within the web-server to automatically calculate the applicationName to use when adding data to an ASP.NET Application Service database.

Now let's assume you develop an ASP.NET 2.0 application locally using Membership, Roles or Profile features and you haven't specified applicationName attribute. You create several new users. Because applicationName property was not specified your users were associated with auto calculated value (something like "/WebSite1").

This works fine when the application continues to run in the "/WebSite1" application virtual path. But if it is copied to another location or server with a different virtual path (for example: "/app1" or more commonly just "/"), then when the Membership APIs are used they will not "see" the users already in our database – since they will lookup membership data using a different application name and filter the users in the application_Users table accordingly. That is why you'll get a "Login attempt unsuccessful, please try again." message when you try to login.

The best way to prevent this from ever happening is to always specify the "applicationName" attribute when declaring your providers. One good default value to use is "/" – which is the root application name. This is the value specified for the default provider that ships with ASP.NET 2.0 (which by default stores the application service data within the ASPNETDB.MDF file under /app_data), and is why if you don't override the provider settings it will work if you copy an app to another machine.

P.S. The reason why the applicationName setting even exists in the first place is so that you can map multiple applications and sites to the same database.

Don't forget to <clear/> when adding providers

Wed, 08 Aug 2007 00:00:00 GMT

You want to configure ASP.NET 2.0 to store your Membership/Role Management/Profile data within a remote SQL database. You decide to register a new provider within your web.config file like below:

<membership>
    <providers>
       <add name="AspNetSqlMembershipProvider"
          type="System.Web.Security.SqlMembershipProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"
          connectionStringName="MyDatabase"
          enablePasswordRetrieval="false"
          enablePasswordReset="true"
          requiresQuestionAndAnswer="true"
          requiresUniqueEmail="false"
          passwordFormat="Hashed"
          maxInvalidPasswordAttempts="5"
          minRequiredPasswordLength="7"
          minRequiredNonalphanumericCharacters="1"
          passwordAttemptWindow="10"
          passwordStrengthRegularExpression=""
          applicationName="/"
       />
    </providers>
</membership>

When you run your application on a machine without SQL Express, though, you see some weird behavior. You might get a SQL error like so:

An error has occurred while establishing a connection to the server. When connecting to SQL Server 2005, this failure may be caused by the fact that under the default settings SQL Server does not allow remote connections. (provider: SQL Network Interfaces, error: 26 - Error Locating Server/Instance Specified)

The root cause of the above problem rests in how the new provider was registered within the web.config file.

The <providers> section within the web.config file is implemented as a collection, and so it is possible to register multiple providers at the same time (this is useful when you want to have some users authenticated using one Membership store, and others authenticated using a separate Membership store).

By default ASP.NET 2.0 registers a set of default SQL Express providers within the root web.config file on your machine that create a SQL Express database within your /app_data directory to store/manage membership/role/profile data when you first access it. Because this is registered at the machine-wide level, all provider collections by default inherit this registration. Unless you explictly <clear/> or override the inherited value, your application will have this default membership/role/profile provider registered.

Because the above web.config file simply added a new provider -- and didn't clear or replace the default provider registration -- the above application now has two Membership providers configured. When you do a Membership.CreateUser() call in your code, ASP.NET will attempt to create the user in both membership databases. If you don't have SQL Express installed on your system, the create-user attempt will fail for this database - which leads to the errors and/or weird behavior above.

To fix this problem add an explicit <clear/> directive before your <add/> statements within your web.config file:

<membership>
    <providers>
       <clear/>
       <add name="AspNetSqlMembershipProvider"
          type="System.Web.Security.SqlMembershipProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"
          connectionStringName="MyDatabase"
          enablePasswordRetrieval="false"
          enablePasswordReset="true"
          requiresQuestionAndAnswer="true"
          requiresUniqueEmail="false"
          passwordFormat="Hashed"
          maxInvalidPasswordAttempts="5"
          minRequiredPasswordLength="7"
          minRequiredNonalphanumericCharacters="1"
          passwordAttemptWindow="10"
          passwordStrengthRegularExpression=""
          applicationName="/"
       />
    </providers>
</membership>

Note that you must do this for each provider declaration that you register. So if you are adding providers for <roles> and <profile>, make sure you add the <clear/> directive in their providers section as well.

How to perform DateTime calculations in a right way

Tue, 07 Aug 2007 00:00:00 GMT

When coding, be careful if you need to perform DateTime calculations (add/subtract) on values representing time zones that practice daylight savings time. Unexpected calculation errors can result. Instead, convert the local time value to universal time, perform the calculation, and convert back to achieve maximum accuracy.

        DateTime d;
        d = DateTime.Parse("Oct 26, 2003 12:00:00 AM");            //date assignment
        d = d.ToUniversalTime().AddHours(3.0).ToLocalTime();    
 
        //' - displays 10/26/2003 02:00:00 AM – Correct!
        MessageBox.Show(d.ToString());

Working with DateTime structs seems to be simple, but it's not. Make sure you are aware of pitfalls discribed in the article Coding Best Practices Using DateTime in the .NET Framework.

How to maintain the position of the scrollbar on postbacks

Mon, 06 Aug 2007 00:00:00 GMT

In ASP.NET 1.1 it was a pain to maintain the position of the scrollbar when doing a postback operation. This was especially true when you had a grid on the page and went to edit a specific row. Instead of staying on the desired row, the page would reload and you'd be placed back at the top and have to scroll down. In ASP.NET 2.0 you can simply add the MaintainScrollPostionOnPostBack attribute to the Page directive:

<% Page Language="C#" ... MaintainScrollPositionOnPostback="true" %>

Strongly-typed access to previous page during cross-page postback

Thu, 02 Aug 2007 00:00:00 GMT

ASP.NET 2.0 introduced the concept of cross-page postbacks where one page could postback information to a page other than itself. This is done by setting the PostBackUrl property of a button to the name of the page that the button should postback data to. Normally, the posted data can be accessed by doing something like PreviousPage.FindControl("ControlID"). However, this requires a cast if you need to access properties of the target control in the previous page (which you normally need to do). If you add a public property into the code-behind page that initiates the postback operation, you can access the property in a strongly-typed manner by adding the PreviousPageType directive into the target page of the postback.

For example, if you have a page called Default.aspx that exposes a public property that returns a Textbox that is defined in the page, the page that data is posted to (lets call it SearchResults.aspx) can access that property in a strongly-typed manner (no FindControl() call is necessary) by adding the PreviousPageType directive into the top of the page:

<%@ PreviousPageType VirtualPath="Default.aspx" %>

By adding this directive, the code in SearchResults.aspx can access the TextBox defined in Default.aspx in a strongly-typed manner. The following example assumes the property defined in Default.aspx is named SearchTextBox.

TextBox tb = PreviousPage.SearchTextBox;

This code obviously only works if the previous page is Default.aspx. PreviousPageType also has a TypeName property as well where you could define a base type that one or more pages derive from to make this technique work with multiple pages.

How to get virtual path of web application

Wed, 01 Aug 2007 00:00:00 GMT

Getting the virtual paths local to server is pretty straight forward most of the time; just use Page.ResolveURL("http://dotnettipoftheday.org/whatever"). But what if you're in the BLL part of your app? Seeing as the Page.ResolveURL is not a static method you would have to create a new instance of Page before you can reference it... not good enough.

In BLL use System.Web.HttpRuntime.AppDomainAppVirtualPath static property to get local virtual path of web application:

string url = HttpRuntime.AppDomainAppVirtualPath + "/whatever";

Note: if web application is in a server root folder AppDomainAppVirtualPath returns just "/". If web application is in a non-root folder it returns virtual path of the folder without "/" in the end.

Strongly-typed access to Master Pages controls

Tue, 31 Jul 2007 00:00:00 GMT

If you have public properties defined in a Master Page that you'd like to access in a strongly-typed manner you can add the MasterType directive into a page as shown next:

<% MasterType VirtualPath="MasterPage.master" %>

You can then access properties in the target master page from a content page by writing code like the following:

this.Master.HeaderText = "Label updated using MasterType directive with VirtualPath attribute.";

Conditional compilation with ConditionalAttribute

Fri, 27 Jul 2007 00:00:00 GMT

It is possible to conditionally compile code out of the final product, this is usually useful when you want to have extra checks in the code (asserts, invariant checking) during development and testing, in debug mode, but do not want to incur the cost of this checking in the final release product. Just put all of the checking into a method and place Conditional attribute on it.

public sealed class Debug
{
      ...
 
      [Conditional("DEBUG")]
      public static void Assert(bool condition, string message)
      {
                TraceInternal.Assert(condition, message);
      }
}

What this actually does is tell the compiler to only call the method when the supplied preprocessor symbol is defined. The method will still be compiled and will still exist in the assembly. So, in a debug build a program that looks like this:

static void Main(string[] args)
{
    Debug.Assert(true, "This condition must be true");
}

will still look like that, but when compiled in release mode, will look like this:

private static void Main(string[] args)
{
}

Note: the Debug classe of the .NET Framework use the ConditionalAttribute. So you don't have to worry about any performance hit whatsoever when you call various methods of this class as a debugging aid. These calls just won't make it in the release build.

How to locate control nested inside of another control

Thu, 26 Jul 2007 00:00:00 GMT

Finding controls within a Page's control hierarchy can be painful but if you know how the controls are nested you can use the lesser known "$" shortcut to find controls without having to write recursive code. The following example shows how to use the DefaultFocus property to set the focus on a textbox that is nested inside of a FormView control. Notice that the "$" is used to delimit the nesting:

<form id="form1" DefaultFocus="formVw$txtName" runat="server">
    <div>
       <asp:FormView ID="formVw" runat="server">
          <ItemTemplate>
             Name:
             <asp:TextBox ID="txtName" runat="server"
                Text='<%# Eval("FirstName") + " " + Eval("LastName") %>' />
          </ItemTemplate>
       </asp:FormView>
    </div>
</form>

This little trick can also be used on the server-side when calling FindControl():

TextBox tb = this.FindControl("form1$formVw$txtName") as TextBox;
if (tb != null)
 {
    //Access TextBox control
 }

How to set the default focus to a control when the page loads

Wed, 25 Jul 2007 00:00:00 GMT

This is another extremely simple thing that can be done without resorting to writing JavaScript. If you only have a single textbox (or two) on a page why should the user have to click in the textbox to start typing? Shouldn't the cursor already be blinking in the textbox so they can type away? Using the DefaultFocus property of the HtmlForm control you can easily do this.

    <form id="frm" DefaultFocus="txtUserName" runat="server">
       ...
    </form>

Set the default button that is triggered when the user hits the Enter key

Tue, 24 Jul 2007 00:00:00 GMT

Use the HtmlForm control's DefaultButton property to set which button should be clicked when the user hits enter. This property is also available on the Panel control in cases where different buttons should be triggered as a user moves into different Panels on a page.

    <form id="frm" DefaultButton="btnSubmit" runat="server">
       ...
    </form>
			

How to change the default browser used in VS 2005

Mon, 23 Jul 2007 00:00:00 GMT

To change what browser is launched and used when running web apps in Visual Studio 2005 and Visual Web Developer (for example: to use FireFox instead of IE) do this:

Right click on a .aspx page in your solution explorer
Select the "browse with" context menu option
In the dialog you can select or add a browser. If you want Firefox in the list, click "add" and point to the firefox.exe filename
Click the "Set as Default" button to make this the default browser when you run any page on the site.

Note that there is also an optional drop-down at the bottom of the dialog that lets you select the default browser window size when loading.

Use server-side comments to temporary disable part of ASP.NET page

Sat, 21 Jul 2007 00:00:00 GMT

You are coding away on an ASP.NET page, and are trying to isolate a problem within the page. You have some existing html/controls/markup/in-line code that is being used on the page, and you want to temporarily comment it out while you fix the problem.
ASP.NET supports a little known feature called “server-side comments” that you can use to completely disable code/controls/html in a page. Server-side comments in ASP.NET are delimited using a <%-- --%> syntax. For example:

    <%--
        Commented out HTML/CODE/Markup. Anything with
        this block will not be parsed/handled by ASP.NET.
 
        <asp:Calendar runat="server"></asp:Calendar>
        <%# Eval("SomeProperty") %>
    --%>

The key difference between client-side HTML comments and server-side comments is that with client-side comments code/controls will still be executed on the server. With server-side comments, the ASP.NET compiler will ignore everything whithin these blocks.

Use parameters instead of string concatenation for forming SQL queries

Fri, 20 Jul 2007 00:00:00 GMT

String concatenation is not a secure approach as clever person can execute unwanted SQL statement by some tricks (SQL injection attack). Use parameters if possible.

Bad code:

    SqlCommand command = new SqlCommand("SELECT COUNT(*) FROM Accounts WHERE Login='" + login + "' AND Password='" + password + "'", conn);

Good code:

    SqlCommand command = new SqlCommand("SELECT COUNT(*) FROM Accounts WHERE Login=@login AND Password=@password", conn);
    SqlParameter param = new SqlParameter("login", SqlDbType.VarChar, 100);
    param.Value = login;
    command.Parameters.Add(param);
    param = new SqlParameter("password", SqlDbType.VarChar, 100);
    param.Value = password;
    command.Parameters.Add(param);

Use "App_Offline.htm" feature while updating a web site

Thu, 19 Jul 2007 00:00:00 GMT

"App_Offline.htm" feature provides a super convenient way to bring down an ASP.NET application while you updating a lot of content or making big changes to the site where you want to ensure that no users are accessing the application until all changes are done.

The way app_offline.htm works is that you place this file in the root of the application. When ASP.NET sees it, it will shut-down the app-domain for the application and instead send back the contents of the app_offline.htm file in response to all new dynamic requests for the application. When you are done updating the site, just delete the file and it will come back online.

Use on-demand web-site compilation option to improve build times

Wed, 18 Jul 2007 00:00:00 GMT

On-demand web-site compilation mode means that when you edit page and then hit F5 (run with debugging) or Ctrl-F5 (run without debugging) the solution will compile all of the class library projects, then compile the /app_code directory and Global.asax file, and then instead of re-verifying all pages within the web-site it will only verify the current page you are working on, and any user controls that the page references. Note that ASP.NET will automatically re-compile any other page or control you access at runtime - so you will always have an up-to-date and current running application (you don't need to worry about old code running).

To enable this, right-click on your web-site project and pull up the project properties page. Click the "Build" tab on the left to pull up its build settings. Within the "Build" tab settings page change the F5 Start Action from "Build Web Site" to the "Build Page" option:

Keep the number of files in your /app_code directory small

Tue, 17 Jul 2007 00:00:00 GMT

In order to improve Web Site Project build times keep number of files in your /app_code directory small. If you end up having a lot of class files within this directory, move them into separate class library project and reference that project from your web-site. This isn't usually an issue if you just have a small number of files in /app_code, but if you have lots of directories or dozens of files you will be able to get speed improvements.

One other thing to be aware of is that whenever you switch from source to design-view within the Visual Studio HTML designer, the designer causes the /app_code directory to be compiled before the designer surface loads. The reason for this is so that you can host controls defined within /app_code in the designer. If you don't have an /app_code directory, or only have a few files defined within it, the page designer will be able to load much quicker (since it doesn't need to perform a big compilation first).

Use DebuggerDisplay attribute for a better debugger experience

Mon, 16 Jul 2007 00:00:00 GMT

Appply DebuggerDisplay attribute to a class or member to determine how it is displayed in the debugger variable windows. For example, the following C# code causes "Count = 4" to be displayed in debugger:

[DebuggerDisplay("Count = {count}")]
class MyHashtable
{
    public int count = 4;
}

How to debug a JavaScript code

Sun, 15 Jul 2007 00:00:00 GMT

Method 1. Open .js file in Visual Studio and insert breakpoint at the line you want to debug. Open Attach to Process dialog window (menu item Debug | Attach to Process...) and attach to Internet Explorer process (iexplore.exe). Execute the code you want to debug in Internet Explorer.

Method 2. Write your JavaScript and place the debugger keyword where ever you want the code to break into debugging. The JavaScript interpreter hits this keyword and halts execution and returns the control back to the IDE. This is like setting a breakpoint inside of Visual Studio.

Note: you must enable script debugging in Internet Explorer to be able to debug. Go to Internet Options inside Internet Explorer and then go to the Advanced tab. Uncheck Disable script debugging (Internet Explorer).

Do not include the "@" character when supplying stored procedure parameter names to a SQL Server database

Sat, 14 Jul 2007 00:00:00 GMT

Avoid using database-specific tokens with stored procedure parameter names. ADO.NET classes for specific providers include code to adjust parameter names as required. This will ease migration existing ADO.NET programs to other DBMSs.