Dynamic Rule Configuration | C# Online Compiler

Dynamic Rule Configuration by garyman99

using System;
using System.Linq;
using System.Collections;
using System.Collections.Generic;

namespace GaryExample
{
	public class Program
	{
		public static void Main()
		{
			var configurationLoader = new GaryExample.Service.ConfigurationLoader();
						
			var config = configurationLoader.LoadApplicationConfiguration();
			
			Console.WriteLine("RUNNING A RULES:");
			foreach(var aRule in config.ARules)
			{
				aRule.DoARuleThings();
			}
			
			Console.WriteLine("RUNNING B RULES:");
			foreach(var bRule in config.BRules)
			{
				bRule.DoBRuleThings();
			}
		}
	}
}

namespace GaryExample.Service
{
	public class ConfigurationLoader
	{
		// this is the reflection bit
		public GaryExample.Domain.Configuration.ApplicationConfiguration LoadApplicationConfiguration()
		{
			var persistedConfig = GaryExample.DataAccess.Configuration.StaticConfigurationProvider.GetConfig();		
			var domainConfig = new GaryExample.Domain.Configuration.ApplicationConfiguration();
		
			// iterate over each of the public properties on the domain configuration object
			foreach(var domainProperty in typeof(GaryExample.Domain.Configuration.ApplicationConfiguration).GetProperties())
			{
				// this is only populating LISTS
				var enumerableType = domainProperty.PropertyType.GetInterfaces().FirstOrDefault(t=>t.IsGenericType && t.GetGenericTypeDefinition() == typeof(IEnumerable<>));
				if (enumerableType != null)
				{
					// determine what the list is of (in our case it's either IRuleA or IRuleB--but this could be anything, really)
					var genericType = enumerableType.GetGenericArguments().First();
					
					// get all of the persisted configurations with this interface type
					var matchingPersistedRules = persistedConfig.Where(r=>r.Interface == genericType.FullName).ToList();
					if (matchingPersistedRules.Any())
					{
						// create our domain rules using the persisted rule settings					
						var matchingDomainRules = (IList) Activator.CreateInstance(typeof(List<>).MakeGenericType(genericType));
						
						foreach(var matchingPersistedRule in matchingPersistedRules)
						{
							// instantiate the rule						
							var concreteType = Type.GetType(matchingPersistedRule.Implementation);
							object instance = Activator.CreateInstance(concreteType);
							
							// if the concrete type has any public properties (basically rule INSTANCE settings)
							foreach(var ruleProperty in concreteType.GetProperties())
							{
								var matchingProperty = matchingPersistedRule.Properties.FirstOrDefault(p=>p.Name == ruleProperty.Name);
								if (matchingProperty != null)
								{
									// populate the property--here's where you could do some magic to handle other special types--we're just dealing with strings in this example, though
									var propertyValue = Convert.ChangeType(matchingProperty.Value, Type.GetType(matchingProperty.Type));
									ruleProperty.SetValue(instance,propertyValue);								
								}	
							}
							
							matchingDomainRules.Add(instance);
						}
						
						// instantiate the collection on the domain configuration
						domainProperty.SetValue(domainConfig, matchingDomainRules);
					}					
				}
			}
			
			return domainConfig;
		}
	}
}

namespace GaryExample.Domain.Configuration
{
	public class ApplicationConfiguration
	{
		public List<GaryExample.Domain.Rule.IRuleTypeA> ARules {get;set;}
		public List<GaryExample.Domain.Rule.IRuleTypeB> BRules {get;set;}
	}
}

namespace GaryExample.Domain.Rule
{
	public interface IRuleTypeA
	{
		void DoARuleThings();
	}

	public interface IRuleTypeB
	{
		void DoBRuleThings();
	}

	public class RuleAOne : IRuleTypeA
	{
		public void DoARuleThings()
		{
			Console.WriteLine("Rule A One doing it's thing");
		}
	}

	public class RuleATwo : IRuleTypeA
	{
		public string SpecialValue {get;set;}
		public void DoARuleThings()
		{
			Console.WriteLine(string.Format("Rule A Two doing it's thing with special value: {0}", SpecialValue));
		}
	}
	
	public class RuleBOne : IRuleTypeB
	{
		public string SuperSpecialValue {get;set;}
		
