From 069753b6962cb98c8663be4023583ffce99068d7 Mon Sep 17 00:00:00 2001
From: Antony Male <antony.male@gmail.com>
Date: Fri, 26 Feb 2016 14:32:08 +0000
Subject: [PATCH 1/5] Fix DesignMode sample

---
 .../Stylet.Samples.DesignMode/Stylet.Samples.DesignMode.csproj | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/Samples/Stylet.Samples.DesignMode/Stylet.Samples.DesignMode.csproj b/Samples/Stylet.Samples.DesignMode/Stylet.Samples.DesignMode.csproj
index 7b643f3..c419a45 100644
--- a/Samples/Stylet.Samples.DesignMode/Stylet.Samples.DesignMode.csproj
+++ b/Samples/Stylet.Samples.DesignMode/Stylet.Samples.DesignMode.csproj
@@ -123,9 +123,6 @@
       <Generator>MSBuild:Compile</Generator>
     </Page>
   </ItemGroup>
-  <ItemGroup>
-    <Resource Include="FodyWeavers.xml" />
-  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.

From fc869b642a0386f43232f572f1b4415f117612d5 Mon Sep 17 00:00:00 2001
From: Antony Male <antony.male@gmail.com>
Date: Fri, 26 Feb 2016 14:35:37 +0000
Subject: [PATCH 2/5] Fix typo in DesignMode sample

---
 Samples/Stylet.Samples.DesignMode/JustIntellisenseView.xaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Samples/Stylet.Samples.DesignMode/JustIntellisenseView.xaml b/Samples/Stylet.Samples.DesignMode/JustIntellisenseView.xaml
index 7488730..a0bd679 100644
--- a/Samples/Stylet.Samples.DesignMode/JustIntellisenseView.xaml
+++ b/Samples/Stylet.Samples.DesignMode/JustIntellisenseView.xaml
@@ -10,7 +10,7 @@
     <DockPanel>
         <TextBlock DockPanel.Dock="Top" TextWrapping="Wrap" Margin="10">
             This demonstrates "just intellisense" design mode. The Visual Studio XAML designer will show intellisense for bindings
-            (try and modify the binding below, and see), but does display values from the ViewModel.
+            (try and modify the binding below, and see), but does not display values from the ViewModel.
         </TextBlock>
         
         <TextBlock DockPanel.Dock="Top" Text="{Binding TextBoxText}"/>

From 235504941fd1af101d6acba5af3697ce99f34bce Mon Sep 17 00:00:00 2001
From: Antony Male <antony.male@gmail.com>
Date: Wed, 2 Mar 2016 17:15:22 +0000
Subject: [PATCH 3/5] Throw (by default) if ToAllImplementations does not find
 any implementations

This will happen if someone takes a concrete class (with no subclasses), uses
ToAllImplementations on it (and InSingletonScope), and wonders why the singleton
registration didn't 'take': the ToAllImplementations didn't create any bindings,
so we fell back to auto-binding the type
---
 Stylet/StyletIoC/FluentInterface.cs           |  6 +++--
 .../Internal/Builders/BuilderBindTo.cs        |  8 +++----
 .../BuilderToAllImplementationsBinding.cs     | 14 +++++++++---
 .../StyletIoC/StyletIoCAutobindingTests.cs    | 22 +++++++++++++++++++
 4 files changed, 41 insertions(+), 9 deletions(-)

diff --git a/Stylet/StyletIoC/FluentInterface.cs b/Stylet/StyletIoC/FluentInterface.cs
index d1ef13d..4747089 100644
--- a/Stylet/StyletIoC/FluentInterface.cs
+++ b/Stylet/StyletIoC/FluentInterface.cs
@@ -69,15 +69,17 @@ namespace StyletIoC
         /// Discover all implementations of the service in the specified assemblies / the current assembly, and bind those to the service
         /// </summary>
         /// <param name="assemblies">Assemblies to search. If empty / null, searches the current assembly</param>
