Added dictionary support.

Author: jamescurran

MicroRuleEngine.Tests/NewAPI.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MicroRuleEngine.Tests.Models;
@@ -177,6 +178,47 @@ public void ListTest()
             Assert.IsFalse(passes);
         }
 
+        class DictTest<T>
+        {
+	        public Dictionary<T, int> Dict { get; set; }
+        }
+
+        [TestMethod]
+        public void Dictionary_StringIndex()
+        {
+	        var objDict = new DictTest<string> { Dict = new Dictionary<string, int>()};
+            objDict.Dict.Add("Key", 1234);
+
+	        Rule rule = Rule.Create("Dict['Key']", mreOperator.Equal, 1234);
+
+	        MRE engine = new MRE();
+	        var compiledRule = engine.CompileRule<DictTest<string>>(rule);
+	        bool passes = compiledRule(objDict);
+	        Assert.IsTrue(passes);
+
+	        objDict.Dict["Key"] = 2345;
+            passes = compiledRule(objDict);
+	        Assert.IsFalse(passes);
+        }
+
+        [TestMethod]
+        public void Dictionary_IntIndex()
+        {
+	        var objDict = new DictTest<int> { Dict = new Dictionary<int, int>() };
+	        objDict.Dict.Add(111, 1234);
+
+	        Rule rule = Rule.Create("Dict[111]", mreOperator.Equal, 1234);
+
+	        MRE engine = new MRE();
+	        var compiledRule = engine.CompileRule<DictTest<int>>(rule);
+	        bool passes = compiledRule(objDict);
+	        Assert.IsTrue(passes);
+
+	        objDict.Dict[111] = 2345;
+	        passes = compiledRule(objDict);
+	        Assert.IsFalse(passes);
+        }
+
         [TestMethod]
         public void SelfReferenialTest()
         {

MicroRuleEngine/MRE.cs

@@ -133,7 +133,8 @@ protected static Expression BinaryExpression(IEnumerable<Expression> expressions
             return expressions.Aggregate(methodExp);
         }
 
-        static readonly Regex _regexIndexed = new Regex(@"(\w+)\[(\d+)\]", RegexOptions.Compiled);
+        private static readonly Regex _regexIndexed =
+	        new Regex(@"(?'Collection'\w+)\[(?:(?'Index'\d+)|(?:['""](?'Key'\w+)[""']))\]", RegexOptions.Compiled);
 
         private static Expression GetProperty(Expression param, string propname)
         {
@@ -146,26 +147,38 @@ private static Expression GetProperty(Expression param, string propname)
                 var isIndexed = _regexIndexed.Match(childprop);
                 if (isIndexed.Success)
                 {
-                    var collectionname = isIndexed.Groups[1].Value;
-                    var index = Int32.Parse(isIndexed.Groups[2].Value);
+	                var indexType = typeof(int);
+                    var collectionname = isIndexed.Groups["Collection"].Value;
                     var collectionProp = propertyType.GetProperty(collectionname);
                     if (collectionProp == null)
-                        throw new RulesException(
-                                $"Cannot find collection property {collectionname} in class {propertyType.Name} (\"{propname}\")");
+	                    throw new RulesException(
+		                    $"Cannot find collection property {collectionname} in class {propertyType.Name} (\"{propname}\")");
                     var collexpr = Expression.PropertyOrField(propExpression, collectionname);
 
+                    Expression expIndex;
+                    if (isIndexed.Groups["Index"].Success)
+                    {
+	                    var index = Int32.Parse(isIndexed.Groups["Index"].Value);
+	                    expIndex = Expression.Constant(index);
+                    }
+                    else
+                    {
+	                    expIndex = Expression.Constant(isIndexed.Groups["Key"].Value);
+	                    indexType = typeof(string);
+                    }
+
                     var collectionType = collexpr.Type;
                     if (collectionType.IsArray)
                     {
-                        propExpression = Expression.ArrayAccess(collexpr, Expression.Constant(index));
+                        propExpression = Expression.ArrayAccess(collexpr, expIndex);
                         propertyType = propExpression.Type;
                     }
                     else
                     {
-                        var getter = collectionType.GetMethod("get_Item", new Type[] { typeof(Int32) });
+                        var getter = collectionType.GetMethod("get_Item", new Type[] { indexType });
                         if (getter == null)
                             throw new RulesException($"'{collectionname} ({collectionType.Name}) cannot be indexed");
-                        propExpression = Expression.Call(collexpr, getter, Expression.Constant(index));
+                        propExpression = Expression.Call(collexpr, getter, expIndex);
                         propertyType = getter.ReturnType;
                     }
                 }
@@ -541,7 +554,7 @@ public static bool IsSimpleType(Type type)
                     ;
             }
             public static BindingFlags flags = BindingFlags.Instance | BindingFlags.Public;
-            public static List<Member> GetFields(System.Type type, string memberName = null, string parentPath = null)
+            public static List<Member> GetFields(Type type, string memberName = null, string parentPath = null)
             {
                 List<Member> toReturn = new List<Member>();
                 var fi = new Member
@@ -624,7 +637,7 @@ public static bool IsGenericList(Type type)
                     mreOperator.IsDouble.ToString("g"),
                     mreOperator.IsDecimal.ToString("g")
                 };
-            public static List<Operator> Operators(System.Type type, bool addLogicOperators = false, bool noOverloads = true)
+            public static List<Operator> Operators(Type type, bool addLogicOperators = false, bool noOverloads = true)
             {
                 List<Operator> operators = new List<Operator>();
                 if (addLogicOperators)

README.md

@@ -52,6 +52,12 @@ You can reference member properties which are `Arrays` or `List<>` by their inde
 	Rule rule = Rule.Create("Items[1].Cost", mreOperator.GreaterThanOrEqual, "5.25");
 ```
 
+Similarly, you can reference element of a string- or integer-keyed dictionary:
+```csharp
+	Rule rule = Rule.Create("Items['myKey'].Cost", mreOperator.GreaterThanOrEqual, "5.25");
+```
+
+
 You can also compare an object to itself indicated by the `*.` at the beginning of the `TargetValue`:
 ```csharp
 	Rule rule = Rule.Create("Items[1].Cost", mreOperator.Equal, "*.Items[0].Cost");