AMT-Cheif
/
Stylet
mirror of https://github.com/AMT-Cheif/Stylet.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add StyleCop support 

Most of the violations were documentation changes
This commit is contained in:
Antony Male 2015-01-09 08:23:59 +00:00
parent 487c288bd3
commit 9e9355ffe0
62 changed files with 612 additions and 237 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
Stylet/BindableCollection.cs
View File

@ -9,7 +9,7 @@ namespace Stylet
/// <summary>
/// Represents a collection which is observasble
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="T">The type of elements in the collections</typeparam>
public interface IObservableCollection<T> : IList<T>, INotifyPropertyChanged, INotifyCollectionChanged
{
/// <summary>
@ -28,15 +28,14 @@ namespace Stylet
/// <summary>
/// Interface encapsulating IReadOnlyList and INotifyCollectionChanged
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="T">The type of elements in the collection</typeparam>
public interface IReadOnlyObservableCollection<T> : IReadOnlyList<T>, INotifyCollectionChanged, INotifyCollectionChanging
{
}
{ }
/// <summary>
/// ObservableCollection subclass which supports AddRange and RemoveRange
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="T">The type of elements in the collection</typeparam>
public class BindableCollection<T> : ObservableCollection<T>, IObservableCollection<T>, IReadOnlyObservableCollection<T>
{
/// <summary>
@ -45,12 +44,13 @@ namespace Stylet
private bool isNotifying = true;
/// <summary>
/// Create a new empty BindableCollection
/// Initialises a new instance of the <see cref="BindableCollection{T}"/> class
/// </summary>
public BindableCollection() : base() { }
public BindableCollection()
{ }
/// <summary>
/// Create a new BindableCollection with the given members
/// Initialises a new instance of the <see cref="BindableCollection{T}"/> class that contains the given members
/// </summary>
/// <param name="collection">The collection from which the elements are copied</param>
public BindableCollection(IEnumerable<T> collection) : base(collection) { }
@ -170,6 +170,8 @@ namespace Stylet
/// Called by base class Collection&lt;T&gt; when an item is added to list;
/// raises a CollectionChanged event to any listeners.
/// </summary>
/// <param name="index">Index at which to insert the item</param>
/// <param name="item">Item to insert</param>
protected override void InsertItem(int index, T item)
{
Execute.OnUIThreadSync(() =>
@ -180,9 +182,11 @@ namespace Stylet
}
/// <summary>
/// Called by base class Collection&lt;T&gt; when an item is set in list;
/// Called by base class Collection{T} when an item is set in list;
/// raises a CollectionChanged event to any listeners.
/// </summary>
/// <param name="index">Index of the item to set</param>
/// <param name="item">Item to set</param>
protected override void SetItem(int index, T item)
{
Execute.OnUIThreadSync(() =>
@ -196,6 +200,7 @@ namespace Stylet
/// Called by base class Collection&lt;T&gt; when an item is removed from list;
/// raises a CollectionChanged event to any listeners.
/// </summary>
/// <param name="index">Index of the item to remove</param>
protected override void RemoveItem(int index)
{
Execute.OnUIThreadSync(() =>

2
Stylet/Bootstrapper.cs
View File

@ -11,7 +11,7 @@ namespace Stylet
public class Bootstrapper<TRootViewModel> : BootstrapperBase<TRootViewModel> where TRootViewModel : class
{
/// <summary>
/// IoC container. This is created after ConfigureIoC has been run.
/// Gets or sets the Bootstrapper's IoC container. This is created after ConfigureIoC has been run.
/// </summary>
protected IContainer Container { get; set; }

20
Stylet/BootstrapperBase.cs
View File

@ -16,23 +16,23 @@ namespace Stylet
public abstract class BootstrapperBase<TRootViewModel> : IBootstrapper, IViewManagerConfig where TRootViewModel : class
{
/// <summary>
/// Reference to the current application
/// Gets the current application
/// </summary>
public Application Application { get; private set; }
/// <summary>
/// Assemblies which are used for IoC container auto-binding and searching for Views.
/// Gets or sets assemblies which are used for IoC container auto-binding and searching for Views.
/// Set this in Configure() if you want to override it
/// </summary>
public IList<Assembly> Assemblies { get; protected set; }
/// <summary>
/// Gets command line arguments that were passed to the application from either the command prompt or the desktop.
/// Gets the command line arguments that were passed to the application from either the command prompt or the desktop.
/// </summary>
public string[] Args { get; protected set; }
public string[] Args { get; private set; }
/// <summary>
/// Instantiate a new BootstrapperBase
/// Initialises a new instance of the <see cref="BootstrapperBase{TRootViewModel}"/> class
/// </summary>
public BootstrapperBase()
{
@ -42,7 +42,7 @@ namespace Stylet
/// <summary>
/// Called by the ApplicationLoader when this bootstrapper is loaded
/// </summary>
/// <param name="application"></param>
/// <param name="application">Application within which Stylet is running</param>
public void Setup(Application application)
{
if (application == null)
@ -59,12 +59,13 @@ namespace Stylet
// Fetch this logger when needed. If we fetch it now, then no-one will have been given the change to enable the LogManager, and we'll get a NullLogger
this.Application.DispatcherUnhandledException += (o, e) => LogManager.GetLogger(typeof(BootstrapperBase<>)).Error(e.Exception, "Unhandled exception");
this.Application.DispatcherUnhandledException += OnApplicationUnhandledExecption;
this.Application.DispatcherUnhandledException += (o, e) => this.OnUnhandledExecption(e);
}
/// <summary>
/// Called on Application.Startup, this does everything necessary to start the application
/// </summary>
/// <param name="args">Command-line arguments used to start this executable</param>
public virtual void Start(string[] args)
{
// Set this before anything else, so everything can use it
@ -108,12 +109,13 @@ namespace Stylet
/// <summary>
/// Hook called on application exit
/// </summary>
/// <param name="e"></param>
/// <param name="e">The exit event data</param>
protected virtual void OnExit(ExitEventArgs e) { }
/// <summary>
/// Hook called on an unhandled exception
/// </summary>
protected virtual void OnApplicationUnhandledExecption(object sender, DispatcherUnhandledExceptionEventArgs e) { }
/// <param name="e">The event data</param>
protected virtual void OnUnhandledExecption(DispatcherUnhandledExceptionEventArgs e) { }
}
}

10
Stylet/Conductor.cs
View File

@ -6,13 +6,13 @@ namespace Stylet
/// <summary>
/// Conductor with a single active item, and no other items
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="T">Type of child to conduct</typeparam>
public partial class Conductor<T> : ConductorBaseWithActiveItem<T> where T : class
{
/// <summary>
/// Activate the given item, discarding the previous ActiveItem
/// </summary>
/// <param name="item"></param>
/// <param name="item">Item to active</param>
public override async void ActivateItem(T item)
{
if (item != null && item.Equals(this.ActiveItem))
@ -20,8 +20,10 @@ namespace Stylet
if (this.IsActive)
ScreenExtensions.TryActivate(item);
}
else if (await this.CanCloseItem(this.ActiveItem)) // This is null-safe
else if (await this.CanCloseItem(this.ActiveItem))
{
// CanCloseItem is null-safe
this.ChangeActiveItem(item, true);
}
}
@ -47,12 +49,12 @@ namespace Stylet
if (await this.CanCloseItem(item))
this.ChangeActiveItem(default(T), true);
}
/// <summary>
/// Determine if this conductor can close. Depends on whether the ActiveItem can close
/// </summary>
/// <returns>Task indicating whether this can be closed</returns>
public override Task<bool> CanCloseAsync()
{
return this.CanCloseItem(this.ActiveItem);

8
Stylet/ConductorAllActive.cs
View File

@ -24,7 +24,7 @@ namespace Stylet
private T[] itemsBeforeReset;
/// <summary>
/// All items associated with this conductor
/// Gets all items associated with this conductor
/// </summary>
public IObservableCollection<T> Items
{
@ -32,7 +32,7 @@ namespace Stylet
}
/// <summary>
/// Creates a new Conductor{T}.Collection.AllActive
/// Initialises a new instance of the <see cref="Conductor{T}.Collection.AllActive"/> class
/// </summary>
public AllActive()
{
@ -119,12 +119,13 @@ namespace Stylet
foreach (var item in this.items)
this.CloseAndCleanUp(item);
items.Clear();
this.items.Clear();
}
/// <summary>
/// Determine if the conductor can close. Returns true if and when all items can close
/// </summary>
/// <returns>A Task indicating whether this conductor can close</returns>
public override Task<bool> CanCloseAsync()
{
return this.CanAllItemsCloseAsync(this.items);
@ -173,6 +174,7 @@ namespace Stylet
/// <summary>
/// Returns all children of this parent
/// </summary>
/// <returns>All children associated with this conductor</returns>
public override IEnumerable<T> GetChildren()
{
return this.items;

16
Stylet/ConductorBase.cs
View File

@ -39,6 +39,7 @@ namespace Stylet
/// <summary>
/// Ensure an item is ready to be activated
/// </summary>
/// <param name="newItem">Item to use</param>
protected virtual void EnsureItem(T newItem)
{
Debug.Assert(newItem != null);
@ -51,17 +52,19 @@ namespace Stylet
/// <summary>
/// Utility method to determine if all of the give items can close
/// </summary>
protected virtual async Task<bool> CanAllItemsCloseAsync(IEnumerable<T> toClose)
/// <param name="itemsToClose">Items to close</param>
/// <returns>Task indicating whether all items can close</returns>
protected virtual async Task<bool> CanAllItemsCloseAsync(IEnumerable<T> itemsToClose)
{
var results = await Task.WhenAll(toClose.Select(x => this.CanCloseItem(x)));
var results = await Task.WhenAll(itemsToClose.Select(this.CanCloseItem));
return results.All(x => x);
}
/// <summary>
/// Determine if the given item can be closed
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
/// <param name="item">Item to use</param>
/// <returns>Task indicating whether the item can be closed</returns>
protected virtual Task<bool> CanCloseItem(T item)
{
var itemAsGuardClose = item as IGuardClose;
@ -71,6 +74,11 @@ namespace Stylet
return Task.FromResult(true);
}
/// <summary>
/// Close the given child
/// </summary>
/// <param name="item">Child to close</param>
/// <param name="dialogResult">Unused in this scenario</param>
void IChildDelegate.CloseItem(object item, bool? dialogResult)
{
T typedItem = item as T;

10
Stylet/ConductorBaseWithActiveItem.cs
View File

@ -6,13 +6,13 @@ namespace Stylet
/// <summary>
/// Base class for all conductors which had a single active item
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="T">Type of item being conducted</typeparam>
public abstract class ConductorBaseWithActiveItem<T> : ConductorBase<T>, IHaveActiveItem<T> where T : class
{
private T _activeItem;
/// <summary>
/// Item which is currently active
/// Gets or sets the item which is currently active
/// </summary>
public T ActiveItem
{
@ -23,14 +23,17 @@ namespace Stylet
/// <summary>
/// From IParent, fetch all items
/// </summary>
/// <returns>Children of this conductor</returns>
public override IEnumerable<T> GetChildren()
{
return new[] { ActiveItem };
return new[] { this.ActiveItem };
}
/// <summary>
/// Switch the active item to the given item
/// </summary>
/// <param name="newItem">New item to activate</param>
/// <param name="closePrevious">Whether the previously-active item should be closed</param>
protected virtual void ChangeActiveItem(T newItem, bool closePrevious)
{
ScreenExtensions.TryDeactivate(this.ActiveItem);
@ -73,5 +76,4 @@ namespace Stylet
this.CloseAndCleanUp(this.ActiveItem);
}
}
}

4
Stylet/ConductorNavigating.cs
View File

@ -64,7 +64,7 @@ namespace Stylet
/// <summary>
/// Close the given item. If it was the ActiveItem, activate the top item in the history stack
/// </summary>
/// <param name="item"></param>
/// <param name="item">Item to close</param>
public override async void CloseItem(T item)
{
if (item == null || !await this.CanCloseItem(item))
@ -90,7 +90,7 @@ namespace Stylet
/// <summary>
/// Returns true if and when all items (ActiveItem + everything in the history stack) can close
/// </summary>
/// <returns></returns>
/// <returns>A task indicating whether this conductor can close</returns>
public override Task<bool> CanCloseAsync()
{
return this.CanAllItemsCloseAsync(this.history.Concat(new[] { this.ActiveItem }));

11
Stylet/ConductorOneActive.cs
View File

@ -18,7 +18,7 @@ namespace Stylet
private readonly BindableCollection<T> items = new BindableCollection<T>();
/// <summary>
/// Items owned by this Conductor, one of which is active
/// Gets the tems owned by this Conductor, one of which is active
/// </summary>
public IObservableCollection<T> Items
{
@ -26,7 +26,7 @@ namespace Stylet
}
/// <summary>
/// Create a new Conductor{T}.Collections.OneActive instance
/// Initialises a new instance of the <see cref="Conductor{T}.Collection.OneActive"/> class
/// </summary>
public OneActive()
{
@ -71,7 +71,7 @@ namespace Stylet
/// <summary>
/// Return all items associated with this conductor
/// </summary>
/// <returns></returns>
/// <returns>All children associated with this conductor</returns>
public override IEnumerable<T> GetChildren()
{
return this.items;
@ -139,6 +139,7 @@ namespace Stylet
/// <summary>
/// Given a list of items, and and item which is going to be removed, choose a new item to be the next ActiveItem
/// </summary>
/// <param name="itemToRemove">Item to remove</param>
/// <returns>The next item to activate, or default(T) if no such item exists</returns>
protected virtual T DetermineNextItemToActivate(T itemToRemove)
{
@ -167,7 +168,7 @@ namespace Stylet
/// <summary>
/// Returns true if and when all children can close
/// </summary>
/// <returns></returns>
/// <returns>A task indicating whether this conductor can close</returns>
public override Task<bool> CanCloseAsync()
{
return this.CanAllItemsCloseAsync(this.items);
@ -187,7 +188,7 @@ namespace Stylet
/// <summary>
/// Ensure an item is ready to be activated
/// </summary>
/// <param name="newItem"></param>
/// <param name="newItem">New item to ensure</param>
protected override void EnsureItem(T newItem)
{
if (!this.items.Contains(newItem))

25
Stylet/Execute.cs
View File

@ -14,16 +14,14 @@ namespace Stylet
private static IDispatcher _dispatcher;
/// <summary>
/// Should be set to the UI thread's Dispatcher. This is normally done by the Bootstrapper.
/// Gets or sets Execute's dispatcher
/// </summary>
/// <remarks>
/// Should be set to the UI thread's Dispatcher. This is normally done by the Bootstrapper.
/// </remarks>
public static IDispatcher Dispatcher
{
get
{
if (_dispatcher == null)
_dispatcher = new SynchronousDispatcher();
return _dispatcher;
}
get { return _dispatcher ?? (_dispatcher = new SynchronousDispatcher()); }
set
{
@ -36,9 +34,15 @@ namespace Stylet
private static bool? inDesignMode;
/// <summary>
/// Default dispatcher used by PropertyChanged events. Defaults to OnUIThread
/// Gets or sets the default dispatcher used by PropertyChanged events.
/// Defaults to OnUIThread
/// </summary>
public static Action<Action> DefaultPropertyChangedDispatcher = a => a();
public static Action<Action> DefaultPropertyChangedDispatcher { get; set; }
static Execute()
{
DefaultPropertyChangedDispatcher = a => a();
}
/// <summary>
/// Dispatches the given action to be run on the UI thread asynchronously, even if the current thread is the UI thread
@ -139,7 +143,8 @@ namespace Stylet
}
/// <summary>
/// Determing if we're currently running in design mode. Settable for really obscure unit testing only
/// Gets or sets a value indicating whether design mode is currently active.
/// Settable for really obscure unit testing only
/// </summary>
public static bool InDesignMode
{

2
Stylet/ExpressionExtensions.cs
View File

@ -11,6 +11,8 @@ namespace Stylet
/// <summary>
/// Given a MemberExpression (or MemberExpression wrapped in a UnaryExpression), get the name of the property
/// </summary>
/// <typeparam name="TDelegate">Type of the delegate</typeparam>
/// <param name="propertyExpression">Expression describe the property whose name we want to extract</param>
/// <returns>Name of the property referenced by the expression</returns>
public static string NameForProperty<TDelegate>(this Expression<TDelegate> propertyExpression)
{

7
Stylet/IConductor.cs
View File

@ -6,12 +6,13 @@ namespace Stylet
/// <summary>
/// Generalised parent, with many children
/// </summary>
/// <typeparam name="T">Type of children</typeparam>
public interface IParent<out T>
{
/// <summary>
/// Fetch all children of this parent
/// </summary>
/// <returns></returns>
/// <returns>All children owned by this parent</returns>
IEnumerable<T> GetChildren();
}
@ -22,7 +23,8 @@ namespace Stylet
public interface IHaveActiveItem<T>
{
/// <summary>
/// Only item which is currently active. This normally corresponds to the item being displayed
/// Gets or sets the only item which is currently active.
/// This normally corresponds to the item being displayed
/// </summary>
T ActiveItem { get; set; }
}
@ -43,6 +45,7 @@ namespace Stylet
/// <summary>
/// Thing which owns one or more children, and can manage their lifecycles accordingly
/// </summary>
/// <typeparam name="T">Type of child being conducted</typeparam>
public interface IConductor<T>
{
/// <summary>

4
Stylet/IDispatcher.cs
View File

@ -15,15 +15,17 @@ namespace Stylet
/// <summary>
/// Execute asynchronously
/// </summary>
/// <param name="action">Action to execute</param>
void Post(Action action);
/// <summary>
/// Execute synchronously
/// </summary>
/// <param name="action">Action to execute</param>
void Send(Action action);
/// <summary>
/// True if invocation isn't required
/// Gets a value indicating whether the current thread is the thread being dispatched to
/// </summary>
bool IsCurrent { get; }
}

3
Stylet/INotifyPropertyChangedDispatcher.cs
View File

@ -8,7 +8,8 @@ namespace Stylet
public interface INotifyPropertyChangedDispatcher
{
/// <summary>
/// The dispatcher to use. Called with an action, which should itself be called in the appropriate context
/// Gets or sets the dispatcher to use.
/// Called with an action, which should itself be called in the appropriate context
/// </summary>
Action<Action> PropertyChangedDispatcher { get; set; }
}

7
Stylet/IScreen.cs
View File

@ -10,7 +10,7 @@ namespace Stylet
public interface IViewAware
{
/// <summary>
/// The view associated with this ViewModel
/// Gets the view associated with this ViewModel
/// </summary>
UIElement View { get; }
@ -76,7 +76,7 @@ namespace Stylet
public interface IHaveDisplayName
{
/// <summary>
/// Name which should be displayed
/// Gets or sets the name which should be displayed
/// </summary>
string DisplayName { get; set; }
}
@ -87,7 +87,7 @@ namespace Stylet
public interface IChild
{
/// <summary>
/// Parent object to this child
/// Gets or sets the parent object to this child
/// </summary>
object Parent { get; set; }
}
@ -101,6 +101,7 @@ namespace Stylet
/// <summary>
/// Returns whether or not the object can close, potentially asynchronously
/// </summary>
/// <returns>A task indicating whether the object can close</returns>
Task<bool> CanCloseAsync();
}

5
Stylet/IValidationAdapter.cs
View File

@ -1,5 +1,6 @@
using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Threading.Tasks;
namespace Stylet
@ -13,7 +14,7 @@ namespace Stylet
/// builder.Bind(typeof(IModelValidator{})).ToAllImplementations()
/// and request a new IModelValidator{MyViewModelType} in your ViewModel's constructor.
/// </remarks>
/// <typeparam name="T"></typeparam>
/// <typeparam name="T">Type of model being validated</typeparam>
public interface IModelValidator<in T> : IModelValidator
{
}
@ -30,7 +31,7 @@ namespace Stylet
/// Called by ValidatingModelBase, which passes in an instance of itself.
/// This allows the IModelValidator to specialize to validating that particular ValidatingModelBase instance
/// </summary>
/// <param name="subject"></param>
/// <param name="subject">Subject to initialize</param>
void Initialize(object subject);
/// <summary>

18
Stylet/LabelledValue.cs
View File

@ -10,34 +10,36 @@ namespace Stylet
public class LabelledValue<T> : PropertyChangedBase, IEquatable<LabelledValue<T>>
{
private string _label;
/// <summary>
/// Label associated with this item. This is displayed in your View
/// Gets or sets the label associated with this item. This is displayed in your View
/// </summary>
public string Label
{
get { return this._label; }
set { SetAndNotify(ref this._label, value); }
set { this.SetAndNotify(ref this._label, value); }
}
private T _value;
/// <summary>
/// Value associated with this item. This is used by your ViewModel
/// Gets or sets the value associated with this item. This is used by your ViewModel
/// </summary>
public T Value
{
get { return this._value; }
set { SetAndNotify(ref this._value, value); }
set { this.SetAndNotify(ref this._value, value); }
}
/// <summary>
/// Create a new LabelledValue, without setting Label or Value
/// Initialises a new instance of the <see cref="LabelledValue{T}"/> class, without setting Label or Value
/// </summary>
public LabelledValue()
{
}
/// <summary>
/// Create a new LabelledValue, with the given label and value
/// Initialises a new instance of the <see cref="LabelledValue{T}"/> class, with the given label and value
/// </summary>
/// <param name="label">Label to use. This value is displayed in your view</param>
/// <param name="value">Value to use. This is used by your ViewModel</param>
@ -97,6 +99,10 @@ namespace Stylet
/// <summary>
/// Construct a new LabelledValue{T}, using method type inference
/// </summary>
/// <typeparam name="T">Type of value</typeparam>
/// <param name="label">Label to assign</param>
/// <param name="value">Value to assign</param>
/// <returns>Constructed LabelledValue{T}</returns>
public static LabelledValue<T> Create<T>(string label, T value)
{
return new LabelledValue<T>(label, value);

22
Stylet/Logging/LogManager.cs
View File

@ -1,5 +1,6 @@
using System;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
namespace Stylet.Logging
{
@ -65,7 +66,7 @@ namespace Stylet.Logging
private readonly string name;
/// <summary>
/// Create a new DebugLogger with the given name
/// Initialises a new instance of the <see cref="TraceLogger"/> class, with the given name
/// </summary>
/// <param name="name">Name of the DebugLogger</param>
public TraceLogger(string name)
@ -115,21 +116,26 @@ namespace Stylet.Logging
private static readonly ILogger nullLogger = new NullLogger();
/// <summary>
/// Set to true to enable logging
/// Gets or sets a value indicating whether logging is enabled
/// </summary>
/// <remarks>
/// When false (the default), a null logger will be returned by GetLogger().
/// When true, LoggerFactory will be used to create a new logger
/// </remarks>
public static bool Enabled;
public static bool Enabled { get; set; }
/// <summary>
/// Factory used to create new ILoggers, used by GetLogger
/// Gets or sets the factory used to create new ILoggers, used by GetLogger
/// </summary>
/// <remarks>
/// e.g. LogManager.LoggerFactory = name => new MyLogger(name);
/// </remarks>
public static Func<string, ILogger> LoggerFactory = name => new TraceLogger(name);
/// <example>
/// LogManager.LoggerFactory = name => new MyLogger(name);
/// </example>
public static Func<string, ILogger> LoggerFactory { get; set; }
static LogManager()
{
LoggerFactory = name => new TraceLogger(name);
}
/// <summary>
/// Get a new ILogger for the given type

38
Stylet/MessageBoxViewModel.cs
View File

@ -23,7 +23,9 @@ namespace Stylet
/// <param name="cancelResult">A System.Windows.MessageBoxResult value that specifies the cancel result of the message box</param>
/// <param name="options">A System.Windows.MessageBoxOptions value object that specifies the options.</param>
/// <param name="buttonLabels">A dictionary specifying the button labels, if desirable</param>
void Setup(string messageBoxText, string caption = null,
void Setup(
string messageBoxText,
string caption = null,
MessageBoxButton buttons = MessageBoxButton.OK,
MessageBoxImage icon = MessageBoxImage.None,
MessageBoxResult defaultResult = MessageBoxResult.None,
@ -32,7 +34,7 @@ namespace Stylet
IDictionary<MessageBoxResult, string> buttonLabels = null);
/// <summary>
/// After the user has clicked a button, holds which button was clicked
/// Gets the button clicked by the user, after they've clicked it
/// </summary>
MessageBoxResult ClickedButton { get; }
}
@ -43,22 +45,22 @@ namespace Stylet
public class MessageBoxViewModel : Screen, IMessageBoxViewModel
{
/// <summary>
/// Mapping of button to text to display on that button. You can modify this to localize your application.
/// Gets or sets the mapping of button to text to display on that button. You can modify this to localize your application.
/// </summary>
public static IDictionary<MessageBoxResult, string> ButtonLabels { get; set; }
/// <summary>
/// Mapping of MessageBoxButton values to the buttons which should be displayed
/// Gets or sets the mapping of MessageBoxButton values to the buttons which should be displayed
/// </summary>
public static IDictionary<MessageBoxButton, MessageBoxResult[]> ButtonToResults { get; set; }
/// <summary>
/// Mapping of MessageBoxImage to the SystemIcon to display. You can customize this if you really want.
/// Gets or sets the mapping of MessageBoxImage to the SystemIcon to display. You can customize this if you really want.
/// </summary>
public static IDictionary<MessageBoxImage, Icon> IconMapping { get; set; }
/// <summary>
/// Mapping of MessageBoxImage to the sound to play when the MessageBox is shown. You can customize this if you really want.
/// Gets or sets the mapping of MessageBoxImage to the sound to play when the MessageBox is shown. You can customize this if you really want.
/// </summary>
public static IDictionary<MessageBoxImage, SystemSound> SoundMapping { get; set; }
@ -77,7 +79,7 @@ namespace Stylet
{ MessageBoxButton.OK, new[] { MessageBoxResult.OK } },
{ MessageBoxButton.OKCancel, new[] { MessageBoxResult.OK, MessageBoxResult.Cancel } },
{ MessageBoxButton.YesNo, new[] { MessageBoxResult.Yes, MessageBoxResult.No } },
{ MessageBoxButton.YesNoCancel, new[] { MessageBoxResult.Yes, MessageBoxResult.No, MessageBoxResult.Cancel} },
{ MessageBoxButton.YesNoCancel, new[] { MessageBoxResult.Yes, MessageBoxResult.No, MessageBoxResult.Cancel } },
};
IconMapping = new Dictionary<MessageBoxImage, Icon>()
@ -111,7 +113,9 @@ namespace Stylet
/// <param name="cancelResult">A System.Windows.MessageBoxResult value that specifies the cancel result of the message box</param>
/// <param name="options">A System.Windows.MessageBoxOptions value object that specifies the options.</param>
/// <param name="buttonLabels">A dictionary specifying the button labels, if desirable</param>
public void Setup(string messageBoxText, string caption = null,
public void Setup(
string messageBoxText,
string caption = null,
MessageBoxButton buttons = MessageBoxButton.OK,
MessageBoxImage icon = MessageBoxImage.None,
MessageBoxResult defaultResult = MessageBoxResult.None,
@ -159,32 +163,32 @@ namespace Stylet
}
/// <summary>
/// List of buttons which are shown in the View.
/// Gets or sets the list of buttons which are shown in the View.
/// </summary>
public IEnumerable<LabelledValue<MessageBoxResult>> ButtonList { get; protected set; }
/// <summary>
/// Item in ButtonList which is the Default button
/// Gets or sets the item in ButtonList which is the Default button
/// </summary>
public LabelledValue<MessageBoxResult> DefaultButton { get; protected set; }
/// <summary>
/// Item in ButtonList which is the Cancel button
/// Gets or sets the item in ButtonList which is the Cancel button
/// </summary>
public LabelledValue<MessageBoxResult> CancelButton { get; protected set; }
/// <summary>
/// Text which is shown in the body of the MessageBox
/// Gets or sets the text which is shown in the body of the MessageBox
/// </summary>
public virtual string Text { get; protected set; }
/// <summary>
/// Icon which the user specified
/// Gets or sets the icon which the user specified
/// </summary>
public virtual MessageBoxImage Icon { get; protected set; }
/// <summary>
/// Icon which is shown next to the text in the View
/// Gets or the icon which is shown next to the text in the View
/// </summary>
public virtual Icon ImageIcon
{
@ -192,17 +196,17 @@ namespace Stylet
}
/// <summary>
/// Which way the document should flow
/// Gets or sets which way the document should flow
/// </summary>
public virtual FlowDirection FlowDirection { get; protected set; }
/// <summary>
/// Text alignment of the message
/// Gets or sets the text alignment of the message
/// </summary>
public virtual TextAlignment TextAlignment { get; protected set; }
/// <summary>
/// Which button the user clicked, once they've clicked a button
/// Gets or sets which button the user clicked, once they've clicked a button
/// </summary>
public virtual MessageBoxResult ClickedButton { get; protected set; }

6
Stylet/PropertyChangedBase.cs
View File

@ -1,6 +1,7 @@
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;
using System.Runtime.CompilerServices;
@ -12,8 +13,9 @@ namespace Stylet
public abstract class PropertyChangedBase : INotifyPropertyChanged, INotifyPropertyChangedDispatcher
{
private Action<Action> _propertyChangedDispatcher = Execute.DefaultPropertyChangedDispatcher;
/// <summary>
/// Dispatcher to use to dispatch PropertyChanged events. Defaults to Execute.DefaultPropertyChangedDispatcher
/// Gets or sets the dispatcher to use to dispatch PropertyChanged events. Defaults to Execute.DefaultPropertyChangedDispatcher
/// </summary>
[System.Xml.Serialization.XmlIgnore]
public virtual Action<Action> PropertyChangedDispatcher
@ -38,6 +40,7 @@ namespace Stylet
/// <summary>
/// Raise a PropertyChanged notification from the property in the given expression, e.g. NotifyOfPropertyChange(() => this.Property)
/// </summary>
/// <typeparam name="TProperty">Type of property being notified</typeparam>
/// <param name="property">Expression describing the property to raise a PropertyChanged notification for</param>
protected virtual void NotifyOfPropertyChange<TProperty>(Expression<Func<TProperty>> property)
{
@ -75,6 +78,7 @@ namespace Stylet
/// <summary>
/// Takes, by reference, a field, and its new value. If field != value, will set field = value and raise a PropertyChanged notification
/// </summary>
/// <typeparam name="T">Type of field being set and notified</typeparam>
/// <param name="field">Field to assign</param>
/// <param name="value">Value to assign to the field, if it differs</param>
/// <param name="propertyName">Name of the property to notify for. Defaults to the calling property</param>

12
Stylet/PropertyChangedExtensions.cs
View File

@ -10,16 +10,16 @@ namespace Stylet
/// <summary>
/// Extension of PropertyChangedEventArgs, which includes the new value of the property
/// </summary>
/// <typeparam name="TProperty"></typeparam>
/// <typeparam name="TProperty">Type of property being notified</typeparam>
public class PropertyChangedExtendedEventArgs<TProperty> : PropertyChangedEventArgs
{
/// <summary>
/// New value of the property
/// Gets the new value of the property
/// </summary>
public virtual TProperty NewValue { get; private set; }
/// <summary>
/// Instantiate a new PropertyChangedExtendedEventArgs
/// Initialises a new instance of the <see cref="PropertyChangedExtendedEventArgs{TProperty}"/> class
/// </summary>
/// <param name="propertyName">Name of the property which changed</param>
/// <param name="newValue">New value of the property which changed</param>
@ -61,7 +61,7 @@ namespace Stylet
{
INotifyPropertyChanged inpc;
if (this.inpc.TryGetTarget(out inpc))
inpc.PropertyChanged -= handler;
inpc.PropertyChanged -= this.handler;
}
}
@ -123,6 +123,8 @@ namespace Stylet
/// Strongly bind to PropertyChanged events for a particular property on a particular object
/// </summary>
/// <example>someObject.Bind(x => x.PropertyNameToBindTo, newValue => /* do something with the new value */)</example>
/// <typeparam name="TSource">Type of object providing the PropertyChanged event</typeparam>
/// <typeparam name="TProperty">Type of property for which the event is raised</typeparam>
/// <param name="target">Object raising the PropertyChanged event you're interested in</param>
/// <param name="targetSelector">MemberExpression selecting the property to observe for changes (e.g x => x.PropertyName)</param>
/// <param name="handler">Handler called whenever that property changed</param>
@ -156,6 +158,8 @@ namespace Stylet
/// Weakly bind to PropertyChanged events for a particular property on a particular object
/// </summary>
/// <example>someObject.Bind(x => x.PropertyNameToBindTo, newValue => /* do something with the new value */)</example>
/// <typeparam name="TSource">Type of object providing the PropertyChanged event</typeparam>
/// <typeparam name="TProperty">Type of property for which the event is raised</typeparam>
/// <param name="target">Object raising the PropertyChanged event you're interested in</param>
/// <param name="targetSelector">MemberExpression selecting the property to observe for changes (e.g x => x.PropertyName)</param>
/// <param name="handler">Handler called whenever that property changed</param>

35
Stylet/Screen.cs
View File

@ -14,12 +14,12 @@ namespace Stylet
private readonly ILogger logger;
/// <summary>
/// Create a new Screen instance (without setting up a validator)
/// Initialises a new instance of the <see cref="Screen"/> class, without setting up a validator
/// </summary>
public Screen() : this(null) { }
/// <summary>
/// Create a new screen instance, which can validate properties using the given validator
/// Initialises a new instance of the <see cref="Screen"/> class, which can validate properties using the given validator
/// </summary>
/// <param name="validator">Validator to use</param>
[SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors", Justification = "Can be safely called from the Ctor, as it doesn't depend on state being set")]
@ -35,12 +35,13 @@ namespace Stylet
private string _displayName;
/// <summary>
/// Name associated with this ViewModel. Shown e.g. in a window's title bar, or as a tab's displayName
/// Gets or sets the name associated with this ViewModel.
/// Shown e.g. in a window's title bar, or as a tab's displayName
/// </summary>
public string DisplayName
{
get { return this._displayName; }
set { SetAndNotify(ref this._displayName, value); }
set { this.SetAndNotify(ref this._displayName, value); }
}
#endregion
@ -55,13 +56,14 @@ namespace Stylet
private bool hasBeenActivatedEver;
private bool _isActive;
/// <summary>
/// True if this Screen is currently active
/// Gets or sets a value indicating whether this Screen is currently active
/// </summary>
public bool IsActive
{
get { return this._isActive; }
set { SetAndNotify(ref this._isActive, value); }
set { this.SetAndNotify(ref this._isActive, value); }
}
[SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "As this is a framework type, don't want to make it too easy for users to call this method")]
@ -73,7 +75,7 @@ namespace Stylet
this.IsActive = true;
this.isClosed = false;
logger.Info("Activating");
this.logger.Info("Activating");
if (!this.hasBeenActivatedEver)
this.OnInitialActivate();
@ -114,7 +116,7 @@ namespace Stylet
this.IsActive = false;
this.isClosed = false;
logger.Info("Deactivating");
this.logger.Info("Deactivating");
this.OnDeactivate();
@ -151,7 +153,7 @@ namespace Stylet
this.View = null;
this.isClosed = true;
logger.Info("Closing");
this.logger.Info("Closing");
this.OnClose();
@ -170,7 +172,7 @@ namespace Stylet
#region IViewAware
/// <summary>
/// View attached to this ViewModel, if any. Using this should be a last resort
/// Gets the View attached to this ViewModel, if any. Using this should be a last resort
/// </summary>
public UIElement View { get; private set; }
@ -182,7 +184,7 @@ namespace Stylet
this.View = view;
logger.Info("Attaching view {0}", view);
this.logger.Info("Attaching view {0}", view);
var viewAsFrameworkElement = view as FrameworkElement;
if (viewAsFrameworkElement != null)
@ -204,13 +206,14 @@ namespace Stylet
#region IChild
private object _parent;
/// <summary>
/// Parent conductor of this screen. Used to TryClose to request a closure
/// Gets or sets the parent conductor of this screen. Used to TryClose to request a closure
/// </summary>
public object Parent
{
get { return this._parent; }
set { SetAndNotify(ref this._parent, value); }
set { this.SetAndNotify(ref this._parent, value); }
}
#endregion
@ -241,19 +244,19 @@ namespace Stylet
/// <summary>
/// Request that the conductor responsible for this screen close it
/// </summary>
/// <param name="dialogResult"></param>
/// <param name="dialogResult">DialogResult to return, if this is a dialog</param>
public virtual void TryClose(bool? dialogResult = null)
{
var conductor = this.Parent as IChildDelegate;
if (conductor != null)
{
logger.Info("TryClose called. Conductor: {0}; DialogResult: {1}", conductor, dialogResult);
this.logger.Info("TryClose called. Conductor: {0}; DialogResult: {1}", conductor, dialogResult);
conductor.CloseItem(this, dialogResult);
}
else
{
var e = new InvalidOperationException(String.Format("Unable to close ViewModel {0} as it must have a conductor as a parent (note that windows and dialogs automatically have such a parent)", this.GetType()));
logger.Error(e);
this.logger.Error(e);
throw e;
}
}

10
Stylet/ScreenExtensions.cs
View File

@ -49,6 +49,8 @@ namespace Stylet
/// Activate the child whenever the parent is activated
/// </summary>
/// <example>child.ActivateWith(this)</example>
/// <param name="child">Child to activate whenever the parent is activated</param>
/// <param name="parent">Parent to observe</param>
public static void ActivateWith(this IActivate child, IActivate parent)
{
WeakEventManager<IActivate, ActivationEventArgs>.AddHandler(parent, "Activated", (o, e) => child.Activate());
@ -58,6 +60,8 @@ namespace Stylet
/// Deactivate the child whenever the parent is deactivated
/// </summary>
/// <example>child.DeactivateWith(this)</example>
/// <param name="child">Child to deactivate whenever the parent is deacgtivated</param>
/// <param name="parent">Parent to observe</param>
public static void DeactivateWith(this IDeactivate child, IDeactivate parent)
{
WeakEventManager<IDeactivate, DeactivationEventArgs>.AddHandler(parent, "Deactivated", (o, e) => child.Deactivate());
@ -67,6 +71,8 @@ namespace Stylet
/// Close the child whenever the parent is closed
/// </summary>
/// <example>child.CloseWith(this)</example>
/// <param name="child">Child to close when the parent is closed</param>
/// <param name="parent">Parent to observe</param>
public static void CloseWith(this IClose child, IClose parent)
{
// Using TryCloseAndDispose ensures that Dispose is called if necessary
@ -77,6 +83,10 @@ namespace Stylet
/// Activate, Deactivate, or Close the child whenever the parent is Activated, Deactivated, or Closed
/// </summary>
/// <example>child.ConductWith(this)</example>
/// <typeparam name="TChild">Type of the child</typeparam>
/// <typeparam name="TParent">Type of the parent</typeparam>
/// <param name="child">Child to conduct with the parent</param>
/// <param name="parent">Parent to observe</param>
public static void ConductWith<TChild, TParent>(this TChild child, TParent parent)
where TChild : IActivate, IDeactivate, IClose
where TParent : IActivate, IDeactivate, IClose

212
Stylet/Settings.StyleCop Normal file
View File

@ -0,0 +1,212 @@
<StyleCopSettings Version="105">
<GlobalSettings>
<StringProperty Name="MergeSettingsFiles">NoMerge</StringProperty>
<StringProperty Name="Culture">en-GB</StringProperty>
</GlobalSettings>
<Analyzers>
<Analyzer AnalyzerId="StyleCop.CSharp.OrderingRules">
<Rules>
<Rule Name="UsingDirectivesMustBePlacedWithinNamespace">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
<Rule Name="ElementsMustAppearInTheCorrectOrder">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
<Rule Name="ElementsMustBeOrderedByAccess">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
<Rule Name="SystemUsingDirectivesMustBePlacedBeforeOtherUsingDirectives">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
<Rule Name="StaticElementsMustAppearBeforeInstanceElements">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
</Rules>
<AnalyzerSettings />
</Analyzer>
<Analyzer AnalyzerId="StyleCop.CSharp.ReadabilityRules">
<Rules>
<Rule Name="SplitParametersMustStartOnLineAfterDeclaration">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
<Rule Name="ParameterMustFollowComma">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
<Rule Name="ParametersMustBeOnSameLineOrSeparateLines">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
<Rule Name="UseStringEmptyForEmptyStrings">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
<Rule Name="UseBuiltInTypeAlias">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
</Rules>
<AnalyzerSettings />
</Analyzer>
<Analyzer AnalyzerId="StyleCop.CSharp.NamingRules">
<Rules>
<Rule Name="FieldNamesMustNotBeginWithUnderscore">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
<Rule Name="StaticReadonlyFieldsMustBeginWithUpperCaseLetter">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
</Rules>
<AnalyzerSettings>
<CollectionProperty Name="Hungarian">
<Value>il</Value>
<Value>in</Value>
<Value>is</Value>
</CollectionProperty>
</AnalyzerSettings>
</Analyzer>
<Analyzer AnalyzerId="StyleCop.CSharp.MaintainabilityRules">
<Rules>
<Rule Name="FileMayOnlyContainASingleClass">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
<Rule Name="CodeAnalysisSuppressionMustHaveJustification">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
<Rule Name="DebugAssertMustProvideMessageText">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
</Rules>
<AnalyzerSettings />
</Analyzer>
<Analyzer AnalyzerId="StyleCop.CSharp.LayoutRules">
<Rules>
<Rule Name="CurlyBracketsMustNotBeOmitted">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
<Rule Name="ElementMustNotBeOnSingleLine">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
<Rule Name="SingleLineCommentMustBePrecededByBlankLine">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
<Rule Name="AllAccessorsMustBeMultiLineOrSingleLine">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
<Rule Name="SingleLineCommentsMustNotBeFollowedByBlankLine">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
<Rule Name="ClosingCurlyBracketMustBeFollowedByBlankLine">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
<Rule Name="ElementsMustBeSeparatedByBlankLine">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
<Rule Name="StatementMustNotBeOnSingleLine">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
</Rules>
<AnalyzerSettings />
</Analyzer>
<Analyzer AnalyzerId="StyleCop.CSharp.DocumentationRules">
<Rules>
<Rule Name="FileMustHaveHeader">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
<Rule Name="FileHeaderMustShowCopyright">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
<Rule Name="FileHeaderMustHaveCopyrightText">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
<Rule Name="FileHeaderMustContainFileName">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
<Rule Name="FileHeaderFileNameDocumentationMustMatchFileName">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
<Rule Name="FileHeaderMustHaveValidCompanyText">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
<Rule Name="FileHeaderFileNameDocumentationMustMatchTypeName">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
<Rule Name="ElementDocumentationMustBeSpelledCorrectly">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
<Rule Name="PartialElementsMustBeDocumented">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
<Rule Name="DocumentationTextMustContainWhitespace">
<RuleSettings>
<BooleanProperty Name="Enabled">False</BooleanProperty>
</RuleSettings>
</Rule>
</Rules>
<AnalyzerSettings>
<BooleanProperty Name="IgnoreInternals">True</BooleanProperty>
<BooleanProperty Name="IgnorePrivates">True</BooleanProperty>
</AnalyzerSettings>
</Analyzer>
</Analyzers>
</StyleCopSettings>

4
Stylet/Stylet.csproj
View File

@ -63,7 +63,9 @@
<Compile Include="StyletIoC\Internal\Creators\AbstractFactoryCreator.cs" />
<Compile Include="StyletIoC\Internal\Creators\CreatorBase.cs" />
<Compile Include="StyletIoC\Internal\Creators\FactoryCreator.cs" />
<Compile Include="StyletIoC\Internal\Creators\TypeCreator.cs" />
<Compile Include="StyletIoC\Internal\Creators\TypeCreator.cs">
<ExcludeFromStyleCop>False</ExcludeFromStyleCop>
</Compile>
<Compile Include="StyletIoC\Creation\IRegistrationContext.cs" />
<Compile Include="StyletIoC\Internal\RegistrationCollections\EmptyRegistrationCollection.cs" />
<Compile Include="StyletIoC\Internal\RegistrationCollections\RegistrationCollection.cs" />

1
Stylet/StyletConductorExtensions.cs
View File

@ -5,6 +5,7 @@ using System.Linq;
namespace Stylet
{
// Don't name ConductorExtensions, otherwise it's too obvious when someone types 'Conductor'
/// <summary>
/// Extension methods used by the Conductor classes
/// </summary>

2
Stylet/StyletIoC/Creation/BuilderUpper.cs
View File

@ -16,7 +16,7 @@ namespace StyletIoC.Creation
private Action<IRegistrationContext, object> implementor;
/// <summary>
/// Instantiate a new BuilderUpper
/// Initialises a new instance of the <see cref="BuilderUpper"/> class
/// </summary>
/// <param name="type">Type of object that the BuilderUpper will work on</param>
/// <param name="parentContext">IRegistrationContext on which this BuilderUpper is registered</param>

3
Stylet/StyletIoC/Creation/ICreator.cs
View File

@ -9,13 +9,14 @@ namespace StyletIoC.Creation
public interface ICreator
{
/// <summary>
/// Type of object that will be created
/// Gets the type of object that will be created
/// </summary>
Type Type { get; }
/// <summary>
/// Fetches an expression evaluating to an instance on demand
/// </summary>
/// <param name="registrationContext">Context which calls this method</param>
/// <returns>An expression evaluating to an instance of the specified Type</returns>
Expression GetInstanceExpression(ParameterExpression registrationContext);
}

3
Stylet/StyletIoC/Creation/IRegistration.cs
View File

@ -20,7 +20,7 @@ namespace StyletIoC.Creation
public interface IRegistration
{
/// <summary>
/// Type of the object returned by the registration
/// Gets the type of the object returned by the registration
/// </summary>
Type Type { get; }
@ -33,6 +33,7 @@ namespace StyletIoC.Creation
/// <summary>
/// Fetches an expression which evaluates to an instance of the relevant type
/// </summary>
/// <param name="registrationContext">Context which calls this method</param>
/// <returns>An expression evaluating to an instance of type Type, which is supplied by the ICreator></returns>
Expression GetInstanceExpression(ParameterExpression registrationContext);
}

4
Stylet/StyletIoC/IContainer.cs
View File

@ -52,7 +52,7 @@ namespace StyletIoC
/// </summary>
/// <param name="type">If IEnumerable{T}, will fetch all implementations of T, otherwise wil fetch a single T</param>
/// <param name="key">Key that implementations of the service to fetch were registered with, defaults to null</param>
/// <returns></returns>
/// <returns>The resolved result</returns>
object GetTypeOrAll(Type type, string key = null);
/// <summary>
@ -60,7 +60,7 @@ namespace StyletIoC
/// </summary>
/// <typeparam name="T">If IEnumerable{T}, will fetch all implementations of T, otherwise wil fetch a single T</typeparam>
/// <param name="key">Key that implementations of the service to fetch were registered with, defaults to null</param>
/// <returns></returns>
/// <returns>The resolved result</returns>
T GetTypeOrAll<T>(string key = null);
/// <summary>

8
Stylet/StyletIoC/InjectAttribute.cs
View File

@ -9,23 +9,23 @@ namespace StyletIoC
public sealed class InjectAttribute : Attribute
{
/// <summary>
/// Create a new InjectAttribute
/// Initialises a new instance of the <see cref="InjectAttribute"/> class
/// </summary>
public InjectAttribute()
{
}
/// <summary>
/// Create a new InjectAttribute, which has the specified key
/// Initialises a new instance of the <see cref="InjectAttribute"/> class, which has the specified key
/// </summary>
/// <param name="key"></param>
/// <param name="key">Key to associate (meaning depends on context)</param>
public InjectAttribute(string key)
{
this.Key = key;
}
/// <summary>
/// Key to use to resolve the relevant dependency
/// Gets or sets the key to use to resolve the relevant dependency
/// </summary>
public string Key { get; set; }
}

4
Stylet/StyletIoC/Internal/Builders/BuilderAbstractFactoryBinding.cs
View File

@ -15,11 +15,11 @@ namespace StyletIoC.Internal.Builders
public override void Build(Container container)
{
var factoryType = container.GetFactoryForType(this.serviceType);
var factoryType = container.GetFactoryForType(this.ServiceType);
var creator = new AbstractFactoryCreator(factoryType);
var registration = new TransientRegistration(creator);
container.AddRegistration(new TypeKey(this.serviceType, this.Key), registration);
container.AddRegistration(new TypeKey(this.ServiceType, this.Key), registration);
}
}
}

21
Stylet/StyletIoC/Internal/Builders/BuilderBindingBase.cs
View File

@ -8,30 +8,31 @@ namespace StyletIoC.Internal.Builders
{
internal abstract class BuilderBindingBase : IInScopeOrWithKeyOrAsWeakBinding, IWithKeyOrAsWeakBinding
{
protected Type serviceType;
protected RegistrationFactory registrationFactory;
protected Type ServiceType { get; set; }
protected RegistrationFactory RegistrationFactory { get; set; }
public string Key { get; protected set; }
public bool IsWeak { get; protected set; }
public BuilderBindingBase(Type serviceType)
{
this.serviceType = serviceType;
this.ServiceType = serviceType;
// Default is transient
this.registrationFactory = (ctx, service, creator, key) => new TransientRegistration(creator);
this.RegistrationFactory = (ctx, service, creator, key) => new TransientRegistration(creator);
}
public IAsWeakBinding WithRegistrationFactory(RegistrationFactory registrationFactory)
{
if (registrationFactory == null)
throw new ArgumentNullException("registrationFactory");
this.registrationFactory = registrationFactory;
this.RegistrationFactory = registrationFactory;
return this;
}
/// <summary>
/// Modify the scope of the binding to Singleton. One instance of this implementation will be generated for this binding.
/// </summary>
/// <returns>Fluent interface to continue configuration</returns>
public IAsWeakBinding InSingletonScope()
{
return this.WithRegistrationFactory((ctx, serviceType, creator, key) => new SingletonRegistration(ctx, creator));
@ -45,7 +46,7 @@ namespace StyletIoC.Internal.Builders
protected void EnsureType(Type implementationType, Type serviceType = null, bool assertImplementation = true)
{
serviceType = serviceType ?? this.serviceType;
serviceType = serviceType ?? this.ServiceType;
if (assertImplementation && (!implementationType.IsClass || implementationType.IsAbstract))
throw new StyletIoCRegistrationException(String.Format("Type {0} is not a concrete class, and so can't be used to implemented service {1}", implementationType.GetDescription(), serviceType.GetDescription()));
@ -68,18 +69,18 @@ namespace StyletIoC.Internal.Builders
throw new StyletIoCRegistrationException(String.Format("You cannot bind the non-generic type {0} to the unbound generic service {1}", implementationType.GetDescription(), serviceType.GetDescription()));
}
if (!implementationType.Implements(this.serviceType))
if (!implementationType.Implements(this.ServiceType))
throw new StyletIoCRegistrationException(String.Format("Type {0} does not implement service {1}", implementationType.GetDescription(), serviceType.GetDescription()));
}
// Convenience...
protected void BindImplementationToService(Container container, Type implementationType, Type serviceType = null)
{
serviceType = serviceType ?? this.serviceType;
serviceType = serviceType ?? this.ServiceType;
if (serviceType.IsGenericTypeDefinition)
{
var unboundGeneric = new UnboundGeneric(serviceType, implementationType, container, this.registrationFactory);
var unboundGeneric = new UnboundGeneric(serviceType, implementationType, container, this.RegistrationFactory);
container.AddUnboundGeneric(new TypeKey(serviceType, this.Key), unboundGeneric);
}
else
@ -94,7 +95,7 @@ namespace StyletIoC.Internal.Builders
// Convenience...
protected IRegistration CreateRegistration(IRegistrationContext registrationContext, ICreator creator)
{
return this.registrationFactory(registrationContext, this.serviceType, creator, this.Key);
return this.RegistrationFactory(registrationContext, this.ServiceType, creator, this.Key);
}
IAsWeakBinding IWithKeyOrAsWeakBinding.WithKey(string key)

6
Stylet/StyletIoC/Internal/Builders/BuilderFactoryBinding.cs
View File

@ -11,8 +11,8 @@ namespace StyletIoC.Internal.Builders
public BuilderFactoryBinding(Type serviceType, Func<IRegistrationContext, TImplementation> factory)
: base(serviceType)
{
if (this.serviceType.IsGenericTypeDefinition)
throw new StyletIoCRegistrationException(String.Format("A factory cannot be used to implement unbound generic type {0}", this.serviceType.GetDescription()));
if (this.ServiceType.IsGenericTypeDefinition)
throw new StyletIoCRegistrationException(String.Format("A factory cannot be used to implement unbound generic type {0}", this.ServiceType.GetDescription()));
this.EnsureType(typeof(TImplementation), assertImplementation: false);
this.factory = factory;
}
@ -22,7 +22,7 @@ namespace StyletIoC.Internal.Builders
var creator = new FactoryCreator<TImplementation>(this.factory, container);
var registration = this.CreateRegistration(container, creator);
container.AddRegistration(new TypeKey(this.serviceType, this.Key), registration);
container.AddRegistration(new TypeKey(this.ServiceType, this.Key), registration);
}
}
}

2
Stylet/StyletIoC/Internal/Builders/BuilderInstanceBinding.cs
View File

@ -23,7 +23,7 @@ namespace StyletIoC.Internal.Builders
var creator = new InstanceCreator(this.instance);
var registration = this.CreateRegistration(container, creator);
container.AddRegistration(new TypeKey(this.serviceType, this.Key), registration);
container.AddRegistration(new TypeKey(this.ServiceType, this.Key), registration);
}
}
}

5
Stylet/StyletIoC/Internal/Builders/BuilderToAllImplementationsBinding.cs
View File

@ -18,8 +18,8 @@ namespace StyletIoC.Internal.Builders
public override void Build(Container container)
{
var candidates = from type in assemblies.Distinct().SelectMany(x => x.GetTypes())
let baseType = type.GetBaseTypesAndInterfaces().FirstOrDefault(x => x == this.serviceType || x.IsGenericType && x.GetGenericTypeDefinition() == this.serviceType)
var candidates = from type in this.assemblies.Distinct().SelectMany(x => x.GetTypes())
let baseType = type.GetBaseTypesAndInterfaces().FirstOrDefault(x => x == this.ServiceType || (x.IsGenericType && x.GetGenericTypeDefinition() == this.ServiceType))
where baseType != null
select new { Type = type, Base = baseType.ContainsGenericParameters ? baseType.GetGenericTypeDefinition() : baseType };
@ -37,5 +37,4 @@ namespace StyletIoC.Internal.Builders
}
}
}
}

6
Stylet/StyletIoC/Internal/Container.cs
View File

@ -5,6 +5,7 @@ using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
@ -12,6 +13,9 @@ using System.Reflection.Emit;
namespace StyletIoC.Internal
{
[SuppressMessage("StyleCop.CSharp.DocumentationRules", "SA1611:ElementParametersMustBeDocumented", Justification = "Internal class, but some documentation added for readability. StyleCop ignores 'Internal only' setting if some documentation exists on member")]
[SuppressMessage("StyleCop.CSharp.DocumentationRules", "SA1615:ElementReturnValueMustBeDocumented", Justification = "Internal class, but some documentation added for readability. StyleCop ignores 'Internal only' setting if some documentation exists on member")]
[SuppressMessage("StyleCop.CSharp.DocumentationRules", "SA1618:GenericTypeParametersMustBeDocumented", Justification = "Internal class, but some documentation added for readability. StyleCop ignores 'Internal only' setting if some documentation exists on member")]
internal class Container : IContainer, IRegistrationContext
{
/// <summary>
@ -162,8 +166,6 @@ namespace StyletIoC.Internal
return true;
}
// Is it a 'get all' request?
IRegistration registration;
return this.TryRetrieveGetAllRegistration(typeKey, out registration);

6
Stylet/StyletIoC/Internal/Creators/CreatorBase.cs
View File

@ -11,11 +11,11 @@ namespace StyletIoC.Internal.Creators
internal abstract class CreatorBase : ICreator
{
public virtual Type Type { get; protected set; }
protected IRegistrationContext parentContext;
protected IRegistrationContext ParentContext { get; set; }
public CreatorBase(IRegistrationContext parentContext)
{
this.parentContext = parentContext;
this.ParentContext = parentContext;
}
// Common utility method
@ -24,7 +24,7 @@ namespace StyletIoC.Internal.Creators
var instanceVar = Expression.Variable(this.Type, "instance");
var assignment = Expression.Assign(instanceVar, creator);
var buildUpExpression = this.parentContext.GetBuilderUpper(this.Type).GetExpression(instanceVar, registrationContext);
var buildUpExpression = this.ParentContext.GetBuilderUpper(this.Type).GetExpression(instanceVar, registrationContext);
// We always start with:
// var instance = new Class(.....)

1
Stylet/StyletIoC/Internal/Creators/FactoryCreator.cs
View File

@ -7,6 +7,7 @@ namespace StyletIoC.Internal.Creators
/// <summary>
/// Knows how to create an instance of a type, by using a Func{IRegistration, T} passed by the user during building
/// </summary>
/// <typeparam name="T">Type of object created by this factory</typeparam>
internal class FactoryCreator<T> : CreatorBase
{
private readonly Func<IRegistrationContext, T> factory;

20
Stylet/StyletIoC/Internal/Creators/TypeCreator.cs
View File

@ -1,5 +1,6 @@
using StyletIoC.Creation;
using System;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
@ -37,6 +38,7 @@ namespace StyletIoC.Internal.Creators
return attribute == null ? null : attribute.Key;
}
[SuppressMessage("StyleCop.CSharp.Readability", "SA1118:ParameterMustNotSpanMultipleLines", Justification = "Honestly, it's clearer like this")]
public override Expression GetInstanceExpression(ParameterExpression registrationContext)
{
if (this.creationExpression != null)
@ -53,28 +55,30 @@ namespace StyletIoC.Internal.Creators
{
ctor = ctorsWithAttribute[0];
var key = ctorsWithAttribute[0].GetCustomAttribute<InjectAttribute>(true).Key;
var cantResolve = ctor.GetParameters().Where(p => !this.parentContext.CanResolve(p.ParameterType, key) && !p.HasDefaultValue).FirstOrDefault();
var cantResolve = ctor.GetParameters().Where(p => !this.ParentContext.CanResolve(p.ParameterType, key) && !p.HasDefaultValue).FirstOrDefault();
if (cantResolve != null)
throw new StyletIoCFindConstructorException(String.Format("Found a constructor with [Inject] on type {0}, but can't resolve parameter '{1}' (of type {2}, and doesn't have a default value).", this.Type.GetDescription(), cantResolve.Name, cantResolve.ParameterType.GetDescription()));
}
else
{
ctor = this.Type.GetConstructors()
.Where(c => c.GetParameters().All(p => this.parentContext.CanResolve(p.ParameterType, this.KeyForParameter(p)) || p.HasDefaultValue))
.Where(c => c.GetParameters().All(p => this.ParentContext.CanResolve(p.ParameterType, this.KeyForParameter(p)) || p.HasDefaultValue))
.OrderByDescending(c => c.GetParameters().Count(p => !p.HasDefaultValue))
.FirstOrDefault();
if (ctor == null)
{
// Get us a bit more information....
var info = String.Join("\n\n", this.Type.GetConstructors().Select(c => String.Format("Constructor:\n{0}\n\n", String.Join("\n", c.GetParameters().Select(p =>
Func<ParameterInfo, string> ctorParameterPrinter = p =>
{
var key = this.KeyForParameter(p);
var canResolve = this.parentContext.CanResolve(p.ParameterType, key) || p.HasDefaultValue;
var canResolve = this.ParentContext.CanResolve(p.ParameterType, key) || p.HasDefaultValue;
var keyStr = key == null ? "" : String.Format(" [Key = {0}]", key);
var usingDefaultStr = (!this.parentContext.CanResolve(p.ParameterType, key) && p.HasDefaultValue) ? " [Using Default]" : "";
var usingDefaultStr = (!this.ParentContext.CanResolve(p.ParameterType, key) && p.HasDefaultValue) ? " [Using Default]" : "";
return String.Format(" {0}{1}: {2}{3}", p.ParameterType.GetDescription(), keyStr, canResolve ? "Success" : "Failure", usingDefaultStr);
})))));
};
var info = String.Join("\n\n", this.Type.GetConstructors().Select(c => String.Format("Constructor:\n{0}\n\n", String.Join("\n", c.GetParameters().Select(ctorParameterPrinter)))));
throw new StyletIoCFindConstructorException(String.Format("Unable to find a constructor for type {0} which we can call:\n{1}", this.Type.GetDescription(), info));
}
@ -86,11 +90,11 @@ namespace StyletIoC.Internal.Creators
var ctorParams = ctor.GetParameters().Select(x =>
{
var key = this.KeyForParameter(x);
if (this.parentContext.CanResolve(x.ParameterType, key))
if (this.ParentContext.CanResolve(x.ParameterType, key))
{
try
{
return this.parentContext.GetSingleRegistration(x.ParameterType, key, true).GetInstanceExpression(registrationContext);
return this.ParentContext.GetSingleRegistration(x.ParameterType, key, true).GetInstanceExpression(registrationContext);
}
catch (StyletIoCRegistrationException e)
{

2
Stylet/StyletIoC/Internal/RegistrationCollections/RegistrationCollection.cs
View File

@ -23,7 +23,7 @@ namespace StyletIoC.Internal.RegistrationCollections
public List<IRegistration> GetAll()
{
List<IRegistration> registrationsCopy;
lock (this.registrationsLock) { registrationsCopy = registrations.ToList(); }
lock (this.registrationsLock) { registrationsCopy = this.registrations.ToList(); }
return registrationsCopy;
}

2
Stylet/StyletIoC/Internal/Registrations/FuncNoKeyRegistration.cs
View File

@ -10,9 +10,9 @@ namespace StyletIoC.Internal.Registrations
// We're only created when we're needed, so no point in trying to be lazy
internal class FuncNoKeyRegistration : IRegistration
{
private IRegistration delegateRegistration;
private readonly Type funcType;
private readonly Func<IRegistrationContext, object> generator;
private IRegistration delegateRegistration;
public Type Type
{

18
Stylet/StyletIoC/Internal/Registrations/RegistrationBase.cs
View File

@ -9,29 +9,25 @@ namespace StyletIoC.Internal.Registrations
/// </summary>
internal abstract class RegistrationBase : IRegistration
{
protected readonly ICreator creator;
public Type Type { get { return this.creator.Type; } }
protected readonly ICreator Creator;
public Type Type { get { return this.Creator.Type; } }
private readonly object generatorLock = new object();
protected Func<IRegistrationContext, object> generator;
protected Func<IRegistrationContext, object> Generator { get; set; }
public RegistrationBase(ICreator creator)
{
this.creator = creator;
this.Creator = creator;
}
public virtual Func<IRegistrationContext, object> GetGenerator()
{
if (this.generator != null)
return this.generator;
if (this.Generator != null)
return this.Generator;
lock (this.generatorLock)
{
if (this.generator == null)
{
this.generator = this.GetGeneratorInternal();
}
return this.generator;
return this.Generator ?? (this.Generator = this.GetGeneratorInternal());
}
}

6
Stylet/StyletIoC/Internal/Registrations/SingletonRegistration.cs
View File

@ -10,9 +10,9 @@ namespace StyletIoC.Internal.Registrations
/// </summary>
internal class SingletonRegistration : RegistrationBase
{
private readonly IRegistrationContext parentContext;
private Expression instanceExpression;
private object instance;
private readonly IRegistrationContext parentContext;
public SingletonRegistration(IRegistrationContext parentContext, ICreator creator)
: base(creator)
@ -25,7 +25,7 @@ namespace StyletIoC.Internal.Registrations
disposable.Dispose();
this.instance = this.instanceExpression = null;
this.generator = null;
this.Generator = null;
};
}
@ -34,7 +34,7 @@ namespace StyletIoC.Internal.Registrations
if (this.instanceExpression != null)
return this.instanceExpression;
this.instance = Expression.Lambda<Func<IRegistrationContext, object>>(this.creator.GetInstanceExpression(registrationContext), registrationContext).Compile()(this.parentContext);
this.instance = Expression.Lambda<Func<IRegistrationContext, object>>(this.Creator.GetInstanceExpression(registrationContext), registrationContext).Compile()(this.parentContext);
// This expression yields the actual type of instance, not 'object'
var instanceExpression = Expression.Constant(this.instance);

2
Stylet/StyletIoC/Internal/Registrations/TransientRegistration.cs
View File

@ -12,7 +12,7 @@ namespace StyletIoC.Internal.Registrations
public override Expression GetInstanceExpression(ParameterExpression registrationContext)
{
return this.creator.GetInstanceExpression(registrationContext);
return this.Creator.GetInstanceExpression(registrationContext);
}
}
}

6
Stylet/StyletIoC/Internal/TypeExtensions.cs
View File

@ -84,10 +84,8 @@ namespace StyletIoC.Internal
string name;
if (genericArguments.Length > 0)
{
return String.Format("{0}<{1}>", type.Name.Split('`')[0], String.Join(", ", genericArguments.Select(x =>
{
return primitiveNameMapping.TryGetValue(x, out name) ? name : x.Name;
})));
var genericArgumentNames = genericArguments.Select(x => primitiveNameMapping.TryGetValue(x, out name) ? name : x.Name);
return String.Format("{0}<{1}>", type.Name.Split('`')[0], String.Join(", ", genericArgumentNames));
}
else
{

2
Stylet/StyletIoC/Internal/UnboundGeneric.cs
View File

@ -6,8 +6,8 @@ namespace StyletIoC.Internal
{
internal class UnboundGeneric
{
private IRegistrationContext parentContext;
private readonly Type serviceType;
private readonly IRegistrationContext parentContext;
public Type Type { get; private set; }
public RegistrationFactory RegistrationFactory { get; private set; }

31
Stylet/StyletIoC/StyletIoCBuilder.cs
View File

@ -18,19 +18,21 @@ namespace StyletIoC
/// <summary>
/// Bind the specified service to itself - if you self-bind MyClass, and request an instance of MyClass, you'll get an instance of MyClass.
/// </summary>
/// <returns></returns>
/// <returns>Fluent interface to continue configuration</returns>
IInScopeOrWithKeyOrAsWeakBinding ToSelf();
/// <summary>
/// Bind the specified service to another type which implements that service. E.g. builder.Bind{IMyClass}().To(typeof(MyClass)), and request an IMyClass: you'll get a MyClass.
/// </summary>
/// <param name="implementationType">Type to bind the service to</param>
/// <returns>Fluent interface to continue configuration</returns>
IInScopeOrWithKeyOrAsWeakBinding To(Type implementationType);
/// <summary>
/// Bind the specified service to another type which implements that service. E.g. builder.Bind{IMyClass}().To{MyClass}(), and request an IMyClass: you'll get a MyClass.
/// </summary>
/// <typeparam name="TImplementation">Type to bind the service to</typeparam>
/// <returns>Fluent interface to continue configuration</returns>
IInScopeOrWithKeyOrAsWeakBinding To<TImplementation>();
/// <summary>
@ -38,29 +40,34 @@ namespace StyletIoC
/// </summary>
/// <typeparam name="TImplementation">Type returned by the factory delegate. Must implement the service</typeparam>
/// <param name="factory">Factory delegate to bind got</param>
/// <returns>Fluent interface to continue configuration</returns>
IInScopeOrWithKeyOrAsWeakBinding ToFactory<TImplementation>(Func<IRegistrationContext, TImplementation> factory);
/// <summary>
/// Bind the specified service to the given untyped instance
/// </summary>
/// <param name="instance">Instance to use</param>
/// <returns>Fluent interface to continue configuration</returns>
IWithKeyOrAsWeakBinding ToInstance(object instance);
/// <summary>
/// If the service is an interface with a number of methods which return other types, generate an implementation of that abstract factory and bind it to the interface.
/// </summary>
/// <returns>Fluent interface to continue configuration</returns>
IWithKeyOrAsWeakBinding ToAbstractFactory();
/// <summary>
/// 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>
/// <returns>Fluent interface to continue configuration</returns>
IInScopeOrWithKeyOrAsWeakBinding ToAllImplementations(IEnumerable<Assembly> assemblies);
/// <summary>
/// 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>
/// <returns>Fluent interface to continue configuration</returns>
IInScopeOrWithKeyOrAsWeakBinding ToAllImplementations(params Assembly[] assemblies);
}
@ -73,15 +80,19 @@ namespace StyletIoC
/// Mark the binding as weak
/// </summary>
/// <remarks>
/// <para>
/// When the container is built, each collection of registrations for each Type+key combination is examined.
/// If only weak bindings exist, then all bindings are built into the container.
/// If any normal bindings exist, then all weak bindings are ignored, and only the normal bindings are built into the container.
///
/// </para>
/// <para>
/// This is very useful for integration StyletIoC into a framework. The framework can add default bindings for services as
/// weak bindings, and the user can use normal bindings. If the user does specify a binding, then this will override
/// the binding set by the framework.
///
/// </para>
/// <para>
/// This is also used by AutoBind when self-binding concrete types, for the sme reason.
/// </para>
/// </remarks>
void AsWeakBinding();
}
@ -95,6 +106,7 @@ namespace StyletIoC
/// Associate a key with this binding. Requests for the service will have to specify this key to retrieve the result of this binding
/// </summary>
/// <param name="key">Key to associate with this binding</param>
/// <returns>Fluent interface to continue configuration</returns>
IAsWeakBinding WithKey(string key);
}
@ -107,11 +119,13 @@ namespace StyletIoC
/// Specify a factory that creates an IRegistration to use for this binding
/// </summary>
/// <param name="registrationFactory">Registration factory to use</param>
/// <returns>Fluent interface to continue configuration</returns>
IAsWeakBinding WithRegistrationFactory(RegistrationFactory registrationFactory);
/// <summary>
/// Modify the scope of the binding to Singleton. One instance of this implementation will be generated for this binding.
/// </summary>
/// <returns>Fluent interface to continue configuration</returns>
IAsWeakBinding InSingletonScope();
}
@ -124,6 +138,7 @@ namespace StyletIoC
/// Associate a key with this binding. Requests for the service will have to specify this key to retrieve the result of this binding
/// </summary>
/// <param name="key">Key to associate with this binding</param>
/// <returns>Fluent interface to continue configuration</returns>
IInScopeOrAsWeakBinding WithKey(string key);
}
@ -136,12 +151,14 @@ namespace StyletIoC
/// Bind the specified service (interface, abstract class, concrete class, unbound generic, etc) to something
/// </summary>
/// <param name="serviceType">Service to bind</param>
/// <returns>Fluent interface to continue configuration</returns>
IBindTo Bind(Type serviceType);
/// <summary>
/// Bind the specified service (interface, abstract class, concrete class, unbound generic, etc) to something
/// </summary>
/// <typeparam name="TService">Service to bind</typeparam>
/// <returns>Fluent interface to continue configuration</returns>
IBindTo Bind<TService>();
/// <summary>
@ -172,12 +189,12 @@ namespace StyletIoC
private readonly List<StyletIoCModule> modules = new List<StyletIoCModule>();
/// <summary>
/// Create a new StyletIoC builder instance
/// Initialises a new instance of the <see cref="StyletIoCBuilder"/> class
/// </summary>
public StyletIoCBuilder() { }
/// <summary>
/// Create a new StyletIoC builder instanc, which contains the given modules
/// Initialises a new instance of the <see cref="StyletIoCBuilder"/> class, which contains the given modules
/// </summary>
/// <param name="modules">Modules to add to the builder</param>
public StyletIoCBuilder(params StyletIoCModule[] modules)
@ -189,6 +206,7 @@ namespace StyletIoC
/// Bind the specified service (interface, abstract class, concrete class, unbound generic, etc) to something
/// </summary>
/// <param name="serviceType">Service to bind</param>
/// <returns>Fluent interface to continue configuration</returns>
public IBindTo Bind(Type serviceType)
{
var builderBindTo = new BuilderBindTo(serviceType);
@ -200,6 +218,7 @@ namespace StyletIoC
/// Bind the specified service (interface, abstract class, concrete class, unbound generic, etc) to something
/// </summary>
/// <typeparam name="TService">Service to bind</typeparam>
/// <returns>Fluent interface to continue configuration</returns>
public IBindTo Bind<TService>()
{
return this.Bind(typeof(TService));
@ -269,7 +288,7 @@ namespace StyletIoC
var container = new Container();
// For each TypeKey, we remove any weak bindings if there are any strong bindings
var groups = this.bindings.GroupBy(x => new { Key = x.Key, Type = x.ServiceType });
var groups = this.bindings.GroupBy(x => new { Key = x.Key, Type = x.ServiceType });
var filtered = groups.SelectMany(group => group.Any(x => !x.IsWeak) ? group.Where(x => !x.IsWeak) : group);
foreach (var binding in filtered)
{

2
Stylet/StyletIoC/StyletIoCModule.cs
View File

@ -18,6 +18,7 @@ namespace StyletIoC
/// Bind the specified service (interface, abstract class, concrete class, unbound generic, etc) to something
/// </summary>
/// <param name="serviceType">Service to bind</param>
/// <returns>Fluent interface to continue configuration</returns>
protected IBindTo Bind(Type serviceType)
{
var builderBindTo = new BuilderBindTo(serviceType);
@ -29,6 +30,7 @@ namespace StyletIoC
/// Bind the specified service (interface, abstract class, concrete class, unbound generic, etc) to something
/// </summary>
/// <typeparam name="TService">Service to bind</typeparam>
/// <returns>Fluent interface to continue configuration</returns>
protected IBindTo Bind<TService>()
{
return this.Bind(typeof(TService));

19
Stylet/ValidatingModelBase.cs
View File

@ -13,8 +13,7 @@ namespace Stylet
/// <summary>
/// Base for ViewModels which require property validation
/// </summary>
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1001:TypesThatOwnDisposableFieldsShouldBeDisposable",
Justification="According to Albahari and Albahari, relying on the GC to tidy up WaitHandles is arguably acceptable, since they're so small.")]
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1001:TypesThatOwnDisposableFieldsShouldBeDisposable", Justification = "According to Albahari and Albahari, relying on the GC to tidy up WaitHandles is arguably acceptable, since they're so small.")]
public class ValidatingModelBase : PropertyChangedBase, INotifyDataErrorInfo
{
/// <summary>
@ -27,7 +26,7 @@ namespace Stylet
private IModelValidator _validator;
/// <summary>
/// IModelValidator to use to validate properties. You're expected to write your own, using your favourite validation library
/// Gets or sets the IModelValidator to use to validate properties. You're expected to write your own, using your favourite validation library
/// </summary>
protected virtual IModelValidator Validator
{
@ -41,12 +40,12 @@ namespace Stylet
}
/// <summary>
/// Whether to run validation for a property automatically every time that property changes
/// Gets or sets a value indicating whether to run validation for a property automatically every time that property changes
/// </summary>
protected bool AutoValidate { get; set; }
/// <summary>
/// Instantiate, without using an IValidatorAdapter
/// Initialises a new instance of the <see cref="ValidatingModelBase"/> class, without using an <see cref="IModelValidator"/>
/// </summary>
public ValidatingModelBase()
{
@ -54,7 +53,7 @@ namespace Stylet
}
/// <summary>
/// Instantiate, using the specified IValidatorAdapter
/// Initialises a new instance of the <see cref="ValidatingModelBase"/> class, using the specifies <see cref="IModelValidator"/>
/// </summary>
/// <param name="validator">Validator adapter to use to perform validations</param>
public ValidatingModelBase(IModelValidator validator) : this()
@ -143,6 +142,7 @@ namespace Stylet
/// <summary>
/// Validate a single property synchronously, by name
/// </summary>
/// <typeparam name="TProperty">Type of property to validate</typeparam>
/// <param name="property">Expression describing the property to validate</param>
/// <returns>True if the property validated successfully</returns>
protected virtual bool ValidateProperty<TProperty>(Expression<Func<TProperty>> property)
@ -153,6 +153,7 @@ namespace Stylet
/// <summary>
/// Validate a single property asynchronously, by name
/// </summary>
/// <typeparam name="TProperty">Type ofproperty to validate</typeparam>
/// <param name="property">Expression describing the property to validate</param>
/// <returns>True if the property validated successfully</returns>
protected virtual Task<bool> ValidatePropertyAsync<TProperty>(Expression<Func<TProperty>> property)
@ -217,7 +218,8 @@ namespace Stylet
/// <summary>
/// Raise a PropertyChanged notification for the named property, and validate that property if this.validation is set and this.autoValidate is true
/// </summary>
/// <param name="propertyName"></param>
/// <param name="propertyName">Name of the property which has changed</param>
[EditorBrowsable(EditorBrowsableState.Never)]
protected override async void OnPropertyChanged(string propertyName)
{
base.OnPropertyChanged(propertyName);
@ -231,6 +233,7 @@ namespace Stylet
/// <summary>
/// Called whenever the error state of any properties changes. Calls NotifyOfPropertyChange(() => this.HasErrors) by default
/// </summary>
/// <param name="changedProperties">List of property names which have changed validation state</param>
protected virtual void OnValidationStateChanged(IEnumerable<string> changedProperties)
{
this.NotifyOfPropertyChange(() => this.HasErrors);
@ -273,7 +276,7 @@ namespace Stylet
}
/// <summary>
/// Gets a value that indicates whether the entity has validation errors.
/// Gets a value indicating whether the entity has validation errors.
/// </summary>
public bool HasErrors
{

12
Stylet/ViewManager.cs
View File

@ -36,7 +36,7 @@ namespace Stylet
public interface IViewManagerConfig
{
/// <summary>
/// Assemblies which are used for IoC container auto-binding and searching for Views.
/// Gets the assemblies which are used for IoC container auto-binding and searching for Views.
/// Set this in Configure() if you want to override it
/// </summary>
IList<Assembly> Assemblies { get; }
@ -57,19 +57,19 @@ namespace Stylet
private static readonly ILogger logger = LogManager.GetLogger(typeof(ViewManager));
/// <summary>
/// Assemblies searched for View types
/// Gets or sets the assemblies searched for View types
/// </summary>
protected IList<Assembly> Assemblies { get; set; }
/// <summary>
/// Factory used to create view instances from their type
/// Gets or sets the factory used to create view instances from their type
/// </summary>
protected Func<Type, object> ViewFactory { get; set; }
/// <summary>
/// Create a new ViewManager, with the given viewFactory
/// Initialises a new instance of the <see cref="ViewManager"/> class, with the given viewFactory
/// </summary>
/// <param name="config">Configuration</param>
/// <param name="config">Configuration to use</param>
public ViewManager(IViewManagerConfig config)
{
this.Assemblies = config.Assemblies;
@ -240,7 +240,7 @@ namespace Stylet
public readonly string ViewTypeName;
/// <summary>
/// Create a new StyletViewLocationException
/// Initialises a new instance of the <see cref="StyletViewLocationException"/> class
/// </summary>
/// <param name="message">Message associated with the Exception</param>
/// <param name="viewTypeName">Name of the View this question was thrown for</param>

17
Stylet/WindowManager.cs
View File

@ -37,6 +37,7 @@ namespace Stylet
/// <param name="cancelResult">A System.Windows.MessageBoxResult value that specifies the cancel result of the message box</param>
/// <param name="options">A System.Windows.MessageBoxOptions value object that specifies the options.</param>
/// <param name="buttonLabels">A dictionary specifying the button labels, if desirable</param>
/// <returns>The result chosen by the user</returns>
MessageBoxResult ShowMessageBox(string messageBoxText, string caption = null,
MessageBoxButton buttons = MessageBoxButton.OK,
MessageBoxImage icon = MessageBoxImage.None,
@ -56,7 +57,7 @@ namespace Stylet
private readonly Func<IMessageBoxViewModel> messageBoxViewModelFactory;
/// <summary>
/// Create a new WindowManager instance, using the given IViewManager
/// Initialises a new instance of the <see cref="WindowManager"/> class, using the given <see cref="IViewManager"/>
/// </summary>
/// <param name="viewManager">IViewManager to use when creating views</param>
/// <param name="messageBoxViewModelFactory">Delegate which returns a new IMessageBoxViewModel instance when invoked</param>
@ -96,6 +97,7 @@ namespace Stylet
/// <param name="cancelResult">A System.Windows.MessageBoxResult value that specifies the cancel result of the message box</param>
/// <param name="options">A System.Windows.MessageBoxOptions value object that specifies the options.</param>
/// <param name="buttonLabels">A dictionary specifying the button labels, if desirable</param>
/// <returns>The result chosen by the user</returns>
public MessageBoxResult ShowMessageBox(string messageBoxText, string caption = "",
MessageBoxButton buttons = MessageBoxButton.OK,
MessageBoxImage icon = MessageBoxImage.None,
@ -157,11 +159,15 @@ namespace Stylet
if (Application.Current == null)
return null;
// We can end up in a really weird situation if they try and display more than one dialog as the application's closing
// Basically the MainWindow's no long active, so the second dialog chooses the first dialog as its owner... But the first dialog
// hasn't yet been shown, so we get an exception ("cannot set owner property to a Window which has not been previously shown").
// Not sure whether checking IsLoaded is the correct solution, but...
var active = Application.Current.Windows.OfType<Window>().Where(x => x.IsActive).FirstOrDefault() ?? Application.Current.MainWindow;
return active == window ? null : active;
}
class WindowConductor : IChildDelegate
private class WindowConductor : IChildDelegate
{
private readonly Window window;
private readonly object viewModel;
@ -186,7 +192,7 @@ namespace Stylet
window.Closing += this.WindowClosing;
if (this.viewModel is IActivate || this.viewModel is IDeactivate)
window.StateChanged += WindowStateChanged;
window.StateChanged += this.WindowStateChanged;
}
private void WindowStateChanged(object sender, EventArgs e)
@ -217,9 +223,6 @@ namespace Stylet
ScreenExtensions.TryCloseAndDispose(this.viewModel);
}
/// <summary>
/// Closing event from the window
/// </summary>
private async void WindowClosing(object sender, CancelEventArgs e)
{
if (e.Cancel)
@ -256,6 +259,8 @@ namespace Stylet
/// <summary>
/// Close was requested by the child
/// </summary>
/// <param name="item">Item to close</param>
/// <param name="dialogResult">DialogResult to close with, if it's a dialog</param>
async void IChildDelegate.CloseItem(object item, bool? dialogResult)
{
if (item != this.viewModel)

10
Stylet/Xaml/ActionExtension.cs
View File

@ -30,7 +30,7 @@ namespace Stylet.Xaml
/// Throw an exception
/// </summary>
Throw
};
}
/// <summary>
/// MarkupExtension used for binding Commands and Events to methods on the View.ActionTarget
@ -38,22 +38,22 @@ namespace Stylet.Xaml
public class ActionExtension : MarkupExtension
{
/// <summary>
/// Name of the method to call
/// Gets or sets the name of the method to call
/// </summary>
public string Method { get; set; }
/// <summary>
/// Behaviour if the View.ActionTarget is nulil
/// Gets or sets the behaviour if the View.ActionTarget is nulil
/// </summary>
public ActionUnavailableBehaviour NullTarget { get; set; }
/// <summary>
/// Behaviour if the action itself isn't found on the View.ActionTarget
/// Gets or sets the behaviour if the action itself isn't found on the View.ActionTarget
/// </summary>
public ActionUnavailableBehaviour ActionNotFound { get; set; }
/// <summary>
/// Create a new ActionExtension
/// Initialises a new instance of the <see cref="ActionExtension"/> class
/// </summary>
/// <param name="method">Name of the method to call</param>
public ActionExtension(string method)

8
Stylet/Xaml/ApplicationLoader.cs
View File

@ -11,7 +11,7 @@ namespace Stylet.Xaml
private readonly ResourceDictionary styletResourceDictionary;
/// <summary>
/// Create a new ApplicationLoader instance
/// Initialises a new instance of the <see cref="ApplicationLoader"/> class
/// </summary>
public ApplicationLoader()
{
@ -22,11 +22,11 @@ namespace Stylet.Xaml
private IBootstrapper _bootstrapper;
/// <summary>
/// Bootstrapper instance to use to start your application. This must be set.
/// Gets or sets the bootstrapper instance to use to start your application. This must be set.
/// </summary>
public IBootstrapper Bootstrapper
{
get { return _bootstrapper; }
get { return this._bootstrapper; }
set
{
this._bootstrapper = value;
@ -37,7 +37,7 @@ namespace Stylet.Xaml
private bool _loadStyletResources;
/// <summary>
/// Control whether to load Stylet's own resources (e.g. StyletConductorTabControl). Defaults to true.
/// Gets or sets a value indicating whether to load Stylet's own resources (e.g. StyletConductorTabControl). Defaults to true.
/// </summary>
public bool LoadStyletResources
{

22
Stylet/Xaml/BoolToVisibilityConverter.cs
View File

@ -1,5 +1,6 @@
using System;
using System.Collections;
using System.Diagnostics.CodeAnalysis;
using System.Windows;
using System.Windows.Data;
@ -8,6 +9,7 @@ namespace Stylet.Xaml
/// <summary>
/// Turn a boolean value into a Visibility
/// </summary>
[SuppressMessage("StyleCop.CSharp.ReadabilityRules", "SA1126:PrefixCallsCorrectly", Justification = "Don't agree with prefixing static method calls with the class name")]
public class BoolToVisibilityConverter : DependencyObject, IValueConverter
{
/// <summary>
@ -16,7 +18,7 @@ namespace Stylet.Xaml
public static readonly BoolToVisibilityConverter Instance = new BoolToVisibilityConverter();
/// <summary>
/// Visibility to use if value is true
/// Gets or sets the visibility to use if value is true
/// </summary>
public Visibility TrueVisibility
{
@ -31,7 +33,7 @@ namespace Stylet.Xaml
DependencyProperty.Register("TrueVisibility", typeof(Visibility), typeof(BoolToVisibilityConverter), new PropertyMetadata(Visibility.Visible));
/// <summary>
/// Visibility to use if value is false
/// Gets or sets the visibility to use if value is false
/// </summary>
public Visibility FalseVisibility
{
@ -45,10 +47,14 @@ namespace Stylet.Xaml
public static readonly DependencyProperty FalseVisibilityProperty =
DependencyProperty.Register("FalseVisibility", typeof(Visibility), typeof(BoolToVisibilityConverter), new PropertyMetadata(Visibility.Collapsed));
/// <summary>
/// Perform the conversion
/// </summary>
/// <param name="value">value as produced by source binding</param>
/// <param name="targetType">target type</param>
/// <param name="parameter">converter parameter</param>
/// <param name="culture">culture information</param>
/// <returns>Converted value</returns>
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
bool result;
@ -68,9 +74,10 @@ namespace Stylet.Xaml
{
result = true; // Non-null non-enumerable reference type = true
}
// Value types from here on in
else
else
{
// Value types from here on in
// This fails if an int can't be converted to it, or for many other reasons
// Easiest is just to try it and see
try
@ -89,6 +96,11 @@ namespace Stylet.Xaml
/// <summary>
/// Perform the inverse conversion. Only valid if the value is bool
/// </summary>
/// <param name="value">value, as produced by target</param>
/// <param name="targetType">target type</param>
/// <param name="parameter">converter parameter</param>
/// <param name="culture">culture information</param>
/// <returns>Converted back value</returns>
public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
if (targetType != typeof(bool))

7
Stylet/Xaml/CommandAction.cs
View File

@ -19,13 +19,14 @@ namespace Stylet.Xaml
public class CommandAction : ICommand
{
private static readonly ILogger logger = LogManager.GetLogger(typeof(CommandAction));
/// <summary>
/// View to grab the View.ActionTarget from
/// Gets the View to grab the View.ActionTarget from
/// </summary>
public DependencyObject Subject { get; private set; }
/// <summary>
/// Method name. E.g. if someone's gone Buttom Command="{s:Action MyMethod}", this is MyMethod.
/// Gets the method name. E.g. if someone's gone Buttom Command="{s:Action MyMethod}", this is MyMethod.
/// </summary>
public string MethodName { get; private set; }
@ -45,7 +46,7 @@ namespace Stylet.Xaml
private readonly ActionUnavailableBehaviour actionNonExistentBehaviour;
/// <summary>
/// Create a new ActionCommand
/// Initialises a new instance of the <see cref="CommandAction"/> class
/// </summary>
/// <param name="subject">View to grab the View.ActionTarget from</param>
/// <param name="methodName">Method name. the MyMethod in Buttom Command="{s:Action MyMethod}".</param>

20
Stylet/Xaml/DebugConverter.cs
View File

@ -1,5 +1,6 @@
using System;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Windows;
using System.Windows.Data;
@ -8,6 +9,7 @@ namespace Stylet.Xaml
/// <summary>
/// Converter which passes through values, but uses Debug.WriteLine to log them. Useful for debugging
/// </summary>
[SuppressMessage("StyleCop.CSharp.ReadabilityRules", "SA1126:PrefixCallsCorrectly", Justification = "Don't agree with prefixing static method calls with the class name")]
public class DebugConverter : DependencyObject, IValueConverter
{
/// <summary>
@ -16,7 +18,7 @@ namespace Stylet.Xaml
public static readonly DebugConverter Instance;
/// <summary>
/// Category to use with Debug.WriteLine
/// Gets or sets the category to use with Debug.WriteLine
/// </summary>
public string Name
{
@ -30,9 +32,8 @@ namespace Stylet.Xaml
public static readonly DependencyProperty NameProperty =
DependencyProperty.Register("Name", typeof(string), typeof(DebugConverter), new PropertyMetadata("DebugConverter"));
/// <summary>
/// Logger to use. Defaults to Debug.WriteLine. Arguments are: Message, Name
/// Gets or sets the Logger to use. Defaults to Debug.WriteLine. Arguments are: Message, Name
/// </summary>
public Action<string, string> Logger
{
@ -46,7 +47,6 @@ namespace Stylet.Xaml
public static readonly DependencyProperty LoggerProperty =
DependencyProperty.Register("Logger", typeof(Action<string, string>), typeof(DebugConverter), new PropertyMetadata(null));
static DebugConverter()
{
// Have to set this from within a static constructor, as it's run after the field initializers
@ -55,7 +55,7 @@ namespace Stylet.Xaml
}
/// <summary>
/// Create a new DebugConverter instance
/// Initialises a new instance of the <see cref="DebugConverter"/> class
/// </summary>
public DebugConverter()
{
@ -66,6 +66,11 @@ namespace Stylet.Xaml
/// <summary>
/// Perform the conversion
/// </summary>
/// <param name="value">value as produced by source binding</param>
/// <param name="targetType">target type</param>
/// <param name="parameter">converter parameter</param>
/// <param name="culture">culture information</param>
/// <returns>Converted value</returns>
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
if (parameter == null)
@ -79,6 +84,11 @@ namespace Stylet.Xaml
/// <summary>
/// Perform the reverse conversion
/// </summary>
/// <param name="value">value, as produced by target</param>
/// <param name="targetType">target type</param>
/// <param name="parameter">converter parameter</param>
/// <param name="culture">culture information</param>
/// <returns>Converted back value</returns>
public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
if (parameter == null)

21
Stylet/Xaml/EqualityConverter.cs
View File

@ -1,4 +1,5 @@
using System;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Windows;
using System.Windows.Data;
@ -8,6 +9,7 @@ namespace Stylet.Xaml
/// <summary>
/// Converter to compare a number of values, and return true (or false if Invert is true) if they are all equal
/// </summary>
[SuppressMessage("StyleCop.CSharp.ReadabilityRules", "SA1126:PrefixCallsCorrectly", Justification = "Don't agree with prefixing static method calls with the class name")]
public class EqualityConverter : DependencyObject, IMultiValueConverter
{
/// <summary>
@ -16,7 +18,7 @@ namespace Stylet.Xaml
public static readonly EqualityConverter Instance = new EqualityConverter();
/// <summary>
/// Return false, instead of true, if call values are equal
/// Gets or sets a value indicating whether to return false, instead of true, if call values are equal
/// </summary>
public bool Invert
{
@ -33,6 +35,15 @@ namespace Stylet.Xaml
/// <summary>
/// Perform the conversion
/// </summary>
/// <param name="values">
/// Array of values, as produced by source bindings.
/// System.Windows.DependencyProperty.UnsetValue may be passed to indicate that
/// the source binding has no value to provide for conversion.
/// </param>
/// <param name="targetType">target type</param>
/// <param name="parameter">converter parameter</param>
/// <param name="culture">culture information</param>
/// <returns>Converted values</returns>
public object Convert(object[] values, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
if (values == null || values.Length == 0)
@ -45,6 +56,14 @@ namespace Stylet.Xaml
/// <summary>
/// Perform the reverse convesion. Not implemented.
/// </summary>
/// <param name="value">value, as produced by target</param>
/// <param name="targetTypes">
/// Array of target types; array length indicates the number and types
/// of values suggested for Convert to return.
/// </param>
/// <param name="parameter">converter parameter</param>
/// <param name="culture">culture information</param>
/// <returns>Converted back values</returns>
public object[] ConvertBack(object value, Type[] targetTypes, object parameter, System.Globalization.CultureInfo culture)
{
throw new NotImplementedException();

11
Stylet/Xaml/EventAction.cs
View File

@ -13,6 +13,9 @@ namespace Stylet.Xaml
{
private static readonly ILogger logger = LogManager.GetLogger(typeof(EventAction));
private readonly ActionUnavailableBehaviour targetNullBehaviour;
private readonly ActionUnavailableBehaviour actionNonExistentBehaviour;
/// <summary>
/// View whose View.ActionTarget we watch
/// </summary>
@ -35,11 +38,8 @@ namespace Stylet.Xaml
private object target;
private readonly ActionUnavailableBehaviour targetNullBehaviour;
private readonly ActionUnavailableBehaviour actionNonExistentBehaviour;
/// <summary>
/// Create a new EventAction
/// Initialises a new instance of the <see cref="EventAction"/> class
/// </summary>
/// <param name="subject">View whose View.ActionTarget we watch</param>
/// <param name="targetProperty">Property on the WPF element we're returning a delegate for</param>
@ -126,9 +126,10 @@ namespace Stylet.Xaml
/// <summary>
/// Return a delegate which can be added to the targetProperty
/// </summary>
/// <returns>An event hander, which, when invoked, will invoke the action</returns>
public RoutedEventHandler GetDelegate()
{
return new RoutedEventHandler(this.InvokeCommand);
return this.InvokeCommand;
}
private void InvokeCommand(object sender, RoutedEventArgs e)

12
Stylet/Xaml/IconToBitmapSourceConverter.cs
View File

@ -1,4 +1,5 @@
using System;
using System.Diagnostics.CodeAnalysis;
using System.Drawing;
using System.Windows;
using System.Windows.Data;
@ -10,6 +11,7 @@ namespace Stylet.Xaml
/// <summary>
/// Converter to take an Icon, and convert it to a BitmapSource
/// </summary>
[SuppressMessage("StyleCop.CSharp.ReadabilityRules", "SA1126:PrefixCallsCorrectly", Justification = "Don't agree with prefixing static method calls with the class name")]
public class IconToBitmapSourceConverter : IValueConverter
{
/// <summary>
@ -20,6 +22,11 @@ namespace Stylet.Xaml
/// <summary>
/// Converts a value
/// </summary>
/// <param name="value">value as produced by source binding</param>
/// <param name="targetType">target type</param>
/// <param name="parameter">converter parameter</param>
/// <param name="culture">culture information</param>
/// <returns>Converted value</returns>
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
var icon = value as Icon;
@ -32,6 +39,11 @@ namespace Stylet.Xaml
/// <summary>
/// Converts a value back. Not implemented.
/// </summary>
/// <param name="value">value, as produced by target</param>
/// <param name="targetType">target type</param>
/// <param name="parameter">converter parameter</param>
/// <param name="culture">culture information</param>
/// <returns>Converted back value</returns>
public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
throw new NotImplementedException();

9
Stylet/Xaml/View.cs
View File

@ -20,9 +20,9 @@ namespace Stylet.Xaml
private static readonly ContentPropertyAttribute defaultContentProperty = new ContentPropertyAttribute("Content");
/// <summary>
/// IViewManager to be used. This should be set by the Bootstrapper.
/// Gets or sets the <see cref="IViewManager"/> to be used. This should be set by the Bootstrapper.
/// </summary>
public static IViewManager ViewManager;
public static IViewManager ViewManager { get; set; }
/// <summary>
/// Get the ActionTarget associated with the given object
@ -31,7 +31,7 @@ namespace Stylet.Xaml
/// <returns>ActionTarget associated with the given object</returns>
public static object GetActionTarget(DependencyObject obj)
{
return (object)obj.GetValue(ActionTargetProperty);
return obj.GetValue(ActionTargetProperty);
}
/// <summary>
@ -57,7 +57,7 @@ namespace Stylet.Xaml
/// <returns>ViewModel currently associated with the given object</returns>
public static object GetModel(DependencyObject obj)
{
return (object)obj.GetValue(ModelProperty);
return obj.GetValue(ModelProperty);
}
/// <summary>
@ -105,7 +105,6 @@ namespace Stylet.Xaml
}
}));
/// <summary>
/// Helper to set the Content property of a given object to a particular View
/// </summary>

4
StyletIntegrationTests/Bootstrapper.cs
View File

@ -17,9 +17,9 @@ namespace StyletIntegrationTests
LogManager.Enabled = true;
}
protected override void OnApplicationUnhandledExecption(object sender, System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e)
protected override void OnUnhandledExecption(System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e)
{
base.OnApplicationUnhandledExecption(sender, e); // Calling this just to trigger some code coverage
base.OnUnhandledExecption(e); // Calling this just to trigger some code coverage
var message = e.Exception.Message;
if (e.Exception is TargetInvocationException)
message = e.Exception.InnerException.Message;