Is there a C# pattern for strongly typed class members with external set/get methods?

Question

I have the following structure and would like a solution with both benefits from the following two classes. The first class is using strings and strongly typed members:

public class UserSessionData
{
    private string Get(string key)
    {
        throw new NotImplementedException("TODO: Get from external source");
    }
    private void Set(string key, string value)
    {
        throw new NotImplementedException("TODO: Set in external source");
    }

    public string CustomerNumber {
        get { return Get("CustomerNumber"); }
        set { Set("CustomerNumber", value); }
    }
    public string FirstName {
        get { return Get("FirstName"); }
        set { Set("FirstName", value); }
    }
    public string LastName {
        get { return Get("LastName"); }
        set { Set("LastName", value); }
    }

    // ... a couple of hundreds of these
}

I can imagine an alternative being a Get and Set method with an enum parameter. Here is the second class:

public class UserSessionData
{
    public enum What {
        CustomerNumber, FirstName, LastName, // ...
    }

    public string Get (What what) { return MyExternalSource(what); }
    public string Set (What what, string value) { return MyExternalSource(what); }
}

But the consumer side of class #2 is not pretty:
UserSessionData.Get(UserSessionData.What.CustomerNumber)
Compare it to the first class: UserSessionData.CustomerNumber

Is there a strongly typed way of calling the Get and Set methods in my first class example? Stated another way: How do I get the benefits from both classes, i.e. the maintainability of strongly typed members and a nice-looking syntax?

Answer 1

.Net 4.5 or newer

If you use .Net 4.5 or newer you can make use of CallerMemberNameAttribute so you can call it like this:

public string CustomerNumber {
    get { return Get(); }
}

To make this work, modify the Get method by adding the attribute to the parameter:

private string Get([CallerMemberName] string key)
{
    ...
}

Performance notice: The compiler will insert a string as parameter at the calling site, so this is fast.

---

.Net 4.0 or earlier

If you use .Net 4.0 or earlier, you can still use strongly typed property names instead of typing strings manually, but you need to implement a method like this to extract the property name from an Expression, and then you can call it using an expression:

public string CustomerNumber {
    get { return Get(() => this.CustomerNumber ); }
}

The setters can be implemented in the same fashion.

Performance notice: The string is extracted at runtime, so this is slower than using CallerMemberNameAttribute.

Answer 2

You can use a T4 template to generate the class. In the T4 template you just name all the properties - you could get them through reflection from an enum, too, but using a string array is simpler.

Add New Item -> Text template

<#@ template debug="false" hostspecific="false" language="C#" #>
<#@ output extension=".cs" #>
<# var properties = new string [] {
      "CustomerNumber", // This is where you define the properties
      "FirstName",
      "LastName"
}; #>
class UserSessionData {
<#  
  foreach (string propertyName in properties) 
  { #>
  public string <#= propertyName #>{
    get { return Get("<#= propertyName #>"); }
    set { Set("<#= propertyName #>", value); }
  }
<# } #>
}

More info @ Design-Time Code Generation by using T4 Text Templates

Answer 3

How about an enum with some extension methods, like this:

// usage:
[TestMethod]
public void example()
{
    UserSessionData.CustomerNumber.Set("cust num");
    Assert.AreEqual("cust num", UserSessionData.CustomerNumber.Get());
}

// implementation:
public enum UserSessionData
{
    CustomerNumber,
    FirstName,
}

public static class UserSessionDataHelper
{
    private static Dictionary<string, string> values = new Dictionary<string, string>();

    private static string GetName(this UserSessionData field)
    {
        return Enum.GetName(typeof(UserSessionData), field);
    }

    public static string Get(this UserSessionData field)
    {
        return values[field.GetName()];
    }

    public static void Set(this UserSessionData field, string value)
    {
        values[field.GetName()] = value;
    }
}

Answer 4

This pattern allows loosely coupled resource keys. A hashmap that excepts any key type, for the purpose of extensibility. You often see this with system messages in IoC containers.

In my experience, this pattern grants great flexibility with the cost of required documentation. Consider solving the problem with convention rather than implementation. I try to stick to enumerated values where possible.

• They are immutable primitives with strong names.
• They can be groupedinto their parent type.
• They can be iterated quite simply if required.
• They respond to refactoring.

Answer 5

If you are using .NET 4.0 or later you can use DynamicObject and override its TryGetMember and TrySetMember methods to do this fully dynamic. This won't be strongly typed though.

Answer 6

I don't know why such a simple soultion has not yet been proposed:

public class UserSessionData
{
    private string Get(What what)
    {
        throw new NotImplementedException("TODO: Get from external source");
    }
    private void Set(What what, string value)
    {
        throw new NotImplementedException("TODO: Set in external source");
    }

    public string CustomerNumber {
        get { return Get(What.CustomerNumber); }
        set { Set(What.CustomerNumber, value); }
    }

    // ... 
}

public enum What
{
    CustomerNumber, FirstName, LastName, // ...
}

And the usage you so liked: userSessionData.CustomerNumber

If your "external source" prefer strings, you can make What enum private and cast enum to string.