Name: Splat.Common.Test
Author: .NET Foundation and Contributors

Splat.Common.Test v16.2.1 — nugetz

ToNative()

// If true, we are running unit tests
ModeDetector.InUnitTestRunner();

// To get a single service registration
var toaster = Locator.Current.GetService<IToaster>();

// To get all service registrations
var allToasterImpls = Locator.Current.GetServices<IToaster>();

// Create a new Toaster any time someone asks
Locator.CurrentMutable.Register(() => new Toaster(), typeof(IToaster));

// Register a singleton instance
Locator.CurrentMutable.RegisterConstant(new ExtraGoodToaster(), typeof(IToaster));

// Register a singleton which won't get created until the first user accesses it
Locator.CurrentMutable.RegisterLazySingleton(() => new LazyToaster(), typeof(IToaster));

Container	NuGet	Read Me
Splat.Autofac		Setup Autofac
Splat.DryIoc		Setup DryIoc
Splat.Microsoft.Extensions.DependencyInjection		Setup Microsoft DI
Splat.Ninject		Setup Ninject
Splat.SimpleInjector		Setup Simple Injector

using Splat;
using Splat.Builder;

// App services
public sealed class CoreModule : IModule
{
    public void Configure(IMutableDependencyResolver resolver)
    {
        // register your services here
        resolver.RegisterLazySingleton(() => new ApiClient(), typeof(IApiClient));
        resolver.Register(() => new MainViewModel(resolver.GetService<IApiClient>()!), typeof(IMainViewModel));
    }
}

// Logging (Serilog adapter) - requires Splat.Serilog package
using Splat.Serilog;
public sealed class SerilogModule : IModule
{
    public void Configure(IMutableDependencyResolver resolver)
    {
        // assumes Serilog.Log has been configured elsewhere
        resolver.UseSerilogFullLogger();
    }
}

// Cross-platform drawing (IBitmapLoader) - requires Splat.Drawing package
public sealed class DrawingModule : IModule
{
    public void Configure(IMutableDependencyResolver resolver)
    {
        resolver.RegisterPlatformBitmapLoader();
    }
}

new CoreModule().Apply(); // calls module.Configure(Locator.CurrentMutable)

using Splat;
using Splat.Builder;

// choose the resolver to configure (Locator.CurrentMutable by default)
new AppBuilder(Locator.CurrentMutable)
    .UsingModule(new CoreModule())
    .UsingModule(new SerilogModule())
    .UsingModule(new DrawingModule())
    // ad-hoc registrations can be added too
    .WithCustomRegistration(r => r.RegisterConstant(new AppConfig("Prod"), typeof(AppConfig)))
    .Build();

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Splat;
using Splat.Builder;
using Splat.Microsoft.Extensions.DependencyInjection;
using Splat.Microsoft.Extensions.Logging;

var services = new ServiceCollection();
services.UseMicrosoftDependencyResolver(); // set Locator.Current to MS.DI resolver backed by IServiceCollection

// register framework logging provider that forwards to Splat
services.AddLogging(b => b.AddSplat());

// build container and rebind Locator.Current to the built provider
var provider = services.BuildServiceProvider();
provider.UseMicrosoftDependencyResolver();

new AppBuilder(Locator.CurrentMutable)
    .UseCurrentSplatLocator() // target whatever Locator.CurrentMutable points to (MS.DI in this case)
    .UsingModule(new CoreModule())
    .WithCustomRegistration(r =>
    {
        // forward Microsoft.Extensions.Logging to Splat
        var factory = provider.GetRequiredService<ILoggerFactory>();
        r.UseMicrosoftExtensionsLoggingWithWrappingFullLogger(factory);
    })
    .Build();

using Splat;
using Splat.Builder;

public sealed class MyAppBuilder : AppBuilder
{
    public MyAppBuilder(IMutableDependencyResolver resolver) : base(resolver) { }

    public override AppBuilder WithCoreServices()
    {
        // register core bits once for your app
        // e.g., default logger, scheduler, or platform services
        // resolver is obtained per registration in Build(),
        // so prefer idempotent registrations guarded by HasRegistration
        return this;
    }
}

// usage
new MyAppBuilder(Locator.CurrentMutable)
    .UsingModule(new CoreModule())
    .Build();

this.Log().Warn("Something bad happened: {0}", errorMessage);
this.Log().ErrorException("Tried to do a thing and failed", exception);

using Splat.Log4Net;

// then in your service locator initialisation
Locator.CurrentMutable.UseLog4NetWithWrappingFullLogger();

using Splat.Microsoft.Extensions.Logging;

// note: this is different from the other adapter extension methods
//       as it needs knowledge of the logger factory
//       also the "container" is how you configured the Microsoft.Logging.Extensions
var loggerFactory = container.Resolve<ILoggerFactory>();
// in theory it could also be
// var loggerFactory = new LoggerFactory();


/// then in your service locator initialisation
Locator.CurrentMutable.UseMicrosoftExtensionsLoggingWithWrappingFullLogger(loggerFactory);

using Splat.NLog;

//  then in your service locator initialisation
Locator.CurrentMutable.UseNLogWithWrappingFullLogger();

using Splat.Serilog;

// Then in your service locator initialisation
Locator.CurrentMutable.UseSerilogFullLogger()

