robbie

vs.net naming conventions

The MSDN documentation on .NET standards and best practises is certainly comprehensive, but as a starting point it’s overwhelming. Naming conventions vary from organisation to organisation, and I am never happy committing hundred page, or more, tomes of (often) fiercely protected “standards” to memory.

I much prefer automated ‘code review’ tools which help maintain such standards, e.g. Enterprise Templates, FX Cop and the brilliant Compuware DevPartner Studio. This download is therefore a readily consumable list of the essential .NET naming conventions, good for initial developer orientation, that is (pretty much), industry standard.

vs.net and xhtml

after a recent dissapointment with an e-book on xhtml compliance and vs.net, what else can be done to help with standards based dev?

vs.net’s ‘extensibility’ options include a DefaultTargetSchema property for a project which uses a prjTargetSchema enum value, which sort of limits the extensibility to that provided by microsoft: setting this property affects intellisense and compiler errors – though earlier versions of the doco claimed that it would also alter the choice of html controls in the toolbar. prjTargetSchema has only three values which map to three xml schemas installed under \Microsoft Visual Studio .NET\Common7\Packages\schemas\html.

Now, whilst you cant easily add to the prjTargetSchema, and so change settings at a project level, you can at a document level. webforms have a targetSchema property, which allows you to specify a schema for that document. by default you can choose from one of the three that map to prjTargetSchema. but there’s nothing stopping you adding your own, and if you do the IDE will helpfully display it as an option in the designer’s dropdown.

having looked over the three provided i was about to grab the xhtml schema and do a quick xslt to make it vs.net friendly, when i found out that Christoph Schneegans had already done so. top man.

I’ve only made a couple of minor, but i think useful, alterations. Christoph’s page also includes transitional and frameset schema’s too if you’re that way inclined. Now this still doesnt make things right – you’ll still experience vs.net pain and need a good xhtml validator, but it is an improvement. here then is my list of ways to ease the pain a little:

• change the default webform template – i include an example in the download
• change the default editor options under Tools|Options – in HHTML/XML to:
  • deselect all ‘Apply Automatic Formatting’ options, select all ‘Automatic Formatting Options’ and ensure that all ‘Capitalisation’ options are set to ‘As entered’
  • select all on the HTML Specific page
• install the xhtml intellisense schema – included in the download
• always check your ouptput with a decent validator

standard template 

A recurring theme on many of the projects I’ve worked on recently has been that of document templates. So I’ve decided to put my most commonly used here on the site. A few years ago standard templates became a big issue at the company I worked for – primarily because there wasn’t really any and this was affecting both individual productivity and client’s perceptions of the company. After much debate I persuaded the company to invest in a copy of the SPC’s EssentialSET, which formed the basis for most of the templates used thereafter. The EssentialSet templates are not pretty, but the are excellent in terms of providing a baseline of standards compliance.

The templates I’ll post here have been through so many revisions – over 40 to the base template alone – and have been used and improved on in so many projects – that they bear little resemblance to their originals, so I think its safe to make them public without stepping on anyone’s copyright.

What makes a good template? Apart from being based on standards and having survived numerous encounters with organisations both large and small, i’d say the ability to easily repurpose for the needs of the immediate project – and I think mine do that well. I know that some consulting architects consider templates part of their unique ‘grab-bag’ they take with them to projects, and as a result, guard them jealously. But I take a different view. I can bring these with me to projects, yes, but I think the ability to adapt and implement are more important qualities. I also hope that by publishing my templates I am in some way contributing to the body of knowledge for software architects, and as such I appreciate any feedback.

So, to kick things off – the most important template: the standard on which all others are based…

config helper class

VS.NET’s out-of-the-box application configuration capabilities are a huge advance on VS6, but they don’t meet the needs of larger distributed systems. Where there are a number of load balanced or clustered production servers, let alone test and development environments, we ideally want a single point of application configuration – securely storing things such as database connection strings that would be a nightmare to manage in each individual web or app config file.

In a previous project I built a set of ‘common utilities’ that were packaged as a COM+ library; each application server had a proxy to it installed. One of these utilities was a class called XConfig (included in the download) which, essentially, loaded an encrypted xml document from an http stream. It was a wondrously useful little class, and one I miss in the framework. So, on a recent distributed .NET project I had one of the developers make something similar. I obviously won’t post that code here, but I will one that I did.

A common question in designing application configuration in large distributed environments is where to configure the configuration? For instance, if we stored the configuration data in a database, where do we store the connection string to it? There is no single answer to this (apart from ‘it depends’), but in many cases I think DNS is a strong candidate. If the configuration is stored in a file (easy to modify), delivered via HTTP (easy to setup, firewall rule friendly, can be load balanced for resilience), then the only configuration required is its address. This is easily managed by a DNS alias that resolves, say, a VIP. The config class can even have the alias hard-coded into it, since the environment into which it is installed will determine the physical location of the file.

The downside? Well, of all the protocols used in most projects, HTTP is perhaps the most latent, so this form of configuration is not going to be lightning fast. The consumers need to make sure they use it wisely – i.e. load it once and cache it – in asp.net pull the configuration on Application_Start; class libraries have several options, one is to use static variables populated from constructors,
as shown in the following example:

private static string _dbConn = null;public Constructor() {
if (_dbConn == null) loadConfig();
}

catch (Exception ex) {
throw new Exception(ERR_CFG_INVALID, ex);
}
}

If you have a number of such config values you should probably consider making your own internal class for your project that will load and hold them all. For more info see the documentation which is included in the download.

I wasn’t going to do this, but I just can’t resist. Look carefully at the following…


// connect to the events web service
EventAccess eventAccessWS = new EventAccess();
EventSearchResults eventsResult = new EventSearchResults();

// Serialize using the XmlTextWriter
serializer.Serialize(writer, eventsResult);
writer.Close();
fs.Close();
...


This code snippet was part of a commercial .NET project developed by consultants that best remain unnamed. It calls a .NET web service, throws away the perfectly good returned .Net object, re-serializes it, manipulates the Xml directly (using a suite of custom Xml utility objects they built for that purpose), with the local file system standing in for temporary storage. No, really…

soap trace helper

On a recent project, we had a number of ‘challenges’ getting our .net web services consumed by a java-based service. In order to even start debugging we needed to know exactly what was being being sent and received on the wire. The consuming application provided easy access to this information, but we needed a way for the .net developers to know this without loading that up or (worse) using a tool like netmon to inspect the network packets directly. Unable to find any immediate way to record this, I provided one using a SoapExtension. Turns out that this MSDN Online link (now) provides an implementation of what I wanted – it would’ve saved a lot of grief.

known issues

• doesnt work with the autogenerated .net web service testrig (I’ve no idea why not)
• this is only intended to be used in a development environment – applying the attribute will require a recompile
• writing to the file system is a privileged operation – you may need to check your local security settings.

Using it is easy enough; adjust the namespace to suit, then simply apply the attribute with an optional path to the log file.

[WebMethod, SoapTrace("d:soap.log")]