Support design-time application running

Samples/Stylet.Samples.ModelValidation/Pages/ShellView.xaml

@@ -2,6 +2,11 @@
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:s="https://github.com/canton7/Stylet"
+        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
+        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+        xmlns:local="clr-namespace:Stylet.Samples.ModelValidation.Pages"
+        mc:Ignorable="d"
+        d:DataContext="{d:DesignInstance local:ShellViewModel, IsDesignTimeCreatable=True}"
         Title="ShellView" Height="300" Width="700">
     <Grid>
         <ContentControl s:View.Model="{Binding ActiveItem}"/>

Samples/Stylet.Samples.ModelValidation/Pages/ShellViewModel.cs

@@ -8,6 +8,11 @@ namespace Stylet.Samples.ModelValidation.Pages
 {
     public class ShellViewModel : Conductor<IScreen>
     {
+        public ShellViewModel()
+        {
+            this.ActiveItem = new UserViewModel(new FluentModelValidator<UserViewModel>(new UserViewModelValidator()));
+        }
+
         public ShellViewModel(UserViewModel userViewModel)
         {
             this.DisplayName = "Stylet.Samples.ModelValidation";

Samples/Stylet.Samples.ModelValidation/Pages/UserView.xaml

@@ -49,6 +49,7 @@
             <RowDefinition Height="Auto"/>
             <RowDefinition Height="Auto"/>
             <RowDefinition Height="Auto"/>
+            <RowDefinition Height="Auto"/>
         </Grid.RowDefinitions>
 
         <Label Grid.Row="0" Grid.Column="0" Target="{Binding ElementName=UserName}">UserName:</Label>
@@ -56,14 +57,17 @@
 
         <Label Grid.Row="1" Grid.Column="0" Target="{Binding ElementName=Email}">Email:</Label>
         <TextBox Grid.Row="1" Grid.Column="1" x:Name="Email" Text="{Binding Email}"/>
-        
-        <Label Grid.Row="2" Grid.Column="0" Target="{Binding ElementName=Password}">Password:</Label>
-        <PasswordBox Grid.Row="2" Grid.Column="1" x:Name="Password" xaml:Secure.Password="{Binding Password}"/>
 
-        <Label Grid.Row="3" Grid.Column="0" Target="{Binding ElementName=PasswordConfirmation}">Password Confirmation:</Label>
-        <PasswordBox Grid.Row="3" Grid.Column="1" x:Name="PasswordConfirmation" xaml:Secure.Password="{Binding PasswordConfirmation}"/>
+        <Label Grid.Row="2" Grid.Column="0" Target="{Binding ElementName=Age}">Age:</Label>
+        <TextBox Grid.Row="2" Grid.Column="1" x:Name="Age" Text="{Binding Age}"/>
+
+        <Label Grid.Row="3" Grid.Column="0" Target="{Binding ElementName=Password}">Password:</Label>
+        <PasswordBox Grid.Row="3" Grid.Column="1" x:Name="Password" xaml:Secure.Password="{Binding Password}"/>
+
+        <Label Grid.Row="4" Grid.Column="0" Target="{Binding ElementName=PasswordConfirmation}">Password Confirmation:</Label>
+        <PasswordBox Grid.Row="4" Grid.Column="1" x:Name="PasswordConfirmation" xaml:Secure.Password="{Binding PasswordConfirmation}"/>
         
-        <CheckBox Grid.Row="4" Grid.Column="0" IsChecked="{Binding AutoValidate}">Auto-Validate</CheckBox>
-        <Button Grid.Row="4" Grid.Column="1" Command="{s:Action Submit}" HorizontalAlignment="Left">Submit</Button>
+        <CheckBox Grid.Row="5" Grid.Column="0" IsChecked="{Binding AutoValidate}">Auto-Validate</CheckBox>
+        <Button Grid.Row="5" Grid.Column="1" Command="{s:Action Submit}" HorizontalAlignment="Left">Submit</Button>
     </Grid>
 </UserControl>

Samples/Stylet.Samples.ModelValidation/Pages/UserViewModel.cs

@@ -13,6 +13,7 @@ namespace Stylet.Samples.ModelValidation.Pages
         public string Email { get; set; }
         public string Password { get; set; }
         public string PasswordConfirmation { get; set; }
+        public Stringable<int> Age { get; set; }
 
         public bool AutoValidate
         {
@@ -49,7 +50,12 @@ namespace Stylet.Samples.ModelValidation.Pages
             RuleFor(x => x.UserName).NotEmpty().Length(1, 20);
             RuleFor(x => x.Email).NotEmpty().EmailAddress();
             RuleFor(x => x.Password).NotEmpty().Matches("[0-9]").WithMessage("{PropertyName} must contain a number");
-            RuleFor(x => x.PasswordConfirmation).NotEmpty().Equal(s => s.Password).WithMessage("{PropertyName} should match Password");
+            RuleFor(x => x.PasswordConfirmation).Equal(s => s.Password).WithMessage("{PropertyName} should match Password");
+            RuleFor(x => x.Age).Must(x => x.IsValid).WithMessage("{PropertyName} must be a valid number");
+            When(x => x.Age.IsValid, () =>
+            {
+                RuleFor(x => x.Age.Value).GreaterThan(0).WithName("Age");
+            });
         }
     }
 }

Samples/Stylet.Samples.ModelValidation/Stringable.cs

@@ -0,0 +1,198 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Stylet.Samples.ModelValidation
+{
+    /// <summary>
+    /// Type which can be converter to and from both a T and a string. Useful for binding a TextBox to, say, an int.
+    /// </summary>
+    /// <remarks>
+    /// Stringable{T} has two value properties - StringValue, which is always set, and Value, which is set if Value can be converted to a T.
+    /// If you create a new Stringable{T} from a T, both Value and StringValue are set. If you Create one from a string (using Stringable{T}.FromString)
+    /// then StringValue is set, and Value is set if that string value can be converted to a T>
+    /// IsValid indicates whether Value could be set.
+    /// 
+    /// This type has an associated TypeConverter, StringableConverter, which will be used by WPF to convert this Stringable{T} to and from a string. 
+    /// </remarks>
+    // I would make this a struct, but it will have to be boxed to go through the TypeConverter, so there's no point
+    [TypeConverter(typeof(StringableConverter))]
+    public class Stringable<T> : IEquatable<Stringable<T>>
+    {
+        private readonly string _stringValue;
+
+        /// <summary>
+        /// String representation of the value
+        /// </summary>
+        public string StringValue
+        {
+            get { return this._stringValue; }
+        }
+
+        private readonly T _value;
+        /// <summary>
+        /// Actual value, or default(T) if IsValid is false
+        /// </summary>
+        public T Value
+        {
+            get { return this._value; }
+        }
+
+        private readonly bool _isValid;
+        /// <summary>
+        /// True if Value ias a proper value (i.e. we were constructed from a T, or we were constructed from a string which could be converted to a T)
+        /// </summary>
+        public bool IsValid
+        {
+            get { return this._isValid; }
+        }
+
+        /// <summary>
+        /// Create a new instance, representing the given value
+        /// </summary>
+        /// <param name="value">Value to represent</param>
+        public Stringable(T value) : this(value, value.ToString(), true) { }
+
+        private Stringable(T value, string stringValue, bool isValid)
+        {
+            this._value = value;
+            this._stringValue = stringValue;
+            this._isValid = isValid;
+        }
+
+        /// <summary>
+        /// Create a new instance from the given string. If the string can be converted to a T, then IsValue is true and Value contains the converted value.
+        /// If not, IsValid is false and Value is default(T)
+        /// </summary>
+        /// <param name="stringValue"></param>
+        /// <returns></returns>
+        public static Stringable<T> FromString(string stringValue)
+        {
+            T dest = default(T);
+            bool isValid = false;
+            
+            // The TypeConverter for String can't convert it into anything else, so don't bother getting that
+            var fromConverter = TypeDescriptor.GetConverter(typeof(T));
+            if (fromConverter.CanConvertFrom(typeof(string)) && fromConverter.IsValid(stringValue))
+            {
+                dest = (T)fromConverter.ConvertFrom(stringValue);
+                isValid = true;
+            }
+
+            return new Stringable<T>(dest, stringValue, isValid);
+        }
+
+        public static implicit operator T(Stringable<T> stringable)
+        {
+            return stringable.Value;
+        }
+
+        public static implicit operator Stringable<T>(T value)
+        {
+            return new Stringable<T>(value);
+        }
+
+        public override string ToString()
+        {
+            return this.StringValue;
+        }
+
+        public override bool Equals(object obj)
+        {
+            return base.Equals(obj as Stringable<T>);
+        }
+
+        public bool Equals(Stringable<T> other)
+        {
+            return other != null && EqualityComparer<T>.Default.Equals(this.Value, other.Value) && this.StringValue == other.StringValue;
+        }
+
+        public static bool operator ==(Stringable<T> o1, Stringable<T> o2)
+        {
+            if (Object.ReferenceEquals(o1, o2))
+                return true;
+            if ((object)o1 == null || (object)o2 == null)
+                return false;
+            return o1.Equals(o2);
+        }
+
+        public static bool operator !=(Stringable<T> o1, Stringable<T> o2)
+        {
+            return !(o1 == o2);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                int hash = 17;
+                hash = hash * 27 + this.Value.GetHashCode();
+                hash = hash * 27 + this.StringValue.GetHashCode();
+                return hash;
+            }
+        }
+    }
+
+    /// <summary>
+    /// TypeConverter for Stringable{T}
+    /// </summary>
+    /// <remarks>
+    /// This is used by WPF. This means that if a Stringable{T} property is bound to a string control (e.g. TextBox), then this TypeConverter
+    /// is used to convert from that string back to a Stringable{T}
+    /// </remarks>
+    public class StringableConverter : TypeConverter
+    {
+        private readonly Type valueType;
+        private readonly Func<string, object> generator;
+
+        public StringableConverter(Type type)
+        {
+            if (!type.IsGenericType || type.GetGenericTypeDefinition() != typeof(Stringable<>) || type.GetGenericArguments().Length != 1)
+                throw new ArgumentException("Incompatible type", "type");
+
+            this.valueType = type;
+
+            // Generate a Func<string, object> which gives us a Stringable<T>, given a string
+            // WPF instantiates us once, then uses us lots, so the overhead of doing this here is worth it
+            var fromMethod = type.GetMethod("FromString", BindingFlags.Static | BindingFlags.Public);
+            var param = Expression.Parameter(typeof(string));
+            this.generator = Expression.Lambda<Func<string, object>>(Expression.Call(fromMethod, param), param).Compile();
+        }
+
+        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
+        {
+            return sourceType == typeof(string) || base.CanConvertFrom(context, sourceType);
+        }
+
+        public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
+        {
+            return this.generator(value as string);
+        }
+
+        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
+        {
+            return destinationType == typeof(string) || destinationType == this.valueType || base.CanConvertTo(context, destinationType);
+        }
+
+        public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
+        {
+            if (value == null)
+                return String.Empty;
+            // Common case = just call the overloaded ToString - no need for reflection
+            if (destinationType == typeof(string))
+                return value.ToString();
+            var valueType = value.GetType();
+            if (destinationType.IsAssignableFrom(this.valueType) && typeof(Stringable<>).IsAssignableFrom(valueType))
+            {
+                var valueProperty = valueType.GetProperty("Value", BindingFlags.Public | BindingFlags.Instance);
+                return valueProperty.GetValue(value);
+            }
+            return base.ConvertTo(context, culture, value, destinationType);
+        }
+    }
+}

