DynamoDS
diff --git a/‎src/Engine/ProtoCore/Lang/CallSite.cs
Copy file name to clipboard
+14-1Lines changed: 14 additions & 1 deletion b/‎src/Engine/ProtoCore/Lang/CallSite.cs
Copy file name to clipboard
+14-1Lines changed: 14 additions & 1 deletion
diff --git a/‎src/Engine/ProtoCore/Properties/AssemblyInfo.cs
Copy file name to clipboard
+1Lines changed: 1 addition & 0 deletions b/‎src/Engine/ProtoCore/Properties/AssemblyInfo.cs
Copy file name to clipboard
+1Lines changed: 1 addition & 0 deletions
diff --git a/‎test/DynamoCoreTests/CallsiteTests.cs
Copy file name to clipboard
+74-3Lines changed: 74 additions & 3 deletions b/‎test/DynamoCoreTests/CallsiteTests.cs
Copy file name to clipboard
+74-3Lines changed: 74 additions & 3 deletions
diff --git a/‎test/core/callsite/RebindingMultiDimension.dyn
Copy file name to clipboard
+350-38Lines changed: 350 additions & 38 deletions b/‎test/core/callsite/RebindingMultiDimension.dyn
Copy file name to clipboard
+350-38Lines changed: 350 additions & 38 deletions
@@ -241,14 +241,27 @@ public List<ISerializable> RecursiveGetNestedData()
         /// deserialization in cases where the exact assemlby that was
         /// used in the serialization is not available. 
         /// </summary>