		public void DoBRuleThings()
		{
			if (string.IsNullOrEmpty(SuperSpecialValue))
			{
				Console.WriteLine("Rule B One doing it's thing");
			}
			else
			{
				Console.WriteLine(string.Format("Rule B On doing it's thing with SUPER special value: {0}", SuperSpecialValue));
			}
		}
	}
	
	public class RuleBTwo : IRuleTypeB
	{
		public bool WriteCoolStuff {get;set;}
		
		public void DoBRuleThings()
		{
			if (WriteCoolStuff)
			{
				Console.WriteLine("Rule B Two writing cool stuff");
			}
			else
			{
				Console.WriteLine("Rule B Two writing BORING stuff");
			}
		}
	}
}


namespace GaryExample.DataAccess.Configuration
{
	public static class StaticConfigurationProvider
	{
		public static List<RuleConfig> GetConfig()
		{
			// this data is persisted
			return new List<RuleConfig>
			{
				new RuleConfig { Interface = "GaryExample.Domain.Rule.IRuleTypeA", Implementation = "GaryExample.Domain.Rule.RuleAOne", },
				new RuleConfig { Interface = "GaryExample.Domain.Rule.IRuleTypeA", Implementation = "GaryExample.Domain.Rule.RuleATwo", Properties = new List<RulePropertyConfig>{new RulePropertyConfig	{	Name = "SpecialValue", Type = "System.String", Value = "Configured Special Value 1", }}},
				new RuleConfig { Interface = "GaryExample.Domain.Rule.IRuleTypeA", Implementation = "GaryExample.Domain.Rule.RuleATwo", Properties = new List<RulePropertyConfig>{new RulePropertyConfig	{	Name = "SpecialValue", Type = "System.String", Value = "Configured Special Value 2", }}},
				new RuleConfig { Interface = "GaryExample.Domain.Rule.IRuleTypeB", Implementation = "GaryExample.Domain.Rule.RuleBOne", },
				new RuleConfig { Interface = "GaryExample.Domain.Rule.IRuleTypeB", Implementation = "GaryExample.Domain.Rule.RuleBOne", Properties = new List<RulePropertyConfig>{new RulePropertyConfig	{	Name = "SuperSpecialValue", Type = "System.String", Value = "Configured SUPER Special Value 1", }}},	
				new RuleConfig { Interface = "GaryExample.Domain.Rule.IRuleTypeB", Implementation = "GaryExample.Domain.Rule.RuleBTwo", Properties = new List<RulePropertyConfig>{new RulePropertyConfig	{	Name = "WriteCoolStuff", Type = "System.Boolean", Value = "True", }}},	
				new RuleConfig { Interface = "GaryExample.Domain.Rule.IRuleTypeB", Implementation = "GaryExample.Domain.Rule.RuleBTwo", Properties = new List<RulePropertyConfig>{new RulePropertyConfig	{	Name = "WriteCoolStuff", Type = "System.Boolean", Value = "False", }}},	
			};
		}
	}

	public class RuleConfig
	{
		public string Interface {get;set;}
		public string Implementation {get;set;}
		public List<RulePropertyConfig> Properties {get;set;}
		
		public RuleConfig()
		{
			Properties = new List<RulePropertyConfig>();
		}
	}

	public class RulePropertyConfig
	{
		public string Name {get;set;}
		public string Type {get;set;}
		public string Value {get;set;}
	}
}

​x
 
