dotNetProfessional

UnitTestEx v1.2 Released!

garrmc.nospam@nospam.dotNetProfessional.com (garrymc) — Thu, 20 Aug 2009 23:23:51 -0800

I’ve just released an update to the UnitTestEx component which as the following additions:

Re-factored API signatures to make them much simpler
ExecuteUnitTestScript to support in/out params
Renamed ExecuteUnitTestValidationScriptReader to ExecuteUnitTestScriptReader which also now supports in params
Added unit test for all database related features ie ExecuteUnitTestScript
Added database scripts to allow testing of the new unit tests.
Compare now supports the ability to treat empty collections as the same as null collections. This feature can be useful if de-serialize your expected results from an XML file and your actual forces some collections to be null but the default behaviour of the code is to have initialized collections.

For anyone who has been using an older version, this version represents a number of breaking changes. The changes however are not significant and the APIs are now quite stable.

If you haven’t checked out the component yet, take a look at the original post and the code on CodePlex.

Visual Studio Debugging Slow? Try this!

garrmc.nospam@nospam.dotNetProfessional.com (GarryMc) — Thu, 20 Aug 2009 22:08:47 -0800

On my current project I find that I’m working with Visual Studio on a VM that is in an isolated domain, which is making life interesting! One of those ‘interesting’ things was that Debugging in Visual Studio was horrendously slow! It would take several minutes to get to the first break point (first line of a unit test), then still be slow when accessing other parts of the code.

The slow part of the process was the loading of the symbol files for each of the referenced dlls, including those of the .NET framework. As it turns out Visual Studio actually loads the symbol files for the .NET Framework from the internet! So the delay is primarily due to timeouts which lead to an unbearable (read unusable) debugging environment. The good news is that there is a solution which is quite simple and easy to implement.

Solution

In order to dramatically improve your debugging you need to have Visual Studio use a cached version of the symbol files, as well as ensure its not trying to locate symbol files on slow network shares.

Here are the steps you need to fix the issue:

Create a directory to store you locally cached symbols. Ie C:\Temp\SymbolCache
Change the debug settings for loading symbols, via Tools|Options|Debugging|Symbols.
(Option 1) Start debugging the code you want (on a machine that can access the internet; even if its slow) and have it sit on a break point. Then go back to the Symbols settings, where you’ll notice the button Load symbols from Microsoft symbol servers is now active (because that was obvious!). Click the button and you’ll see a popup windows indicating the download of the symbol files. After this is complete you can close out of this window and stop debugging. If you now check your Symbol Cache directory you’ll see you have a load of downloaded symbols (may vary depending on what you’ve referenced).
(Option 2) If you have already done option 1 and you need to apply this to another machine, such as a team members machine, you can simply copy the files from one machine to the other.
Depending on your environment you may also have one of two environment variables that need updating. Set either of these environment variables to the same location as the cache created in setup 2. The environment variables to change are _NT_SYMBOL_PATH or _NT_ALT_SYMBOL_PATH. The default setting for these are pointing to the Microsoft Symbols server. You can access the variables either via DOS (set command) or via the Advanced System Properties dialog in Windows.

One you’ve completed the changes you should see a dramatic improvement in your performance. Remember to check in Step 2 that you don’t have any non-existent paths or UNC paths defined as this will also slow things down.

dnp.Framework code released!

garrmc.nospam@nospam.dotNetProfessional.com (garrymc) — Thu, 21 May 2009 22:25:05 -0800

In an effort to start getting more of the code I’ve been working on out in the public domain, I’ve finally released all the code for the dnp.Framework on CodePlex. While its not all complete, most of the code is quite stable and can be used now!

Some of the major components that are included in the framework include:

Database Explorer API: An object oriented database schema API which is ideal for anyone wanting to do code generation. Its based on the provider pattern, so while it currently only supports SQL Server 2005+ its fairly easy to create a new provider for any system. This is stable enough for production use and has an extensive set of unit tests.
Data Provider: This is a database agnostic API which is fairly similar to the one in the enterprise library except it doesn’t support datasets and the like. Its also has little overhead. This was designed before the Enterprise Library had a decent model, and it has also been used on mobile devices with the compact framework.
DomainModeller: An abstract domain model view of a database schema (extends Database Explorer API). This API is most useful to creating scripts for code generation, where you can concentrate on domain concepts such as base classes, derived classes, namespaces and relationships etc, rather than database concepts. Using this API for code generation can significantly reduce the amount of code typically required.
ServiceModel: This project is still under development, but aims to provide the first ‘Model’ that extends the Domain Modeller to define a Service based Application framework. The ServiceModel acts as the abstract API for the final code generation scripts which are currently written using CodeSmith. The scripts currently have good support for the data access layer (repository), service layer (business logic) and entities (using design discussed here).

There are other components that are less substantial but provide useful features:

Configuration: classes to allow custom sections in config files.
IO: classes to make getting info from resource files easier.
Collections: classes that support multi-keyed collections. This is useful when you want to key on a natural or business key which is made up of more than one field.
Reflection: classes to help with serialization
Scripting: classes that help with naming such as converting names to plural or singular versions, casing such as pascal, camel and proper. There’s also an expression evaluator that allows evaluating an expression against an object. This is used heavily in the Domain Modeller and ServiceModel config files.
Security: CookieProtection, MachineKey encoding
Web: SafeLocalStorage, thread wide TimeZone conversions, Web log (IIS) Linq provider

This framework has taken some time to get this far and while not complete does provide a number of features that are useful today. Over the next few months I’ll blog about some of the features mentioned above to provide a better understanding of how to use them. For now the best way to get a feel for how classes are used is to look at the unit tests for the class. Most of the features have tests which give a good idea of how its used.

If you’d like to have a particular feature explained in more depth, leave a comment here otherwise I’ll pick the ones I like :)

Oh and you can find all the code here!

Unit Testing and Test Spy Library Released!

garrmc.nospam@nospam.dotNetProfessional.com (garrymc) — Wed, 20 May 2009 21:12:09 -0800

Its been some time since my last post, so I thought I’d start back with news of a small Unit Testing library I’ve been using with my current client. I developed the library to solve a number of issues I was facing while doing my unit tests. The focus of the library is to provide support for:

Test Spy Pattern: a type of of fake that monitors calls and data passed rather than trying to mock the implementation. A discussion of the pattern can be found in the xUnit Patterns book.
Comparing entities: the amount of code generally required to test that an entities properties match those of the expected version can be large and tedious to write.
Data access testing: while using Fakes and the like is great, you still need to test the code that actually talks to the database. This usually ends up taking a reasonable amount of code to setup and execute, making the test harder to read.

This library provides solutions to the above problems which in my experience has produced cleaner tests that are easier to read and understand. The library comes with a fairly detailed User Guide so I wont go into the details of how everything works here, however I will provide a quick overview of how the library attempts to solve these issues.

Test Spy pattern: adding a single property per method that you want to track to your existing Fake (Test Double) and one or two lines of code to the Fakes method implementation provides the following features:
- Was called
- Method call count
- Parameters passed in to method (per call)
- Ability to define the data returned from any method of a dependency
- Ability to simulate an exception in a dependency
Comparing entities: given two object graphs you can compare each property in a single line of code using the Compare method. The library also supports the ability to ignore certain properties that tend to always change such as primary keys that are identity fields. The Compare method currently handles the basic value types and strings as well as more complex types such as XmlDocument and DataTable, adding a new complex type is a achievable by simply defining a new Type rule.
Data access testing: when testing code that affects a database, you need to ensure the database is in a particular state before starting. This can be done via calling a stored procedure or maybe running a database script. The library opts for the second approach and allows you to embed SQL script files which can then be executed with a single line of code. This approach ensures devs always have the latest scripts and dont have to remember to update their local copy of the database. There are a other methods that help with querying the database after executing the code under test too.

The library also provides helper routines around Serialization and IO. You can download the library and its User Guide from the CodePlex project below:

http://www.codeplex.com/UnitTestEx

As I find the time I’ll blog about some of the technical aspects of the library such as extending the Compare method it to support new complex data types.

If you end up using it in your project, please leave a comment or if you have any feature improvements (or bugs) post them to the CodePlex site.

Turn multiple rows into a single string in SQL Server

garrmc.nospam@nospam.dotNetProfessional.com (garrymc) — Fri, 27 Jun 2008 22:56:56 -0800

I recently had the task of creating a report where they wanted one of the columns to list out all the users associated with a given report line item in a single comma separated string. My initial thoughts were, that this would involve some type of cursor or at least a loop of some description, which I'd then have to attach to the main result set. However, it seems there's a very nice little trick you can use that will solve this issue without the use of cursors or loops!

