Type conversion

The properties now have the correct type but we’re returning strings from the properties so the code won’t compile. We now need to convert the string values as obtained from ConfigurationManager to the correct type. To keep this relatively clean we’ll create yet another private method that accepts a type as a parameter and returns the name of the conversion function to call. We’ll wrap the entire call to ConfigurationManager with a call to the conversion routine. In the case of a string there is no conversion so the generated property will just be wrapped in parenthesis.

private Lazy<Dictionary<Type, string>> m_settingsConverter = new Lazy<Dictionary<Type, string>>(InitializeSettingsConverter);

private string GetSettingConverter ( Type type )
{
   string converter;
   if (m_settingsConverter.Value.TryGetValue(type, out converter))
      return converter;

   return "";
}

private static Dictionary<Type, string> InitializeSettingsConverter ()
{
   return new Dictionary<Type, string>() {
      { typeof(sbyte), "SByte.Parse" },
      { typeof(short), "Int16.Parse" },
      { typeof(int), "Int32.Parse" },
      { typeof(long), "Int64.Parse" },

      { typeof(byte), "Byte.Parse" },
      { typeof(ushort), "UInt16.Parse" },
      { typeof(uint), "UInt32.Parse" },
      { typeof(ulong), "UInt64.Parse" },

      { typeof(float), "Float.Parse" },
      { typeof(double), "Double.Parse" },
      { typeof(decimal), "Decimal.Parse" },

      { typeof(bool), "Boolean.Parse" },
      { typeof(char), "Char.Parse" },
      { typeof(DateTime), "DateTime.Parse" },
      { typeof(Guid), "Guid.Parse" },
      { typeof(TimeSpan), "TimeSpan.Parse" },

      { typeof(string), "" }
   };
}

The type to converter mapping is stored in a dictionary to optimize performance. For this code I’m using the standard Parse methods but you can replace it with any method you want. Here’s the updated property block.

public <#= GetFriendlyName(type) #> <#= MakeIdentifier(setting.Key) #>
{
   get { return <#= GetSettingConverter(type) #>(GetConfigSetting("<#= setting.Key #>")); } 
}

We’ve finished the propery generation code. Depending upon the value stored in the config file (when the template is generated) a strongly typed property will be generated for each app setting. Type conversion is used to convert the value in the config file at runtime to the correct type. We have effectively replaced the Settings-based code added to .NET with our own implementation that works similarily but without having to add anything to our config files. But we aren’t quite done yet as we’re still using hard coded values. It is time to retrieve the settings from the config file directly.

Reading the Configuration File

In order to get the settings from the configuration file we have to locate the config file in the project (keeping in mind it could be a web or Windows app). We already have the code to find a specific project item so we just need to use it to find the config file. For now we’ll assume the config file exists. In a later article we’ll see how to handle a missing config file.

public EnvDTE.ProjectItem FindConfigProjectItem ( EnvDTE.Project source )
{
   return FindItem(source, "web.config", true) ?? FindItem(source, "app.config", true);
}

Now it becomes a simple matter of loading the settings from the config file using ConfigurationManager. We’ll modify our stub method of earlier to return the information. Note we need to add another import for System.Configuration. We’ll also need to ensure we have an assembly directive for System.Configuration because it is not included by default.

private KeyValueConfigurationCollection GetAppSettings ()
{
   //Get the config file
   var configItem = FindConfigProjectItem(ActiveProject);

   return GetAppSettings(configItem);
}

private KeyValueConfigurationCollection GetAppSettings ( EnvDTE.ProjectItem configItem )
{
   if (configItem != null)
   {
      var configFile = new ExeConfigurationFileMap() { ExeConfigFilename = GetProjectItemFileName(configItem) };
      var config = ConfigurationManager.OpenMappedExeConfiguration(configFile, ConfigurationUserLevel.None);

      return (config.AppSettings != null) ? config.AppSettings.Settings : null;
   };

   return null;
}

Notice that we changed the return type to match what the configuration subsystem will return. We’ll have to update the foreach block as well but the rest of the code is fine.

<# 
foreach (KeyValueConfigurationElement setting in GetAppSettings()) 
{
   var type = GetSettingType(setting.Value);
#>

Save the template and the same properties we had hard coded earlier should still be available. This time though they are being pulled from the project’s config file. Feel free to add more settings to confirm everything is working correctly. At this point we have a fully working and useful template that we can use in projects to clean up settings code. Not bad for 300 lines of code. We have met 3 of the 6 initial requirements. In the next article we’re going to modify the template to meet the remaining requirements making it more useful and flexible to meet the needs of complex projects.

Download the Code