From 9e9355ffe08db1617313b7a6d779a8db1ddb0228 Mon Sep 17 00:00:00 2001 From: Antony Male Date: Fri, 9 Jan 2015 08:23:59 +0000 Subject: [PATCH] Add StyleCop support Most of the violations were documentation changes --- Stylet/BindableCollection.cs | 23 +- Stylet/Bootstrapper.cs | 2 +- Stylet/BootstrapperBase.cs | 20 +- Stylet/Conductor.cs | 10 +- Stylet/ConductorAllActive.cs | 8 +- Stylet/ConductorBase.cs | 16 +- Stylet/ConductorBaseWithActiveItem.cs | 10 +- Stylet/ConductorNavigating.cs | 4 +- Stylet/ConductorOneActive.cs | 11 +- Stylet/Execute.cs | 25 ++- Stylet/ExpressionExtensions.cs | 2 + Stylet/IConductor.cs | 7 +- Stylet/IDispatcher.cs | 4 +- Stylet/INotifyPropertyChangedDispatcher.cs | 3 +- Stylet/IScreen.cs | 7 +- Stylet/IValidationAdapter.cs | 5 +- Stylet/LabelledValue.cs | 18 +- Stylet/Logging/LogManager.cs | 22 +- Stylet/MessageBoxViewModel.cs | 38 ++-- Stylet/PropertyChangedBase.cs | 6 +- Stylet/PropertyChangedExtensions.cs | 12 +- Stylet/Screen.cs | 35 +-- Stylet/ScreenExtensions.cs | 10 + Stylet/Settings.StyleCop | 212 ++++++++++++++++++ Stylet/Stylet.csproj | 4 +- Stylet/StyletConductorExtensions.cs | 1 + Stylet/StyletIoC/Creation/BuilderUpper.cs | 2 +- Stylet/StyletIoC/Creation/ICreator.cs | 3 +- Stylet/StyletIoC/Creation/IRegistration.cs | 3 +- Stylet/StyletIoC/IContainer.cs | 4 +- Stylet/StyletIoC/InjectAttribute.cs | 8 +- .../Builders/BuilderAbstractFactoryBinding.cs | 4 +- .../Internal/Builders/BuilderBindingBase.cs | 21 +- .../Builders/BuilderFactoryBinding.cs | 6 +- .../Builders/BuilderInstanceBinding.cs | 2 +- .../BuilderToAllImplementationsBinding.cs | 5 +- Stylet/StyletIoC/Internal/Container.cs | 6 +- .../Internal/Creators/CreatorBase.cs | 6 +- .../Internal/Creators/FactoryCreator.cs | 1 + .../Internal/Creators/TypeCreator.cs | 20 +- .../RegistrationCollection.cs | 2 +- .../Registrations/FuncNoKeyRegistration.cs | 2 +- .../Registrations/RegistrationBase.cs | 18 +- .../Registrations/SingletonRegistration.cs | 6 +- .../Registrations/TransientRegistration.cs | 2 +- Stylet/StyletIoC/Internal/TypeExtensions.cs | 6 +- Stylet/StyletIoC/Internal/UnboundGeneric.cs | 2 +- Stylet/StyletIoC/StyletIoCBuilder.cs | 31 ++- Stylet/StyletIoC/StyletIoCModule.cs | 2 + Stylet/ValidatingModelBase.cs | 19 +- Stylet/ViewManager.cs | 12 +- Stylet/WindowManager.cs | 17 +- Stylet/Xaml/ActionExtension.cs | 10 +- Stylet/Xaml/ApplicationLoader.cs | 8 +- Stylet/Xaml/BoolToVisibilityConverter.cs | 22 +- Stylet/Xaml/CommandAction.cs | 7 +- Stylet/Xaml/DebugConverter.cs | 20 +- Stylet/Xaml/EqualityConverter.cs | 21 +- Stylet/Xaml/EventAction.cs | 11 +- Stylet/Xaml/IconToBitmapSourceConverter.cs | 12 + Stylet/Xaml/View.cs | 9 +- StyletIntegrationTests/Bootstrapper.cs | 4 +- 62 files changed, 612 insertions(+), 237 deletions(-) create mode 100644 Stylet/Settings.StyleCop diff --git a/Stylet/BindableCollection.cs b/Stylet/BindableCollection.cs index 4869170..f1293c1 100644 --- a/Stylet/BindableCollection.cs +++ b/Stylet/BindableCollection.cs @@ -9,7 +9,7 @@ namespace Stylet /// /// Represents a collection which is observasble /// - /// + /// The type of elements in the collections public interface IObservableCollection : IList, INotifyPropertyChanged, INotifyCollectionChanged { /// @@ -28,15 +28,14 @@ namespace Stylet /// /// Interface encapsulating IReadOnlyList and INotifyCollectionChanged /// - /// + /// The type of elements in the collection public interface IReadOnlyObservableCollection : IReadOnlyList, INotifyCollectionChanged, INotifyCollectionChanging - { - } + { } /// /// ObservableCollection subclass which supports AddRange and RemoveRange /// - /// + /// The type of elements in the collection public class BindableCollection : ObservableCollection, IObservableCollection, IReadOnlyObservableCollection { /// @@ -45,12 +44,13 @@ namespace Stylet private bool isNotifying = true; /// - /// Create a new empty BindableCollection + /// Initialises a new instance of the class /// - public BindableCollection() : base() { } + public BindableCollection() + { } /// - /// Create a new BindableCollection with the given members + /// Initialises a new instance of the class that contains the given members /// /// The collection from which the elements are copied public BindableCollection(IEnumerable collection) : base(collection) { } @@ -170,6 +170,8 @@ namespace Stylet /// Called by base class Collection<T> when an item is added to list; /// raises a CollectionChanged event to any listeners. /// + /// Index at which to insert the item + /// Item to insert protected override void InsertItem(int index, T item) { Execute.OnUIThreadSync(() => @@ -180,9 +182,11 @@ namespace Stylet } /// - /// Called by base class Collection<T> 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. /// + /// Index of the item to set + /// Item to set protected override void SetItem(int index, T item) { Execute.OnUIThreadSync(() => @@ -196,6 +200,7 @@ namespace Stylet /// Called by base class Collection<T> when an item is removed from list; /// raises a CollectionChanged event to any listeners. /// + /// Index of the item to remove protected override void RemoveItem(int index) { Execute.OnUIThreadSync(() => diff --git a/Stylet/Bootstrapper.cs b/Stylet/Bootstrapper.cs index a173fae..ad4b613 100644 --- a/Stylet/Bootstrapper.cs +++ b/Stylet/Bootstrapper.cs @@ -11,7 +11,7 @@ namespace Stylet public class Bootstrapper : BootstrapperBase where TRootViewModel : class { /// - /// 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. /// protected IContainer Container { get; set; } diff --git a/Stylet/BootstrapperBase.cs b/Stylet/BootstrapperBase.cs index 0361466..365b207 100644 --- a/Stylet/BootstrapperBase.cs +++ b/Stylet/BootstrapperBase.cs @@ -16,23 +16,23 @@ namespace Stylet public abstract class BootstrapperBase : IBootstrapper, IViewManagerConfig where TRootViewModel : class { /// - /// Reference to the current application + /// Gets the current application /// public Application Application { get; private set; } /// - /// 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 /// public IList Assemblies { get; protected set; } /// - /// 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. /// - public string[] Args { get; protected set; } + public string[] Args { get; private set; } /// - /// Instantiate a new BootstrapperBase + /// Initialises a new instance of the class /// public BootstrapperBase() { @@ -42,7 +42,7 @@ namespace Stylet /// /// Called by the ApplicationLoader when this bootstrapper is loaded /// - /// + /// Application within which Stylet is running 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); } /// /// Called on Application.Startup, this does everything necessary to start the application /// + /// Command-line arguments used to start this executable public virtual void Start(string[] args) { // Set this before anything else, so everything can use it @@ -108,12 +109,13 @@ namespace Stylet /// /// Hook called on application exit /// - /// + /// The exit event data protected virtual void OnExit(ExitEventArgs e) { } /// /// Hook called on an unhandled exception /// - protected virtual void OnApplicationUnhandledExecption(object sender, DispatcherUnhandledExceptionEventArgs e) { } + /// The event data + protected virtual void OnUnhandledExecption(DispatcherUnhandledExceptionEventArgs e) { } } } diff --git a/Stylet/Conductor.cs b/Stylet/Conductor.cs index 50fce38..00b9a5b 100644 --- a/Stylet/Conductor.cs +++ b/Stylet/Conductor.cs @@ -6,13 +6,13 @@ namespace Stylet /// /// Conductor with a single active item, and no other items /// - /// + /// Type of child to conduct public partial class Conductor : ConductorBaseWithActiveItem where T : class { /// /// Activate the given item, discarding the previous ActiveItem /// - /// + /// Item to active 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); - } /// /// Determine if this conductor can close. Depends on whether the ActiveItem can close /// + /// Task indicating whether this can be closed public override Task CanCloseAsync() { return this.CanCloseItem(this.ActiveItem); diff --git a/Stylet/ConductorAllActive.cs b/Stylet/ConductorAllActive.cs index b0d604d..7afece5 100644 --- a/Stylet/ConductorAllActive.cs +++ b/Stylet/ConductorAllActive.cs @@ -24,7 +24,7 @@ namespace Stylet private T[] itemsBeforeReset; /// - /// All items associated with this conductor + /// Gets all items associated with this conductor /// public IObservableCollection Items { @@ -32,7 +32,7 @@ namespace Stylet } /// - /// Creates a new Conductor{T}.Collection.AllActive + /// Initialises a new instance of the class /// public AllActive() { @@ -119,12 +119,13 @@ namespace Stylet foreach (var item in this.items) this.CloseAndCleanUp(item); - items.Clear(); + this.items.Clear(); } /// /// Determine if the conductor can close. Returns true if and when all items can close /// + /// A Task indicating whether this conductor can close public override Task CanCloseAsync() { return this.CanAllItemsCloseAsync(this.items); @@ -173,6 +174,7 @@ namespace Stylet /// /// Returns all children of this parent /// + /// All children associated with this conductor public override IEnumerable GetChildren() { return this.items; diff --git a/Stylet/ConductorBase.cs b/Stylet/ConductorBase.cs index 6014bb4..51d0fde 100644 --- a/Stylet/ConductorBase.cs +++ b/Stylet/ConductorBase.cs @@ -39,6 +39,7 @@ namespace Stylet /// /// Ensure an item is ready to be activated /// + /// Item to use protected virtual void EnsureItem(T newItem) { Debug.Assert(newItem != null); @@ -51,17 +52,19 @@ namespace Stylet /// /// Utility method to determine if all of the give items can close /// - protected virtual async Task CanAllItemsCloseAsync(IEnumerable toClose) + /// Items to close + /// Task indicating whether all items can close + protected virtual async Task CanAllItemsCloseAsync(IEnumerable 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); } /// /// Determine if the given item can be closed /// - /// - /// + /// Item to use + /// Task indicating whether the item can be closed protected virtual Task CanCloseItem(T item) { var itemAsGuardClose = item as IGuardClose; @@ -71,6 +74,11 @@ namespace Stylet return Task.FromResult(true); } + /// + /// Close the given child + /// + /// Child to close + /// Unused in this scenario void IChildDelegate.CloseItem(object item, bool? dialogResult) { T typedItem = item as T; diff --git a/Stylet/ConductorBaseWithActiveItem.cs b/Stylet/ConductorBaseWithActiveItem.cs index bdb37b3..fb20d11 100644 --- a/Stylet/ConductorBaseWithActiveItem.cs +++ b/Stylet/ConductorBaseWithActiveItem.cs @@ -6,13 +6,13 @@ namespace Stylet /// /// Base class for all conductors which had a single active item /// - /// + /// Type of item being conducted public abstract class ConductorBaseWithActiveItem : ConductorBase, IHaveActiveItem where T : class { private T _activeItem; /// - /// Item which is currently active + /// Gets or sets the item which is currently active /// public T ActiveItem { @@ -23,14 +23,17 @@ namespace Stylet /// /// From IParent, fetch all items /// + /// Children of this conductor public override IEnumerable GetChildren() { - return new[] { ActiveItem }; + return new[] { this.ActiveItem }; } /// /// Switch the active item to the given item /// + /// New item to activate + /// Whether the previously-active item should be closed protected virtual void ChangeActiveItem(T newItem, bool closePrevious) { ScreenExtensions.TryDeactivate(this.ActiveItem); @@ -73,5 +76,4 @@ namespace Stylet this.CloseAndCleanUp(this.ActiveItem); } } - } diff --git a/Stylet/ConductorNavigating.cs b/Stylet/ConductorNavigating.cs index b530699..aec4db8 100644 --- a/Stylet/ConductorNavigating.cs +++ b/Stylet/ConductorNavigating.cs @@ -64,7 +64,7 @@ namespace Stylet /// /// Close the given item. If it was the ActiveItem, activate the top item in the history stack /// - /// + /// Item to close public override async void CloseItem(T item) { if (item == null || !await this.CanCloseItem(item)) @@ -90,7 +90,7 @@ namespace Stylet /// /// Returns true if and when all items (ActiveItem + everything in the history stack) can close /// - /// + /// A task indicating whether this conductor can close public override Task CanCloseAsync() { return this.CanAllItemsCloseAsync(this.history.Concat(new[] { this.ActiveItem })); diff --git a/Stylet/ConductorOneActive.cs b/Stylet/ConductorOneActive.cs index c0bb6e8..6f52f3f 100644 --- a/Stylet/ConductorOneActive.cs +++ b/Stylet/ConductorOneActive.cs @@ -18,7 +18,7 @@ namespace Stylet private readonly BindableCollection items = new BindableCollection(); /// - /// Items owned by this Conductor, one of which is active + /// Gets the tems owned by this Conductor, one of which is active /// public IObservableCollection Items { @@ -26,7 +26,7 @@ namespace Stylet } /// - /// Create a new Conductor{T}.Collections.OneActive instance + /// Initialises a new instance of the class /// public OneActive() { @@ -71,7 +71,7 @@ namespace Stylet /// /// Return all items associated with this conductor /// - /// + /// All children associated with this conductor public override IEnumerable GetChildren() { return this.items; @@ -139,6 +139,7 @@ namespace Stylet /// /// Given a list of items, and and item which is going to be removed, choose a new item to be the next ActiveItem /// + /// Item to remove /// The next item to activate, or default(T) if no such item exists protected virtual T DetermineNextItemToActivate(T itemToRemove) { @@ -167,7 +168,7 @@ namespace Stylet /// /// Returns true if and when all children can close /// - /// + /// A task indicating whether this conductor can close public override Task CanCloseAsync() { return this.CanAllItemsCloseAsync(this.items); @@ -187,7 +188,7 @@ namespace Stylet /// /// Ensure an item is ready to be activated /// - /// + /// New item to ensure protected override void EnsureItem(T newItem) { if (!this.items.Contains(newItem)) diff --git a/Stylet/Execute.cs b/Stylet/Execute.cs index 28b7cc5..a0d3d6a 100644 --- a/Stylet/Execute.cs +++ b/Stylet/Execute.cs @@ -14,16 +14,14 @@ namespace Stylet private static IDispatcher _dispatcher; /// - /// Should be set to the UI thread's Dispatcher. This is normally done by the Bootstrapper. + /// Gets or sets Execute's dispatcher /// + /// + /// Should be set to the UI thread's Dispatcher. This is normally done by the Bootstrapper. + /// 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; /// - /// Default dispatcher used by PropertyChanged events. Defaults to OnUIThread + /// Gets or sets the default dispatcher used by PropertyChanged events. + /// Defaults to OnUIThread /// - public static Action DefaultPropertyChangedDispatcher = a => a(); + public static Action DefaultPropertyChangedDispatcher { get; set; } + + static Execute() + { + DefaultPropertyChangedDispatcher = a => a(); + } /// /// 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 } /// - /// 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 /// public static bool InDesignMode { diff --git a/Stylet/ExpressionExtensions.cs b/Stylet/ExpressionExtensions.cs index 3bb80cf..9ac7ac9 100644 --- a/Stylet/ExpressionExtensions.cs +++ b/Stylet/ExpressionExtensions.cs @@ -11,6 +11,8 @@ namespace Stylet /// /// Given a MemberExpression (or MemberExpression wrapped in a UnaryExpression), get the name of the property /// + /// Type of the delegate + /// Expression describe the property whose name we want to extract /// Name of the property referenced by the expression public static string NameForProperty(this Expression propertyExpression) { diff --git a/Stylet/IConductor.cs b/Stylet/IConductor.cs index 9453b8a..84813af 100644 --- a/Stylet/IConductor.cs +++ b/Stylet/IConductor.cs @@ -6,12 +6,13 @@ namespace Stylet /// /// Generalised parent, with many children /// + /// Type of children public interface IParent { /// /// Fetch all children of this parent /// - /// + /// All children owned by this parent IEnumerable GetChildren(); } @@ -22,7 +23,8 @@ namespace Stylet public interface IHaveActiveItem { /// - /// 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 /// T ActiveItem { get; set; } } @@ -43,6 +45,7 @@ namespace Stylet /// /// Thing which owns one or more children, and can manage their lifecycles accordingly /// + /// Type of child being conducted public interface IConductor { /// diff --git a/Stylet/IDispatcher.cs b/Stylet/IDispatcher.cs index 2e86024..4944fdb 100644 --- a/Stylet/IDispatcher.cs +++ b/Stylet/IDispatcher.cs @@ -15,15 +15,17 @@ namespace Stylet /// /// Execute asynchronously /// + /// Action to execute void Post(Action action); /// /// Execute synchronously /// + /// Action to execute void Send(Action action); /// - /// True if invocation isn't required + /// Gets a value indicating whether the current thread is the thread being dispatched to /// bool IsCurrent { get; } } diff --git a/Stylet/INotifyPropertyChangedDispatcher.cs b/Stylet/INotifyPropertyChangedDispatcher.cs index b3c354b..f3e2ddd 100644 --- a/Stylet/INotifyPropertyChangedDispatcher.cs +++ b/Stylet/INotifyPropertyChangedDispatcher.cs @@ -8,7 +8,8 @@ namespace Stylet public interface INotifyPropertyChangedDispatcher { /// - /// 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 /// Action PropertyChangedDispatcher { get; set; } } diff --git a/Stylet/IScreen.cs b/Stylet/IScreen.cs index c2f9066..8f418ae 100644 --- a/Stylet/IScreen.cs +++ b/Stylet/IScreen.cs @@ -10,7 +10,7 @@ namespace Stylet public interface IViewAware { /// - /// The view associated with this ViewModel + /// Gets the view associated with this ViewModel /// UIElement View { get; } @@ -76,7 +76,7 @@ namespace Stylet public interface IHaveDisplayName { /// - /// Name which should be displayed + /// Gets or sets the name which should be displayed /// string DisplayName { get; set; } } @@ -87,7 +87,7 @@ namespace Stylet public interface IChild { /// - /// Parent object to this child + /// Gets or sets the parent object to this child /// object Parent { get; set; } } @@ -101,6 +101,7 @@ namespace Stylet /// /// Returns whether or not the object can close, potentially asynchronously /// + /// A task indicating whether the object can close Task CanCloseAsync(); } diff --git a/Stylet/IValidationAdapter.cs b/Stylet/IValidationAdapter.cs index a065200..b76b271 100644 --- a/Stylet/IValidationAdapter.cs +++ b/Stylet/IValidationAdapter.cs @@ -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. /// - /// + /// Type of model being validated public interface IModelValidator : 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 /// - /// + /// Subject to initialize void Initialize(object subject); /// diff --git a/Stylet/LabelledValue.cs b/Stylet/LabelledValue.cs index 3daefeb..3bc2106 100644 --- a/Stylet/LabelledValue.cs +++ b/Stylet/LabelledValue.cs @@ -10,34 +10,36 @@ namespace Stylet public class LabelledValue : PropertyChangedBase, IEquatable> { private string _label; + /// - /// 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 /// public string Label { get { return this._label; } - set { SetAndNotify(ref this._label, value); } + set { this.SetAndNotify(ref this._label, value); } } private T _value; + /// - /// 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 /// public T Value { get { return this._value; } - set { SetAndNotify(ref this._value, value); } + set { this.SetAndNotify(ref this._value, value); } } /// - /// Create a new LabelledValue, without setting Label or Value + /// Initialises a new instance of the class, without setting Label or Value /// public LabelledValue() { } /// - /// Create a new LabelledValue, with the given label and value + /// Initialises a new instance of the class, with the given label and value /// /// Label to use. This value is displayed in your view /// Value to use. This is used by your ViewModel @@ -97,6 +99,10 @@ namespace Stylet /// /// Construct a new LabelledValue{T}, using method type inference /// + /// Type of value + /// Label to assign + /// Value to assign + /// Constructed LabelledValue{T} public static LabelledValue Create(string label, T value) { return new LabelledValue(label, value); diff --git a/Stylet/Logging/LogManager.cs b/Stylet/Logging/LogManager.cs index ad68157..4135f4e 100644 --- a/Stylet/Logging/LogManager.cs +++ b/Stylet/Logging/LogManager.cs @@ -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; /// - /// Create a new DebugLogger with the given name + /// Initialises a new instance of the class, with the given name /// /// Name of the DebugLogger public TraceLogger(string name) @@ -115,21 +116,26 @@ namespace Stylet.Logging private static readonly ILogger nullLogger = new NullLogger(); /// - /// Set to true to enable logging + /// Gets or sets a value indicating whether logging is enabled /// /// /// When false (the default), a null logger will be returned by GetLogger(). /// When true, LoggerFactory will be used to create a new logger /// - public static bool Enabled; + public static bool Enabled { get; set; } /// - /// Factory used to create new ILoggers, used by GetLogger + /// Gets or sets the factory used to create new ILoggers, used by GetLogger /// - /// - /// e.g. LogManager.LoggerFactory = name => new MyLogger(name); - /// - public static Func LoggerFactory = name => new TraceLogger(name); + /// + /// LogManager.LoggerFactory = name => new MyLogger(name); + /// + public static Func LoggerFactory { get; set; } + + static LogManager() + { + LoggerFactory = name => new TraceLogger(name); + } /// /// Get a new ILogger for the given type diff --git a/Stylet/MessageBoxViewModel.cs b/Stylet/MessageBoxViewModel.cs index dfdd88e..8f1fcd1 100644 --- a/Stylet/MessageBoxViewModel.cs +++ b/Stylet/MessageBoxViewModel.cs @@ -23,7 +23,9 @@ namespace Stylet /// A System.Windows.MessageBoxResult value that specifies the cancel result of the message box /// A System.Windows.MessageBoxOptions value object that specifies the options. /// A dictionary specifying the button labels, if desirable - 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 buttonLabels = null); /// - /// After the user has clicked a button, holds which button was clicked + /// Gets the button clicked by the user, after they've clicked it /// MessageBoxResult ClickedButton { get; } } @@ -43,22 +45,22 @@ namespace Stylet public class MessageBoxViewModel : Screen, IMessageBoxViewModel { /// - /// 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. /// public static IDictionary ButtonLabels { get; set; } /// - /// 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 /// public static IDictionary ButtonToResults { get; set; } /// - /// 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. /// public static IDictionary IconMapping { get; set; } /// - /// 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. /// public static IDictionary 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() @@ -111,7 +113,9 @@ namespace Stylet /// A System.Windows.MessageBoxResult value that specifies the cancel result of the message box /// A System.Windows.MessageBoxOptions value object that specifies the options. /// A dictionary specifying the button labels, if desirable - 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 } /// - /// List of buttons which are shown in the View. + /// Gets or sets the list of buttons which are shown in the View. /// public IEnumerable> ButtonList { get; protected set; } /// - /// Item in ButtonList which is the Default button + /// Gets or sets the item in ButtonList which is the Default button /// public LabelledValue DefaultButton { get; protected set; } /// - /// Item in ButtonList which is the Cancel button + /// Gets or sets the item in ButtonList which is the Cancel button /// public LabelledValue CancelButton { get; protected set; } /// - /// Text which is shown in the body of the MessageBox + /// Gets or sets the text which is shown in the body of the MessageBox /// public virtual string Text { get; protected set; } /// - /// Icon which the user specified + /// Gets or sets the icon which the user specified /// public virtual MessageBoxImage Icon { get; protected set; } /// - /// 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 /// public virtual Icon ImageIcon { @@ -192,17 +196,17 @@ namespace Stylet } /// - /// Which way the document should flow + /// Gets or sets which way the document should flow /// public virtual FlowDirection FlowDirection { get; protected set; } /// - /// Text alignment of the message + /// Gets or sets the text alignment of the message /// public virtual TextAlignment TextAlignment { get; protected set; } /// - /// 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 /// public virtual MessageBoxResult ClickedButton { get; protected set; } diff --git a/Stylet/PropertyChangedBase.cs b/Stylet/PropertyChangedBase.cs index 7ef5d0f..c6a9ed5 100644 --- a/Stylet/PropertyChangedBase.cs +++ b/Stylet/PropertyChangedBase.cs @@ -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 _propertyChangedDispatcher = Execute.DefaultPropertyChangedDispatcher; + /// - /// 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 /// [System.Xml.Serialization.XmlIgnore] public virtual Action PropertyChangedDispatcher @@ -38,6 +40,7 @@ namespace Stylet /// /// Raise a PropertyChanged notification from the property in the given expression, e.g. NotifyOfPropertyChange(() => this.Property) /// + /// Type of property being notified /// Expression describing the property to raise a PropertyChanged notification for protected virtual void NotifyOfPropertyChange(Expression> property) { @@ -75,6 +78,7 @@ namespace Stylet /// /// Takes, by reference, a field, and its new value. If field != value, will set field = value and raise a PropertyChanged notification /// + /// Type of field being set and notified /// Field to assign /// Value to assign to the field, if it differs /// Name of the property to notify for. Defaults to the calling property diff --git a/Stylet/PropertyChangedExtensions.cs b/Stylet/PropertyChangedExtensions.cs index 9e653d2..2335a37 100644 --- a/Stylet/PropertyChangedExtensions.cs +++ b/Stylet/PropertyChangedExtensions.cs @@ -10,16 +10,16 @@ namespace Stylet /// /// Extension of PropertyChangedEventArgs, which includes the new value of the property /// - /// + /// Type of property being notified public class PropertyChangedExtendedEventArgs : PropertyChangedEventArgs { /// - /// New value of the property + /// Gets the new value of the property /// public virtual TProperty NewValue { get; private set; } /// - /// Instantiate a new PropertyChangedExtendedEventArgs + /// Initialises a new instance of the class /// /// Name of the property which changed /// New value of the property which changed @@ -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 /// /// someObject.Bind(x => x.PropertyNameToBindTo, newValue => /* do something with the new value */) + /// Type of object providing the PropertyChanged event + /// Type of property for which the event is raised /// Object raising the PropertyChanged event you're interested in /// MemberExpression selecting the property to observe for changes (e.g x => x.PropertyName) /// Handler called whenever that property changed @@ -156,6 +158,8 @@ namespace Stylet /// Weakly bind to PropertyChanged events for a particular property on a particular object /// /// someObject.Bind(x => x.PropertyNameToBindTo, newValue => /* do something with the new value */) + /// Type of object providing the PropertyChanged event + /// Type of property for which the event is raised /// Object raising the PropertyChanged event you're interested in /// MemberExpression selecting the property to observe for changes (e.g x => x.PropertyName) /// Handler called whenever that property changed diff --git a/Stylet/Screen.cs b/Stylet/Screen.cs index d4900f4..86c1394 100644 --- a/Stylet/Screen.cs +++ b/Stylet/Screen.cs @@ -14,12 +14,12 @@ namespace Stylet private readonly ILogger logger; /// - /// Create a new Screen instance (without setting up a validator) + /// Initialises a new instance of the class, without setting up a validator /// public Screen() : this(null) { } /// - /// Create a new screen instance, which can validate properties using the given validator + /// Initialises a new instance of the class, which can validate properties using the given validator /// /// Validator to use [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; /// - /// 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 /// 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; + /// - /// True if this Screen is currently active + /// Gets or sets a value indicating whether this Screen is currently active /// 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 /// - /// 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 /// 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; + /// - /// 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 /// 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 /// /// Request that the conductor responsible for this screen close it /// - /// + /// DialogResult to return, if this is a dialog 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; } } diff --git a/Stylet/ScreenExtensions.cs b/Stylet/ScreenExtensions.cs index 2cbe5c3..2b32993 100644 --- a/Stylet/ScreenExtensions.cs +++ b/Stylet/ScreenExtensions.cs @@ -49,6 +49,8 @@ namespace Stylet /// Activate the child whenever the parent is activated /// /// child.ActivateWith(this) + /// Child to activate whenever the parent is activated + /// Parent to observe public static void ActivateWith(this IActivate child, IActivate parent) { WeakEventManager.AddHandler(parent, "Activated", (o, e) => child.Activate()); @@ -58,6 +60,8 @@ namespace Stylet /// Deactivate the child whenever the parent is deactivated /// /// child.DeactivateWith(this) + /// Child to deactivate whenever the parent is deacgtivated + /// Parent to observe public static void DeactivateWith(this IDeactivate child, IDeactivate parent) { WeakEventManager.AddHandler(parent, "Deactivated", (o, e) => child.Deactivate()); @@ -67,6 +71,8 @@ namespace Stylet /// Close the child whenever the parent is closed /// /// child.CloseWith(this) + /// Child to close when the parent is closed + /// Parent to observe 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 /// /// child.ConductWith(this) + /// Type of the child + /// Type of the parent + /// Child to conduct with the parent + /// Parent to observe public static void ConductWith(this TChild child, TParent parent) where TChild : IActivate, IDeactivate, IClose where TParent : IActivate, IDeactivate, IClose diff --git a/Stylet/Settings.StyleCop b/Stylet/Settings.StyleCop new file mode 100644 index 0000000..90fb9b1 --- /dev/null +++ b/Stylet/Settings.StyleCop @@ -0,0 +1,212 @@ + + + NoMerge + en-GB + + + + + + + False + + + + + False + + + + + False + + + + + False + + + + + False + + + + + + + + + + False + + + + + False + + + + + False + + + + + False + + + + + False + + + + + + + + + + False + + + + + False + + + + + + il + in + is + + + + + + + + False + + + + + False + + + + + False + + + + + + + + + + False + + + + + False + + + + + False + + + + + False + + + + + False + + + + + False + + + + + False + + + + + False + + + + + + + + + + False + + + + + False + + + + + False + + + + + False + + + + + False + + + + + False + + + + + False + + + + + False + + + + + False + + + + + False + + + + + True + True + + + + \ No newline at end of file diff --git a/Stylet/Stylet.csproj b/Stylet/Stylet.csproj index 22249cb..9d41374 100644 --- a/Stylet/Stylet.csproj +++ b/Stylet/Stylet.csproj @@ -63,7 +63,9 @@ - + + False + diff --git a/Stylet/StyletConductorExtensions.cs b/Stylet/StyletConductorExtensions.cs index b089b7f..7b56e23 100644 --- a/Stylet/StyletConductorExtensions.cs +++ b/Stylet/StyletConductorExtensions.cs @@ -5,6 +5,7 @@ using System.Linq; namespace Stylet { // Don't name ConductorExtensions, otherwise it's too obvious when someone types 'Conductor' + /// /// Extension methods used by the Conductor classes /// diff --git a/Stylet/StyletIoC/Creation/BuilderUpper.cs b/Stylet/StyletIoC/Creation/BuilderUpper.cs index 67c518c..2080ed3 100644 --- a/Stylet/StyletIoC/Creation/BuilderUpper.cs +++ b/Stylet/StyletIoC/Creation/BuilderUpper.cs @@ -16,7 +16,7 @@ namespace StyletIoC.Creation private Action implementor; /// - /// Instantiate a new BuilderUpper + /// Initialises a new instance of the class /// /// Type of object that the BuilderUpper will work on /// IRegistrationContext on which this BuilderUpper is registered diff --git a/Stylet/StyletIoC/Creation/ICreator.cs b/Stylet/StyletIoC/Creation/ICreator.cs index b54896f..2049aa5 100644 --- a/Stylet/StyletIoC/Creation/ICreator.cs +++ b/Stylet/StyletIoC/Creation/ICreator.cs @@ -9,13 +9,14 @@ namespace StyletIoC.Creation public interface ICreator { /// - /// Type of object that will be created + /// Gets the type of object that will be created /// Type Type { get; } /// /// Fetches an expression evaluating to an instance on demand /// + /// Context which calls this method /// An expression evaluating to an instance of the specified Type Expression GetInstanceExpression(ParameterExpression registrationContext); } diff --git a/Stylet/StyletIoC/Creation/IRegistration.cs b/Stylet/StyletIoC/Creation/IRegistration.cs index eefbdd1..93c3aae 100644 --- a/Stylet/StyletIoC/Creation/IRegistration.cs +++ b/Stylet/StyletIoC/Creation/IRegistration.cs @@ -20,7 +20,7 @@ namespace StyletIoC.Creation public interface IRegistration { /// - /// Type of the object returned by the registration + /// Gets the type of the object returned by the registration /// Type Type { get; } @@ -33,6 +33,7 @@ namespace StyletIoC.Creation /// /// Fetches an expression which evaluates to an instance of the relevant type /// + /// Context which calls this method /// An expression evaluating to an instance of type Type, which is supplied by the ICreator> Expression GetInstanceExpression(ParameterExpression registrationContext); } diff --git a/Stylet/StyletIoC/IContainer.cs b/Stylet/StyletIoC/IContainer.cs index 455055e..48bb97a 100644 --- a/Stylet/StyletIoC/IContainer.cs +++ b/Stylet/StyletIoC/IContainer.cs @@ -52,7 +52,7 @@ namespace StyletIoC /// /// If IEnumerable{T}, will fetch all implementations of T, otherwise wil fetch a single T /// Key that implementations of the service to fetch were registered with, defaults to null - /// + /// The resolved result object GetTypeOrAll(Type type, string key = null); /// @@ -60,7 +60,7 @@ namespace StyletIoC /// /// If IEnumerable{T}, will fetch all implementations of T, otherwise wil fetch a single T /// Key that implementations of the service to fetch were registered with, defaults to null - /// + /// The resolved result T GetTypeOrAll(string key = null); /// diff --git a/Stylet/StyletIoC/InjectAttribute.cs b/Stylet/StyletIoC/InjectAttribute.cs index f2e518b..3c72fac 100644 --- a/Stylet/StyletIoC/InjectAttribute.cs +++ b/Stylet/StyletIoC/InjectAttribute.cs @@ -9,23 +9,23 @@ namespace StyletIoC public sealed class InjectAttribute : Attribute { /// - /// Create a new InjectAttribute + /// Initialises a new instance of the class /// public InjectAttribute() { } /// - /// Create a new InjectAttribute, which has the specified key + /// Initialises a new instance of the class, which has the specified key /// - /// + /// Key to associate (meaning depends on context) public InjectAttribute(string key) { this.Key = key; } /// - /// Key to use to resolve the relevant dependency + /// Gets or sets the key to use to resolve the relevant dependency /// public string Key { get; set; } } diff --git a/Stylet/StyletIoC/Internal/Builders/BuilderAbstractFactoryBinding.cs b/Stylet/StyletIoC/Internal/Builders/BuilderAbstractFactoryBinding.cs index 5410a12..080883f 100644 --- a/Stylet/StyletIoC/Internal/Builders/BuilderAbstractFactoryBinding.cs +++ b/Stylet/StyletIoC/Internal/Builders/BuilderAbstractFactoryBinding.cs @@ -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); } } } diff --git a/Stylet/StyletIoC/Internal/Builders/BuilderBindingBase.cs b/Stylet/StyletIoC/Internal/Builders/BuilderBindingBase.cs index 1ebdfea..9170f6f 100644 --- a/Stylet/StyletIoC/Internal/Builders/BuilderBindingBase.cs +++ b/Stylet/StyletIoC/Internal/Builders/BuilderBindingBase.cs @@ -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; } /// /// Modify the scope of the binding to Singleton. One instance of this implementation will be generated for this binding. /// + /// Fluent interface to continue configuration 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) diff --git a/Stylet/StyletIoC/Internal/Builders/BuilderFactoryBinding.cs b/Stylet/StyletIoC/Internal/Builders/BuilderFactoryBinding.cs index 9085e66..05bbffa 100644 --- a/Stylet/StyletIoC/Internal/Builders/BuilderFactoryBinding.cs +++ b/Stylet/StyletIoC/Internal/Builders/BuilderFactoryBinding.cs @@ -11,8 +11,8 @@ namespace StyletIoC.Internal.Builders public BuilderFactoryBinding(Type serviceType, Func 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(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); } } } diff --git a/Stylet/StyletIoC/Internal/Builders/BuilderInstanceBinding.cs b/Stylet/StyletIoC/Internal/Builders/BuilderInstanceBinding.cs index a87a39f..a0979bf 100644 --- a/Stylet/StyletIoC/Internal/Builders/BuilderInstanceBinding.cs +++ b/Stylet/StyletIoC/Internal/Builders/BuilderInstanceBinding.cs @@ -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); } } } diff --git a/Stylet/StyletIoC/Internal/Builders/BuilderToAllImplementationsBinding.cs b/Stylet/StyletIoC/Internal/Builders/BuilderToAllImplementationsBinding.cs index 8b3fe24..2323b87 100644 --- a/Stylet/StyletIoC/Internal/Builders/BuilderToAllImplementationsBinding.cs +++ b/Stylet/StyletIoC/Internal/Builders/BuilderToAllImplementationsBinding.cs @@ -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 } } } - } diff --git a/Stylet/StyletIoC/Internal/Container.cs b/Stylet/StyletIoC/Internal/Container.cs index 6edfda0..1715484 100644 --- a/Stylet/StyletIoC/Internal/Container.cs +++ b/Stylet/StyletIoC/Internal/Container.cs @@ -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 { /// @@ -162,8 +166,6 @@ namespace StyletIoC.Internal return true; } - - // Is it a 'get all' request? IRegistration registration; return this.TryRetrieveGetAllRegistration(typeKey, out registration); diff --git a/Stylet/StyletIoC/Internal/Creators/CreatorBase.cs b/Stylet/StyletIoC/Internal/Creators/CreatorBase.cs index 8b31346..8d07337 100644 --- a/Stylet/StyletIoC/Internal/Creators/CreatorBase.cs +++ b/Stylet/StyletIoC/Internal/Creators/CreatorBase.cs @@ -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(.....) diff --git a/Stylet/StyletIoC/Internal/Creators/FactoryCreator.cs b/Stylet/StyletIoC/Internal/Creators/FactoryCreator.cs index 0610353..f56c1d4 100644 --- a/Stylet/StyletIoC/Internal/Creators/FactoryCreator.cs +++ b/Stylet/StyletIoC/Internal/Creators/FactoryCreator.cs @@ -7,6 +7,7 @@ namespace StyletIoC.Internal.Creators /// /// Knows how to create an instance of a type, by using a Func{IRegistration, T} passed by the user during building /// + /// Type of object created by this factory internal class FactoryCreator : CreatorBase { private readonly Func factory; diff --git a/Stylet/StyletIoC/Internal/Creators/TypeCreator.cs b/Stylet/StyletIoC/Internal/Creators/TypeCreator.cs index f45ce3a..ebabb29 100644 --- a/Stylet/StyletIoC/Internal/Creators/TypeCreator.cs +++ b/Stylet/StyletIoC/Internal/Creators/TypeCreator.cs @@ -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(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 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) { diff --git a/Stylet/StyletIoC/Internal/RegistrationCollections/RegistrationCollection.cs b/Stylet/StyletIoC/Internal/RegistrationCollections/RegistrationCollection.cs index 8015db6..ac6f2d6 100644 --- a/Stylet/StyletIoC/Internal/RegistrationCollections/RegistrationCollection.cs +++ b/Stylet/StyletIoC/Internal/RegistrationCollections/RegistrationCollection.cs @@ -23,7 +23,7 @@ namespace StyletIoC.Internal.RegistrationCollections public List GetAll() { List registrationsCopy; - lock (this.registrationsLock) { registrationsCopy = registrations.ToList(); } + lock (this.registrationsLock) { registrationsCopy = this.registrations.ToList(); } return registrationsCopy; } diff --git a/Stylet/StyletIoC/Internal/Registrations/FuncNoKeyRegistration.cs b/Stylet/StyletIoC/Internal/Registrations/FuncNoKeyRegistration.cs index b152ad3..3253226 100644 --- a/Stylet/StyletIoC/Internal/Registrations/FuncNoKeyRegistration.cs +++ b/Stylet/StyletIoC/Internal/Registrations/FuncNoKeyRegistration.cs @@ -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 generator; + private IRegistration delegateRegistration; public Type Type { diff --git a/Stylet/StyletIoC/Internal/Registrations/RegistrationBase.cs b/Stylet/StyletIoC/Internal/Registrations/RegistrationBase.cs index 851daa2..2445695 100644 --- a/Stylet/StyletIoC/Internal/Registrations/RegistrationBase.cs +++ b/Stylet/StyletIoC/Internal/Registrations/RegistrationBase.cs @@ -9,29 +9,25 @@ namespace StyletIoC.Internal.Registrations /// 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 generator; + protected Func Generator { get; set; } public RegistrationBase(ICreator creator) { - this.creator = creator; + this.Creator = creator; } public virtual Func 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()); } } diff --git a/Stylet/StyletIoC/Internal/Registrations/SingletonRegistration.cs b/Stylet/StyletIoC/Internal/Registrations/SingletonRegistration.cs index 07e5eed..a3ac5a7 100644 --- a/Stylet/StyletIoC/Internal/Registrations/SingletonRegistration.cs +++ b/Stylet/StyletIoC/Internal/Registrations/SingletonRegistration.cs @@ -10,9 +10,9 @@ namespace StyletIoC.Internal.Registrations /// 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>(this.creator.GetInstanceExpression(registrationContext), registrationContext).Compile()(this.parentContext); + this.instance = Expression.Lambda>(this.Creator.GetInstanceExpression(registrationContext), registrationContext).Compile()(this.parentContext); // This expression yields the actual type of instance, not 'object' var instanceExpression = Expression.Constant(this.instance); diff --git a/Stylet/StyletIoC/Internal/Registrations/TransientRegistration.cs b/Stylet/StyletIoC/Internal/Registrations/TransientRegistration.cs index 9be7689..1177bad 100644 --- a/Stylet/StyletIoC/Internal/Registrations/TransientRegistration.cs +++ b/Stylet/StyletIoC/Internal/Registrations/TransientRegistration.cs @@ -12,7 +12,7 @@ namespace StyletIoC.Internal.Registrations public override Expression GetInstanceExpression(ParameterExpression registrationContext) { - return this.creator.GetInstanceExpression(registrationContext); + return this.Creator.GetInstanceExpression(registrationContext); } } } diff --git a/Stylet/StyletIoC/Internal/TypeExtensions.cs b/Stylet/StyletIoC/Internal/TypeExtensions.cs index b00ae73..580b2f3 100644 --- a/Stylet/StyletIoC/Internal/TypeExtensions.cs +++ b/Stylet/StyletIoC/Internal/TypeExtensions.cs @@ -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 { diff --git a/Stylet/StyletIoC/Internal/UnboundGeneric.cs b/Stylet/StyletIoC/Internal/UnboundGeneric.cs index 5a11f61..b447d1e 100644 --- a/Stylet/StyletIoC/Internal/UnboundGeneric.cs +++ b/Stylet/StyletIoC/Internal/UnboundGeneric.cs @@ -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; } diff --git a/Stylet/StyletIoC/StyletIoCBuilder.cs b/Stylet/StyletIoC/StyletIoCBuilder.cs index 5bca561..6f8ebdd 100644 --- a/Stylet/StyletIoC/StyletIoCBuilder.cs +++ b/Stylet/StyletIoC/StyletIoCBuilder.cs @@ -18,19 +18,21 @@ namespace StyletIoC /// /// Bind the specified service to itself - if you self-bind MyClass, and request an instance of MyClass, you'll get an instance of MyClass. /// - /// + /// Fluent interface to continue configuration IInScopeOrWithKeyOrAsWeakBinding ToSelf(); /// /// 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. /// /// Type to bind the service to + /// Fluent interface to continue configuration IInScopeOrWithKeyOrAsWeakBinding To(Type implementationType); /// /// 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. /// /// Type to bind the service to + /// Fluent interface to continue configuration IInScopeOrWithKeyOrAsWeakBinding To(); /// @@ -38,29 +40,34 @@ namespace StyletIoC /// /// Type returned by the factory delegate. Must implement the service /// Factory delegate to bind got + /// Fluent interface to continue configuration IInScopeOrWithKeyOrAsWeakBinding ToFactory(Func factory); /// /// Bind the specified service to the given untyped instance /// /// Instance to use + /// Fluent interface to continue configuration IWithKeyOrAsWeakBinding ToInstance(object instance); /// /// 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. /// + /// Fluent interface to continue configuration IWithKeyOrAsWeakBinding ToAbstractFactory(); /// /// Discover all implementations of the service in the specified assemblies / the current assembly, and bind those to the service /// /// Assemblies to search. If empty / null, searches the current assembly + /// Fluent interface to continue configuration IInScopeOrWithKeyOrAsWeakBinding ToAllImplementations(IEnumerable assemblies); /// /// Discover all implementations of the service in the specified assemblies / the current assembly, and bind those to the service /// /// Assemblies to search. If empty / null, searches the current assembly + /// Fluent interface to continue configuration IInScopeOrWithKeyOrAsWeakBinding ToAllImplementations(params Assembly[] assemblies); } @@ -73,15 +80,19 @@ namespace StyletIoC /// Mark the binding as weak /// /// + /// /// 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. - /// + /// + /// /// 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. - /// + /// + /// /// This is also used by AutoBind when self-binding concrete types, for the sme reason. + /// /// 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 /// /// Key to associate with this binding + /// Fluent interface to continue configuration IAsWeakBinding WithKey(string key); } @@ -107,11 +119,13 @@ namespace StyletIoC /// Specify a factory that creates an IRegistration to use for this binding /// /// Registration factory to use + /// Fluent interface to continue configuration IAsWeakBinding WithRegistrationFactory(RegistrationFactory registrationFactory); /// /// Modify the scope of the binding to Singleton. One instance of this implementation will be generated for this binding. /// + /// Fluent interface to continue configuration 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 /// /// Key to associate with this binding + /// Fluent interface to continue configuration IInScopeOrAsWeakBinding WithKey(string key); } @@ -136,12 +151,14 @@ namespace StyletIoC /// Bind the specified service (interface, abstract class, concrete class, unbound generic, etc) to something /// /// Service to bind + /// Fluent interface to continue configuration IBindTo Bind(Type serviceType); /// /// Bind the specified service (interface, abstract class, concrete class, unbound generic, etc) to something /// /// Service to bind + /// Fluent interface to continue configuration IBindTo Bind(); /// @@ -172,12 +189,12 @@ namespace StyletIoC private readonly List modules = new List(); /// - /// Create a new StyletIoC builder instance + /// Initialises a new instance of the class /// public StyletIoCBuilder() { } /// - /// Create a new StyletIoC builder instanc, which contains the given modules + /// Initialises a new instance of the class, which contains the given modules /// /// Modules to add to the builder 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 /// /// Service to bind + /// Fluent interface to continue configuration 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 /// /// Service to bind + /// Fluent interface to continue configuration public IBindTo Bind() { 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) { diff --git a/Stylet/StyletIoC/StyletIoCModule.cs b/Stylet/StyletIoC/StyletIoCModule.cs index 1ec1200..b7908d5 100644 --- a/Stylet/StyletIoC/StyletIoCModule.cs +++ b/Stylet/StyletIoC/StyletIoCModule.cs @@ -18,6 +18,7 @@ namespace StyletIoC /// Bind the specified service (interface, abstract class, concrete class, unbound generic, etc) to something /// /// Service to bind + /// Fluent interface to continue configuration 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 /// /// Service to bind + /// Fluent interface to continue configuration protected IBindTo Bind() { return this.Bind(typeof(TService)); diff --git a/Stylet/ValidatingModelBase.cs b/Stylet/ValidatingModelBase.cs index 16ffe86..341a7d7 100644 --- a/Stylet/ValidatingModelBase.cs +++ b/Stylet/ValidatingModelBase.cs @@ -13,8 +13,7 @@ namespace Stylet /// /// Base for ViewModels which require property validation /// - [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 { /// @@ -27,7 +26,7 @@ namespace Stylet private IModelValidator _validator; /// - /// 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 /// protected virtual IModelValidator Validator { @@ -41,12 +40,12 @@ namespace Stylet } /// - /// 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 /// protected bool AutoValidate { get; set; } /// - /// Instantiate, without using an IValidatorAdapter + /// Initialises a new instance of the class, without using an /// public ValidatingModelBase() { @@ -54,7 +53,7 @@ namespace Stylet } /// - /// Instantiate, using the specified IValidatorAdapter + /// Initialises a new instance of the class, using the specifies /// /// Validator adapter to use to perform validations public ValidatingModelBase(IModelValidator validator) : this() @@ -143,6 +142,7 @@ namespace Stylet /// /// Validate a single property synchronously, by name /// + /// Type of property to validate /// Expression describing the property to validate /// True if the property validated successfully protected virtual bool ValidateProperty(Expression> property) @@ -153,6 +153,7 @@ namespace Stylet /// /// Validate a single property asynchronously, by name /// + /// Type ofproperty to validate /// Expression describing the property to validate /// True if the property validated successfully protected virtual Task ValidatePropertyAsync(Expression> property) @@ -217,7 +218,8 @@ namespace Stylet /// /// Raise a PropertyChanged notification for the named property, and validate that property if this.validation is set and this.autoValidate is true /// - /// + /// Name of the property which has changed + [EditorBrowsable(EditorBrowsableState.Never)] protected override async void OnPropertyChanged(string propertyName) { base.OnPropertyChanged(propertyName); @@ -231,6 +233,7 @@ namespace Stylet /// /// Called whenever the error state of any properties changes. Calls NotifyOfPropertyChange(() => this.HasErrors) by default /// + /// List of property names which have changed validation state protected virtual void OnValidationStateChanged(IEnumerable changedProperties) { this.NotifyOfPropertyChange(() => this.HasErrors); @@ -273,7 +276,7 @@ namespace Stylet } /// - /// Gets a value that indicates whether the entity has validation errors. + /// Gets a value indicating whether the entity has validation errors. /// public bool HasErrors { diff --git a/Stylet/ViewManager.cs b/Stylet/ViewManager.cs index 112e112..357514a 100644 --- a/Stylet/ViewManager.cs +++ b/Stylet/ViewManager.cs @@ -36,7 +36,7 @@ namespace Stylet public interface IViewManagerConfig { /// - /// 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 /// IList Assemblies { get; } @@ -57,19 +57,19 @@ namespace Stylet private static readonly ILogger logger = LogManager.GetLogger(typeof(ViewManager)); /// - /// Assemblies searched for View types + /// Gets or sets the assemblies searched for View types /// protected IList Assemblies { get; set; } /// - /// Factory used to create view instances from their type + /// Gets or sets the factory used to create view instances from their type /// protected Func ViewFactory { get; set; } /// - /// Create a new ViewManager, with the given viewFactory + /// Initialises a new instance of the class, with the given viewFactory /// - /// Configuration + /// Configuration to use public ViewManager(IViewManagerConfig config) { this.Assemblies = config.Assemblies; @@ -240,7 +240,7 @@ namespace Stylet public readonly string ViewTypeName; /// - /// Create a new StyletViewLocationException + /// Initialises a new instance of the class /// /// Message associated with the Exception /// Name of the View this question was thrown for diff --git a/Stylet/WindowManager.cs b/Stylet/WindowManager.cs index 961fb12..d59378e 100644 --- a/Stylet/WindowManager.cs +++ b/Stylet/WindowManager.cs @@ -37,6 +37,7 @@ namespace Stylet /// A System.Windows.MessageBoxResult value that specifies the cancel result of the message box /// A System.Windows.MessageBoxOptions value object that specifies the options. /// A dictionary specifying the button labels, if desirable + /// The result chosen by the user MessageBoxResult ShowMessageBox(string messageBoxText, string caption = null, MessageBoxButton buttons = MessageBoxButton.OK, MessageBoxImage icon = MessageBoxImage.None, @@ -56,7 +57,7 @@ namespace Stylet private readonly Func messageBoxViewModelFactory; /// - /// Create a new WindowManager instance, using the given IViewManager + /// Initialises a new instance of the class, using the given /// /// IViewManager to use when creating views /// Delegate which returns a new IMessageBoxViewModel instance when invoked @@ -96,6 +97,7 @@ namespace Stylet /// A System.Windows.MessageBoxResult value that specifies the cancel result of the message box /// A System.Windows.MessageBoxOptions value object that specifies the options. /// A dictionary specifying the button labels, if desirable + /// The result chosen by the user 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().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); } - /// - /// Closing event from the window - /// private async void WindowClosing(object sender, CancelEventArgs e) { if (e.Cancel) @@ -256,6 +259,8 @@ namespace Stylet /// /// Close was requested by the child /// + /// Item to close + /// DialogResult to close with, if it's a dialog async void IChildDelegate.CloseItem(object item, bool? dialogResult) { if (item != this.viewModel) diff --git a/Stylet/Xaml/ActionExtension.cs b/Stylet/Xaml/ActionExtension.cs index e2f96c7..1e34660 100644 --- a/Stylet/Xaml/ActionExtension.cs +++ b/Stylet/Xaml/ActionExtension.cs @@ -30,7 +30,7 @@ namespace Stylet.Xaml /// Throw an exception /// Throw - }; + } /// /// MarkupExtension used for binding Commands and Events to methods on the View.ActionTarget @@ -38,22 +38,22 @@ namespace Stylet.Xaml public class ActionExtension : MarkupExtension { /// - /// Name of the method to call + /// Gets or sets the name of the method to call /// public string Method { get; set; } /// - /// Behaviour if the View.ActionTarget is nulil + /// Gets or sets the behaviour if the View.ActionTarget is nulil /// public ActionUnavailableBehaviour NullTarget { get; set; } /// - /// 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 /// public ActionUnavailableBehaviour ActionNotFound { get; set; } /// - /// Create a new ActionExtension + /// Initialises a new instance of the class /// /// Name of the method to call public ActionExtension(string method) diff --git a/Stylet/Xaml/ApplicationLoader.cs b/Stylet/Xaml/ApplicationLoader.cs index b9e6a78..b0690a3 100644 --- a/Stylet/Xaml/ApplicationLoader.cs +++ b/Stylet/Xaml/ApplicationLoader.cs @@ -11,7 +11,7 @@ namespace Stylet.Xaml private readonly ResourceDictionary styletResourceDictionary; /// - /// Create a new ApplicationLoader instance + /// Initialises a new instance of the class /// public ApplicationLoader() { @@ -22,11 +22,11 @@ namespace Stylet.Xaml private IBootstrapper _bootstrapper; /// - /// 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. /// public IBootstrapper Bootstrapper { - get { return _bootstrapper; } + get { return this._bootstrapper; } set { this._bootstrapper = value; @@ -37,7 +37,7 @@ namespace Stylet.Xaml private bool _loadStyletResources; /// - /// 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. /// public bool LoadStyletResources { diff --git a/Stylet/Xaml/BoolToVisibilityConverter.cs b/Stylet/Xaml/BoolToVisibilityConverter.cs index a5fb521..7b026a8 100644 --- a/Stylet/Xaml/BoolToVisibilityConverter.cs +++ b/Stylet/Xaml/BoolToVisibilityConverter.cs @@ -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 /// /// Turn a boolean value into a Visibility /// + [SuppressMessage("StyleCop.CSharp.ReadabilityRules", "SA1126:PrefixCallsCorrectly", Justification = "Don't agree with prefixing static method calls with the class name")] public class BoolToVisibilityConverter : DependencyObject, IValueConverter { /// @@ -16,7 +18,7 @@ namespace Stylet.Xaml public static readonly BoolToVisibilityConverter Instance = new BoolToVisibilityConverter(); /// - /// Visibility to use if value is true + /// Gets or sets the visibility to use if value is true /// public Visibility TrueVisibility { @@ -31,7 +33,7 @@ namespace Stylet.Xaml DependencyProperty.Register("TrueVisibility", typeof(Visibility), typeof(BoolToVisibilityConverter), new PropertyMetadata(Visibility.Visible)); /// - /// Visibility to use if value is false + /// Gets or sets the visibility to use if value is false /// 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)); - /// /// Perform the conversion /// + /// value as produced by source binding + /// target type + /// converter parameter + /// culture information + /// Converted value 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 /// /// Perform the inverse conversion. Only valid if the value is bool /// + /// value, as produced by target + /// target type + /// converter parameter + /// culture information + /// Converted back value public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture) { if (targetType != typeof(bool)) diff --git a/Stylet/Xaml/CommandAction.cs b/Stylet/Xaml/CommandAction.cs index f92c380..69dde37 100644 --- a/Stylet/Xaml/CommandAction.cs +++ b/Stylet/Xaml/CommandAction.cs @@ -19,13 +19,14 @@ namespace Stylet.Xaml public class CommandAction : ICommand { private static readonly ILogger logger = LogManager.GetLogger(typeof(CommandAction)); + /// - /// View to grab the View.ActionTarget from + /// Gets the View to grab the View.ActionTarget from /// public DependencyObject Subject { get; private set; } /// - /// 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. /// public string MethodName { get; private set; } @@ -45,7 +46,7 @@ namespace Stylet.Xaml private readonly ActionUnavailableBehaviour actionNonExistentBehaviour; /// - /// Create a new ActionCommand + /// Initialises a new instance of the class /// /// View to grab the View.ActionTarget from /// Method name. the MyMethod in Buttom Command="{s:Action MyMethod}". diff --git a/Stylet/Xaml/DebugConverter.cs b/Stylet/Xaml/DebugConverter.cs index 9e05d88..15b17b5 100644 --- a/Stylet/Xaml/DebugConverter.cs +++ b/Stylet/Xaml/DebugConverter.cs @@ -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 /// /// Converter which passes through values, but uses Debug.WriteLine to log them. Useful for debugging /// + [SuppressMessage("StyleCop.CSharp.ReadabilityRules", "SA1126:PrefixCallsCorrectly", Justification = "Don't agree with prefixing static method calls with the class name")] public class DebugConverter : DependencyObject, IValueConverter { /// @@ -16,7 +18,7 @@ namespace Stylet.Xaml public static readonly DebugConverter Instance; /// - /// Category to use with Debug.WriteLine + /// Gets or sets the category to use with Debug.WriteLine /// 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")); - /// - /// 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 /// public Action Logger { @@ -46,7 +47,6 @@ namespace Stylet.Xaml public static readonly DependencyProperty LoggerProperty = DependencyProperty.Register("Logger", typeof(Action), 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 } /// - /// Create a new DebugConverter instance + /// Initialises a new instance of the class /// public DebugConverter() { @@ -66,6 +66,11 @@ namespace Stylet.Xaml /// /// Perform the conversion /// + /// value as produced by source binding + /// target type + /// converter parameter + /// culture information + /// Converted value public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture) { if (parameter == null) @@ -79,6 +84,11 @@ namespace Stylet.Xaml /// /// Perform the reverse conversion /// + /// value, as produced by target + /// target type + /// converter parameter + /// culture information + /// Converted back value public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture) { if (parameter == null) diff --git a/Stylet/Xaml/EqualityConverter.cs b/Stylet/Xaml/EqualityConverter.cs index c2350b3..549e39a 100644 --- a/Stylet/Xaml/EqualityConverter.cs +++ b/Stylet/Xaml/EqualityConverter.cs @@ -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 /// /// Converter to compare a number of values, and return true (or false if Invert is true) if they are all equal /// + [SuppressMessage("StyleCop.CSharp.ReadabilityRules", "SA1126:PrefixCallsCorrectly", Justification = "Don't agree with prefixing static method calls with the class name")] public class EqualityConverter : DependencyObject, IMultiValueConverter { /// @@ -16,7 +18,7 @@ namespace Stylet.Xaml public static readonly EqualityConverter Instance = new EqualityConverter(); /// - /// 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 /// public bool Invert { @@ -33,6 +35,15 @@ namespace Stylet.Xaml /// /// Perform the conversion /// + /// + /// 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. + /// + /// target type + /// converter parameter + /// culture information + /// Converted values 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 /// /// Perform the reverse convesion. Not implemented. /// + /// value, as produced by target + /// + /// Array of target types; array length indicates the number and types + /// of values suggested for Convert to return. + /// + /// converter parameter + /// culture information + /// Converted back values public object[] ConvertBack(object value, Type[] targetTypes, object parameter, System.Globalization.CultureInfo culture) { throw new NotImplementedException(); diff --git a/Stylet/Xaml/EventAction.cs b/Stylet/Xaml/EventAction.cs index c1624c8..d037010 100644 --- a/Stylet/Xaml/EventAction.cs +++ b/Stylet/Xaml/EventAction.cs @@ -13,6 +13,9 @@ namespace Stylet.Xaml { private static readonly ILogger logger = LogManager.GetLogger(typeof(EventAction)); + private readonly ActionUnavailableBehaviour targetNullBehaviour; + private readonly ActionUnavailableBehaviour actionNonExistentBehaviour; + /// /// View whose View.ActionTarget we watch /// @@ -35,11 +38,8 @@ namespace Stylet.Xaml private object target; - private readonly ActionUnavailableBehaviour targetNullBehaviour; - private readonly ActionUnavailableBehaviour actionNonExistentBehaviour; - /// - /// Create a new EventAction + /// Initialises a new instance of the class /// /// View whose View.ActionTarget we watch /// Property on the WPF element we're returning a delegate for @@ -126,9 +126,10 @@ namespace Stylet.Xaml /// /// Return a delegate which can be added to the targetProperty /// + /// An event hander, which, when invoked, will invoke the action public RoutedEventHandler GetDelegate() { - return new RoutedEventHandler(this.InvokeCommand); + return this.InvokeCommand; } private void InvokeCommand(object sender, RoutedEventArgs e) diff --git a/Stylet/Xaml/IconToBitmapSourceConverter.cs b/Stylet/Xaml/IconToBitmapSourceConverter.cs index 38058d1..d0a883e 100644 --- a/Stylet/Xaml/IconToBitmapSourceConverter.cs +++ b/Stylet/Xaml/IconToBitmapSourceConverter.cs @@ -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 /// /// Converter to take an Icon, and convert it to a BitmapSource /// + [SuppressMessage("StyleCop.CSharp.ReadabilityRules", "SA1126:PrefixCallsCorrectly", Justification = "Don't agree with prefixing static method calls with the class name")] public class IconToBitmapSourceConverter : IValueConverter { /// @@ -20,6 +22,11 @@ namespace Stylet.Xaml /// /// Converts a value /// + /// value as produced by source binding + /// target type + /// converter parameter + /// culture information + /// Converted value 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 /// /// Converts a value back. Not implemented. /// + /// value, as produced by target + /// target type + /// converter parameter + /// culture information + /// Converted back value public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture) { throw new NotImplementedException(); diff --git a/Stylet/Xaml/View.cs b/Stylet/Xaml/View.cs index ff7e90a..1e65494 100644 --- a/Stylet/Xaml/View.cs +++ b/Stylet/Xaml/View.cs @@ -20,9 +20,9 @@ namespace Stylet.Xaml private static readonly ContentPropertyAttribute defaultContentProperty = new ContentPropertyAttribute("Content"); /// - /// IViewManager to be used. This should be set by the Bootstrapper. + /// Gets or sets the to be used. This should be set by the Bootstrapper. /// - public static IViewManager ViewManager; + public static IViewManager ViewManager { get; set; } /// /// Get the ActionTarget associated with the given object @@ -31,7 +31,7 @@ namespace Stylet.Xaml /// ActionTarget associated with the given object public static object GetActionTarget(DependencyObject obj) { - return (object)obj.GetValue(ActionTargetProperty); + return obj.GetValue(ActionTargetProperty); } /// @@ -57,7 +57,7 @@ namespace Stylet.Xaml /// ViewModel currently associated with the given object public static object GetModel(DependencyObject obj) { - return (object)obj.GetValue(ModelProperty); + return obj.GetValue(ModelProperty); } /// @@ -105,7 +105,6 @@ namespace Stylet.Xaml } })); - /// /// Helper to set the Content property of a given object to a particular View /// diff --git a/StyletIntegrationTests/Bootstrapper.cs b/StyletIntegrationTests/Bootstrapper.cs index 6b523d0..78a2393 100644 --- a/StyletIntegrationTests/Bootstrapper.cs +++ b/StyletIntegrationTests/Bootstrapper.cs @@ -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;