Samples/Stylet.Samples.ModelValidation/Stylet.Samples.ModelValidation.csproj

@@ -67,6 +67,7 @@
       <DependentUpon>App.xaml</DependentUpon>
       <SubType>Code</SubType>
     </Compile>
+    <Compile Include="Stringable.cs" />
     <Compile Include="Xaml\Secure.cs" />
   </ItemGroup>
   <ItemGroup>

Samples/Stylet.Samples.ModelValidation/Xaml/Secure.cs

@@ -25,9 +25,12 @@ namespace Stylet.Samples.ModelValidation.Xaml
             obj.SetValue(PasswordProperty, value);
         }
 
-        // Using a DependencyProperty as the backing store for Password.  This enables animation, styling, binding, etc...
+        // We play a trick here. If we set the initial value to something, it'll be set to something else when the binding kicks in,
+        // and HandleBoundPasswordChanged will be called, which allows us to set up our event subscription.
+        // If the binding sets us to a value which we already are, then this doesn't happen. Therefore start with a value that's
+        // definitely unique.
         public static readonly DependencyProperty PasswordProperty =
-            DependencyProperty.RegisterAttached("Password", typeof(string), typeof(Secure), new FrameworkPropertyMetadata(String.Empty, HandleBoundPasswordChanged)
+            DependencyProperty.RegisterAttached("Password", typeof(string), typeof(Secure), new FrameworkPropertyMetadata(Guid.NewGuid().ToString(), HandleBoundPasswordChanged)
             { 
                 BindsTwoWayByDefault = true,
                 DefaultUpdateSourceTrigger = UpdateSourceTrigger.LostFocus // Match the default on Binding
@@ -75,8 +78,13 @@ namespace Stylet.Samples.ModelValidation.Xaml
             obj.SetValue(SecurePasswordProperty, value);
         }
 
+        // Similarly, we'll be set to something which isn't this exact instance of SecureString when the binding kicks in
         public static readonly DependencyProperty SecurePasswordProperty =
-            DependencyProperty.RegisterAttached("SecurePassword", typeof(SecureString), typeof(Secure), new FrameworkPropertyMetadata(new SecureString(), HandleBoundSecurePasswordChanged) { BindsTwoWayByDefault = true });
+            DependencyProperty.RegisterAttached("SecurePassword", typeof(SecureString), typeof(Secure), new FrameworkPropertyMetadata(new SecureString(), HandleBoundSecurePasswordChanged)
+            {
+                BindsTwoWayByDefault = true,
+                DefaultUpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged,
+            });
 
 
         private static void HandleBoundSecurePasswordChanged(DependencyObject dp, DependencyPropertyChangedEventArgs e)

Stylet/Bootstrapper.cs

@@ -15,6 +15,18 @@ namespace Stylet
     /// <typeparam name="TRootViewModel">Type of the root ViewModel. This will be instantiated and displayed</typeparam>
     public class Bootstrapper<TRootViewModel> : BootstrapperBase<TRootViewModel> where TRootViewModel : class
     {
+        /// <summary>
+        /// Create a new Bootstrapper, which automatically starts and launches
+        /// </summary>
+        public Bootstrapper() : base() { }
+
+        /// <summary>
+        /// Create a new Bootstrapper, and specify whether to auto-start and auto-launhc
+        /// </summary>
+        /// <param name="autoStart">True to call this.Start() at the end of this constructor</param>
+        /// <param name="autoLaunch">True to call this.Launch at the end of this.Start()</param>
+        public Bootstrapper(bool autoStart, bool autoLaunch) : base(autoStart, autoLaunch) { }
+
         /// <summary>
         /// IoC container. This is created after ConfigureIoC has been run.
         /// </summary>

Stylet/BootstrapperBase.cs

@@ -1,6 +1,7 @@
 using Stylet.Xaml;
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Reflection;
 using System.Text;
@@ -17,34 +18,42 @@ namespace Stylet
     /// <typeparam name="TRootViewModel">Type of the root ViewModel. This will be instantiated and displayed</typeparam>
     public abstract class BootstrapperBase<TRootViewModel> where TRootViewModel : class
     {
+        private bool autoLaunch;
+
         /// <summary>
         /// Reference to the current application
         /// </summary>
         protected Application Application { get; private set; }
 
-        public BootstrapperBase()
+        /// <summary>
+        /// Create a new BootstrapperBase, which automatically starts and launches
+        /// </summary>
+        public BootstrapperBase() : this(true, true) { }
+
+        /// <summary>
+        /// Create a new BootstrapperBase, and specify whether to auto-start and auto-launhc
+        /// </summary>
+        /// <param name="autoStart">True to call this.Start() at the end of this constructor</param>
+        /// <param name="autoLaunch">True to call this.Launch at the end of this.Start()</param>
+        [SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors", Justification = "Calling the virtual Start here really is the cleanest, most sensible thing to do")]
+        public BootstrapperBase(bool autoStart, bool autoLaunch)
         {
-            // Stitch the IoC shell to us
-            IoC.GetInstance = this.GetInstance;
-            IoC.GetAllInstances = this.GetAllInstances;
-            IoC.BuildUp = this.BuildUp;
+            this.autoLaunch = autoLaunch;
 
             this.Application = Application.Current;
 
             // Allows for unit testing
             if (this.Application != null)
             {
-                // Call this before calling our Start method
-                this.Application.Startup += (o, e) =>
-                {
-                    this.OnStartup(o, e);
-                    this.Start();
-                };
+                this.Application.Startup += this.OnStartup;
 
                 // Make life nice for the app - they can handle these by overriding Bootstrapper methods, rather than adding event handlers
                 this.Application.Exit += OnExit;
                 this.Application.DispatcherUnhandledException += OnUnhandledExecption;
             }
+
+            if (autoStart)
+                this.Start();
         }
 
         /// <summary>
@@ -52,6 +61,11 @@ namespace Stylet
         /// </summary>
         protected virtual void Start()
         {
+            // Stitch the IoC shell to us
+            IoC.GetInstance = this.GetInstance;
+            IoC.GetAllInstances = this.GetAllInstances;
+            IoC.BuildUp = this.BuildUp;
+
             // Use the current SynchronizationContext for the Execute helper
             Execute.Dispatcher = new DispatcherWrapper();
 
@@ -64,6 +78,16 @@ namespace Stylet
             this.Configure();
 
             View.ViewManager = IoC.Get<IViewManager>();
+
+            if (this.autoLaunch && !Execute.InDesignMode)
+                this.Launch();
+        }
+
+        /// <summary>
+        /// Launch the root view
+        /// </summary>
+        protected virtual void Launch()
+        {
             IoC.Get<IWindowManager>().ShowWindow(IoC.Get<TRootViewModel>());
         }
 

StyletUnitTests/BootstrapperBaseTests.cs

@@ -21,10 +21,12 @@ namespace StyletUnitTests
             private IViewManager viewManager;
             private IWindowManager windowManager;
 
-            public MyBootstrapperBase(IViewManager viewManager, IWindowManager windowManager)
+            public MyBootstrapperBase(IViewManager viewManager, IWindowManager windowManager) : base(false, false)
             {
                 this.viewManager = viewManager;
                 this.windowManager = windowManager;
+
+                this.Start();
             }
 
             public bool GetInstanceCalled;

StyletUnitTests/BootstrapperTests.cs

@@ -21,6 +21,8 @@ namespace StyletUnitTests
 
         private class MyBootstrapper<T> : Bootstrapper<T> where T : class
         {
+            public MyBootstrapper() : base(true, false) { }
+
             public IContainer Container
             {
                 get { return base.container; }