Jack @ ASP.NET

Some members of the C# community were discussing optional parameters and the implications for future versions when optional parameter values change.  In short, you need to realize that changing the value of optional parameters in a public API is a change that is observable at client code. The ramifications vary greatly, from “no big” to “stop the world”. I’ll give a brief explanation of how the feature works, and what you need to watch for and how to separate reasonable caution from irrational fear from using a feature.

While most modern programming languages provide some way of declaring optional function parameters, C# doesn’t provide a way of directly doing so, despite the fact that VB.NET and .NET’s attribute system both support this functionality. This is a subject of some debate currently in the C# community. The C# development team’s position seems to boil down to the following: When provided, this feature is usually nothing more than dressing up method overloading with a little syntactic sugar.

When you get right down to it, their position makes some sense. A function with an optional parameter is in reality two different functions: one that assumes some default behavior if the optional parameter is omitted, and another that performs more specific behavior based on the value of the optional parameter if provided. But that doesn’t change the fact that using overloaded methods to provide optional parameter support feels a little clunky. It works, but you always wind up writing more code, and you pollute your object interface with the extra method signatures required to support all of your optional parameters. Let’s look at some alternatives.

TryParse

int index;
int.TryParse(Request.QueryString["index"], out index);

This version isn’t so bad since it requires no conditional processing. The problem with the TryParse method is the out parameter, which requires the initial declaration of variable whether or not you want or need it. This also prevents it from being used in a declarative statement, since the return value is whether the value was parsed. This can be used declaratively using the ternary operator, but it is rather odd since the result is already defined. Many people opt to use imperative logic instead, testing for !<t>.TryParse.

Here’s are examples of non-zero default value. The first using an if statement and the second with the ternary operator.

int index;
if (!int.TryParse(Request.QueryString["index"], out index))
{
    index = 1;
}

int index;
index = int.TryParse(Request.QueryString["index"], outindex) ? index : 1;

Convert

var index = Convert.ToInt32(Request.QueryString["index"]);

Convert is more declarative in this form, but it has a fatal flaw. If the string being parsed is an invalid value (not null, but something like “asdf”), then it will throw an exception. Exceptions are expensive, and it requires wrapping the code in a try… catch block since the exception is typically meaningless aside from preventing the assignment. Perhaps the above statement would be better expressed as:

int index = 0;
try
{
    index = Convert.ToInt32(Request.QueryString["index"]);
}
catch { }

The typical conversion failure use case is to assign a default value. However, additional logic is sometimes necessary. With TryParse, you test the return value for false. With Convert, you catch the exception. With Maybe, you test for null.

int? result = Maybe.ToInt32(Request.QueryString["index"]); if (result == null) { // Failure processing }

Since it is sometimes necessary to know if a the parsing was successful, I didn’t opt to create a ParseWithDefault method.

A set of extensions to Visual Studio Professional (and above) which improves developer productivity.

• Searchable Add Reference Dialog
  The new Add Reference dialog makes it faster and easier for you to find the reference that you are looking for and add it to your VB, C# or F# project.  From the Solution Explorer, simply right click on the References node, select the Add Reference command to see the updated Add Reference Dialog. 
• Highlight Current Line
  As the resolution of monitors increases, it’s becoming more difficult to find the caret in the code editor.  The highlight current line extension makes it easy to find the caret by highlighting the line that the caret is on in the editor.  You can even configure the default colour by changing the setting for “Current Line (Extension)” and “Current Line Inactive (Extension)” in Tools Options Fonts & Colors. 
• HTML Copy
  This extension provides support for the HTML Clipboard format when copying code from the editor.  This means that you’ll no longer have to go fix up the formatting of your code when you paste it into a TFS bug form or any other HTML based control. 
• Triple Click
  It’s never been easier to select a line of code from the mouse by simple triple-clicking anywhere on the line. 
• Fix Mixed Tabs
  Some developers prefer tabs, others prefer spaces, and nobody likes mixing tabs & spaces.  This extension promotes developer harmony by warning as they are open or save a file that has a mixture of tabs & spaces.  The information bar also provides an easy way to fix the file to suit your preference. 
• Ctrl + Click Go To Definition
  This extension gives the editor a web browser by adding clickable hyperlinks to symbols in your code as you hold down the Ctrl key.
• Colorized Parameter Help
  This extension improves consistency with the editor by applying syntax highlighting to the contents of the Parameter Help window for C# &VB. 
• Move Line Up/Down Commands
  This extension maps the Alt+Up Arrow & Alt+Down Arrow keys such that they will move the current line of code or the selected lines up and down through the editor. 
• Column Guides
  Since Visual Studio 2002, there has been a not so secret registry key which allowed user to draw a vertical line in the code editor.  This is very useful to remind developers that their full line of code or comments may not fit one a single screen. Thanks to this extension this feature has returned with UI configure it.  Simply place the cursor at the appropriate column and select Add Guideline from the context menu

Building the Http Module

In order to build an Http module we only need to implement
the IHttpModule interface. The following is a simple
LoggingHttpModule which log details when a web request start
and when web request end:

using System;

using System.Web;

using Microsoft.Practices.EnterpriseLibrary.Common.Configuration;

using Microsoft.Practices.EnterpriseLibrary.Logging;

namespace HttpModules

{

  public class LoggingHttpModule : IHttpModule

  {

    #region Members

    private LogWriter _writer;

    #endregion

    #region IHttpModule Members

    public void Dispose()

    {

      if (_writer != null)

      {

        _writer.Dispose();

      }

    }

    public void Init(HttpApplication context)

    {

      CreateLogWriter();

      context.BeginRequest += new EventHandler(context_BeginRequest);

      context.EndRequest += new EventHandler(context_EndRequest);

    }

    private void CreateLogWriter()

    {

      ConfigureEnterpriseLibraryContainer();

      _writer = EnterpriseLibraryContainer.Current.GetInstance<LogWriter>();

    }

    private void ConfigureEnterpriseLibraryContainer()

    {

      var builder = new ConfigurationSourceBuilder();

      builder.ConfigureInstrumentation().EnableLogging();

      builder.ConfigureLogging().WithOptions

             .LogToCategoryNamed("General")

               .WithOptions

               .SetAsDefaultCategory()

               .SendTo

               .FlatFile("Log File")

               .FormatWith(new FormatterBuilder()

               .TextFormatterNamed("Textformatter"))

                   .ToFile("file.log");

      var configSource = new DictionaryConfigurationSource();

      builder.UpdateConfigurationWithReplace(configSource);

      EnterpriseLibraryContainer.Current =

        EnterpriseLibraryContainer.CreateDefaultContainer(configSource);

    }

    void context_BeginRequest(object sender, EventArgs e)

    {

      _writer.Write(new LogEntry

      {

        Message = "BeginRequest"

      });

    }

    void context_EndRequest(object sender, EventArgs e)

    {

      _writer.Write(new LogEntry

      {

        Message = "EndRequest"

      });

    }

    #endregion

  }

}

Using The Module

In order to use the module all we need to do is to add a reference
to the class library that holds the LoggingHttpModule. Then we need
to register the module in the web.config file in the httpModules 
element like:

<httpModules>

    <add name="LoggingHttpModlue" type="HttpModules.LoggingHttpModule, HttpModules"/>

</httpModules>

That is it. Now the module will be executed whenever a request
start or end.

Silverlight Tooling Support

PowerCommands 10.0 is a set of useful extensions for the Visual Studio 2010 adding additional functionality to various areas of the IDE. Visit the VSX Developer Center at http://msdn.com/vsx for more information about extending Visual Studio.