+        /// <param name="allowZeroImplementations">By default, ToAllImplementations will throw an exception if no implementations are found. Set this parameter to true to allow this case</param>
         /// <returns>Fluent interface to continue configuration</returns>
-        IInScopeOrWithKeyOrAsWeakBinding ToAllImplementations(IEnumerable<Assembly> assemblies);
+        IInScopeOrWithKeyOrAsWeakBinding ToAllImplementations(IEnumerable<Assembly> assemblies, bool allowZeroImplementations = false);
 
         /// <summary>
         /// Discover all implementations of the service in the specified assemblies / the current assembly, and bind those to the service
         /// </summary>
+        /// <param name="allowZeroImplementations">By default, ToAllImplementations will throw an exception if no implementations are found. Set this parameter to true to allow this case</param>
         /// <param name="assemblies">Assemblies to search. If empty / null, searches the current assembly</param>
         /// <returns>Fluent interface to continue configuration</returns>
-        IInScopeOrWithKeyOrAsWeakBinding ToAllImplementations(params Assembly[] assemblies);
+        IInScopeOrWithKeyOrAsWeakBinding ToAllImplementations(bool allowZeroImplementations = false, params Assembly[] assemblies);
     }
 
     /// <summary>
diff --git a/Stylet/StyletIoC/Internal/Builders/BuilderBindTo.cs b/Stylet/StyletIoC/Internal/Builders/BuilderBindTo.cs
index d524efa..35c8336 100644
--- a/Stylet/StyletIoC/Internal/Builders/BuilderBindTo.cs
+++ b/Stylet/StyletIoC/Internal/Builders/BuilderBindTo.cs
@@ -77,15 +77,15 @@ namespace StyletIoC.Internal.Builders
             return this.builderBinding;
         }
 
-        public IInScopeOrWithKeyOrAsWeakBinding ToAllImplementations(IEnumerable<Assembly> assemblies)
+        public IInScopeOrWithKeyOrAsWeakBinding ToAllImplementations(IEnumerable<Assembly> assemblies, bool allowZeroImplementations = false)
         {
-            this.builderBinding = new BuilderToAllImplementationsBinding(this.ServiceTypes, this.getAssemblies(assemblies, "ToAllImplementations"));
+            this.builderBinding = new BuilderToAllImplementationsBinding(this.ServiceTypes, this.getAssemblies(assemblies, "ToAllImplementations"), allowZeroImplementations);
             return this.builderBinding;
         }
 
-        public IInScopeOrWithKeyOrAsWeakBinding ToAllImplementations(params Assembly[] assemblies)
+        public IInScopeOrWithKeyOrAsWeakBinding ToAllImplementations(bool allowZeroImplementations = false, params Assembly[] assemblies)
         {
-            return this.ToAllImplementations(assemblies.AsEnumerable());
+            return this.ToAllImplementations(assemblies.AsEnumerable(), allowZeroImplementations);
         }
 
         internal void Build(Container container)