With the use of the COALESCE keyword you can create a list in a single line of SQL (except for declarations). I'll use the AdventureWorks database to demonstrate the technique. Assume you need to get a list of Countries and the regions they contain, in a report similar to the one below:

To produce a list you can use the following SQL:

DECLARE @result varchar(max)

SELECT    @result = coalesce(@result + ', ', '') + Name

FROM    Person.StateProvince

WHERE    Person.StateProvince.CountryRegionCode = @CountryRegionCode

RETURN @Result

View Plain | Copy To Clipboard

The way this works is the COALESCE function returns the first non-null expression. For the first record this would be the empty string + Name as @Result would be null. However, the interesting thing is that because we keep concatinating to @Result a single value is returned from the whole result set. The only issue is that for this to work we need a variable to keep storing the information in. So if you want to apply this against another table that supplies the filter, you'll have to create a function that returns the string. As this is a scalar function (ie doesn't return a result set) its use within another query is extremely easy. Assuming a function for the above is called dbo.fnRegionsToString we are left with:

SELECT Name AS Country, dbo.fnRegionsToString(CountryRegionCode) States

FROM
         Person.CountryRegion

View Plain | Copy To Clipboard

The whole script which you can test against the AdventureWorks database is:

IF  EXISTS (SELECT * FROM dbo.sysobjects WHERE [id] = OBJECT_ID(N'[dbo].[fnRegionsToString]') AND type in (N'FN', N'IF', N'TF', N'FS', N'FT'))

    DROP FUNCTION dbo.fnRegionsToString

GO

CREATE FUNCTION dbo.fnRegionsToString

    @CountryRegionCode varchar(5)

RETURNS varchar(Max)

AS

BEGIN

    DECLARE @result varchar(max)

    SELECT    @result = coalesce(@result + ', ', '') + Name

    FROM    Person.StateProvince

    WHERE    Person.StateProvince.CountryRegionCode = @CountryRegionCode

    RETURN @Result

END

GO

SELECT Name AS Country, dbo.fnRegionsToString(CountryRegionCode) States

FROM         Person.CountryRegion

View Plain | Copy To Clipboard

This makes for a very clean solution to an otherwise painful problem. So the next time you need to turn a lot of records into a single one, check to see if this technique can help.

Modeling many-to-one (M:1) entity relationships Part II

garrmc.nospam@nospam.dotNetProfessional.com (garrymc) — Wed, 25 Jun 2008 19:00:13 -0800

This is the second part of the series which discusses the issues around modeling M:1 (many-to-one) relationships. If you've not read the first part, then its advisable that you read that first before continuing with this part. To keep up to date with this and other blog's you might consider registering with the RSS feed.

Part I: The Problem

Part III: BusinessKey as a value type

Modeling many-to-one (M:1) entity relationships Part I

garrmc.nospam@nospam.dotNetProfessional.com (garrymc) — Sun, 22 Jun 2008 13:06:18 -0800

Designing a domain model can be a tough job and if you're lucky enough to start from scratch then it becomes even tougher once you apply it to the physical database model. Over the next few posts I' like to discuss the issues we encounter when modeling this relationship type, examine the way its 'normally' done and then present an alternative that I believe presents a more domain model centric view of the world. The series will be broken up into the following sections, with this being the first. To keep up to date with this and other blog's you might consider registering with the RSS feed.

Part I: The Problem

Part II: Suggested Solution

Part III: BusinessKey as a value type

The main issue when designing a domain model is that they don't have these oddities called foreign keys, as the relationships are known by association. However, once you turn your domain model into a database schema we have to start adding all these extra keys, which get worse when you have a M:M (many-to-many) relationship! In this post I'd like to discuss how we normally model the M:1 (many-to-one) relationship and its pitfalls.

The Problem

When designing a domain model (entity model) in UML its unlikely that you'd include foreign key relationships as part of your design as this is a database concept rather than a domain concept. If we take a very simple and arguably contrived example (its very basic just to highlight the concepts I want to discuss) of an Order it might look something like this (note I'm using the VS class designer which doesn't support multiplicities hence I have to use two associations to highlight relationships):

In this example we have three different types of M:1 relationships being modeled, which are:

Entity - The OrderDetail --> Product and Oder-->Customer are M:1 relationships which map to other entities within the business domain.
Reference - The Order.OrderType property is one that is restricted by a known set of values. However, this set of values can change over the life time of the application. That is its data driven and so the current values can't be coded directly within the application. Also a reference value is usually defined as a single field with no other business properties.
Enum - The Order.Status property is also restricted by a known set of values. However, unlike a reference type the values don't or can't change. These values typically drive logic which is set during design, adding a new value after deployment wouldn't add value as the application wouldn't know what to do with it.

Now that I've defined the different M:1 relationship types, they would typically be modeled in the database all the same way as foreign key constraints to their respective tables. The following diagram shows the ER (Entity Relationship) diagram of the physical database model.

So the next step in modeling our sample is to create the actual business entities that we can use in a real application, taking into account how our data is physically stored so that we can map our logical to the physical as easy as possible. This of course is where things typically start to deviate from our nice logical model. We have to take these foreign keys into consideration as the database needs them, so typically we end up with something more like the following figure than our original logical model. The following was created using Linq for SQL, which like most O/RMs (the Entity Framework will improve on this) will create something like the following:

You'll notice from this model that it more resembles the database model than it does our original logical model. We have an extra entity in the OrderType which we'd probably have in our logical too, to allow for maintenance but we didn't need to tie this object to our Order entity. The changes that were made to our original model can be summarized as:

Simple types are now complex types, namely instead of a simple enum or string we now have full entities with their associated complexities.
Our 'domain' entities now have system keys liberally scattered throughout to support persistence back to the database.

We also have the following issues as a result of this:

We expose a lot of internal information about our database when we expose foreign keys, exposing this data presents a security risk as a hacker may attempt to corrupt your data by altering the primary or foreign keys. This becomes a bigger issue when you expose your data via web services.
In the case of Linq to SQL we also have duplication of foreign key fields, namely we have both an OrderTypeID (foreign key field) and an object reference to the OrderType entity. This just looks plain ugly! Also lets say you want to change the OrderType to a different one, if you change the OrderTypeID from 1 to 2, and you did have an OrderType entity associated at the time, you'd be out of sync! The entity version of the OrderType wouldn't match the change you've just made. In the Linq to SQL architecture you're not even allowed to change the foreign key once its been set! You have to change the OrderType entity which will then update the Order.OrderTypeID. Which only goes to highlight the problems.

So now that I've expressed the issue and the potential problems with this type of design which is an all to common pattern, with the exception of the double foreign key reference that Linq to SQL uses . The question becomes why? The reasons as I see it are two fold:

Effort, it takes some effort to design more closely to the original logical model
Architectural/Technical in that we need those damn keys, so the issue is how do we make a nicer model without loosing the essential information we need?

The next part of the series will examine what we can do to fix this situation and bring our model back in line with what we originally intended.

Create a full entity class diagram with a T4 template

garrmc.nospam@nospam.dotNetProfessional.com (garrymc) — Wed, 26 Mar 2008 05:42:02 -0800

I've just released another sample for the Database Explorer API, this time using the built in features of Visual Studio 2008 (should work with VS 2005 with a download of the SDK). Visual Studio 2008 comes with a built in code generator known as T4. While the built in editing experience leaves a bit to be desired the free T4 editor by Clarius Consulting goes a long way to making it workable. If you download the editor, it indicates that the time bomb expires in Jan 1, 2008; this however isn't the case as they're still working on the next release.

This sample creates a fairly decent (not perfect by any means) set of entities which you can then easily drop on to a class designer and get a good feel for how your domain model looks. It has support for all but the recursive relationship type, which could be added as the API does support this. This sample is provided to show how much you can do with both T4 and the API in only a small amout of code. I've included a screen shot from the Adventure Works sample, which as you can see supports many relationship types. The sample download includes the results run against the AdventureWorks sample database.

To download the new sample visit the projects CodePlex page.

Remember to provide as much feed back on the samples and API as you can. Enjoy!

Learning DSL tools with Videos!

garrmc.nospam@nospam.dotNetProfessional.com (garrymc) — Fri, 21 Mar 2008 08:35:20 -0800

I'm in the process of getting up to speed with DSL tools, and while there's a whole lot of info out there, at the end of a long day I'd prefer to watch a video on a new subject rather than pour over the written docs, but trying to locate all the video's can be difficult, and even more if you want to view them in the right order. Well this is my effort to make things a little easier. Unless otherwise stated these videos's relate to Visual Studio 2008 edition of DSL tools, as I discover more DSL video's I'll add them to the list. If you know of a good one I've missed, leave a comment and I'll get it added.

Presenter: Hilton Giesenow

How Do I: Create And Use T4 Templates?

Presenter: Dylan Miles

