configs

config by type

 public static class ConfiguredValues
    {
        public static int Get(Func<DynamicLookup, dynamic> value, int defaultValue)
        {
            int returnValue;
            var globalSettingValue = value(DynamicLookup.Resolve);

            if (globalSettingValue is int)
            {
                returnValue = globalSettingValue;
            }
            else if (!int.TryParse(globalSettingValue as string, out returnValue))
            {
                returnValue = defaultValue;
            }

            return returnValue;
        }

        public static long Get(Func<DynamicLookup, dynamic> value, long defaultValue)
        {
            long returnValue;
            var globalSettingValue = value(DynamicLookup.Resolve);

            if (globalSettingValue is long)
            {
                returnValue = globalSettingValue;
            }
            else if (!long.TryParse(globalSettingValue as string, out returnValue))
            {
                returnValue = defaultValue;
            }

            return returnValue;
        }

        public static float Get(Func<DynamicLookup, dynamic> value, float defaultValue)
        {
            float returnValue;
            var globalSettingValue = value(DynamicLookup.Resolve);

            if (globalSettingValue is float)
            {
                returnValue = globalSettingValue;
            }
            else if (!float.TryParse(globalSettingValue as string, out returnValue))
            {
                returnValue = defaultValue;
            }

            return returnValue;
        }

        public static double Get(Func<DynamicLookup, dynamic> value, double defaultValue)
        {
            double returnValue;
            var globalSettingValue = value(DynamicLookup.Resolve);

            if (globalSettingValue is double)
            {
                returnValue = globalSettingValue;
            }
            else if (!double.TryParse(globalSettingValue as string, out returnValue))
            {
                returnValue = defaultValue;
            }

            return returnValue;
        }

        public static bool Get(Func<DynamicLookup, dynamic> value, bool defaultValue)
        {
            bool returnValue;
            var globalSettingValue = value(DynamicLookup.Resolve);

            if (globalSettingValue is bool)
            {
                returnValue = globalSettingValue;
            }
            else if (!bool.TryParse(globalSettingValue as string, out returnValue))
            {
                returnValue = defaultValue;
            }

            return returnValue;
        }

        public static string Get(Func<DynamicLookup, dynamic> value, string defaultValue)
        {
            var globalSettingValue = value(DynamicLookup.Resolve);
            return globalSettingValue as string ?? defaultValue;
        }

        public static StringComparer Get(Func<DynamicLookup, dynamic> value, StringComparer defaultValue)
        {
            var globalSettingValue = value(DynamicLookup.Resolve);
            return globalSettingValue ?? defaultValue;
        }
    }


 public delegate NameValueCollection GetConfigurationValues();

    public class DynamicLookup
    {
        private readonly GetConfigurationValues getConfiguredValues;

        public DynamicLookup(GetConfigurationValues getConfigurationValues)
        {
            getConfiguredValues = getConfigurationValues;
        }

        internal static DynamicLookup Resolve { get { return ServiceLocator.Resolve<DynamicLookup>(); } }

        private dynamic defaults;
        public dynamic DefaultSetting
        {
            get
            {
                Contract.Assert(SettingsNotYetResolved(), "Default configuration values have already been consumed.");
                return defaults ?? (defaults = new ExpandoObject());
            }
        }

        private dynamic allConfiguredValues;
        public dynamic Setting
        {
            get
            {
                return allConfiguredValues ??
                    (allConfiguredValues = AllConfiguredValuesFrom(DefaultSetting as IDictionary<string, object>, getConfiguredValues()));
            }
        }

        private static dynamic AllConfiguredValuesFrom(IEnumerable<KeyValuePair<string, object>> defaults, NameValueCollection configured)
        {
            var values = new ConfiguredValueCache();
            
            //add all the default in to the dictionary first
            foreach (var itm in defaults)
            {
                values[itm.Key] = itm.Value;
            }

            // override them with configured values if they are present
            foreach (var itm in configured.AllKeys)
            {
                values[itm] = configured[itm];
            }
            
            return values;
        }

        private bool SettingsNotYetResolved()
        {
            return allConfiguredValues == null;
        }
    }


public class ConfiguredValueCache : DynamicObject
    {
        private readonly Dictionary<string, object> backingDictionary = new Dictionary<string, object>();

        public object this[string key]
        {
            get { return backingDictionary[key]; }
            set { backingDictionary[key] = value; }
        }

        public override bool TrySetMember(SetMemberBinder binder, object value)
        {
            backingDictionary[binder.Name] = value;
            return true;
        }

        public override bool TryGetMember(GetMemberBinder binder, out object result)
        {
            //we always return true, we dont care if the value doesnt exist, we want to return null instead,
            //otherwise the dlr will throw an exception, which we want to avoid here
            backingDictionary.TryGetValue(binder.Name, out result);
            return true;
        }

        public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result)
        {
            var index = (string)indexes[0];
            return backingDictionary.TryGetValue(index, out result);
        }
    }


 internal static class ConfiguredAppSettingValues
    {
        /// <summary>
        /// returns appsetting values and connection strings combined as one collection
        /// </summary>
        /// <returns></returns>
        public static NameValueCollection All()
        {
            var valueCollection = new NameValueCollection();
            var connectionStrings = ConfigurationManager.ConnectionStrings ?? new ConnectionStringSettingsCollection();
            var appSettingsKeyValuePairs = ConfigurationManager.AppSettings;

            foreach (ConnectionStringSettings connectionString in connectionStrings)
            {
                valueCollection.Add(connectionString.Name, connectionString.ConnectionString);
            }

            foreach (var key in appSettingsKeyValuePairs.AllKeys)
            {
                valueCollection.Add(key, appSettingsKeyValuePairs[key]);
            }

            return valueCollection;
        }
    }