Programming tidbits: store & retrieve : Visual Studio

.NET Framework 4.0 implements WS-Discovery

OanaPlaton — Fri, 12 Jun 2009 00:52:50 GMT

The .NET Framework 4.0 and Visual Studio 2010 Beta 1 are live. If you haven’t tried the bits, do so and give the team feedback. There are some very cool features added – just take a look at the highlights.

On the Communications front, Windows Communication Foundation has 3 major new features: support for WS-Discovery, standard endpoints (pre-defined endpoints with some of the properties fixed) and workflow services (messaging activities make the implementation of workflows very easy).

I am really excited with the support for the WS-Discovery protocol. From the msdn documentation:

“The Service Discovery feature enables client applications to dynamically discover service addresses at run time in an interoperable way using WS-Discovery. The WS-Discovery specification outlines the message-exchange patterns (MEPs) required for performing lightweight discovery of services, both by multicast (ad hoc) and unicast (using a network resource).”

To learn more about Discovery, take a at the Discovery MSDN SDK samples. Plus, the Discovery team is blogging, so go to the Discovery team’s blog. Or start with the Channel9 Discovery video:

Performance Comparison: Regex versus string operations

OanaPlaton — Sat, 04 Apr 2009 23:25:00 GMT

I consider regular expressions one of the most useful features ever. I use them a lot, not only when coding, but also when editing files and instead of copy and paste. I find the Visual Studio Find/Replace feature with regular expressions really useful as well. In case you are not familiar with it, you can use regular expressions to find and replace characters like this:

In the picture, I used the expression {[^;]+}; - meaning tag the string formed by any characters until ";" (at least one character) and replace the matching text with "// " followed by the tagged expression, forgetting the last ";". There are a lot of tutorials about regular expressions. I just learned the basics, and now I just try, fail, undo, and try again until I get it right.

Moving back to coding, .NET has great support for regular expressions. The classes are relatively easy to use (though at the beginning I had to play a while to find out how to capture strings in one match and other more advanced features). The biggest advantages I find in using Regex are that it makes parsing input very easy (once you have the regular expression in place) and it makes it much harder to introduce bugs - less code has by definition fewer bugs, and parsing with regular expressions requires less code than the traditional method of parsing strings with different string methods like get substring at different indexes, check that is starts or ends with certain characters etc.

However, there are cases when the string concatenation and parsing is better than the regular expressions: when the checks are done on a path that is executed a lot (a hot path), and that has strict performance requirements. Why? The regular expressions are slower than string concatenation.

I did a simple experiment and measured the time needed by regex and strings to perform the same operations. I considered I need to keep data about persons in the format "Firstname:Oana Lastname:Platon Money:2183 UniqueIdentifier:fwsjfjehfjkwh8r378". I have defined a constant that represents this format, and I'll use it to serialize the person data.

const string nameFormat = "Firstname:{0} Lastname:{1} Money:{2} UniqueIdentifier:{3}";

The data must be serialized and deserialized a lot of times (lets say that we need to send the data on the wire frequently or something like that). When deserializing the data, we need to make sure that it respects the pattern and then we need to extract the firstname, lastname etc.

1. Using regular expressions

I defined a regular expression like this:

static Regex regex = new Regex("^Firstname:(\\w+)\\sLastname:(\\w+)\\sMoney:(\\d{1,9})\\sUniqueIdentifier:([\\w-]+)$", RegexOptions.IgnoreCase | RegexOptions.Compiled);

Then, the code to parse the expressions and get the desired data is:

void ParseWithRegex(string description)

{

Match m = regex.Match(description);

if (!m.Success)

{

throw new ArgumentException("description doesn't follow the expected format");

}

this.firstname = m.Groups[1].Value;

this.lastname = m.Groups[2].Value;

if (!int.TryParse(m.Groups[3].Value, out this.age))

{

throw new ArgumentException("age doesn't have the correct value");

}

this.uniqueIdentifier = m.Groups[4].Value;

}

2. Using string operations

The verification that the given string respects the format becomes more difficult. In our case, the patters is pretty simple, but imagine that we needed to check an email address or something more complicated. In that case, the code would have had a lot of cases, to follow all possible solutions.

void ParseWithStrings(string description)

{

string[] parts = description.Split(new char[] { ' ', '\t' });

if (parts.Length != 4)

{

throw new ArgumentException("description doesn't follow the expected pattern");

}

this.firstname = parts[0].Substring(parts[0].IndexOf(":") + 1);

this.lastname = parts[1].Substring(parts[1].IndexOf(":") + 1);

if (!int.TryParse(parts[2].Substring(parts[2].IndexOf(":") + 1), out this.age))

{

throw new ArgumentException("age doesn't have the correct value");

}

this.uniqueIdentifier = parts[3].Substring(parts[3].IndexOf(":") + 1); ;

}

See that this is much more error prone than the previous code, because it needs to look at a lot of indexes and to substract the desired part of the string.

However, when I run the 2 methods in a loop and I measure how long they take with a stopwatch (from System.Diagnostics namespace), I get these results:

In conclusion, when choosing between using traditional string parsing or regular expressions, I would recommend:

- Start with regular expressions; if the path is not a hot path and doesn't have any strict performance requirements, this is the best choice, since it makes the code easier to read and maintain.

- If the performance goals are not reached (which means you have performance goals and you measured the performance!), try to improve your regular expressions. For example, adding ^ and $ (to specify that the pattern you are looking for is at the beginning or at the end of the string) when appropriate can improve the performance a lot. Also, make sure you use compiled expressions (if possible).