How Do I: Get Started with the Visual Studio Domain Specific Languages?

How Do I: Create and Customize My Domain Specific Language?

How Do I: Use Advanced Customization?

How Do I: Generate Code from my Domain Specific Language Using DSL Tools?

How Do I: Create a Multi Project Template?

For those interested in DSL tools and need a rich database schema API to go with it, I've developed the Database Explorer API which provides a rich model to access your database schemas. This API is part of the larger dnp.Framework which will also include a Domain Model API amongst other things. Register for the RSS feed to keep updated on any updates.

Database Explorer API beta released

garrmc.nospam@nospam.dotNetProfessional.com (garrymc) — Mon, 17 Mar 2008 17:10:56 -0800

For anyone that's read my blog entries you've seen me make mention to a framework that I've been working on. Well today marks the release of the first beta of part of that framework. The Database Explorer API, is a database schema API that is designed to make accessing database schema information easy and intuitive.

The API has support for schemas, tables, views, indexes, constraints, relationships ie 1-1, 1-M, M-M, M-1 and recursion. While its original goal was as a replacement for the SchemaExplorer API provided with the Code Smith product, its uses are most definitely not limited to code generation. The API has no dependencies on any other libraries except the ones required to run your database. So if you're a user of MyGeneration, ArchAngel or some other code generation tool, or even if you want to use it in a windows form application you'll only have to reference the dll's to get started; oh and its free too!

The API is fairly complete but does lack support for stored procedures, functions, and retrieving contents of views. However, these are slated for a future release and any feed back on which are more important would be appreciated.

At present the API is in beta and only supports SQL Server 2005, however the provider model being used can easily be used to support other databases. If you are working with another database I'd be happy to work with you to get that database supported.

I've tried to supply a reasonable about of documentation and a few samples (which I'll blog about in more detail over the next week or so) to help get you up and running fast, because I know if it takes more than 10 minutes to get a feel for something, its probably too hard. For those not familiar with Code Smith I've just completed a sample using a console app so you can see it works as easy without Code Smith. The sample is the same as the one detailed in the API overview so check that out for more details.

As this is a beta I welcome all feed back, positive or negative (though keep it constructive) and I intend to keep releasing updates regularly. To keep updated, I'd recommend registering with the rss feed. The following links provide you with more information about the current release and what to expect in future releases.

dnp.Framework - Provides a summary of the framework and its components. You can also download the framework here.

Database Explorer API Overview - provides an overview of the API and a covers one of the samples within the API.

Database Explorer API - Provides more detailed information about the API including a class diagram. (work in progress)

Download: Database Explorer - Console Sample.zip (39.42 kb)

Did you forget something when you deployed your ASP.NET App?

garrmc.nospam@nospam.dotNetProfessional.com (garrymc) — Sat, 15 Mar 2008 04:54:28 -0800

While I don't normally get involved with deploying web applications (we normally have 'people' for that) however I did have to deploy the application you're using now. Which brings me to the blog post I recently found which discusses the top 10 best practices for ASP.NET which I've linked to on my toolbox page. The main one that concerned was of concern to me was forgetting to switch off debug mode.

   1: <system.web>

   2:   <compilation debug="false" />

   3: </system.web>

View Plain | Copy To Clipboard

This setting appears to have a large impact on production web sites so I'd check out the detail in the this post to get all the details. Also you might want to check the config files of the production apps you work on or blog if you host your own; lets just say we may need to update a few of ours!

Visual Studio Extensibility (VSX) gets serious!

garrmc.nospam@nospam.dotNetProfessional.com (garrymc) — Thu, 13 Mar 2008 02:51:39 -0800

I went along to the .NET developers association in Redmond on Monday where Ken Levy demonstrated the extensibility tools of VS.NET 2008 (which also relates to VS 2005 to some extent). It seems that MS have decided to offer the VS 2008 shell license free! If you're anyone who's looking at providing third party tools (related or not to Visual Studio) and need a good IDE host, you've just saved yourself a bucket load of time. Also, it runs in two modes, integrated (merges with your instance of VS 2008) or isolated where it acts as its own (customisable too I was led to believe) IDE without the need for VS 2008.

If you're not so inclined to use the VS Shell, you may want to try adding your own custom extensions to VS to provide addition features MS haven't gotten around to yet. The API which used to be only available to partners (at a large cost - which is now free!) allows you to extend the IDE in just about any way you want. The VSX site provides links to numerous samples and they seem quite committed to building a large community around this technology, so I'd keep an eye on their Visual Studio Gallery where the community will post their extensions.

Other improvements seem to be in the area of DSLs (Domain Specific Languages) where they now provide DSL tools to build your own DSLs. This is an area I believe will become more important as people begin to realize that a lot of what we do is based on a known pattern, with customizations for a given problem.

I'll be looking into how DSLs can be leveraged with the framework I'm currently developing that code gens your stored procs, entities and services. Anyway for those who are interested in learning more about these new tools I'd recommend you visit the following sites:

http://msdn.com/vsx - The Visual Studio Extensibility home page

http://blogs.msdn.com/klevy - Ken Levy's blog

Also MS sponsored CoDe magazine for a special focus on VSX which allows you to download the full magazine which has a heap of VSX information. You can download the PDF here.

Oh should mention that the demo's are quite impressive, take a look at the World of War Craft editor (with its own language) using the VS Shell.

ASP.NET Dynamic Controls & State Management

garrmc.nospam@nospam.dotNetProfessional.com (garrymc) — Thu, 06 Mar 2008 06:00:35 -0800

This article was originally published in the April 2003 issue of Visual Studio Magazine. Their online version has been archived, so it has been reproduced here. The articles code requires updating for .NET 2.0 which will be the subject of a future post.

ASP.NET has brought about a huge change in how we as developers think about designing a web site. We all know that ASP.NET now gives us the opportunity to create reusable custom controls which we can drag and drop onto our pages, which can even remember the information entered between postbacks, using the viewstate mechanism built into ASP.NET. This has proven to be a huge advantage in designing our pages, by allowing us to bring our more traditional programming model to the Web for the first time. ASP.NET also allows us to add these same controls dynamically at runtime.

The sample project which we will create is a relatively simple one, which should clearly demonstrate all the issues that you will face when trying to create dynamic controls yourself. In general Microsoft has done a good job with their architecture and made it really quite straightforward. However, there are circumstances where things do start to get somewhat more interesting, and we will tackle this area in detail so that you will be armed with all the knowledge you need to tackle any dynamic control issue.

Why Use Dynamic Controls?

The ability to add controls at runtime gives us the ability to create some very sophisticated web sites. We could for example have the home page render completely differently based on the users profile. We could also dynamically load the modules or controls that the user wanted so that the experience would be unique for each user. This is a particularly powerful technique if you need to change branding of your site dynamically. However, this is not the only use, if you were to create a Wizard, then you would want to load different screens based on the previous selection.

Creating our first Dynamic Control Page