diff --git a/Stylet/StyletIoC/Internal/Builders/BuilderToAllImplementationsBinding.cs b/Stylet/StyletIoC/Internal/Builders/BuilderToAllImplementationsBinding.cs
index 5790e4f..91d66aa 100644
--- a/Stylet/StyletIoC/Internal/Builders/BuilderToAllImplementationsBinding.cs
+++ b/Stylet/StyletIoC/Internal/Builders/BuilderToAllImplementationsBinding.cs
@@ -10,23 +10,31 @@ namespace StyletIoC.Internal.Builders
     internal class BuilderToAllImplementationsBinding : BuilderBindingBase
     {
         private readonly IEnumerable<Assembly> assemblies;
+        private readonly bool allowZeroImplementations;
+
         private BuilderTypeKey ServiceType { get { return this.ServiceTypes[0]; } }
 
-        public BuilderToAllImplementationsBinding(List<BuilderTypeKey> serviceTypes, IEnumerable<Assembly> assemblies)
+        public BuilderToAllImplementationsBinding(List<BuilderTypeKey> serviceTypes, IEnumerable<Assembly> assemblies, bool allowZeroImplementations)
             : base(serviceTypes)
         {
             // This should be ensured by the fluent interfaces
             Trace.Assert(this.ServiceTypes.Count == 1);
 
             this.assemblies = assemblies;
+            this.allowZeroImplementations = allowZeroImplementations;
         }
 
         public override void Build(Container container)
         {
-            var candidates = from type in this.assemblies.Distinct().SelectMany(x => x.GetTypes())
+            var candidates = (from type in this.assemblies.Distinct().SelectMany(x => x.GetTypes())
                              let baseType = type.GetBaseTypesAndInterfaces().FirstOrDefault(x => x == this.ServiceType.Type || (x.IsGenericType && x.GetGenericTypeDefinition() == this.ServiceType.Type))
                              where baseType != null
-                             select new { Type = type, Base = baseType.ContainsGenericParameters ? baseType.GetGenericTypeDefinition() : baseType };
+                             select new { Type = type, Base = baseType.ContainsGenericParameters ? baseType.GetGenericTypeDefinition() : baseType }).ToList();
+
+            if (!this.allowZeroImplementations && candidates.Count == 0)
+            {
+                throw new StyletIoCRegistrationException(String.Format("Did not find any implementations of the type {0}", this.ServiceType.Type));
+            }
 
             foreach (var candidate in candidates)
             {
diff --git a/StyletUnitTests/StyletIoC/StyletIoCAutobindingTests.cs b/StyletUnitTests/StyletIoC/StyletIoCAutobindingTests.cs
index e4d9228..9c63aa3 100644
--- a/StyletUnitTests/StyletIoC/StyletIoCAutobindingTests.cs
+++ b/StyletUnitTests/StyletIoC/StyletIoCAutobindingTests.cs
@@ -26,6 +26,9 @@ namespace StyletUnitTests
         [Inject("Key")]
         class C4 { }
 
+        interface I5 { }
+        class C5 { }
+
         [Test]
         public void NongenericInterfaceToAllImplementations()
         {
@@ -162,5 +165,24 @@ namespace StyletUnitTests
 
             Assert.IsInstanceOf<C11>(ioc.Get<C11>());
         }
+
+        [Test]
+        public void ToAllImplementationsThrowsIfNoImplementationsFound()
+        {
+            var builder = new StyletIoCBuilder();
+            builder.Bind<I5>().ToAllImplementations();
+            Assert.Throws<StyletIoCRegistrationException>(() => builder.BuildContainer());
+        }
+
+        [Test]
+        public void ToAllImplementationsDoesNotThrowIfNoImplementationsFoundAndAllowZeroImplementationsIsTrue()
+        {
+            var builder = new StyletIoCBuilder();
+            builder.Bind<I5>().ToAllImplementations(allowZeroImplementations: true);
+            IContainer ioc = null;
+            Assert.DoesNotThrow(() => ioc = builder.BuildContainer());
+
+            Assert.DoesNotThrow(() => ioc.GetAll<I5>());
+        }
     }
 }

From ffac9b60161b1c18a7500787b3af2b4de9e18155 Mon Sep 17 00:00:00 2001
From: Antony Male <antony.male@gmail.com>
Date: Tue, 22 Mar 2016 18:40:50 +0000
Subject: [PATCH 4/5] Fix bug in ViewManager when searching multiple assemblies

Also helpfully search the same assembly as the ViewModel was in
---
 Stylet/ViewManager.cs               | 10 ++++++----
 StyletUnitTests/ViewManagerTests.cs |  9 +++++----
 2 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/Stylet/ViewManager.cs b/Stylet/ViewManager.cs
index 07529b6..c4b4271 100644
--- a/Stylet/ViewManager.cs
+++ b/Stylet/ViewManager.cs
@@ -227,13 +227,14 @@ namespace Stylet
         }
 
         /// <summary>
-        /// Given the expected name for a view, locate its type (or throw an exception if a suitable type couldn't be found)
+        /// Given the expected name for a view, locate its type (or return null if a suitable type couldn't be found)
         /// </summary>
         /// <param name="viewName">View name to locate the type for</param>