-        private class TraceBinder : SerializationBinder
+        internal class TraceBinder : SerializationBinder
         {
             // Use a custom serialization binder to make the serializer more permissive
             // https://www.codeproject.com/Articles/11079/NET-XML-and-SOAP-Serialization-Samples-Tips
 
             public override System.Type BindToType(string assemblyName, string typeName)
             {
                 var assemblies = AppDomain.CurrentDomain.GetAssemblies().Where(a => !a.IsDynamic);
+                var assemblyNameObj = new AssemblyName(assemblyName);
+                //find matching assemblies by name, version is not used.
+                var matchingAssembly = assemblies.FirstOrDefault(x => x.GetName().Name == assemblyNameObj.Name);
+                if(matchingAssembly!= null)
+                {
+                   var matchingType = matchingAssembly.GetType(typeName);
+                    if(matchingType != null)
+                    {
+                        return matchingType;
+                    }
+                }
+                //if there was no matching assembly, or type, try all assemblies and all types.
+                //TODO(DYN-1594 - remove this fallback when we can determine if it is required. It is very slow.)
                 var types = new List<System.Type>();
                 foreach (var a in assemblies)
                 {
 
@@ -12,4 +12,5 @@
 // [assembly: AssemblyKeyFile("ProtoCore.snk")]
 [assembly: InternalsVisibleTo("ProtoTest")]
 [assembly: InternalsVisibleTo("ProtoTestFx")]
+[assembly: InternalsVisibleTo("DynamoCoreTests")]
 
@@ -10,6 +10,8 @@
 using Dynamo.Graph.Workspaces;
 using NUnit.Framework;
 using Dynamo.Graph.Nodes;
+using static ProtoCore.CallSite;
+using System.Diagnostics;
 
 namespace Dynamo.Tests
 {
@@ -38,6 +40,7 @@ protected override void GetLibrariesToPreload(List<string> libraries)
             libraries.Add("ProtoGeometry.dll");
             libraries.Add("DesignScriptBuiltin.dll");
             libraries.Add("DSCoreNodes.dll");
+            libraries.Add("FFITarget.dll");
             base.GetLibrariesToPreload(libraries);
         }
 
@@ -59,9 +62,11 @@ protected override string GetUserUserDataRootFolder()
          * A + node with the list and the double connected and CARTESIAN PRODUCT lacing.
          */
 
-        [Test, Category("Failure")]
+        [Test]
         public void Callsite_MultiDimensionDecreaseDimensionOnOpenAndRun_OrphanCountCorrect()
         {
+            CurrentDynamoModel.LibraryServices.ImportLibrary(Path.Combine(TestDirectory, "pkgs", "Dynamo Samples", "bin", "SampleLibraryZeroTouch.dll"));
+
             OpenChangeAndCheckOrphans("RebindingMultiDimension.dyn", "0..1", 3);
         }
 
@@ -79,9 +84,11 @@ public void CallSite_MultiDimensionIncreaseDimensionOnOpenAndRun()
          * A + node with the list and the double connected and SINGLE lacing.
          */
 
-        [Test, Category("Failure")]
+        [Test]
         public void Callsite_SingleDimensionDecreaseDimensionOnOpenAndRun()
         {
+            CurrentDynamoModel.LibraryServices.ImportLibrary(Path.Combine(TestDirectory, "pkgs", "Dynamo Samples", "bin", "SampleLibraryZeroTouch.dll"));
+
             OpenChangeAndCheckOrphans("RebindingSingleDimension.dyn", "0..1", 1);
         }
 
@@ -105,9 +112,12 @@ private void OpenChangeAndCheckOrphans(string testFileName, string numNodeValue,
             BeginRun();
         }
 
-        [Test, Category("Failure")]
+        [Test]
         public void Callsite_DeleteNodeBeforeRun()
         {
+            //load required assembly for test
+            CurrentDynamoModel.LibraryServices.ImportLibrary(Path.Combine(TestDirectory, "pkgs", "Dynamo Samples", "bin", "SampleLibraryZeroTouch.dll"));
+
             var ws = Open<HomeWorkspaceModel>(TestDirectory, callsiteDir, "RebindingSingleDimension.dyn");
 
             CurrentDynamoModel.TraceReconciliationProcessor = new TestTraceReconciliationProcessor(3);
@@ -137,5 +147,66 @@ public void Callsite_RunWithTraceDataFromUnresolvedNodes_DoesNotCrash()
 
             Assert.Pass();
         }
+
+        [Test]
+        public void Callsite_ElementBinding()
+        {
+            // This graph has 2 "WrapperObject" creation nodes that is defined in FFITarget.
+            // The node wraps a static ISerializable ID that increments each time you create a new node.
+            // One of the nodes in the graph is created the 2nd time and the other the 3rd time
+            // in the same session. Therefore the ID of the first is 2 and the second is 3 and the graph
+            // stores the trace data for each node. This test tests that on reopening the graph the ID's
+            // of each of these nodes do not change and remain 2 and 3 respectively due to element binding.
+            var ws = Open<HomeWorkspaceModel>(TestDirectory, callsiteDir, "element_binding.dyn");
+
+            BeginRun();
+
+            AssertPreviewValue("c760af7e-042c-4722-a834-3445bf41f549", 2);
+            AssertPreviewValue("5f277520-13aa-4833-aa82-b17a822e6d8c", 3);
+        }
+
+        [Test]
+        public void Callsite_ElementBinding_Timing()
+        {
+            //This graph loads trace data for 1500 "WrapperObjects" in Manual run mode.
+            var ws = Open<HomeWorkspaceModel>(TestDirectory, callsiteDir, "element_binding_large.dyn");
+            var sw = new Stopwatch();
+            sw.Start();
+
+            BeginRun();
+            sw.Stop();
+            Assert.Less(sw.Elapsed.Milliseconds, 20000);
+            Console.WriteLine(sw.Elapsed);
+            AssertPreviewValue("056d9c584f3b42acabec727e64188fae", Enumerable.Range(6,1501).ToList());
+        }
+
+        [Test]
+        public void TraceBinderReturnsCorrectType_WithMatchingVersionAssembly()
+        {
+            var binder = new TraceBinder();
+            var assembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(x => x.GetName().Name == "FFITarget");
+            Assert.IsNotNull(assembly);
+            var typeName = "FFITarget.IDHolder";
+            var type = binder.BindToType(assembly.FullName, typeName);
+            Assert.IsNotNull(type);
+            Assert.AreEqual(typeName, type.FullName);
+        }
+
+        [Test]
+        public void TraceBinderReturnsCorrectType_WithDifferentVersionAssembly()
+        {
+            var binder = new TraceBinder();
+
+            var fakeAssembly = new AssemblyName();
+            fakeAssembly.Name = "FFITarget";
+            fakeAssembly.Version = new Version(100,100,100);
+
+
+            var typeName = "FFITarget.IDHolder";
+            var type = binder.BindToType(fakeAssembly.FullName, typeName);
+            Assert.IsNotNull(type);
+            Assert.AreEqual(typeName, type.FullName);
+            Assert.AreNotEqual(fakeAssembly.Version, type.Assembly.GetName().Version);
+        }
     }
 }