using System;
using System.Linq;
using System.Collections;
using System.Collections.Generic;
​
namespace GaryExample
{
    public class Program
    {
        public static void Main()
        {
            var configurationLoader = new GaryExample.Service.ConfigurationLoader();
                        
            var config = configurationLoader.LoadApplicationConfiguration();
            
            Console.WriteLine("RUNNING A RULES:");
            foreach(var aRule in config.ARules)
            {
                aRule.DoARuleThings();
            }
            
            Console.WriteLine("RUNNING B RULES:");
            foreach(var bRule in config.BRules)
            {
                bRule.DoBRuleThings();
            }
        }
    }
}
​
namespace GaryExample.Service
{
    public class ConfigurationLoader
    {
        // this is the reflection bit
        public GaryExample.Domain.Configuration.ApplicationConfiguration LoadApplicationConfiguration()
        {
            var persistedConfig = GaryExample.DataAccess.Configuration.StaticConfigurationProvider.GetConfig();     
            var domainConfig = new GaryExample.Domain.Configuration.ApplicationConfiguration();
        
            // iterate over each of the public properties on the domain configuration object
            foreach(var domainProperty in typeof(GaryExample.Domain.Configuration.ApplicationConfiguration).GetProperties())
            {
                // this is only populating LISTS
                var enumerableType = domainProperty.PropertyType.GetInterfaces().FirstOrDefault(t=>t.IsGenericType && t.GetGenericTypeDefinition() == typeof(IEnumerable<>));
                if (enumerableType != null)
                {
                    // determine what the list is of (in our case it's either IRuleA or IRuleB--but this could be anything, really)
                    var genericType = enumerableType.GetGenericArguments().First();
                    
                    // get all of the persisted configurations with this interface type
                    var matchingPersistedRules = persistedConfig.Where(r=>r.Interface == genericType.FullName).ToList();
                    if (matchingPersistedRules.Any())
                    {
                        // create our domain rules using the persisted rule settings                    
                        var matchingDomainRules = (IList) Activator.CreateInstance(typeof(List<>).MakeGenericType(genericType));
                        
                        foreach(var matchingPersistedRule in matchingPersistedRules)
                        {
                            // instantiate the rule                     
                            var concreteType = Type.GetType(matchingPersistedRule.Implementation);
                            object instance = Activator.CreateInstance(concreteType);
                            
                            // if the concrete type has any public properties (basically rule INSTANCE settings)
                            foreach(var ruleProperty in concreteType.GetProperties())
                            {
                                var matchingProperty = matchingPersistedRule.Properties.FirstOrDefault(p=>p.Name == ruleProperty.Name);
                                if (matchingProperty != null)
                                {
                                    // populate the property--here's where you could do some magic to handle other special types--we're just dealing with strings in this example, though
                                    var propertyValue = Convert.ChangeType(matchingProperty.Value, Type.GetType(matchingProperty.Type));
                                    ruleProperty.SetValue(instance,propertyValue);                              
                                }   
                            }
                            
                            matchingDomainRules.Add(instance);
                        }
                        
                        // instantiate the collection on the domain configuration
                        domainProperty.SetValue(domainConfig, matchingDomainRules);
                    }                   
                }
            }
            
            return domainConfig;
        }
    }
}
​
namespace GaryExample.Domain.Configuration
{
    public class ApplicationConfiguration
    {
        public List<GaryExample.Domain.Rule.IRuleTypeA> ARules {get;set;}
        public List<GaryExample.Domain.Rule.IRuleTypeB> BRules {get;set;}
    }
}
​
namespace GaryExample.Domain.Rule
{
    public interface IRuleTypeA
    {
        void DoARuleThings();
    }
​
    public interface IRuleTypeB
    {
        void DoBRuleThings();
    }
​
    public class RuleAOne : IRuleTypeA
    {
        public void DoARuleThings()
        {
            Console.WriteLine("Rule A One doing it's thing");
        }
    }
​
    public class RuleATwo : IRuleTypeA
    {
        public string SpecialValue {get;set;}
        public void DoARuleThings()
        {
            Console.WriteLine(string.Format("Rule A Two doing it's thing with special value: {0}", SpecialValue));
        }
    }
    
    public class RuleBOne : IRuleTypeB
    {
        public string SuperSpecialValue {get;set;}
        
        public void DoBRuleThings()
        {
            if (string.IsNullOrEmpty(SuperSpecialValue))
            {
                Console.WriteLine("Rule B One doing it's thing");
            }
            else
            {
                Console.WriteLine(string.Format("Rule B On doing it's thing with SUPER special value: {0}", SuperSpecialValue));
            }
        }
    }
    
    public class RuleBTwo : IRuleTypeB
    {
        public bool WriteCoolStuff {get;set;}
        