- If you are still not in graphic, replace the regular expressions with string concatenation and parsing.

Visual Studio Templates – Add New Item to project

OanaPlaton — Fri, 06 Mar 2009 05:24:00 GMT

Using Visual Studio to write code requires creating a project (well, you can use Visual Studio without a project, but you won’t get very much past Notepad functionality – there’s not even Intellisense on files) . After creating / opening an existing project, we can add new files (classes, class diagrams, XML files etc) by selecting the Project menu, then Add New Item (or add Class / Windows Forms / Windows Component or User Control, if this is what you need). After you specify all the details (file name), a file is added with some default text in it. Assuming you have Visual Studio 2008 SP1 installed, the templates that generate this text are stored at %ProgramFiles%\Microsoft Visual Studio 9.0\Common7\IDE\ProjectTemplates and %ProgramFiles%\Microsoft Visual Studio 9.0\Common7\IDE\ProjectTemplatesCache (for x64 machines, look in % ProgramFiles(x86)%).

Let’s add a new C# class, Tester, to the class library project SimpleTests. By default, in Visual Studio 2008 it will contain the following text:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace SimpleTests

{

class Tester

{

}

This text comes from the Class template. If we look in the ProjectTemplateCache folder, inside CSharp (the language we used to add the class) -> Code -> 1033 -> Class.zip, we find a class.cs looking like this:

using System;

using System.Collections.Generic;

$if$ ($targetframeworkversion$ == 3.5)using System.Linq;

$endif$using System.Text;

namespace $rootnamespace$

{

class $safeitemrootname$

{

}

This explains the text we get. But how can we customize the default? I really would appreciate some changes:

- I don’t want all these usings added by default – I prefer to start without any using statement, and to add them while the code requires them. Of course, I could do it the other way around: add all the usings I think I may need; when I am done coding, remove the unused ones. Visual Studio lets you do that easily by right clicking on the page, selecting Organize Usings -> Remove Unused Usings (or Remove and Sort).

- Second, I prefer Usings inside the namespace declaration and I want to add a header to the file.

I can change the Class.cs file and replace the Class.zip in ProjectTemplatesCache folder:

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

// Copyright (c) Oana Platon

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

namespace $rootnamespace$

{

using System;

class $safeitemrootname$

{

}

Then when I reopen Visual Studio and Add a class, I get this file:

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

// Copyright (c) Oana Platon

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

namespace SimpleTests

{

using System;

class MyCustomizedTester

{

}

Cool, right?

This change will be lost the first time when devenv /installvstemplates command is called (this command replaces the ItemTemplatesCache folder with what finds in ItemTemplates folder). To make it permanent, make the change in ItemTemplates folder instead and run devenv /installvstemplates to propagate the change to ItemTemplatesCache.

The Beauty of Visual Studio Immediate Window

OanaPlaton — Sun, 24 Aug 2008 00:32:00 GMT

The Visual Studio Immediate Window is a great tool to increase your productivity. A lot of people are not aware that you can test functions in your program without writing any code by using this little tool. Look in the msdn entry for Immediate Window for more information.

Here is an example on how I use it. I have a small function I want to test, and I don’t want to add any testing code for it. Don’t do that for production code, it works great for prototypes only. I start debugging: from the Debug menu->Start Debugging (F5) if you have some breakpoints defined or the best way is with Debug->Step Over (F10), that stops on the first line of Main.

To bring my immediate window, I usually start the Command Window (shortcut Ctrl+Alt+A by default, or go to View->Other Windows->Command Window). In the Command Window, I type immed – which brings the immediate window. Now I start calling my function. And I have IntelliSense and everything I need!

Here are the results:

Visual Studio 2008: Missing items from toolbox

OanaPlaton — Sun, 08 Jun 2008 23:58:00 GMT

A couple of days ago I reinstalled VS 2008 RTM version and I happily tried to create a website. Unfortunately, my productivity was totally ruined ‘cause most of the toolbox items were missing. To be exact, I only had the HTML tab.

Here are the steps to get your items back. Navigate to C:\Users\<username>\AppData\Local\Microsoft\VisualStudio\9.0 (on Vista or Longhorn) or “C:\Documents and Settings\<username>\Local Settings\Application Data\Microsoft\VisualStudio\9.0” (older Windows versions) from a command prompt or in explorer (you may need to configure explorer to show hidden folders: Tools -> Folder Options -> View -> check Show hidden files and folders). Here, just delete these files:

· toolbox.tbd

· toolboxIndex.tbd

· toolbox_reset.tbd

· toolboxIndex_reset.tbd

Then restart VS 2008 and the toolbox should look normal again. Same steps apply to VS 2005 (just replace 8.0 with 9.0 in the path)

If you still have problems, try the following:

- Check that the .NET Framework is properly installed. You could use the script at .NET Framework 3.5 Installation validation tool

- Try restoring the IDE's default settings: from the folder where VS 2008 is installed (eg. %ProgramFiles%\Microsoft Visual Studio 9.0\Common7\IDE), run devenv.exe /ResetSettings. You can also specify a VSSettings file to restore settings from.

- To clears all SkipLoading tags added to VSPackages, run devenv.exe /ResetSkipPkgs.

- Launches the IDE in safe mode loading minimal windows: devenv.exe /SafeMode.

If your controls are grayed out, you might want to check your mouse. This post shows the effects of a weird interaction between some wireless mice drivers and the idle timing that ASP.NET designer relies on.