NullReferenceException in PathBinder.AccessMember when instance implements IDictionary<,> explicitily

[oopee]

PathBinder.AccessMember tries to find method ContainsKey via reflection for instances that implement generic IDictionary<,> interface. However, at the moment this throws a NullReferenceException if the instance implements ContainsKey method using explicit interface implementation.

Is there any reason to call GetMethod for the concrete instance type instead for the dictionary interface type? It seems that replacing

// Lines 287 - 290 in PathBinder.cs
if ((bool)instanceType.GetMethod("ContainsKey").Invoke(instance, new[] { key }))
{
    return instanceType.GetMethod("get_Item").Invoke(instance, new[] { key });
}

with

if ((bool)iDictInstance.GetMethod("ContainsKey").Invoke(instance, new[] { key }))
{
    return iDictInstance.GetMethod("get_Item").Invoke(instance, new[] { key });
}

would fix the issue.

Obviously this might break some code in some rare cases (e.g. a class which is derived from Dictionary and which provides a new (non-virtual) implementation for ContainsKey).

[oopee]

Code to reproduce:

using HandlebarsDotNet;
using System.Collections.Generic;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            IHandlebars handlebars = Handlebars.Create();
            string source = @"{{foo bar}}";
            handlebars.RegisterHelper("foo", (writer, context, arguments) => { });
            string formattedString = handlebars.Compile(source).Invoke(new Tester());
        }
    }

    public class Tester : IDictionary<string, object>
    {
        Dictionary<string, object> data = new Dictionary<string, object>();

        bool IDictionary<string, object>.ContainsKey(string key)
        {
            return ((IDictionary<string, object>)data).ContainsKey(key);
        }

        public object this[string key] { get => ((IDictionary<string, object>)data)[key]; set => ((IDictionary<string, object>)data)[key] = value; }
        public ICollection<string> Keys => ((IDictionary<string, object>)data).Keys;
        public ICollection<object> Values => ((IDictionary<string, object>)data).Values;
        public int Count => ((IDictionary<string, object>)data).Count;
        public bool IsReadOnly => ((IDictionary<string, object>)data).IsReadOnly;

        public void Add(string key, object value)
        {
            ((IDictionary<string, object>)data).Add(key, value);
        }

        public void Add(KeyValuePair<string, object> item)
        {
            ((IDictionary<string, object>)data).Add(item);
        }

        public void Clear()
        {
            ((IDictionary<string, object>)data).Clear();
        }

        public bool Contains(KeyValuePair<string, object> item)
        {
            return ((IDictionary<string, object>)data).Contains(item);
        }

        public void CopyTo(KeyValuePair<string, object>[] array, int arrayIndex)
        {
            ((IDictionary<string, object>)data).CopyTo(array, arrayIndex);
        }

        public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
        {
            return ((IDictionary<string, object>)data).GetEnumerator();
        }

        public bool Remove(string key)
        {
            return ((IDictionary<string, object>)data).Remove(key);
        }

        public bool Remove(KeyValuePair<string, object> item)
        {
            return ((IDictionary<string, object>)data).Remove(item);
        }

        public bool TryGetValue(string key, out object value)
        {
            return ((IDictionary<string, object>)data).TryGetValue(key, out value);
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return ((IDictionary<string, object>)data).GetEnumerator();
        }
    }
}

[rexm]

PR welcome