        public void DoBRuleThings()
        {
            if (WriteCoolStuff)
            {
                Console.WriteLine("Rule B Two writing cool stuff");
            }
            else
            {
                Console.WriteLine("Rule B Two writing BORING stuff");
            }
        }
    }
}
​
​
namespace GaryExample.DataAccess.Configuration
{
    public static class StaticConfigurationProvider
    {
        public static List<RuleConfig> GetConfig()
        {
            // this data is persisted
            return new List<RuleConfig>
            {
                new RuleConfig { Interface = "GaryExample.Domain.Rule.IRuleTypeA", Implementation = "GaryExample.Domain.Rule.RuleAOne", },
                new RuleConfig { Interface = "GaryExample.Domain.Rule.IRuleTypeA", Implementation = "GaryExample.Domain.Rule.RuleATwo", Properties = new List<RulePropertyConfig>{new RulePropertyConfig    {   Name = "SpecialValue", Type = "System.String", Value = "Configured Special Value 1", }}},
                new RuleConfig { Interface = "GaryExample.Domain.Rule.IRuleTypeA", Implementation = "GaryExample.Domain.Rule.RuleATwo", Properties = new List<RulePropertyConfig>{new RulePropertyConfig    {   Name = "SpecialValue", Type = "System.String", Value = "Configured Special Value 2", }}},
                new RuleConfig { Interface = "GaryExample.Domain.Rule.IRuleTypeB", Implementation = "GaryExample.Domain.Rule.RuleBOne", },
                new RuleConfig { Interface = "GaryExample.Domain.Rule.IRuleTypeB", Implementation = "GaryExample.Domain.Rule.RuleBOne", Properties = new List<RulePropertyConfig>{new RulePropertyConfig    {   Name = "SuperSpecialValue", Type = "System.String", Value = "Configured SUPER Special Value 1", }}},    
                new RuleConfig { Interface = "GaryExample.Domain.Rule.IRuleTypeB", Implementation = "GaryExample.Domain.Rule.RuleBTwo", Properties = new List<RulePropertyConfig>{new RulePropertyConfig    {   Name = "WriteCoolStuff", Type = "System.Boolean", Value = "True", }}},  
                new RuleConfig { Interface = "GaryExample.Domain.Rule.IRuleTypeB", Implementation = "GaryExample.Domain.Rule.RuleBTwo", Properties = new List<RulePropertyConfig>{new RulePropertyConfig    {   Name = "WriteCoolStuff", Type = "System.Boolean", Value = "False", }}}, 
            };
        }
    }
​
    public class RuleConfig
    {
        public string Interface {get;set;}
        public string Implementation {get;set;}
        public List<RulePropertyConfig> Properties {get;set;}
        
        public RuleConfig()
        {
            Properties = new List<RulePropertyConfig>();
        }
    }
​
    public class RulePropertyConfig
    {
        public string Name {get;set;}
        public string Type {get;set;}
        public string Value {get;set;}
    }
}

Unhandled exception. System.TypeInitializationException: The type initializer for 'System.Data.Entity.DbContext' threw an exception.
---> System.TypeInitializationException: The type initializer for 'Z.EntityFramework.Classic.EntityFrameworkManager' threw an exception.
---> System.TypeInitializationException: The type initializer for '' threw an exception.
---> System.IO.FileNotFoundException: Could not load file or assembly 'System.Configuration.ConfigurationManager, Version=8.0.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51'. The system cannot find the file specified.

File name: 'System.Configuration.ConfigurationManager, Version=8.0.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51'
   at Z.Expressions.CompilerManager..cctor()
   at Z.Expressions.CompilerManager.LoadEntityFrameworkClassicConfiguration()
   at Z.Expressions.ExceptionMessage.ThrowLicenseException()
   at ..cctor()
   --- End of inner exception stack trace ---
   at .()
   at Z.EntityFramework.Classic.EntityFrameworkManager..cctor()
   --- End of inner exception stack trace ---
   at Z.EntityFramework.Classic.EntityFrameworkManager.Initialize()
   at System.Data.Entity.DbContext..cctor()
   --- End of inner exception stack trace ---
   at System.Data.Entity.DbContext..ctor(String nameOrConnectionString)
   at Program.EntityContext..ctor()
   at Program.Main()
Command terminated by signal 6

Last Run:	12:14:41 am
Compile:	0.047s
Execute:	0.22s
Memory:	10.82Mb
CPU:	0.267s

View IL Code