+        /// <param name="extraAssemblies">Extra assemblies to search through</param>
         /// <returns>Type for that view name</returns>
-        protected virtual Type ViewTypeForViewName(string viewName)
+        protected virtual Type ViewTypeForViewName(string viewName, IEnumerable<Assembly> extraAssemblies)
         {
-            return this.ViewAssemblies.Select(x => x.GetType(viewName)).FirstOrDefault();
+            return this.ViewAssemblies.Concat(extraAssemblies).Select(x => x.GetType(viewName)).FirstOrDefault(x => x != null);
         }
 
         /// <summary>
@@ -277,7 +278,8 @@ namespace Stylet
             if (modelName == viewName)
                 throw new StyletViewLocationException(String.Format("Unable to transform ViewModel name {0} into a suitable View name", modelName), viewName);
 
-            var viewType = this.ViewTypeForViewName(viewName);
+            // Also include the ViewModel's assembly, to be helpful
+            var viewType = this.ViewTypeForViewName(viewName, new[] { modelType.Assembly });
             if (viewType == null)
             {
                 var e = new StyletViewLocationException(String.Format("Unable to find a View with type {0}", viewName), viewName);
diff --git a/StyletUnitTests/ViewManagerTests.cs b/StyletUnitTests/ViewManagerTests.cs
index 6a62531..8234939 100644
--- a/StyletUnitTests/ViewManagerTests.cs
+++ b/StyletUnitTests/ViewManagerTests.cs
@@ -7,6 +7,7 @@ using System.Collections.Generic;
 using System.Reflection;
 using System.Windows;
 using System.Windows.Controls;
+using System.Linq;
 
 namespace StyletUnitTests
 {
@@ -50,9 +51,9 @@ namespace StyletUnitTests
                 return base.LocateViewForModel(modelType);
             }
 
-            public new Type ViewTypeForViewName(string viewName)
+            public new Type ViewTypeForViewName(string viewName, IEnumerable<Assembly> extraAssemblies)
             {
-                return base.ViewTypeForViewName(viewName);
+                return base.ViewTypeForViewName(viewName, Enumerable.Empty<Assembly>());
             }
         }
 
@@ -97,7 +98,7 @@ namespace StyletUnitTests
                : base(config) { }
 
             public Type ViewType;
-            protected override Type ViewTypeForViewName(string viewName)
+            protected override Type ViewTypeForViewName(string viewName, IEnumerable<Assembly> extraAssemblies)
             {
                 return ViewType;
             }
@@ -236,7 +237,7 @@ namespace StyletUnitTests
                 ViewFactory = type => null,
                 ViewAssemblies = new List<Assembly>() { typeof(BootstrapperBase).Assembly, Assembly.GetExecutingAssembly() }
             });
-            Assert.IsNull(viewManager.ViewTypeForViewName("Test"));
+            Assert.IsNull(viewManager.ViewTypeForViewName("Test", Enumerable.Empty<Assembly>()));
         }
 
         [Test]

From 5b94122832394968626a2739da87564538c6e023 Mon Sep 17 00:00:00 2001
From: Antony Male <antony.male@gmail.com>
Date: Tue, 22 Mar 2016 18:42:44 +0000
Subject: [PATCH 5/5] Update changelog

---
 CHANGELOG.txt | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/CHANGELOG.txt b/CHANGELOG.txt
index 8c7bd58..9bc2a3d 100644
--- a/CHANGELOG.txt
+++ b/CHANGELOG.txt
@@ -1,6 +1,14 @@
 Stylet Changelog
 ================
 
+v1.1.14
+-------
+
+ - Fix bug where ViewManager wouldn't search multiple assemblies for Views
+ - ViewManager searches the assembly containing the ViewModel by default
+ - Throw (by default) if StyletIoC's ToAllImplementations() doesn't find any implementations
+ - Fix typo DesignMode sample
+
 v1.1.13
 -------