Home

Initializing the library

You can call the static XamUInfrastructure.Init method to do the common initialization tasks. This should only be called once. It registers each of the built-in implementations with the defined abstractions:

• FormsNavigationPageService => INavigationService
• FormsMessageVisualizerService => IMessageVisualizerService
• DependencyServiceWrapper => IDependencyService

This is an optional call - if you decide to use your own implementations, or want to use a different IoC container, then omit this call and register the services on your own. The static initializer returns the dependency service wrapper abstraction which you can pass around your app to locate services.

// Initialize our services
IDependencyService ds = XamarinUniversity.Services.XamUInfrastructure.Init();
ds.Register<MainViewModel>();
ds.Register<ISomeOtherService, SomeImplementation>();
...

Changing the Service Locator (DependencyService)

By default, the library uses the static DependencyService built into Xamarin.Forms. However, you can change this by supplying a different implementation of the IDependencyService abstraction to the XamUInfrastructure.Init() method. For example, you could wrap the Unity Container.

First, turn it into a IDependencyService:

public class UnityWrapper : IDependencyService
{
    UnityContainer container;

    public UnityWrapper(UnityContainer container)
    {
       this.container = container;
    }

    public T Get<T>() where T : class
    {
        return container.Resolve<T>();
    }

    public void Register<T> () where T : class, new()
    {
        container.RegisterType<T>();
    }

    public void Register<T, TImpl> () 
        where T : class
        where TImpl : class, T, new()
    {
        container.RegisterType<T,TImpl>();
    }
}

Then, pass your implementation into the Init method:

// Setup Unity
var container = new UnityWrapper(new UnityContainer());

// Initialize our services - pass in the container we want to use
IDependencyService ds = XamarinUniversity.Services.XamUInfrastructure.Init(container);
ds.Register<MainViewModel>();
ds.Register<ISomeOtherService, SomeImplementation>();
...

Available Types

This is a list of the reusable classes included in the library. Most are independent and have not required dependencies on each other so you can pick and choose what you utilize in your code. For example you can choose to use the message visualizer service but not the navigation service.

Commands

• NavigationCommands - a static class which exposes static properties of the navigation commands.
• NavigationBackCommand - an ICommand which performs a NavigationService.GoBackAsync.
• NavigationToCommand - an ICommand which performs a NavigationService.NavigateAsync.

Data Binding

• NamedDataTemplateSelector - a DataTemplateSelector which uses the context type name to locate visual data templates.

Behaviors

• EventToCommandBehavior - used to handle a .NET event as a Command.
• PickerBindBehavior - used to data bind a Picker to a set of properties in a ViewModel.
• NumericValidationBehavior - restricts an Entry to only support numeric values.

Controls

• ItemsControl - a simple bindable template creator which will instantiate a set of Label elements or DataTemplate driven elements from a bound list. Similar to a ListView, but the produced content is not scrollable, nor does it provide any interactivity outside the generate content.

Value Converters

• DebugConverter - a value converter which outputs the Convert and ConvertBack to the debug console.
• IntegerToBooleanConverter - a value converter which converts an integer value into a boolean.
• NotBooleanConverter - a value converter which flips the value of a boolean.
• NullOrEmptyBooleanConverter - a value converter which takes an object/string and turns it into a boolean.
• ImageResourceConverter - a value converter to load an ImageSource from embedded resources so you can data bind an Image from a ViewModel.

Collections

• GroupedObservableCollection - used to hold observable grouped collections for ListView.
• ObservableDictionary - a Dictionary which supports change notifications for bindings.
• OptimizedObservableCollection - an ObservableCollection which lets you disable change notifications for a brief period for mass updates.
• RefreshingCollection - an ObservableCollection which supports asynchronous refreshing behavior.

Extension methods

• CollectionExtensions - a set of extension methods for collection/IEnumerable types.
• ElementExtensions - extension methods for Xamarin.Forms Element types.
• ExceptionExtensions - extension methods for processing Exception types.
• TaskExtensions - extension methods for Task.

Interfaces

• IAsyncDelegateCommand - an interface to expose ExecuteAsync. Derives from IDelegateCommand.
• IDelegateCommand - an interface to expose RaiseCanExecuteChanged. This derives from ICommand.
• IDependencyService - an abstraction over a typical Service Locator such as Xamarin.Forms DependencyService.
• IMessageVisualizerService - an abstraction over a "MessageBox" display such as Xamarin.Forms Page.DisplayAlert.
• INavigationService - an abstraction for a basic navigation service using string-based keys to represent the pages you can navigate to.

Markup Extensions

• DependencyServiceExtension - a XAML extension to use DependencyService.Get<T> to fill in a property value.
• ImageResourceExtension - a XAML extension to retrieve an ImageSource from embedded resources.
• RelativeBindingContext - simpler way to capture BindingContext from one element to another.

MVVM classes

• AsyncDelegateCommand - an implementation of IAsyncDelegateCommand.
• DelegateCommand - an implementation of IDelegateCommand. Useful to avoid dependencies in your ViewModels on Xamarin.Forms.
• PropertyObserver - a fluid property observer which lets you easily monitor PropertyChange notifications on child ViewModels.
• SimpleViewModel - a base ViewModel implementation for MVVM which supports property change notifications.

Services

• DependencyServiceWrapper - a wrapper around Xamarin.Forms static DependencyService class to turn it into a service based on IDependencyService.
• FormsMessageVisualizerService - a wrapper around Xamarin.Forms Page.DisplayAlert method to turn it into a service based on IMessageVisualizerService.
• FormsNavigationPageService - an example service which implements the included INavigationService and supports basic stack-based navigation through Xamarin.Forms.