// This System.Drawing class works, even on WinRT where it's not supposed to exist
// Also, this works in a Portable Library, in your ViewModel
ProfileBackgroundAccentColor = Color.FromArgb(255, 255, 255, 255);

ImageView.Background = ViewModel.ProfileBackgroundAccentColor.ToNativeBrush();

// In a netstandard library
SplatColor BackgroundColor = SplatColor.Red;

// From an iOS project
UIColor bgColor = ViewModel.BackgroundColor.ToNative();

// From an Android project
Android.Graphics.Color bgColor = ViewModel.BackgroundColor.ToNative();

Locator.CurrentMutable.RegisterPlatformBitmapLoader();

//
// Load an Image
// This code even works in a Portable Library
//

var wc = new WebClient();
Stream imageStream = wc.OpenRead("http://octodex.github.com/images/Professortocat_v2.png");

// IBitmap is a type that provides basic image information such as dimensions
IBitmap profileImage = await BitmapLoader.Current.Load(imageStream, null /* Use original width */, null /* Use original height */);

// ToNative always converts an IBitmap into the type that the platform
// uses, such as UIBitmap on iOS or BitmapSource in WPF
ImageView.Source = ViewModel.ProfileImage.ToNative();

var profileImage = await BitmapLoader.Current.LoadFromResource("DefaultAvatar.png", null, null);

var blankImage = BitmapLoader.Current.Create(512.0f, 512.0f);
await blankImage.Save(CompressedBitmapFormat.Png, 0.0, File.Open("ItsBlank.png"));

// If true, we are running inside Blend, so don't do anything
PlatformModeDetector.InDesignMode();

Product	Package	NuGet	Maturity Level	Error Reporting	Feature Usage Tracking	View Tracking
Appcenter	Splat.AppCenter		Alpha	TODO	Native	Native
Application Insights	Splat.ApplicationInsights		Alpha	TODO	Native	Native
Exceptionless	Splat.Exceptionless		Alpha	TODO	Native	By Convention
New Relic	N\A	N\A	Not Started	TODO	TODO	TODO
OpenTrace	N\A	N\A	Not Started	TODO	TODO	TODO
Raygun	Splat.Raygun		Prototype	TODO	By Convention	By Convention

        /// <summary>
        /// Dummy object for testing IEnableFeatureUsageTracking.
        /// </summary>
        public sealed class TestObjectThatSupportsFeatureUsageTracking : IEnableFeatureUsageTracking
        {
			public async Task SomeFeatureIWantToTrack()
			{
                using (var trackingSession = this.FeatureUsageTrackingSession("featureName"))
                {
					try
					{
						// do some work here.
					}
					catch (Exception exception)
					{
						trackingSession.OnException(exception);
					}
                }
			}
        }

        /// <summary>
        /// Dummy object for testing IEnableFeatureUsageTracking.
        /// </summary>
        public sealed class TestObjectThatSupportsFeatureUsageTracking : IEnableFeatureUsageTracking
        {
			public async Task SomeFeatureIWantToTrack()
			{
                using (var mainFeature = this.FeatureUsageTrackingSession("featureName"))
                {
					try
					{
						await DoSubFeature(mainFeature).ConfigureAwait(false);
					}
					catch (Exception exception)
					{
						mainFeature.OnException(exception);
					}
                }
			}

			public async Task SomeFeatureIWantToTrack(IFeatureUsageTrackingSession parentFeature)
			{
                using (var subFeature = parentFeature.SubFeature("subFeatureName"))
                {
					try
					{
						// do some work here.
					}
					catch (Exception exception)
					{
						subFeature.OnException(exception);
					}
                }
			}
        }

using Splat.AppCenter;

// then in your service locator initialisation
Locator.CurrentMutable.UseAppcenterApm();

using Splat.ApplicationInsights;

// then in your service locator initialisation
Locator.CurrentMutable.UseApplicationInsightsApm();

using Splat.Exceptionless;

// then in your service locator initialisation
Locator.CurrentMutable.UseExceptionlessApm();

using Splat.Raygun;

// then in your service locator initialisation
Locator.CurrentMutable.UseRaygunApm();

Glenn Watson Melbourne, Australia	Rodney Littles II Texas, USA
David Vreony UK	Chris Pulman UK

glennawatson/Splat.Common.Testv16.2.1

Get Started

Readme

Splat

What does it do?

Core Team

How do I install?

Detecting whether you're in a unit test runner

Service Location

Dependency Injection Source Generator

Dependency Resolver Packages

AppBuilder and IModule (AOT-friendly configuration)

Define modules

Build your application registrations

Using an external container as the Splat resolver

Extending AppBuilder

Logging

Available logging adapters

Log4Net

Microsoft.Extensions.Logging

NLog

Serilog

Cross platform drawing

Using Cross-Platform Colors and Geometry

Cross-platform Image Loading

Detecting if you're in design mode

Application Performance Monitoring

Goals of the Splat APM feature

Getting started with APM with Splat

Error Reporting

Feature Usage Tracking

View Tracking

Configuring Appcenter

Configuring Application Insights

Configuring Exceptionless

Configuring New Relic

Configuring OpenTrace

Configuring Raygun

Testing and developing the APM functionality

Contribute

Target	Package	NuGet
Console	Splat
Debug	Splat
Log4Net	Splat.Log4Net
Microsoft Extensions Logging	Splat.Microsoft.Extensions.Logging
NLog	Splat.NLog
Serilog	Splat.Serilog