Elton Stoneman

Retrieving Nested Properties from Lambda Expressions

EltonStoneman — Fri, 06 Nov 2009 04:14:55 GMT

[Source: http://geekswithblogs.net/EltonStoneman]

Supposing you’re using a lambda expression as a neat way to access a named property:

s => s.FirstName

- when what you really want is to access it without using a string for the property name (“FirstName”), for example to specify the source or target property for a mapping exercise.

It’s easy if the expression is a direct property of the parameter type – a member of the “s” in the expression; casting the whole expression as a MemberExpression gives you access to the member as a PropertyInfo. You can encapsulate it in an extension method of LambdaExpression:

public static PropertyInfo AsPropertyInfo(this LambdaExpression expression)

{

PropertyInfo info = null;

if (expression.Body.NodeType == ExpressionType.MemberAccess)

{

info = ((MemberExpression)expression.Body).Member as PropertyInfo;

}

return info;

}

- which lets you access the property like this:

Expression<Func<FullUser, object>> exp = s => s.FirstName;

PropertyInfo sourceProperty = exp.AsPropertyInfo();

But if the expression represents a property of a nested type, or a property of a nested type of a nested type:

s => s.Address.Line1

s => s.Address.PostCode.Code

- then it’s different.

What you want in this case is an executable expression which will access the containing object of the property (e.g. get you the Address property of the source object, or the PostCode property of the Address property of the source object). You also want the PropertyInfo of the target property (e.g. Line1 or Code). And you want both the property accessor and the PropertyInfo from the same expression.

This is not too difficult. It doesn’t require a stack of target objects and PropertyInfos as originally feared. Firstly store the PropertyInfo from the nested target in the normal way:

targetPropertyInfo = targetExpression.AsPropertyInfo();

- this gives us access to Line1 or Code. Then store the expression which retrieves the path to the containing object for the property from the original source - .Address or .Address.Postcode. In the expression tree, this is the expression which contains the root to the original parameter:

if (targetExpression.Body.NodeType == ExpressionType.MemberAccess)

{

MemberExpression memberExpression = targetExpression.Body as MemberExpression;

if (memberExpression.Expression.NodeType != ExpressionType.Parameter)

{

ParameterExpression parameter = GetParameterExpression(memberExpression.Expression);

if (parameter != null)

{

_targetExpression = Expression.Lambda(memberExpression.Expression, parameter);

}

The key line is the one which contains Expression.Lambda(). The parent expression is a MemberExpression (e.g. s.Address, or s.Address.PostCode) which itself is not executable. You can’t compile a MemberExpression and execute it on an object to get the member, as the expression needs to know the parameter it executes against.

Expression.Lambda creates a compilable, executable expression against a provided target parameter – which we already have from the “s” of the original expression, and we can find for any level of nesting:

private ParameterExpression GetParameterExpression(Expression expression)

{

while (expression.NodeType == ExpressionType.MemberAccess)

{

expression = ((MemberExpression)expression).Expression;

}

if (expression.NodeType == ExpressionType.Parameter)

{

return (ParameterExpression)expression;

}

return null;

}

So now we have the PropertyInfo for the nested target, and an expression which will give us the nested target, we can set the target property value like this:

object target; //this is the top-level object

//...

realTarget = expression.Compile().DynamicInvoke(target);

targetPropertyInfo.SetValue(realTarget, value, null);

It’s quite a complex requirement, but the solution is straightforward and the complexity is isolated from the calling code. Note that the example code above only deals with nested properties, not expressions with mixed properties and method calls (e.g. s.Address.GetPostCode().InwardCode), but it’s straightforward to cover those cases too.

Avoiding TNSNAMES in Oracle .NET data connections

EltonStoneman — Fri, 06 Nov 2009 04:03:04 GMT

[Source: http://geekswithblogs.net/EltonStoneman]

The typical approach for connecting to Oracle data sources using ODP.NET is to use a named source in the connection string and rely on the name being resolved through SQLNAMES.ORA and TNSNAMES.ORA:

app.config:

</connectionStrings>

TNSNAMES.ORA:

XYZ.WORLD =

(DESCRIPTION =

(ADDRESS_LIST =

(LOAD_BALANCE = off)

(FAILOVER = on)

(ADDRESS_LIST =

(LOAD_BALANCE = on)

(FAILOVER = on)

(ADDRESS = (PROTOCOL = TCP)(HOST = XYZ1-1.internal.xyz.org.uk)(PORT = 1522))

(ADDRESS = (PROTOCOL = TCP)(HOST = XYZ1-2.internal.xyz.org.uk)(PORT = 1522))

)

(ADDRESS_LIST =

(LOAD_BALANCE = on)

(FAILOVER = on)

(ADDRESS = (PROTOCOL = TCP)(HOST = XYZ2-1.internal.xyz.org.uk)(PORT = 1522))

(ADDRESS = (PROTOCOL = TCP)(HOST = XYZ2-2.internal.xyz.org.uk)(PORT = 1522))

)

(CONNECT_DATA =

(SERVICE_NAME = XYZ)

(FAILOVER_MODE =

(TYPE = select)

(METHOD = basic)

(RETRIES = 16)

(DELAY = 1)

)

This is fine until you upgrade your Oracle client, or have multiple instances – if the wrong TNSNAMES gets picked up you’ll get error ORA-12514: TNS:could not resolve the connect identifier specified, and it can be fiddly to track down.

A neater way is to put the whole set of service details in the connection string, avoid the named identifier and circumvent TNSNAMES.ORA altogether:

<add name="XYZ" connectionString="Data Source=(DESCRIPTION =

(ADDRESS_LIST =

(LOAD_BALANCE = off)

(FAILOVER = on)

(ADDRESS_LIST =

(LOAD_BALANCE = on)

(FAILOVER = on)

(ADDRESS = (PROTOCOL = TCP)(HOST = XYZ1-1.internal.xyz.org.uk)(PORT = 1522))

(ADDRESS = (PROTOCOL = TCP)(HOST = XYZ1-2.internal.xyz.org.uk)(PORT = 1522))

)

(ADDRESS_LIST =

(LOAD_BALANCE = on)

(FAILOVER = on)

(ADDRESS = (PROTOCOL = TCP)(HOST = XYZ2-1.internal.xyz.org.uk)(PORT = 1522))

)

(CONNECT_DATA =

(SERVICE_NAME = UVASA)

(FAILOVER_MODE =

(TYPE = select)

(METHOD = basic)

(RETRIES = 16)

(DELAY = 1)

)

);User ID=xyz;Password=xyz;"/>

</connectionStrings>

Service details contain the whole of the TNSNAMES entry following the identifier (i.e. from DESCRIPTION= onwards), and can span multiple lines in the config file.

Incidentally, if you’re not using ODP.NET in favour of the Microsoft’s framework Oracle provider, System.Data.OracleClient, consider migrating as it will be deprecated from .NET 4.0.

jQuery Date Validation in Chrome

EltonStoneman — Thu, 29 Oct 2009 19:20:53 GMT

[Source: http://geekswithblogs.net/EltonStoneman]

We had a fiddly issue with date validation in an ASP.NET MVC page failing for a valid date in Chrome, but passing in Firefox, IE etc. Tracing through our own code and xVal, the issue was narrowed down to the jQuery validation plugin (jquery.validate.js). For simple date validation, the library instantiates a date object from the given text value and lets JavaScript raise errors for invalid dates:

date: function(value, element) {

return this.optional(element) || !/Invalid|NaN/.test(new Date(value));

Chrome seems to ignore the current locale when it creates the date object, so a valid date in UK dd/mm/yy format – 29/10/2009 – fails as Chrome seems to interpret it in US mm/dd/yy format. Easy to test outside of all other code by entering some simple JavaScript into the address bar:

javascript:new Date('29/10/2009').toString()

Which Firefox renders as expected:

- as does IE (even IE6):

- but which Chrome renders as an invalid date:

You can also test it by navigating to the jQuery date validation sample page, and checking results for the same date in different browsers.

The fix is a simple change to the jQuery script to force the use of the current locale:

// http://docs.jquery.com/Plugins/Validation/Methods/date

date: function(value, element) {

//ES - Chrome does not use the locale when new Date objects instantiated:

//return this.optional(element) || !/Invalid|NaN/.test(new Date(value));

var d = new Date();

return this.optional(element) || !/Invalid|NaN/.test(new Date(d.toLocaleDateString(value)));

Duck Typing with Castle

EltonStoneman — Wed, 21 Oct 2009 07:59:24 GMT

[Source: http://geekswithblogs.net/EltonStoneman]

David Meyer has a neat duck typing library for .NET which I’ve been looking at as I had a requirement to treat objects of various types in the same way. They all expose a “Value” property, but don’t implement an interface.

The library does more than I needed so I put together a quick duck typing implementation which just lets me treat an instance of an object which tacitly implements an interface, as a true implementation of the interface. In this example I can access BespokeDateTime and BespokeInt as IHasValue:

Using Castle’s Dynamic Proxy, this is simple to do – just requiring you to generate an interface proxy with a custom interceptor. The interceptor invokes the interface method on the real object, so you effectively wrap an instance in an interface it doesn’t explicitly implement:

BespokeDateTime bespoke = new BespokeDateTime(new DateTime(2000, 1, 1));

IHasValue duck = DuckType.As<IHasValue>(bespoke);

Console.WriteLine(duck.Value);

- or using an object extension to hide the implementation:

bespoke.As<IHasValue>().Value;

Iterating over collections is much cleaner with duck typing – if I have a collection that contains both BespokeDateTime and BespokeInt objects, to get all their values I can use:

foreach (object obj in GetObjects())

{

Assert.IsNotNull(DuckType.As<IHasValue>(obj).Value);

}

- compared to casting each object:

foreach (object obj in GetObjects())

{

BespokeDateTime bespokeDateTime = obj as BespokeDateTime;

if (bespokeDateTime != null)

{

Assert.IsNotNull(bespokeDateTime.Value);

}

else

{

BespokeInt bespokeInt = (BespokeInt) obj;

Assert.IsNotNull(bespokeInt.Value);

}

Use with caution over large collections, as there is a noticeable performance hit in using the duck type. Over 500,000 items the duck-typed code takes 40-50 times as long as the casting code, averaging 8 seconds to 0.2 seconds, with duck-typing by extension taking marginally longer again:

The full code (all 34 lines – including validation that the type to duck does tacitly implement the interface) is on MSDN Code Gallery here: Duck Typing with Castle.

The People’s Jukebox

EltonStoneman — Wed, 30 Sep 2009 19:00:38 GMT

[Source: http://geekswithblogs.net/EltonStoneman]

For a forthcoming celebration, I've been working on a jukebox web application:

The client controls the music being played on the server, so its intended for local networks where you want shared control of a central music player. If you can find a use for it, help yourself – it's on CodePlex here: The People's Jukebox. If nothing else it's a straightforward example of a Silverlight 2.0 client talking to WCF REST services, in what's probably a familiar domain.

The user experience is meant to be zero-guidance. You can try it out on a version where the UI functions but doesn't play any music: The People's Jukebox on sixeyed.com.

The initial screen shows what's currently playing and has a big button for you to select a track. In the next screen you choose either to search for a specific track, browse through the collection, or have the jukebox randomly choose some options for you. From any of those routes, you select a track, confirm your choice and it gets queued:

The queuing is what gives The People's Jukebox its democratic flavour – if you select a track which is already queued, you increment its vote count. When the current track finishes, the jukebox picks the next track with the most votes. When a track is selected the UI forces you to wait for a few seconds before you can continue, to discourage The People from abusing their power and making the same selection over and over again.

If no one's choosing tracks, the jukebox will randomly pick one which it hasn't already played, so it should keep playing until all the songs are played, or the web server is stopped.

Usage

Run the MSI and the jukebox Web site and services will be installed with default configuration options, using the installing user's "My Music" as the root folder to look for tracks. It will populate the track catalogue from the file system, expecting to find a conventional root/artist/album/track hierarchy:

My Music
- The Beatles
  - Abbey Road
    - 01. Come Together
    - etc.

Open http://localhost/ThePeoplesJukebox/ and hit Start - the music should start playing and you should be able to navigate around your music collection. The jukebox services log everything they do, by default to C:\TEMP\PeoplesJukeboxService.log, so if nothing happens that's the place to look for clues.

Configuration

The jukebox is configurable through Web.config on the services. Options are documented in comments – the installer sets up the root music directory, and the types of music files in the fileSystemConfiguration element:

<!--Specify the root path for music files, and

the types of files to load. Directory can be

a network path, extensions are comma-separated:-->

<fileSystemCatalogueConfiguration

rootDirectory="x:\My Music"

fileExtensions="*.wav,*.mp3"

rootDirectory can be local or a UNC path, e.g. \\nas\music.

Track Lists

Track lists are what drives the song selection behaviour; this is also configurable. Three types of tracklist are provided. When the jukebox finishes playing a track, it will query the tracklists in priority order until one returns a track, which will be loaded and played next:

<!-- Tracklists to use, and the order in which they are queried.

Specify "chosenByText" to display which tracklist chose the

Now Playing track on the client -->

</trackLists>

In default form, the jukebox lets you start off with some specified songs, moving onto the selections of The People, with the jukebox picking a random track if none are queued, so tracklists are queried in the following order:

1. ConfiguredTrackList – reads a list of specific track names from configuration, and returns them in priority order. Will not play a track that's already been played. Configuration looks like:

</tracks>

</trackConfiguration>

Intended to start the evening off with a known selection, when the configured tracks have been played, the list returns null so the jukebox moves on to the next tracklist.

2. SelectedTrackList – hopefully the main provider, queues up track requests as users make a selection. Operates the voting mechanism, so tracks which are selected multiple times move up the queue. If all queued tracks have the same number of votes, they're played in the order they were first selected. Will allow tracks to be played multiple times, but not sequentially – if you choose a track that's already queued, you increase its vote count; if you choose the same track again whilst its playing, or after it has been played, it gets queued again. Returns null if no tracks are queued.

3. RandomTrackList – failsafe list, to ensure music is always playing, picks tracks at random from the catalogue. Will not play a track that's already been played. Allows the administrator to sneak in some favourites by configuring "must-have" tracks. Must-haves will be inserted between random selections, at a configured frequency:

</mustHaveTracks>

</randomTrackListConfiguration>

- meaning every fifth track will be picked from the configured list, then the next four will be random. If no must-haves are specified, or they have all been played, the selection will be random.

Technical Details

Much of the implementation is straightforward. WCF has in-built support for REST, so you can expose a WCF service with a RESTful endpoint like http://localhost/PeoplesJukebox.Services/CatalogueService.svc/artist/2 (to get the list of tracks from artist with ID=2 from the catalogue service), just by flagging the service implementation with the WebGet attribute:

[WebGet(UriTemplate = "artist/{artistId}", ResponseFormat = WebMessageFormat.Xml)]

public Artist GetArtist(string artistId)

{...

Task-driven workflow implementation in Silverlight is also straightforward, by hosting multiple pages on the application, all of which are invisible except the current page. When the current page completes, it hides itself and loads the next page – handled through events in Page.xaml.cs:

public Page()

{

InitializeComponent();

foreach (PageBase page in Pages)

{

page.Complete += new PageBase.OnCompleteEventHandler(PageComplete);

page.Cancelled += new PageBase.OnCancelledEventHandler(PageCancelled);

}

this.CurrentPage = this.ucStartPage;

}

Silverlight 2.0 doesn't work so well with non-GET web requests, which is why all the services are GETs where some should really be POSTs.

The only difficult part was playing music files through IIS in a background thread, while continuing to respond to web service and web site requests. If you're really interested in looking into this, you'll see the music playing component is also specified in config:

<!-- Core configuration - which implementations to use for

media player and catalogue components -->

<peoplesJukeboxConfiguration

mediaPlayer="PeoplesJukebox.Core.Players.FMODPlayer, PeoplesJukebox.Core"

mediaCatalogue="PeoplesJukebox.Core.Catalogues.FileSystemCatalogue, PeoplesJukebox.Core"

There are several (failed) implementations in the source which are not built in the solution (under ..\PeoplesJukebox\PeoplesJukebox.Core\Players). Of the five attempts, all of them had showstopper issues except the excellent FMOD library:

DirectX – using the Audio class from the managed wrapper in the DirectX SDK. Redistributable install is massive, which is offputting, but more importantly the Audio.Ending event didn't fire reliably, so playback would intermittently stop and never resume;
Windows Media Player – using the managed WMPLib wrapper in the Windows Media Player SDK, to devolve playing responsibility to Media Player. Didn't like the extra dependency, or the alarming memory profile. Worse, the player would randomly change state to Stopping in the middle of playback and not resume;
Sound – using .NET's native sound player in System.Media. Fine for playing WAVs, at the cost of having to manage your own threads. Main issue that WAVs are not normalized so tracks will be played at their native volume, which is likely to mean volume changes between songs. Unable to play other media types;
Alvas Audio – looked good, but highly unfriendly API. Couldn't get the thing to play at all;
FMOD – highly-featured C++ audio processor which does its own thread management, copes with various media types, plays reliably for extended periods and has an efficient memory model. The library is free for non-commercial use, so The People's Jukebox has the same restriction. The library is complex, but I've used it through FMOD.NET – Rafael Nicoletti's very nice C# wrapper.

The mediaCatalogue element lets you choose how the catalogue is built. Currently, only a file system catalogue is provided, but extending it (e.g. to use SqueezeCenter – now SqueezeBox Server), is an option.

If you download the jukebox and find any issues using it, let me know through a comment or a CodePlex bug.

Resolving Special Folders in WiX 3.0

EltonStoneman — Tue, 29 Sep 2009 18:09:43 GMT

[Source: http://geekswithblogs.net/EltonStoneman]

One of the frustrations of working with WiX is that when you want to do something out of the ordinary, chances are it's provided somewhere in a WiX extension, but unless you trawl through the XSDs you're not likely to find it. I had this issue when I wanted to resolve the special folder My Music through WiX, so I could put the full path into a config file.

Various special folders are already available as properties to the installer, including My Documents and My Pictures, but not My Music. Adding an extension to expose Environment.GetSpecialFolder() to WiX is a trivial implementation in a couple of classes (comments omitted for brevity):

public class EnvironmentExtension : WiXExtension

{

private EnvironmentPreprocessorExtension preprocessorExtension;

public override PreprocessorExtension PreprocessorExtension

{

get

{

if (this.preprocessorExtension == null)

{

this.preprocessorExtension = new EnvironmentPreprocessorExtension();

}

return this.preprocessorExtension;

}

public class EnvironmentPreprocessorExtension : PreprocessorExtension

{

private const string SPECIALFOLDER = "specialFolder";

public override string[] Prefixes { get { return new string[] { SPECIALFOLDER }; } }

private List<string> _specialFolders;

private List<string> SpecialFolders

{

get

{

if (_specialFolders == null)

{

_specialFolders = new List<string>(Enum.GetNames(typeof(Environment.SpecialFolder)));

}

return _specialFolders;

}

public override string GetVariableValue(string prefix, string name)

{

string result = null;

if (prefix == SPECIALFOLDER && SpecialFolders.Contains(name))

{

Environment.SpecialFolder specialFolder = (Environment.SpecialFolder)Enum.Parse(typeof(Environment.SpecialFolder), name, true);

result = Environment.GetFolderPath(specialFolder);

}

return result;

}

Reference the folder you want from the Environment.SpecialFolders enum as a property in your WiX script:

- and add the extension assembly to your light and candle calls, making sure the DLL is available at runtime :

candle -out x.y.z.WiXobj x.y.z.wxs -ext EnvironmentExtension

light -out x.y.z.msi x.y.z.WiXobj -ext EnvironmentExtension -cultures:en-us

But I suspect it's already available somewhere in WiX.

Lazy-Loading with Object Extensions

EltonStoneman — Wed, 23 Sep 2009 18:38:57 GMT

[Source: http://geekswithblogs.net/EltonStoneman]

If you make heavy use of lazy-loaded properties, the repetitive if-backing-field-null-then-instantiate code can be centralized in an extension method on the object class:

/// <summary>

/// Extension methods for <see cref="Object"/>

/// </summary>

public static class ObjectExtensions

{

/// <summary>

/// Lazy-loads a property

/// </summary>

/// <typeparam name="T">Type of property</typeparam>

/// <param name="obj">Extended object</param>

/// <param name="field">Property backing field</param>

/// <param name="load">Property loading function</param>

/// <returns>Lazy-loaded property</returns>

public static T LazyLoad<T>(this object obj, ref T field, Func<T> load)

{

if (field == null || field.Equals(default(T)))

{

field = load();

}

return field;

}

Classes then define lazy-loaded properties using the extension method, specifying the backing field and the method used to populate it:

protected List<MediaItem> AllItems

{

get

{

return this.LazyLoad<List<MediaItem>>(ref this._allItems,

() => new List<MediaItem>());

}

- rather than:

protected List<MediaItem> AllItems

{

get

{

if (this._allItems == null)

{

this._allItems = new List<MediaItem>();

}

return this._allItems;

}

Only a tiny enhancement, but it isolates some general code and reduces the chances of causing an infinite loop by typing the property name rather than the field name.

CA1502:AvoidExcessiveComplexity and Lambdas

EltonStoneman — Mon, 21 Sep 2009 20:47:01 GMT

[Source: http://geekswithblogs.net/EltonStoneman]

In code with lots of lambda expressions, you may trigger a false positive for the Code Analysis rule CA1502 "AvoidExcessiveComplexity". The rule calculates cyclomatic complexity using the logic in Microsoft.FxCop.Sdk.MethodMetrics, which enumerates the instruction set and increments complexity count when it finds one of a given set of opcodes.

The rule was triggered by code which uses the Fluent DAL approach to populate a composite entity:

public static Entity GetEntity(int entityId)

{

//populate basic details:

Entity entity = Fluently.Load<Entity>().With<EntityMap>()

.From<GetEntity>(i => i.Id = entityId,

x => x.Execute());

//load child entities:

if (entity.IsKnown)

{

entity.Address = Fluently.Load<Address>().With<AddressMap>()

.From<GetEntityAddresses>(i => i.Id = entityId,

x => x.Execute());

entity.Contact = Fluently.Load<Contact>().With<ContactMap>()

.From<GetEntityContacts>(i => i.Id = entityId,

x => x.Execute());

}

else

{

//more of the same...

The method in question had a single if/else branch, no other conditional logic, but 7 fluent calls totalling 12 lambdas. I calculate the cyclomatic complexity to be 2, and NDepend agrees. FxCop tells me the complexity is 26.

I stripped this down to a much simpler sample and found the same issue:

public void CCCheck2()

{

Fluently.Load().With().From(i => i.ToString(), x => x.ToString());

}

- this gives a CC of 13, although it has no conditional logic at all.

The answer's in the IL – the lambdas are emitted as private static classes and executed using an instance which is lazy-loaded:

IL_000b: ldsfld class [System.Core]System.Func`2<int32,string> FxCopCC.LambdaSample::'CS$<>9__CachedAnonymousMethodDelegate6'

IL_0010: brtrue.s IL_0025

IL_0012: ldnull

IL_0013: ldftn string FxCopCC.LambdaSample::'<CCCheck>b__0'(int32)

IL_0019: newobj instance void class [System.Core]System.Func`2<int32,string>::.ctor(object,

native int)

IL_001e: stsfld class [System.Core]System.Func`2<int32,string> FxCopCC.LambdaSample::'CS$<>9__CachedAnonymousMethodDelegate6'

IL_0023: br.s IL_0025

br and brtrue are transfer of control statements, so every lambda expression actually causes a branch – where the IL checks to see if there's a cached instance of the delegate, or whether it needs to instantiate one – and a return. The complexity rating is correct for the IL, as 1 + 2x(number of lambdas).

But cyclomatic complexity is a measure of readability, so the additional branches in the IL should be irrelevant. The short term solution is to suppress the message on methods with heavy lambda usage. A longer term option is an alternative rule which uses a different calculation.

A side point is that the IL isn't aggressively optimised by the compiler – lambdas with identical code are generated as separate private classes, each with their own lazy-loading check, so to avoid that overhead lambdas which are reused can be centralised:

private Func<int, string> GetInitialise()

{

return new Func<int,string>(i => i.ToString());

}

WCF Personalization Provider for ASP.NET

EltonStoneman — Tue, 15 Sep 2009 19:49:24 GMT

[Source: http://geekswithblogs.net/EltonStoneman]

The ASP.NET Web Part framework uses a plug-in framework for loading and saving personalization data to a persistent source. Out of the box, a SQL Server data source is provided (via the aspnet_regsql tool), along with a SQL personalization provider – specified in the system.web configuration section:

<add name="SqlPersonalizationProvider"

type="System.Web.UI.WebControls.WebParts.SqlPersonalizationProvider"

connectionStringName="local"

applicationName="WcfPersonalizationSample" />

It's painless to set up and gets you running Web Part-enabled sites quickly. But if your Web servers and database servers are separated by a physical boundary with app servers in between, you can't use the SQL provider directly from the ASP.NET application and will need to write a custom personalization provider.

Exposing the existing SQL personalization store through a custom WCF provider is a straightforward option – so your app server hosts a WCF service which itself uses the SQL personalization provider, and the Web server uses the WCF service through the custom provider. Although the implementation is fairly trivial, there are a couple of issues to work around:

PersonalizationProvider is an abstract class which requires you to implement methods with out and ref parameters. You'll need to write methods with different signatures to work over WCF;
SqlPersonalizationProvider has methods for loading personalization data as byte arrays, which are useful for the WCF service. To access them you'll need another custom provider which inherits from SqlPersonalizationProvider, as the underlying methods are protected.

I've worked this through as a sample on MSDN Code Gallery: WCF Personalization Provider Sample.

To use it, the WCF service host needs to be configured to use the custom provider which wraps the SQL store, and a connection string entry for the data store:

<add name="local"

connectionString="Data Source=.;Initial Catalog=WcfPersonalizationSample;Integrated Security=True"

providerName="System.Data.SqlClient" />

</connectionStrings>

<system.web>

<add name="PersonalizationServiceProvider"

type="WcfPersonalizationProvider.PersonalizationServiceProvider"

connectionStringName="local"

applicationName="WcfPersonalizationSample" />

</providers>

</personalization>

</webParts>

...

(Note that this is using ASP.NET functionality in the WCF service, but you do not need to set the WCF service up for ASP.NET compatibility mode.)

The Web site need to be configured to use the custom provider which accesses the WCF service, and a service client entry for the WCF service:

<add name="WcfPersonalizationProvider"

type="WcfPersonalizationSample.ServiceClient.WcfPersonalizationProvider"

applicationName="WcfPersonalizationSample" />

</providers>

</personalization>

</webParts>

...

<endpoint address="http://localhost/PersonalizationService.svc"

binding="basicHttpBinding"

contract="PersonalizationService.IPersonalizationService"

name="BasicHttpBinding_IPersonalizationService" />

</client>

Both providers need to specify the same applicationName value, and your Web Part personalization, for shared and user scopes, will work without the Web servers accessing the database.

FluentHtmlTextWriter

EltonStoneman — Fri, 11 Sep 2009 00:32:28 GMT

[Source: http://geekswithblogs.net/EltonStoneman]

Keeping up the fluent work, I've put together a fluent interface which wraps the framework HtmlTextWriter. For ASP.NET MVC, this makes generating HTML in extension methods to HtmlHelper safer than string.Format() and more readable than HtmlTextWriter:

public static string Image(this HtmlHelper helper, string imageRelativeUrl, string altText)

{

return FluentHtmlTextWriter.Begin()

.WriteTag(HtmlTextWriterTag.Img)

.WithAttribute(HtmlTextWriterAttribute.Src, GetImageUrl(imageRelativeUrl))

.WithAttribute(HtmlTextWriterAttribute.Alt, altText)

.End();

}

The equivalent using HtmlTextWriter is:

public static string Image(this HtmlHelper helper, string imageRelativeUrl, string altText)

{

StringBuilder htmlBuilder = new StringBuilder();

HtmlTextWriter writer = new HtmlTextWriter(new StringWriter(htmlBuilder));

writer.AddAttribute(HtmlTextWriterAttribute.Src, GetImageUrl(imageRelativeUrl));

writer.AddAttribute(HtmlTextWriterAttribute.Alt, altText);

writer.RenderBeginTag(HtmlTextWriterTag.Img);

writer.RenderEndTag();

writer.Flush();

return htmlBuilder.ToString();

}

Unlike the framework writer, you're not constrained to specify attributes in any particular order, and tags which aren't nested can be written with a single WriteTag(), rather than BeginTag() and EndTag() calls. The writer copes with multi-level tag hierarchies - this sample builds a Superfish CSS menu:

FluentHtmlTextWriter writer = FluentHtmlTextWriter.Begin();

writer.BeginTag(HtmlTextWriterTag.Ul)

.WithAttribute(HtmlTextWriterAttribute.Id, "menu.Name")

.WithAttribute(HtmlTextWriterAttribute.Class, "sf-menu sf-vertical");

.BeginTag(HtmlTextWriterTag.Li)

.BeginTag(HtmlTextWriterTag.A)

.WithAttribute(HtmlTextWriterAttribute.Class, "sf-with-ul")

.WithAttribute(HtmlTextWriterAttribute.Href, "#")

.WithValue("Link 1")

.WriteTag(HtmlTextWriterTag.Span)

.WithAttribute(HtmlTextWriterAttribute.Class, "sf-sub-indicator")

.WithValue("»")

.EndTag()

.EndTag();

string html = writer.End();

Assert.AreEqual("<ul id=\"menu.Name\" class=\"sf-menu sf-vertical\">\r\n\t<li><a class=\"sf-with-ul\" href=\"#\">Link 1<span class=\"sf-sub-indicator\">»</span></a></li>\r\n</ul>",

html);

The HtmlTextWriter equivalent is unthinkable.

Patrik Hägne has an alternative fluent HtmlTextWriter implementation, which is nicely put together, but I wanted slightly different functionality. Firstly I wanted to get the HTML string from the writer directly, without needing to instantiate a StringBuilder and StringWriter. Secondly I wanted minimal new code – Patrik uses a separate class to manage writing attributes, and has specific functions for known tag types. Thirdly, I didn't really like Patrik's syntax, with the need to specify the tag type when you write an end tag – and when tags aren't nested, I wanted to write them in a single unit:

string html = FluentHtmlTextWriter.Begin()

.WriteTag(HtmlTextWriterTag.Span)

.WithAttribute(HtmlTextWriterAttribute.Id, "id_span")

.WithValue("contents_span")

.End();

Assert.AreEqual("<span id=\"id_span\">contents_span</span>", html);

My version is on MSDN Code Gallery here: FluentHtmlTextWriter. It works by building up a list of actions when you start writing a tag, and flushing them in the correct order to an internal HtmlTextWriter when you start writing the next tag. When you call End() it flushes the internal writer and outputs its contents. An alternative constructor lets you write directly to an output stream, in which case you can Flush() the writer and don't need to call End().

The current implementation only deals with basic tag, attribute and style functionality, and doesn't include optional HTML encoding overloads. It's only 75 lines of code, and extending it should be trivial.

There is a negligible performance hit in using FluentHtmlTextWriter – running the image tag generation code above 20,000 times on my dev machine, the fluent version takes between 0.01and 0.02 seconds longer than the framework version (on average 0.07 seconds compared to 0.05).