Windows Phone + Caliburn.Micro + Autofac

// Project: Caliburn.Micro.Autofac // File name: AutofacBootstrapper.cs // File GUID: C5C743E2-7AD1-496C-824A-9AEFBF5F8979 // Authors: David Buksbaum (david@buksbaum.us), Mike Eshva (mike@eshva.ru) // Date of creation: 20.05.2012 using System; using System.Collections.Generic; using System.ComponentModel; using System.Linq; using System.Reflection; using System.Windows.Controls; using Autofac; using Microsoft.Phone.Controls; using IContainer = Autofac.IContainer; namespace Caliburn.Micro.Autofac { /// <summary> /// Autofac specific <see cref="PhoneBootstrapper"/> realization. /// </summary> public class AutofacBootstrapper : PhoneBootstrapper { #region Public properties /// <summary> /// Gets or sets flag should the namespace convention be enforced for type registration. The /// default is true. For views, this would require a views namespace to end with Views For /// view-models, this would require a view models namespace to end with ViewModels. /// </summary> /// <remarks> /// Case is important as views would not match. /// </remarks> public bool EnforceNamespaceConvention { get; set; } /// <summary> /// Gets or sets flag should the view be treated as loaded when registering the /// <see cref="INavigationService"/>. /// </summary> public bool TreatViewAsLoaded { get; set; } /// <summary> /// Gets or sets the base type required for a view model. /// </summary> public Type ViewModelBaseType { get; set; } /// <summary> /// Gets or sets method for creating the window manager. /// </summary> public Func<IWindowManager> CreateWindowManager { get; set; } /// <summary> /// Gets or sets method for creating the event aggregator. /// </summary> public Func<IEventAggregator> CreateEventAggregator { get; set; } /// <summary> /// Gets or sets method for creating the frame adapter. /// </summary> public Func<FrameAdapter> CreateFrameAdapter { get; set; } /// <summary> /// Gets or sets method for creating the phone application service adapter. /// </summary> public Func<PhoneApplicationServiceAdapter> CreatePhoneApplicationServiceAdapter { get; set; } /// <summary> /// Gets or sets method for creating the vibrate controller. /// </summary> public Func<IVibrateController> CreateVibrateController { get; set; } /// <summary> /// Gets or sets method for creating the sound effect player. /// </summary> public Func<ISoundEffectPlayer> CreateSoundEffectPlayer { get; set; } #endregion #region Protected interface /// <summary> /// Gets Autofac container instance. /// </summary> protected IContainer Container { get; private set; } /// <summary> /// Do not override this method. This is where the IoC container is configured. /// </summary> /// <exception cref="NullReferenceException"> /// Either CreateFrameAdapter or CreateWindowManager or CreateEventAggregator or /// CreatePhoneApplicationServiceAdapter or CreateVibrateController or /// CreateSoundEffectPlayer is null. /// </exception> protected override void Configure() { // allow base classes to change bootstrapper settings ConfigureBootstrapper(); // validate settings if (CreateFrameAdapter == null) { throw new NullReferenceException("CreateFrameAdapter is not specified."); } if (CreateWindowManager == null) { throw new NullReferenceException("CreateWindowManager is not specified."); } if (CreateEventAggregator == null) { throw new NullReferenceException("CreateEventAggregator is not specified."); } if (CreatePhoneApplicationServiceAdapter == null) { throw new NullReferenceException( "CreatePhoneApplicationServiceAdapter is not specified."); } if (CreateVibrateController == null) { throw new NullReferenceException("CreateVibrateController is not specified."); } if (CreateSoundEffectPlayer == null) { throw new NullReferenceException("CreateSoundEffectPlayer is not specified."); } // Configure container. ContainerBuilder lBuilder = new ContainerBuilder(); // Register phone services. Assembly lCaliburnAssembly = typeof (IStorageMechanism).Assembly; // Register IStorageMechanism implementors. lBuilder.RegisterAssemblyTypes(lCaliburnAssembly) .Where( aType => typeof (IStorageMechanism).IsAssignableFrom(aType) && !aType.IsAbstract && !aType.IsInterface) .As<IStorageMechanism>() .InstancePerLifetimeScope(); // Register IStorageHandler implementors. lBuilder.RegisterAssemblyTypes(AssemblySource.Instance.ToArray()) .Where( aType => typeof (IStorageHandler).IsAssignableFrom(aType) && !aType.IsAbstract && !aType.IsInterface) .As<IStorageHandler>() .InstancePerLifetimeScope(); // Register view models. lBuilder.RegisterAssemblyTypes(AssemblySource.Instance.ToArray()) // Must be a type with a name that ends with ViewModel. .Where(aType => aType.Name.EndsWith("ViewModel")) // Mmust be in a namespace ending with ViewModels. .Where( aType => !EnforceNamespaceConvention || (!string.IsNullOrEmpty(aType.Namespace) && aType.Namespace.EndsWith("ViewModels"))) // Must implement INotifyPropertyChanged (deriving from PropertyChangedBase will statisfy this). .Where(aType => aType.GetInterface(ViewModelBaseType.Name, false) != null) // Registered as self. .AsSelf() // Subscribe on Activated event for viewmodels to make storage mechanism work. .OnActivated(aArgs => ActivateInstance(aArgs.Instance)) // Always create a new one. .InstancePerDependency(); // Register views. lBuilder.RegisterAssemblyTypes(AssemblySource.Instance.ToArray()) // Must be a type with a name that ends with View. .Where(aType => aType.Name.EndsWith("View")) // Must be in a namespace that ends in Views. .Where( aType => !EnforceNamespaceConvention || (!string.IsNullOrEmpty(aType.Namespace) && aType.Namespace.EndsWith("Views"))) // Registered as self. .AsSelf() // Always create a new one. .InstancePerDependency(); // Register the singletons. lBuilder.Register<IPhoneContainer>( aContext => new AutofacPhoneContainer(aContext.Resolve<IComponentContext>())) .SingleInstance(); lBuilder.RegisterInstance<INavigationService>(CreateFrameAdapter()) .SingleInstance(); PhoneApplicationServiceAdapter lPhoneService = CreatePhoneApplicationServiceAdapter(); lBuilder.RegisterInstance<IPhoneService>(lPhoneService) .SingleInstance(); lBuilder.Register(aContext => CreateEventAggregator()) .SingleInstance(); lBuilder.Register(aContext => CreateWindowManager()) .SingleInstance(); lBuilder.Register(aContext => CreateVibrateController()) .SingleInstance(); lBuilder.Register(aContext => CreateSoundEffectPlayer()) .SingleInstance(); lBuilder.RegisterType<StorageCoordinator>().AsSelf() .SingleInstance(); lBuilder.RegisterType<TaskController>().AsSelf() .SingleInstance(); // Allow derived classes to add to the container. ConfigureContainer(lBuilder); // Build the container Container = lBuilder.Build(); // Get the phone container instance. PhoneContainer = (AutofacPhoneContainer) Container.Resolve<IPhoneContainer>(); // Start the storage coordinator. StorageCoordinator lStorageCoordinator = Container.Resolve<StorageCoordinator>(); lStorageCoordinator.Start(); // Start the task controller. TaskController lTaskController = Container.Resolve<TaskController>(); lTaskController.Start(); // Add custom conventions for the phone. AddCustomConventions(); } /// <summary> /// Do not override unless you plan to full replace the logic. This is how the framework /// retrieves services from the Autofac container. /// </summary> /// <param name="aService"> /// The service to locate. /// </param> /// <param name="aKey"> /// The key to locate. /// </param> /// <returns> /// The located service. /// </returns> /// <exception cref="Exception"> /// Could not locate any instances of service. /// </exception> protected override object GetInstance(Type aService, string aKey) { object lInstance; if (string.IsNullOrEmpty(aKey)) { if (Container.TryResolve(aService, out lInstance)) { return lInstance; } } else { if (Container.TryResolveNamed(aKey, aService, out lInstance)) { return lInstance; } } throw new Exception( string.Format( "Could not locate any instances of service {0}.", aKey ?? aService.Name)); } /// <summary> /// Do not override unless you plan to full replace the logic. This is how the framework /// retrieves services from the Autofac container. /// </summary> /// <param name="aService"> /// The service to locate. /// </param> /// <returns> /// The located services. /// </returns> protected override IEnumerable<object> GetAllInstances(Type aService) { IEnumerable<object> lResult = Container.Resolve(typeof (IEnumerable<>).MakeGenericType(aService)) as IEnumerable<object>; return lResult; } /// <summary> /// Do not override unless you plan to full replace the logic. This is how the framework /// retrieves services from the Autofac container. /// </summary> /// <param name="aInstance"> /// The instance to perform injection on. /// </param> protected override void BuildUp(object aInstance) { Container.InjectProperties(aInstance); } /// <summary> /// Override to provide configuration prior to the Autofac configuration. You must call the base version BEFORE any /// other statement or the behaviour is undefined. /// Current Defaults: /// EnforceNamespaceConvention = true /// TreatViewAsLoaded = false /// ViewModelBaseType = <see cref="System.ComponentModel.INotifyPropertyChanged"/> /// CreateWindowManager = <see cref="Caliburn.Micro.WindowManager"/> /// CreateEventAggregator = <see cref="Caliburn.Micro.EventAggregator"/> /// CreateFrameAdapter = <see cref="Caliburn.Micro.FrameAdapter"/> /// CreatePhoneApplicationServiceAdapter = <see cref="Caliburn.Micro.PhoneApplicationServiceAdapter"/> /// CreateVibrateController = <see cref="Caliburn.Micro.SystemVibrateController"/> /// CreateSoundEffectPlayer = <see cref="Caliburn.Micro.XnaSoundEffectPlayer"/> /// </summary> protected virtual void ConfigureBootstrapper() { // By default, enforce the namespace convention. EnforceNamespaceConvention = true; // By default, do not treat the view as loaded. TreatViewAsLoaded = false; // The default view model base type. ViewModelBaseType = typeof (INotifyPropertyChanged); // Default window manager. CreateWindowManager = () => new WindowManager(); // Default event aggregator. CreateEventAggregator = () => new EventAggregator(); // Default frame adapter. CreateFrameAdapter = () => new FrameAdapter(RootFrame, TreatViewAsLoaded); // Default phone application service adapter. CreatePhoneApplicationServiceAdapter = () => new PhoneApplicationServiceAdapter(RootFrame); // Default vibrate controller. CreateVibrateController = () => new SystemVibrateController(); // Default sound effect player. CreateSoundEffectPlayer = () => new XnaSoundEffectPlayer(); } /// <summary> /// Override to include your own Autofac configuration after the framework has finished its /// configuration, but before the container is created. /// </summary> /// <param name="aBuilder"> /// The Autofac configuration builder. /// </param> protected virtual void ConfigureContainer(ContainerBuilder aBuilder) { } /// <summary> /// Activates an instance in phone container. Derived types should call this method for /// registering types that should support storage mechanism. /// </summary> /// <param name="aInstance"> /// Instance to activate. /// </param> /// <remarks> /// Use this method as event handler on service registation in /// <see cref="ConfigureContainer"/> method. ViewModels already registering with using it. /// </remarks> protected void ActivateInstance(object aInstance) { if (PhoneContainer == null) { return; } PhoneContainer.ActivateInstance(aInstance); } #endregion #region Private properties private AutofacPhoneContainer PhoneContainer { get; set; } #endregion #region Private methods private static void AddCustomConventions() { ConventionManager.AddElementConvention<Pivot>( ItemsControl.ItemsSourceProperty, "SelectedItem", "SelectionChanged").ApplyBinding = (aViewModelType, aPath, aProperty, aElement, aConvention) => { if (ConventionManager .GetElementConvention(typeof (ItemsControl)) .ApplyBinding(aViewModelType, aPath, aProperty, aElement, aConvention)) { ConventionManager .ConfigureSelectedItem( aElement, Pivot.SelectedItemProperty, aViewModelType, aPath); ConventionManager .ApplyHeaderTemplate( aElement, Pivot.HeaderTemplateProperty, null, aViewModelType); return true; } return false; }; ConventionManager.AddElementConvention<Panorama>( ItemsControl.ItemsSourceProperty, "SelectedItem", "SelectionChanged").ApplyBinding = (aViewModelType, aPath, aProperty, aElement, aConvention) => { if (ConventionManager .GetElementConvention(typeof (ItemsControl)) .ApplyBinding(aViewModelType, aPath, aProperty, aElement, aConvention)) { ConventionManager .ConfigureSelectedItem( aElement, Panorama.SelectedItemProperty, aViewModelType, aPath); ConventionManager .ApplyHeaderTemplate( aElement, Panorama.HeaderTemplateProperty, null, aViewModelType); return true; } return false; }; } #endregion } } 

 // Project: Caliburn.Micro.Autofac // File name: AutofacBootstrapper.cs // File GUID: CB807DF7-2D69-4B05-AC17-C3E191D7C182 // Authors: Mike Eshva (mike@eshva.ru) // Date of creation: 20.05.2012 using System; using System.IO.IsolatedStorage; using Autofac; namespace Caliburn.Micro.Autofac { /// <summary> /// Component that allows storage system to communicate with Autofac IoC container. /// </summary> public class AutofacPhoneContainer : IPhoneContainer { #region Constructors /// <summary> /// Initialize new instance of component that allows storage system to communicate with /// Autofac IoC container. /// </summary> /// <param name="aContext"> /// Autofac IoC context. /// </param> /// <exception cref="ArgumentNullException"> /// Autofac IoC context not specified. /// </exception> public AutofacPhoneContainer(IComponentContext aContext) { if (aContext == null) { throw new ArgumentNullException("aContext", "Autofac IoC context is not specified."); } Context = aContext; } #endregion #region IPhoneContainer Members /// <summary> /// Registers the service as a singleton stored in the phone state. /// </summary> /// <param name="aService"> /// The service. /// </param> /// <param name="aPhoneStateKey"> /// The phone state key. /// </param> /// <param name="aImplementation"> /// The implementation. /// </param> public void RegisterWithPhoneService (Type aService, string aPhoneStateKey, Type aImplementation) { string lObjectKey = aPhoneStateKey ?? aService.FullName; IPhoneService lPhoneService = Context.Resolve<IPhoneService>(); if (!lPhoneService.State.ContainsKey(lObjectKey)) { // There is no object with such a key in the phone state. // Create a plain new object and store it the phone state. object lEntireGraphObject = Context.Resolve(aService); lPhoneService.State[lObjectKey] = lEntireGraphObject; // Effectively replace service registration in // Autofac-container (the last registration wins). ContainerBuilder lBuilder = new ContainerBuilder(); lBuilder.RegisterType(aImplementation) .As(aService) .OnActivating( // Replace an object build by the container with one // from the phone state using OnActivating event. aArgs => { IPhoneService lInnerPhoneService = aArgs.Context.Resolve<IPhoneService>(); if (lInnerPhoneService.State.ContainsKey(lObjectKey)) { object lInstance = lInnerPhoneService.State[lObjectKey]; aArgs.ReplaceInstance(lInstance); } }); lBuilder.Update(Context.ComponentRegistry); } } /// <summary> /// Registers the service as a singleton stored in the app settings. /// </summary> /// <param name="aService"> /// The service. /// </param> /// <param name="aPhoneSettingsKey"> /// The app settings key. /// </param> /// <param name="aImplementation"> /// The implementation. /// </param> /// <exception cref="ArgumentNullException"> /// Service or implementation not specified. /// </exception> public void RegisterWithAppSettings (Type aService, string aPhoneSettingsKey, Type aImplementation) { string lObjectKey = aPhoneSettingsKey ?? aService.FullName; if (!IsolatedStorageSettings.ApplicationSettings.Contains(lObjectKey)) { // There is no object with such a key in the application isolated storage. // Probably it is the first time application executed. // Create a plain new object and store it the application isolated storage. object lEntireGraphObject = Context.Resolve(aImplementation); IsolatedStorageSettings.ApplicationSettings[lObjectKey] = lEntireGraphObject; } // Effectively replace service registration in // Autofac-container (the last registration wins). ContainerBuilder lBuilder = new ContainerBuilder(); lBuilder.RegisterType(aImplementation) .As(aService) .OnActivating( // Replace an object build by the container with one // from the application isolated storage using OnActivating event. aArgs => { if (IsolatedStorageSettings.ApplicationSettings.Contains(lObjectKey)) { object lInstance = IsolatedStorageSettings.ApplicationSettings[lObjectKey]; aArgs.ReplaceInstance(lInstance); } }); lBuilder.Update(Context.ComponentRegistry); } /// <summary> /// Occurs when a new instance is created. /// </summary> public event Action<object> Activated = delegate { }; #endregion #region Assembly interface /// <summary> /// Activates <paramref name="aInstance"/>. /// </summary> /// <param name="aInstance"> /// Instance to activate. /// </param> internal void ActivateInstance(object aInstance) { Activated(aInstance); } #endregion #region Private properties private IComponentContext Context { get; set; } #endregion } }