The good news is that ASP.NET allows us to create dynamic controls very easily, well it does in part but I’ll come to that later. To dynamically create a control at runtime all we need to do is use the following line of code.

   1: Me.Controls.Add(Page.LoadControl(“~/MyControl.ascx”)

View Plain | Copy To Clipboard

You should note however that the control to be loaded must be the fully qualified name otherwise you may get a file not found error. A good tip is to use the ‘~’ tilde at the beginning as it is a special character which represents the root of the web application, when used with Server side controls.

This is the most basic way to display a dynamic control. In the example above we just added the control to the pages control collection. However, you can do the same thing for any container control such as a Panel or Placeholder control. In most cases you will probably want to use a Panel or Placeholder as it will allow easier positioning on the page. This is precisely what we use in our sample project, see Figure 1. As you can see we have arranged three Panel controls on the page to represent a Title, Menu/Login and Content area. This should be a familiar web design to most of you. As you can see there isn’t any real visual content yet, as we will be adding this content dynamically each time the page loads. We will be creating several simple User Controls to insert into the panel areas which we can easily create in VS.NET. It should be kept in mind that these controls can comprise any number of ASP.NET Controls. To demonstrate the use of dynamic controls we will create a series of steps or screens to guide a potential user of our site through registration. To keep it simple we will assume that anyone who isn’t registered will want to be and make our registration page our home page. You will I trust not replicate this in your site!

Due to the time it would take to describe exactly what I’ve built, I’d prefer to mention the ‘interesting’ points of code and ask that you download the sample project which contains all the code. For instructions on how to make use of these samples check out the sidebar.

Creating a Wizard Control

The sample consists of the following User Controls

Banner.ascx	Banner no advertising
Banner_Advertising.ascx	Banner with advertising
Wizard.ascx	Container for each step
Wizard_Step1.ascx	Get Username & Password
Wizard_Step2.ascx	Get personal Details
Wizard_Step3.ascx	Confirm Data Collected
Login.ascx	Allow user to login
Menu.ascx	Sample of a menu

What we want to do is create a Wizard interface that we can then dynamically load our steps into at runtime. This has several advantages, namely that it keeps the code for each step simple and also allows you to change the Wizards look and feel anytime without going back to the individual steps. Figure 2 shows the structure of our Wizard interface, the other controls such as the Banner are simply text written onto the control, one having some advertising the other not. All of these controls will be dynamically loaded into the Template shown in Figure 1 as previously discussed. The UseControl in the middle of the Wizard will be discussed later in the article.

Looking at the Wizard template you’ll notice that I’ve decided to keep the traditional Wizard style interface and have a Title and Description for each step. These details will be taken from each step as it is loaded into the control. The question then arises how do we achieve this? The best way is to make use of Interfaces. As we know an Interface allows us to create a type of contract that each object that implements it must adhere to. Then when we want to reference those objects, we can be guaranteed that if they have implemented the interface that it will have at least those properties and methods defined by the interface. Another great advantage of using interfaces is that it allows us to use early binding in our code, and therefore reduces potential errors. So I’ve created the IWizard interface which has the following signature (a signature is a common term to describe the properties and methods that make up an interface).

   1: Public Interface IWizard

   2:     ReadOnly Property Title() As String

   3:     ReadOnly Property Description() As String

   4:     ReadOnly Property NextStep() As String

   5:     ReadOnly Property PreviousStep() As String

   6: End Interface

View Plain | Copy To Clipboard

I have added a few extras to help us know what the next and previous steps in the wizard are. This will help our container control (ie Wizard.ascx) know which control to load next and which buttons should be enabled etc. As this is directly related to the Wizard UI I’ve put this Interface code in the Wizard.ascx file. You can see how all this code has been implemented by looking at the code behind file for the Wizard.

Now that we have defined our Wizard interface we need to ensure that each step implements it. To see how this is done check Listing 1. A thing to note about this code is how we determine the next step. In essence we check that the information entered on the screen for that step is valid. If it is then return the next step, if not then return the current step.

Now that we have coded all the steps to incorporate our IWizard interface and have coded the Wizard itself, its time to see if it works. When we run our first sample application (Example1.aspx), we get a screen that should look like that of Figure 3. Here you can see that we have loaded three controls dynamically into the Template (see Listing 2). In this case, as the user has not logged in, they are presented with the ability to register. To keep things simple you can see that the code merely checks a QueryString parameter for a value of ‘True’.

Maintaining State between PostBacks

When we enter our details and press next we notice that we get a rather unexpected result, none of the controls we added are still there. The reason for this is because of the way we normally code our ASP.NET Form_Load events. Normally we would do the following as is the case in our first example (see Listing 2).

   1: If Not Me.IsPostBack Then

   2:     …

   3: End If

View Plain | Copy To Clipboard

If we hadn’t created these controls dynamically this style of coding would be both fine and preferable, as it means we don’t have to do any extra work. However, this doesn’t work because despite how much Microsoft have done for us, we are still living in a stateless environment, and to that end if you create something at runtime, ASP.NET won’t keep track of it for you. You will need to do that for yourself. This means you can’t make use of this feature as you must always recreate the controls each time.

   Listing 1 – Wizard_Step1.ascx

   1: #Region "IWizard Interface"

2:

   3:     Public ReadOnly Property Title() _

   4:         As String Implements IWizard.Title

   5:         Get

   6:             Return "User Registration"

   7:         End Get

   8:     End Property

9:

  10:     Public ReadOnly Property Description() As _

  11:             String Implements IWizard.Description

  12:         Get

  13:             Return "Please enter the Username and Password you wish to use on our site."

  14:         End Get

  15:     End Property

16:

  17:     Public ReadOnly Property NextStep() As String _

  18:             Implements IWizard.NextStep

  19:         Get

  20:             If Me.txtName.Text.Length > 0 AndAlso _

  21:                     Me.txtPassword.Text.Length > 0 Then

  22:                 Return "~/Wizard_Step2.ascx"

  23:             Else

  24:                 Return "~/Wizard_Step1.ascx"

  25:             End If

  26:         End Get

  27:     End Property

28:

  29:     Public ReadOnly Property PreviousStep() As String _

  30:             Implements IWizard.PreviousStep

  31:         Get

  32:             Return "Start"

  33:         End Get

  34:     End Property

35:

  36: #End Region

View Plain | Copy To Clipboard

We could overcome this by removing the IF condition and it would fix our initial problem by recreating the controls during each postback, however there are still many issues that need to be resolved such as the following.

We need to keep track of the last control, load it and have its events fire before we remove it to replace it with the control for the next step.
Replace current control with the next one.

This process can start to become rather complicated and it would be much better if we were able to wrap this complexity up into a user control. This is exactly what we will be tackling next.

Creating a Dynamic Control Host Control

To make our coding life easier and to solve the problems associated with creating dynamic controls, we can create a control which handles all the more complex tasks for us. This then leaves us with a simple object model to program against. This is what we will be using in Example 2, and it makes what would otherwise be a complicated task easy.

The amount of code required for our control isn’t particularly large, but the concepts behind it all can be a bit confusing. I will try to explain the code presented in Listing 3, and point out the issues as we go along.

   Listing 2 – Load Event of Example1.aspx

   1: Private Sub Page_Load(ByVal sender As System.Object, _

   2:         ByVal e As System.EventArgs) Handles MyBase.Load

   3:     'Put user code to initialise the page here

   4:     ' Create the page based on the user who has entered

   5:     If Not Me.IsPostBack Then

   6:         If Request.QueryString("Registered") = "True" Then

   7:             ' Top security here, you might want to do better

   8:             ‘ authentication

   9:             Me.pnlBanner.Controls. _

  10:                 Add(Page.LoadControl("~/Banner.ascx"))

  11:             Me.pnlMenu.Controls. _

  12:                 Add(Page.LoadControl("~/menu.ascx"))

  13:         Else

  14:             Me.pnlBanner.Controls. _

  15:                 Add(Page.LoadControl("~/Banner_Advertising.ascx"))

  16:             Me.pnlMenu.Controls.Add(Page.LoadControl("~/Login.ascx"))

  17:             Me.pnlContent.Controls. _

  18:                 Add(Page.LoadControl("~/Wizard.ascx"))

  19:         End If

  20:     End If

  21: End Sub

View Plain | Copy To Clipboard

Basically what we want the control to handle for us is the whole state management of our controls once we tell it to create it. That is once we put our DynamicControlHost.ascx on our form and tell it to dynamically load a particular control, we want to assume that when we do a post back it will just be there, and we as the user of the control don’t have to worry about recreating it. In essence we want it to act like a control we placed there at design time.

To start with, we create ourselves a blank User Control in VS.NET. Next we put a Panel control onto our design surface and set the width and height properties to be 100%. This will ensure that anything we put into this will use the entire area. We then want to name it and Panel1 is not my recommendation, so we will name it ‘pnlHost’ which should make it somewhat easier to understand later. That’s all there is to it from the UI standpoint. Now let’s examine the code in Listing 3 which contains all the code necessary to finish off the control.

   Listing 3 – Dynamic Host Control

   1: Public MustInherit Class DynamicControlHost

   2:     Inherits System.Web.UI.UserControl

   3:     Protected WithEvents pnlHost As _

   4:             System.Web.UI.WebControls.Panel

5:

   6:     Web Form Designer Generated Code Here.

   7:     Dim m_strUserControl As String = ""

8:

   9:     Private ReadOnly Property UniqueKey() As String

  10:         Get

  11:             Return Me.UniqueID & "DynamicControl"

  12:         End Get

  13:     End Property

  14:     Private Sub Init2_Load(ByVal sender As _

  15:             System.Object, ByVal e As System.EventArgs) _

  16:             Handles MyBase.Init

  17:         'Now change the ID of this control to that of what

  18:         'it was previously if it is a postback

  19:         If Me.Page.IsPostBack Then

  20:             If Me.UserControlPath.Length <> 0 Then

  21:                 Me.pnlHost.Controls. _

  22:                         Add(Page.LoadControl(Me.UserControlPath))

  23:             End If

  24:         End If

  25:     End Sub

  26:     Property UserControlPath() As String

  27:         Get

  28:             If m_strUserControl.Length = 0 Then

  29:                 If Not Request.Form(Me.UniqueKey) _

  30:                         Is Nothing Then

  31:                     m_strUserControl = Request.Form(Me.UniqueKey)

  32:                 End If

  33:             End If

34:

  35:             Return m_strUserControl

  36:         End Get

  37:         Set(ByVal Value As String)

  38:             If Me.pnlHost.Controls.Count > 0 Then

  39:                 ' check that the current control isn't the same

  40:                 ' as this new one

  41:                 If Me.UserControlPath <> Value Then

  42:                     ' Remove old items because we can't simply

  43:                     ' replace them!

  44:                     Me.pnlHost.Controls. _

  45:                             Remove(Me.pnlHost.Controls(0))

  46:                     ' Add New Items

  47:                     Me.pnlHost.Controls. _

  48:                             Add(Page.LoadControl(Value))

  49:                     ' Store the new values

  50:                     m_strUserControl = Value

  51:                 End If

  52:             Else

  53:                 Me.pnlHost.Controls. _

  54:                         Add(Page.LoadControl(Value))

  55:                 m_strUserControl = Value

  56:             End If

  57:         End Set

  58:     End Property

59:

  60:     ReadOnly Property UserControl() As Control

  61:         Get

  62:             Return Me.pnlHost.Controls(0)

  63:         End Get

  64:     End Property

65:

  66:     Protected Overrides Sub Render(ByVal writer As _

  67:             System.Web.UI.HtmlTextWriter)

  68:         ' We want to include a HTML Form field to store the

  69:         ' current UI Object

  70:         MyBase.Render(writer)

  71:         writer.Write("<input type=""hidden"" name=""" & _

  72:                 Me.UniqueKey & """value=""" & _

  73:                 Me.UserControlPath & """/>")

  74:     End Sub

  75: End Class

View Plain | Copy To Clipboard

Looking at Listing 4 we can see how the code in Listing 3 is used. One of the first things to note is that we can still use our Me.IsPostBack statement, this is due to the fact we have put our custom control on the form which ASP.NET will automatically recreate for us. The only code we actually need to write to use the control is the following.

   1: Me.dchBanner.UserControlPath = "~/Banner.ascx"

View Plain | Copy To Clipboard

Where we simply set the path of the Usercontrol we wish to load. Now looking at the code in Listing 3 we can find out what is happening when we set this property.

First we check if we have previously loaded a control by checking the number of controls in the pnlHost control collection. As our control will only ever support one at a time we simply check if its greater than zero. If we haven’t loaded a control yet, then we simply add the control to the Panel object and set the private strUserControl to the value of the Usercontrol, which we will store later.

If however we had loaded a control then we would need to first check if the new control is the same as the current one. If it is not, we need to remove it from the Panel control collection and replace it with the new one. This sounds simple enough, but as luck would have it once you add a control you can’t simply replace it with another, you must remove it and then add your new one.

This doesn’t seem like it would cause many problems, but it does! At the moment our control would only work every second time, to understand why this is so we need to get a very close look at how ViewState works, which is our next Topic, but before we do we need to finish discussing the other properties.

As mentioned earlier we can now check for PostBack, this is possible due to our control automatically recreating the previously loaded control during its Page_Init event. I’ve decided to use a separate routine that handles the event as I find it makes maintenance easier if you can see all your code, as opposed to having some hidden in the Form Designer code area.

The code is fairly straight forward in that is simply checks for a PostBack event signaling that we should have a control to load back too, but we double check this by seeing if we have a control stored. The technique used to store the previous control is worth discussing and is wrapped up in the UserControlPath property and Render method which is discussed below.

Once we have determined a control has been previously loaded we load it into the Panel object ready to use. As you will notice from Figure 5, this makes the control ready to be used prior to the Load Events, thereby making our dynamic control act just like a control added at design time.

Back to how we store the current UserControl, we can look at the property Get of the UserControlPath property which first checks if the local variable has been set (remember that this is a stateless environment and this variable is reset at the start of each PostBack), if it is then this is returned. However if it isn’t then it is repopulated by getting the value that was stored with the form. The value is stored with the form during the Render method which has been overridden. I have chosen this technique for a few reasons.

At the time we need to know the current UserControl, ViewState is not available to us, and so we can’t use that. Another alternative would have been to use session state which I did use in the first versions of this control. However, apart from using resources on the Server, which is never a good thing, it suffered a major issue with users using the browser back button. As the current control is stored on the Server if a previous page is sent back, our control will attempt to load a control which is incompatible with the ViewState data held in the form. When this happens it all ends in a crash! So there had to be a better way. Server controls were out as they again weren’t available to us in the Page_Init event, and the hidden input box control didn’t seem to render for some reason. Therefore I used the technique of adding the hidden input box directly to the output stream. A hidden text box (as Classic ASP programmers will know) is a great way to pass information from page to page, and in fact is the way Microsoft handle their ViewState data. This form field will be available during the Page_Init using the following line of code, as used in the property Get of UserControlPath.

   1: Request.Form(Me.UniqueKey)

View Plain | Copy To Clipboard

The UniqueKey property is used to ensure that should we have several of our controls on the one form each will be able to be identified uniquely. This is achieved by simply annotating the text ‘DyanmicControl’ to the end of the controls UniqueID property.

UserControl is our last property and is useful if you want to access the control as an object once you’ve created it. The code is very straight forward, basically just returning the first control in the panels control collection.

   1: Return Me.pnlHost.Controls(0)

View Plain | Copy To Clipboard

Getting a close look at ViewState

We would have all heard of and probably even looked at ViewState by now. However how does ASP.NET make use of the hidden variable? View state is a wonderful piece of technology that Microsoft has given us to simulate a state full environment. Most of the time we need not worry too much about how it works, because it just does. However when we start to get a bit tricky as we are in this example we do need to understand what’s happening under the covers, because something isn’t working right and we need to understand why.

I’ve written two little utilities which let us get a better look at what’s happening, you’ll find the code in the download. One lists all the form controls and their contents, and the other lists the contents of ViewState.

To see what is happening when we run our project lets put a break point on the following line in Example2.aspx, which is located in the PreRender event. This line does nothing except to allow us code to place a break point on, now run the project.

   1: Dim x as Integer = 1

View Plain | Copy To Clipboard

Press continue when the code stops, the first page will then appear to run fine so enter a username and password, now before the next screen appears the code will stop again. At this point type the following into the command window.

   1: web.utils.debug.displayFormVars (Me.Controls)

View Plain | Copy To Clipboard

This will produce a long list of all the controls that are on the page, now look for the following section.

    ID:(dchContent:_ctl0:_ctl4)
                ID:(dchContent:_ctl0:dchStep:_ctl1:_ctl0)
                ID:Label2(dchContent:_ctl0:dchStep:_ctl1:Label2)
                ID:(dchContent:_ctl0:dchStep:_ctl1:_ctl1)
                ID:txtAddress(dchContent:_ctl0:dchStep:_ctl1:txtAddress)
                ID:(dchContent:_ctl0:dchStep:_ctl1:_ctl2)
                ID:Label3(dchContent:_ctl0:dchStep:_ctl1:Label3)
                ID:(dchContent:_ctl0:dchStep:_ctl1:_ctl3)
                ID:txtPhone(dchContent:_ctl0:dchStep:_ctl1:txtPhone)
            ID:(dchContent:_ctl0:dchStep:_ctl1:_ctl4)
        ID:(dchContent:_ctl0:dchStep:_ctl1)
        ID:pnlHost(dchContent:_ctl0:dchStep:pnlHost)
        ID:(dchContent:_ctl0:dchStep:_ctl2)

The thing I’d like to draw your attention to is the UniqueID of the dynamic control host content control (dchContent), and one of the controls that it contains like the textbox for the Name. At the moment the UniqueID is dchContent:_ctl0:dchStep:_ctl1:txtAddress. Lets, now continue the program and stop it again after we enter some details.

Now if you do the same thing again you’ll notice that the UniqueID is now dchContent:_ctl0:dchStep:_ctl0:txtAddress, but why is it different, and what does it mean? What it means is that unless the UniqueID’s are exactly the same between postback’s ViewState will not work!, and neither will the events on the control. However, if you try running the page again, by reentering the data you’ll notice as pointed out earlier that on the second attempt it does in fact work. Looking at the UniqueID’s again after the postback you’ll notice it’s the same as the previous. So why is this happening? The reason is quite simple, basically when ever you add a control to a container ASP.NET keeps an internal count which it then uses to calculate the UniqueID for that control. The reason it does this is because you could have 4 texboxes all with the same name (such as in a grid), and .NET needs to identify them all uniquely, it does this by means of a UniqueID. This is all fine, except when you want to remove an item from the collection and add a new one. The problem is the internal counter doesn’t reset, which means if you add ten controls then remove them all again then add one more control the internal counter would be 10 not 0. This makes sense because unless .NET can guarantee a UniqueID for every control it generates the ViewState mechanism just wouldn’t work properly. So what does this mean for our control? Well it means that unless we can always make the UniqueID for each control the same on postback our control simply won’t work!

   Listing 4 - Example 2 Page Load

   1: Private Sub Page_Load(ByVal sender As System.Object, _

   2:     ByVal e As System.EventArgs) Handles MyBase.Load

   3:     ' Put user code to initialize the page here

   4:     ' Create the page based on the user who has entered

   5:     If Not Me.IsPostBack Then

   6:         If Request.QueryString("Registered") = _

   7:                 "True" Then

   8:             ' Top security here, you might want to do

   9:             ' better authentication

  10:             Me.dchBanner.UserControlPath = "~/Banner.ascx"

  11:             Me.dchMenu.UserControlPath = "~/menu.ascx"

  12:         Else

  13:             Me.dchBanner.UserControlPath =

  14:                     "~/Banner_Advertising.ascx"

  15:             Me.dchMenu.UserControlPath = "~/Login.ascx"

  16:             Me.dchContent.UserControlPath = _

  17:                     "~/Wizard2.ascx"

  18:         End If

  19:     End If

  20: End Sub

View Plain | Copy To Clipboard

I’m not completely satisfied with the solution I’ve found, however it does seem to do the trick, and is very easy to implement. The interesting thing is you don’t have to touch our custom control. Instead you need to add a little bit of code to each control which will be created dynamically. As we can override properties in .NET we are able to override the UniqueID property of all our controls. So to get everything to work you simply include this piece of code in all your custom controls.

   1: Public Overrides ReadOnly Property UniqueID() As String

   2:     Get

   3:         Return Me.Parent.Parent.UniqueID & ":_ctl0"

   4:     End Get

   5: End Property

View Plain | Copy To Clipboard

The purpose of this code is to ensure that the UniqueID for each control within the container remains _ctl0 regardless of what the internal counter would have made it. Now given that we have basically removed the safeguard that Microsoft has put in, there are some ramifications. You will only be able to include one control per instance of the DyanamicControlHost control. However, given that we don’t support more than one anyway that’s not a big issue, but it is one to remember if you use the technique elsewhere. Also you may have problems if the control is used outside the dynamic control host control.

So given that you’ve added this code to your controls the DyanamicControlHost is now complete and makes using dynamically created controls as easy to use as those we create at design time (see Listing 4). Note that in the code download the first step in the wizard (Wizard_Step1.ascx) has this code commented out to demonstrate how it worked without the code. You will need to uncomment this code again to make example 2 work properly.

As an alternative in the second step, I have tried to demonstrate another technique. Now that we have a full OO language we can take advantage of Inheritance, and so I have created a WizardBase class which includes the overridden UniqueID property and the IWizard interface. So you can now Inherit from this class instead of System.Web.UI.UserControl. This means instead of implementing the properties of IWizard you now override the properties of the base class instead. The base class has been included in the Wizard.ascx code behind file. This method preferable as it ensures you don’t forget to override the UniqueID property while still forcing you to implement all the IWizard properties.

Storing Data after PostBack

Now that we have solved the issues with the dynamic controls being created we need look at how we can persist data between round trips to the server, so that we can make use of the data when the finish button is pressed.

To do this we need to store the data between postbacks in a way that’s easy to retrieve. The .NET framework provides a number of nice ways to do this. To give more options when storing our data, I designed a simple Data Storage component for post back data (see Figure 4), which takes advantage of the .NET features but simplifies their use. This currently makes use of the cache object, but could be reconfigured to use just about anything. The code is included as part of the download but was a bit lengthy to include here.

So using our new Data Storage system it becomes a simple matter of storing and retrieving information as the following examples demonstrate.

   1: Web.Data.Store("Registration.Name", Me.txtName.Text)

2:

   3: strName = CType(Web.Data.Retrieve("Registration.Name", ""),String)

View Plain | Copy To Clipboard

Note that the first parameter takes a key, this is used to identify the data once it has been stored. Looking at the UML model of the data object we can see that it is overloaded and allows for a default value if so desired. Another overloaded parameter is that of sessionWide which determines whether this value is cleared when the clear method is called. Remember not to store many items here as it will remain in memory until the session has ended.

We are now ready to start collecting our information from the forms. Each form simply stores the current value of its controls during the changed event of the particular control. As all the code for this is virtually identical, I’ll only detail one of them.

   1: Private Sub txtName_TextChanged(ByVal sender As System.Object, _

   2:         ByVal e As System.EventArgs) Handles txtName.TextChanged

   3:     '  We want to store this information so that we can use it later on.

   4:     Web.Data.Store("Registration.Name", Me.txtName.Text)

   5: End Sub

View Plain | Copy To Clipboard

To retrieve the data once stored is again a simple process as this excerpt from the third step in the Wizard shows.

   1: Me.lblName.Text = CType(Web.Data.Retrieve("Registration.Name", ""), String)

View Plain | Copy To Clipboard

Notice how we always use the CType function, this is because the Retrieve method returns back a data type of Object. If you turn Option Strict On, which you should do as it actually makes your code run faster as well as reducing potential errors. You’ll notice that you get an error if you don’t explicitly cast the returned object into the correct data type of the receiving object. In this case the Text property of the Label control has a type of String.

It’s also interesting to note that it’s important to re-populate controls during the Page_PreRender event and not the Page_Load event. The reason for this is evident if you examine Figure 5, here you can see that the Page_Load events fires before the events of individual controls. This means that if you re-populate the controls during the Load event you would in fact overwrite any changes the user had made, which would not be very desirable.

So once we have wired up all the controls to store their values into our new Data object, we can then make use of this data to redisplay it in our last step of the sample. In reality we would pass the data to a database and do other validation, but we have kept the sample simple.

Bits & Pieces

That’s covered the core section of the article, however there are a few other bits and pieces which are worth knowing when you start to create your own implementations.

Caching is a new feature in ASP.NET and we have the ability to cache at either the page level or control level. Making use of this with your dynamic controls means you can create container sites where most of the work is already cached and only the inner content has to be processed.

Also, it is possible to create one page that then dynamically loads each of the content controls into the content area via a query string parameter, such as;

   1: http://LocalHost/Default.aspx?url=~/Page1.ascx

View Plain | Copy To Clipboard

Your page can then dynamically load the URL into the content area. An advantage of this technique would be that if you needed to change the layout of the main pages you’d only have to do it in one place.

Conclusion

We have covered a large amount of material in this article, material which if mastered will help you produce more dynamic and exciting web applications. The techniques discussed here were varied from data storage to process flows using a Wizard metaphor. I encourage you to test drive the code supplied and let your imagination loose on the possibilities that dynamic controls can bring.

Source - DynamicControls.zip (72 kb)

Encrypt sections of Web.Config or App.Config

garrmc.nospam@nospam.dotNetProfessional.com (garrymc) — Mon, 03 Mar 2008 18:03:24 -0800

In many application be they web or otherwise it can be important to secure parts of the configuration files incase the file is compromised by a hacker or you simply don't want anyone to know what the true values are. It turns out that this is fairly easy to do using the ASP.NET IIS Registration Tool (Aspnet_regiis.exe) (obvious right?). To illustrate the point I'll show you a typical config file and what's required to encrypt parts of it.

   1: <?xml version="1.0" encoding="utf-8" ?>

   2: <!--

   3:   Initial Config file without taking encryption into concideration

   4: -->

5:

   6: <configuration>

   7:   <configSections>

   8:     <section name="dataConfiguration" type="Microsoft.Practices.EnterpriseLibrary.

   9:             Data.Configuration.DatabaseSettings, Microsoft.Practices.EnterpriseLibrary.Data,

  10:             Version=3.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />

  11:   </configSections>

  12:   <dataConfiguration defaultDatabase="MyDatabase">

  13:     <providerMappings>

  14:       <add databaseType="Microsoft.Practices.EnterpriseLibrary.Data.Sql.SqlDatabase,

  15:             Microsoft.Practices.EnterpriseLibrary.Data, Version=3.0.0.0, Culture=neutral,

  16:             PublicKeyToken=b03f5f7f11d50a3a" name="System.Data.SqlClient" />

  17:     </providerMappings>

  18:   </dataConfiguration>

19:

  20:   <appSettings>

  21:     <add key="BufferSize" value="999999"/>

  22:     <add key="SomeService.UserName" value="secure-username"/>

  23:     <add key="SomeService.Password" value="secure-password"/>

  24:   </appSettings>

25:

  26:   <connectionStrings>

  27:     <add name="MyConnectionString" connectionString="Data Source=.;

  28:         Integrated Security=SSPI;Initial Catalog=MyApplicationDB;"

  29:         providerName="System.Data.SqlClient" />

  30:   </connectionStrings>

  31: </configuration>

View Plain | Copy To Clipboard

The settings of each of these can easily be retrieved using the following code which is included in the download as a console app.

   1: static void Main(string[] args)

   2: {

   3:     // Write out the contents of the config file.

   4:     Console.WriteLine("MyConnectionString = " +

   5:         ConfigurationManager.ConnectionStrings["MyConnectionString"]);

   6:     Console.WriteLine("BufferSize = " + ConfigurationManager.AppSettings["BufferSize"]);

   7:     Console.WriteLine("SomeService.UserName = " +

   8:         ConfigurationManager.AppSettings["SomeService.UserName"]);

   9:     Console.WriteLine("SomeService.Password = " +

  10:         ConfigurationManager.AppSettings["SomeService.Password"]);

11:

  12:     Console.ReadLine();

  13: }

View Plain | Copy To Clipboard

In the example above you may want to encrypt the connection string and two of the keys in appSettings, but probably not the BufferSize property as you'd like that to be easily accessible or at least readable on the production server. The problem we have is that the Aspnet_regiis.exe tool only works on entire sections ie appSettings, connectionStrings. So encrypting the connectionStrings section is fairly straightforward and can be done with the following command lines:

   1: copy App.Config App.Config.original

   2: rename App.config web.config

   3: aspnet_regiis -pef connectionStrings . -prov DataProtectionConfigurationProvider

   4: rename web.config App.config

View Plain | Copy To Clipboard

So this is a little strange and the reason is that the tool only works with web.config files, however by renaming, then processing our app.config file we can get the desired result. I've included this as a batch file in the project download. You just need to run the batch file in the directory that your app.config file resides in. If you want to run this against your web.config then you only need the third line. The new config file should look something like this (I've reformatted it a bit):

   1: <?xml version="1.0" encoding="utf-8" ?>

   2: <!--

   3:   Initial Config file without taking encryption into concideration

   4: -->

5:

   6: <configuration>

   7:   <configSections>

   8:     <section name="dataConfiguration" type="Microsoft.Practices.EnterpriseLibrary.

   9:         Data.Configuration.DatabaseSettings, Microsoft.Practices.EnterpriseLibrary.Data,

  10:         Version=3.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />

  11:   </configSections>

  12:   <dataConfiguration defaultDatabase="MyDatabase">

  13:     <providerMappings>

  14:       <add databaseType="Microsoft.Practices.EnterpriseLibrary.Data.Sql.SqlDatabase,

  15:          Microsoft.Practices.EnterpriseLibrary.Data, Version=3.0.0.0, Culture=neutral,

  16:          PublicKeyToken=b03f5f7f11d50a3a" name="System.Data.SqlClient" />

  17:     </providerMappings>

  18:   </dataConfiguration>

19:

  20:   <appSettings>

  21:     <add key="BufferSize" value="999999"/>

  22:     <add key="SomeService.UserName" value="secure-username"/>

  23:     <add key="SomeService.Password" value="secure-password"/>

  24:   </appSettings>

25:

  26:   <connectionStrings configProtectionProvider="DataProtectionConfigurationProvider">

  27:     <EncryptedData>

  28:       <CipherData>

  29:         <CipherValue>AQAAANCMnd8BFdERjHoAwE/Cl+sBAAAALNO8kQcyL0SKbOQ8HQGp0AQAAAACAAA

  30:         AAAADZgAAqAAAABAAAAAd1TPFE24MHo78J8HYFRXKAAAAAASAAACgAAAAEAAAAAJ8yjPvsnqP0Lo

  31:         Qt05ynrWoAQAANJdt/En21VeyYb8OJcTE3p+MeKOMG4xsFPzjlrHnyaJmVEekYVMCkX2RG/1pV1J

  32:         DfsaCAXKSyBnxDiCM5yAQEA5TSxeedQYvKXWBWrUxMMIjNUmjZDsbc8I/eBKarMCHav7d+oguijn

  33:         HFf948x48Z25434QY1lZ4hnkP7oW5dO9639iaT3+uWJRoARzHzcfvNYxtJ/+jowoZyt+JRcHjR1Q

  34:         MBD/CMsehNh4nQeWX2zp09tYm2EdIj7LmSyWwrE9Livf1qs/IBGRv1zWPIue956mAwDbXPg4tuF1

  35:         Ml4Qdm3rj9+mCp/sht80ixkWM9nID8/OaqZqzaaK/J/3vMjZF+w4SeFws8Vo40xb48/Mr1Q5EOZe

  36:         JMNa1ySiard4pckR1Xd3rRPA+J1+6BBTCws0qsmBtd5pVs0KW0xt0HIlUELA7NYIsXML+zGFgJ2C

  37:         TTGcTQsUF5y3+soUeXxfM2Eq3NqSVouWJMImT2udvR6PCiHGsNMiT9/ZK8TL0C5aAzD47IAc0ngA

  38:         DF/uTcX8ERWUy7LPwIlDRXamTlRmVvXt712na83nFf+FExhQAAADDz+jCgtqU0npcs6WJgVP/+QU

  39:         cQQ==</CipherValue>

  40:       </CipherData>

  41:     </EncryptedData>

  42:   </connectionStrings>

  43: </configuration>

View Plain | Copy To Clipboard

So that's how easy it is to encrypt a section of the config file, however, we still have an issue with encrypting part of our appSettings. The problem is you can't selectively encrypt part of a section, its an all or nothing scenario. Therefore, to achieve our goal, we have to add a new section and encrypt that. This leaves us with a config file that looks like this:

   1: <?xml version="1.0" encoding="utf-8" ?>

   2: <!--

   3:   Config file taking encryption into concideration

   4: -->

5:

   6: <configuration>

   7:   <configSections>

   8:     <section name="secureAppSettings" type="System.Configuration.NameValueSectionHandler,

   9:         System, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />

  10:     <section name="dataConfiguration" type="Microsoft.Practices.EnterpriseLibrary.Data.

  11:         Configuration.DatabaseSettings, Microsoft.Practices.EnterpriseLibrary.Data,

  12:         Version=3.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />

  13:   </configSections>

  14:   <dataConfiguration defaultDatabase="MyDatabase">

  15:     <providerMappings>

  16:       <add databaseType="Microsoft.Practices.EnterpriseLibrary.Data.Sql.SqlDatabase,

  17:         Microsoft.Practices.EnterpriseLibrary.Data, Version=3.0.0.0, Culture=neutral,

  18:         PublicKeyToken=b03f5f7f11d50a3a" name="System.Data.SqlClient" />

  19:     </providerMappings>

  20:   </dataConfiguration>

21:

  22:   <appSettings>

  23:     <add key="BufferSize" value="999999"/>

  24:   </appSettings>

25:

  26:   <secureAppSettings>

  27:     <add key="SomeService.UserName" value="secure-username"/>

  28:     <add key="SomeService.Password" value="secure-password"/>

  29:   </secureAppSettings>

30:

  31:   <connectionStrings>

  32:     <add name="MyConnectionString" connectionString="Data Source=.;Integrated Security=SSPI;

  33:         Initial Catalog=MyApplicationDB;" providerName="System.Data.SqlClient" />

  34:   </connectionStrings>

  35: </configuration>

View Plain | Copy To Clipboard

The new parts have been highlighted and show that I've added a new secureAppSettings (can be anything) section and then added the section with the name value pairs that I want to encrypt. Now all I need do is modify the original batch file to include this section too:

   1: copy App.Config App.Config.original

   2: rename App.config web.config

   3: aspnet_regiis -pef connectionStrings . -prov DataProtectionConfigurationProvider

   4: aspnet_regiis -pef secureAppSettings . -prov DataProtectionConfigurationProvider

   5: rename web.config App.config

View Plain | Copy To Clipboard

This then produces the following encrypted config file ready for deployment - well almost...

   1: <?xml version="1.0" encoding="utf-8" ?>

   2: <!--

   3:   Config file taking encryption into concideration

   4: -->

5:

   6: <configuration>

   7:   <configSections>

   8:     <section name="secureAppSettings" type="System.Configuration.NameValueSectionHandler,

   9:         System, Version=1.0.3300.0,Culture=neutral, PublicKeyToken=b77a5c561934e089" />

  10:     <section name="dataConfiguration" type="Microsoft.Practices.EnterpriseLibrary.Data.

  11:         Configuration.DatabaseSettings,Microsoft.Practices.EnterpriseLibrary.Data,

  12:         Version=3.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />

  13:   </configSections>

  14:   <dataConfiguration defaultDatabase="MyDatabase">

  15:     <providerMappings>

  16:       <add databaseType="Microsoft.Practices.EnterpriseLibrary.Data.Sql.SqlDatabase,

  17:         Microsoft.Practices.EnterpriseLibrary.Data, Version=3.0.0.0, Culture=neutral,

  18:         PublicKeyToken=b03f5f7f11d50a3a" name="System.Data.SqlClient" />

  19:     </providerMappings>

  20:   </dataConfiguration>

21:

  22:   <appSettings>

  23:     <add key="BufferSize" value="999999"/>

  24:   </appSettings>

25:

  26:   <secureAppSettings configProtectionProvider="DataProtectionConfigurationProvider">

  27:     <EncryptedData>

  28:       <CipherData>

  29:         <CipherValue>AQAAANCMnd8BFdERjHoAwE/Cl+sBAAAALNO8kQcyL0SKbOQ8HQGp0AQAAAACAAAA

  30:         AAADZgAAqAAAABAAAACF8idXnx0O07526CxQFh9BAAAAAASAAACgAAAAEAAAACNxLiQ6eAyzE8jZG

  31:         yUhwThYAQAAii89rtpXJsxeklxD/7LhjtLzzaRGxcCpWUDuI+uNKuN0GrDeKSXRB0s7tfumGdzkZM

  32:         iR6qlTE9ueIDWO8tm79pVJ3emkYSiBRGi4KXs5oAPugwyuZ/Qfq3LC2d1U07EWGvOBQK4SjTC56De

  33:         KKZDLwu+3WRBYLGLdJapCnMQ4lB/Ev29R9XYW9iqQfgOFE3iFdtcfts4+8Ig7y6CYe3A845VZWBD0

  34:         6SFu2obFZ8vGCRmF2qr0M9N9uxT+xOCRX7G5vkbH+TpFSiUQoV+cC5f9y98uCyj2xL60GxO+PZM8W

  35:         UJFYknRoX6SkVzfRwX+GWcdRc+nYSM1+I/hica32POuWur5lAhye0JO2SHTKSj66S+XjiM64fkh+b

  36:         HNp1LXf0ciEZQNIZeknVzClns6vHHDYYPI3iPYs+dTv3hoNPSDe4kee9BhuPWgRBS3uObPt6ySv46

  37:         QHJH4QWsUAAAAxcEHWBLJ1zw1Y5etR7t4EFeU5X8=</CipherValue>

  38:       </CipherData>

  39:     </EncryptedData>

  40:   </secureAppSettings>

41:

  42:   <connectionStrings configProtectionProvider="DataProtectionConfigurationProvider">

  43:     <EncryptedData>

  44:       <CipherData>

  45:         <CipherValue>AQAAANCMnd8BFdERjHoAwE/Cl+sBAAAALNO8kQcyL0SKbOQ8HQGp0AQAAAACAAAA

  46:         AAADZgAAqAAAABAAAABv17Dh+HaRnrZppOfniJMaAAAAAASAAACgAAAAEAAAAF1mqOQdo+lvm45mQ

  47:         MwaiaKoAQAAHVHExOIDaItnnbRK7n/qHudiSUAq22t2qRTSxQDxE/lYyN2gA/cWHTw4njHVRu+MJN

  48:         awquuIFKW7RLFAlDYdJPA2xPHakwJXt6MLCOgdXmd+YojqP7AYHrPbFuRGF/8sNY+SlH0QOZya53D

  49:         AuljzMUQoE27BQbsCT+tLriMnGgmc8SaCjAFqqVc538zxxKLFnLZJLttHm5qAq7/y65abZDMjYo4Y

  50:         m4RpmhxQ5ZyITWpGt8RWabZ10MgWvcWS+QiL+ONVhs7lgR5wo0tDk1aoMh0f2VrSZPfXYoC8ZR2JV

  51:         0jqVSNasYmZN/+AO2G+6/S8YxETJqYD3BL8qFBtok9NUzvvoGMZYw+lJniSoLCBWtNoFpFM90/v0x

  52:         hCfRZZqiYj/8OOpJQT38ycG1N/zskhK/LAKe7loZGgPMl1wUjnFGpLOHW+f2ikVtYtHkH3+qxqny8

  53:         AeSZKovMnhfZlXUJx18G0Ugpvskmgju9aKtnE6UWLZbiiygJAfifQUjTwjFXgibQmuvFPxlWuUSW7

  54:         e6fBzVggx1zpDqnu5RGksN+zOg3S7IyiC79GihQAAAAWBM1NaI+3SdfalbKCGvuhxxTNSQ==

  55:         </CipherValue>

  56:       </CipherData>

  57:     </EncryptedData>

  58:   </connectionStrings>

  59: </configuration>

View Plain | Copy To Clipboard

If we try and run our original console app the values for our secure settings won't be retrieved, which if you've been paying attention you'll no-doubt have worked this out as the values are no longer part of the appSettings section but part of the secureAppSettings section. So we need to update our original console app to look at this section instead:

   1: static void Main(string[] args)

   2: {

   3:     // Write out the contents of the config file.

   4:     Console.WriteLine("MyConnectionString = " +

   5:         ConfigurationManager.ConnectionStrings["MyConnectionString"]);

   6:     Console.WriteLine("BufferSize = " + ConfigurationManager.AppSettings["BufferSize"]);

7:

   8:     // Access the secureAppSettings

   9:     NameValueCollection secureAppSettings =

  10:         (NameValueCollection)ConfigurationManager.GetSection("secureAppSettings");

  11:     Console.WriteLine("SomeService.UserName = " + secureAppSettings["SomeService.UserName"]);

  12:     Console.WriteLine("SomeService.Password = " + secureAppSettings["SomeService.Password"]);

13:

  14:     Console.ReadLine();

  15: }

View Plain | Copy To Clipboard

Running this version gives the same result as the original except that now all the parts that we want encrypted are. The really cool thing is that this works if the config is encrypted or not, which allows you to work with an un-encrypted version during dev and then have your Ops people encrypt it (once they put the real values in) just prior to deploy or as part of the deployment script.

EncryptionSample.zip

Programming Microsoft Message Queues (MSMQ) in .NET Book Chapters

garrmc.nospam@nospam.dotNetProfessional.com (garrymc) — Tue, 09 Oct 2007 19:11:30 -0800

Here is Chapters 4 & 5 of the book I never got around to publishing. The chapters cover MSMQ in a fair amount of depth, but remember whole books have been written on this subject. So don’t expect it to be some type of bible. Having said that, if you don’t need to be a guru then these Chapters will give you more than enough knowledge to start working with MSMQ and also explain why it’s a good fit for a particular situation. I’ve included the table of contents so you’ll have an idea of what’s being covered. If you have any feedback feel free to leave a comment!

dotNetProfessional

UnitTestEx v1.2 Released!

Visual Studio Debugging Slow? Try this!

Solution

dnp.Framework code released!

Unit Testing and Test Spy Library Released!

Turn multiple rows into a single string in SQL Server

Modeling many-to-one (M:1) entity relationships Part II

Suggested Solution

Modeling M:1 Entities

Modeling many-to-one (M:1) entity relationships Part I

The Problem

Create a full entity class diagram with a T4 template

Learning DSL tools with Videos!

Database Explorer API beta released

Did you forget something when you deployed your ASP.NET App?

Visual Studio Extensibility (VSX) gets serious!

ASP.NET Dynamic Controls & State Management

Why Use Dynamic Controls?

Creating our first Dynamic Control Page

Creating a Wizard Control

Maintaining State between PostBacks

Creating a Dynamic Control Host Control

Getting a close look at ViewState

Storing Data after PostBack

Bits & Pieces

Conclusion

Encrypt sections of Web.Config or App.Config

Programming Microsoft Message Queues (MSMQ) in .NET Book Chapters

Chapter 4 Contents

Message Queues 101.

A Simple Analogy.

The Mechanics.

Types of Queues.

Why use Message Queues?.

What are my Options?.

Choosing the correct option.

Simple.

Complex.

Recoverable.

Transactional

Acknowledgements, Time Outs, Journaling and Dead-letters.

Queued Components.

MSMQ Triggers.

Installing MSMQ.

MessageQueue Object

Queue to connect

MessageQueue.Send.

Simple Method.

Example 1a – Sending a Text Message (Hand coding)

Example 1b – Sending a Text Message (IDE)

Complex Method.

Example 2 – Sending an Object

Example 3 – Recoverable Messages.

MessageQueue.Receive.

Example 4 – Message Monitor

Static Methods.

Summary.

Resources:

Chapter 5 Contents

Using Transactions.

Internal Transactions.

Example 5 – Sending a Transactional Message.

External Transactions.

Using COM+ for DTC Support

Using COM+ to update a Database.

Example 5c – Creating a DTC enabled Message receiver

Acknowledgements, Time outs and Journaling.

Acknowledgements.

Example 6a – Setting Acknowledgements.

Example 6b – Receiving Acknowledgements.

Example 6c – Receiving Messages.

Timeouts.

Example 7 – Timeouts.

Journaling & Dead-letters.

Example 8a – Keeping copies of received messages.

Example 8b – Keeping copies of sent messages.

Example 8c Receiving messages from Public Queues.

Example 8d – Resending a Timed out message.

WMI.