Optimized more to beat new unit tests for speed.

Author: jayt

ImpromptuInterface.Silverlight/ImpromptuInterface.Silverlight.csproj

@@ -122,6 +122,9 @@
     <Compile Include="..\ImpromptuInterface\Impromptu.cs">
       <Link>Impromptu.cs</Link>
     </Compile>
+    <Compile Include="..\ImpromptuInterface\Optimization\BinderHash.cs">
+      <Link>Optimization\BinderHash.cs</Link>
+    </Compile>
     <Compile Include="..\ImpromptuInterface\Optimization\InvokeHelper.cs">
       <Link>Optimization\InvokeHelper.cs</Link>
     </Compile>

ImpromptuInterface/Impromptu.cs

@@ -30,10 +30,12 @@ namespace ImpromptuInterface
     /// </summary>
     public static class Impromptu
     {
-        private static readonly IDictionary<Tuple<Type, string, Type>, CallSite> _binderCache = new Dictionary<Tuple<Type, string, Type>, CallSite>();
+        private static readonly IDictionary<BinderHash, CallSite> _binderCache = new Dictionary<BinderHash, CallSite>();
         private static readonly object _binderCacheLock = new object();
 
 
+     
+
         /// <summary>
         /// Creates a cached call site at runtime. 
         /// </summary>
@@ -49,7 +51,7 @@ public static class Impromptu
         public static CallSite CreateCallSite(Type delegateType, CallSiteBinder binder, string name, Type context)
         {
 
-            var tHash = Tuple.Create(delegateType, name, context);
+            var tHash = BinderHash.Create(delegateType, name, context);
             lock (_binderCacheLock)
             {
                 CallSite tOut = null;
@@ -101,7 +103,7 @@ public static CallSite CreateCallSite(Type delegateType, CallSiteBinder binder,
         /// <seealso cref="CreateCallSite"/>
         public static CallSite<T> CreateCallSite<T>(CallSiteBinder binder, string name, Type context) where T: class
         {
-            var tHash = Tuple.Create(typeof(T), name, context);
+            var tHash = BinderHash<T>.Create(name, context);
             lock (_binderCacheLock)
             {
                 CallSite tOut = null;
@@ -145,9 +147,13 @@ public static dynamic InvokeMember(object target, string name, params object[] a
                             {
                                 CSharp.CSharpArgumentInfo.Create(CSharp.CSharpArgumentInfoFlags.None, null)
                             };
-            tList.AddRange(args.Select(
-                                           it =>
-                                           CSharp.CSharpArgumentInfo.Create(CSharp.CSharpArgumentInfoFlags.UseCompileTimeType, null)));
+
+            //Optimization: linq statement creates a slight overhead in this case
+            // ReSharper disable LoopCanBeConvertedToQuery
+            for (int i = 0; i < args.Length; i++)
+                tList.Add(CSharp.CSharpArgumentInfo.Create(CSharp.CSharpArgumentInfoFlags.UseCompileTimeType, null));
+            // ReSharper restore LoopCanBeConvertedToQuery
+
             var tBinder =CSharp.Binder.InvokeMember(CSharp.CSharpBinderFlags.None, name, null,
                                        tContext,tList);
 
@@ -187,9 +193,11 @@ public static void InvokeMemberAction(object target, string name, params object[
                             {
                                 CSharp.CSharpArgumentInfo.Create(CSharp.CSharpArgumentInfoFlags.None, null)
                             };
-            tArgs.AddRange(args.Select(
-                it =>
-                CSharp.CSharpArgumentInfo.Create(CSharp.CSharpArgumentInfoFlags.UseCompileTimeType, null)));
+            //Optimization: linq statement creates a slight overhead in this case
+            // ReSharper disable LoopCanBeConvertedToQuery
+            for (int i = 0; i < args.Length; i++)
+                tArgs.Add(CSharp.CSharpArgumentInfo.Create(CSharp.CSharpArgumentInfoFlags.UseCompileTimeType, null));
+            // ReSharper restore LoopCanBeConvertedToQuery
             var tContext = target.GetType();
             var tBinder = CSharp.Binder.InvokeMember(CSharp.CSharpBinderFlags.ResultDiscarded, name, null,
                                        tContext,tArgs);

ImpromptuInterface/ImpromptuInterface.csproj

@@ -72,6 +72,7 @@
     <Compile Include="EmitProxy\BuildProxy.cs" />
     <Compile Include="EmitProxy\EmitExtensions.cs" />
     <Compile Include="Dynamic\ImpromptuObject.cs" />
+    <Compile Include="Optimization\BinderHash.cs" />
     <Compile Include="Optimization\InvokeHelper.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="EmitProxy\TypeHash.cs" />

ImpromptuInterface/Optimization/BinderHash.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ImpromptuInterface.Optimization
+{
+    internal class BinderHash
+    {
+        protected BinderHash(Type delegateType, string name, Type context)
+        {
+            DelegateType = delegateType;
+            Name = name;
+            Context = context;
+        }
+
+        public static BinderHash Create(Type delType, string name, Type context)
+        {
+            return new BinderHash(delType, name, context);
+        }
+
+
+
+        public Type DelegateType { get; protected set; }
+        public string Name { get; protected set; }
+        public Type Context { get; protected set; }
+
+
+        public virtual bool Equals(BinderHash other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+            return Equals(other.DelegateType, DelegateType) && Equals(other.Name, Name) && Equals(other.Context, Context);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (!(obj is BinderHash)) return false;
+            return Equals((BinderHash)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                int result = DelegateType.GetHashCode();
+                result = (result * 397) ^ Name.GetHashCode();
+                result = (result * 397) ^ Context.GetHashCode();
+                return result;
+            }
+        }
+    }
+
+    internal class GenericBinderHashBase : BinderHash
+    {
+        protected GenericBinderHashBase(Type delegateType, string name, Type context)
+            : base(delegateType, name, context)
+        {
+        }
+    }
+
+    internal class BinderHash<T> : GenericBinderHashBase where T : class
+    {
+
+        public static BinderHash<T> Create(string name, Type context)
+        {
+            return new BinderHash<T>(name, context);
+        }
+
+        protected BinderHash(string name, Type context)
+            : base(typeof(T), name, context)
+        {
+        }
+
+
+        public override bool Equals(BinderHash other)
+        {
+            if (other is GenericBinderHashBase)
+            {
+                if (other is BinderHash<T>)
+                {
+                    return Equals(other.Name, Name) && Equals(other.Context, Context);
+                }
+                return false;
+            }
+            return base.Equals(other);
+        }
+    }
+}

ImpromptuInterface/Properties/AssemblyInfo.cs

@@ -52,4 +52,4 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("3.0.0.*")]
+[assembly: AssemblyVersion("3.0.1.*")]

nuget/ImpromptuInterface.nuspec

@@ -2,7 +2,7 @@
 <package> 
   <metadata> 
     <id>ImpromptuInterface</id> 
-    <version>3.0.0</version> 
+    <version>3.0.1</version> 
     <authors>Jay Tuley</authors> 
     <owners>Jay Tuley</owners>
     <description>A Lightweight Duck Casting Framework for dynamic C# 4.0 (.net4 &amp; silverlight4). Includes helper methods for dynamic invocation via method and property names known only at runtime (runs faster than reflection).</description>