public App()
{
DependencyEmbedder dependencyEmbedder = new DependencyEmbedder();
dependencyEmbedder.AddPackage("Newtonsoft.Json");
dependencyEmbedder.AddPackage("SharpDX.DirectInput");
dependencyEmbedder.AddPackage("SharpDX");
dependencyEmbedder.AddPackage("Hardcodet.Wpf.TaskbarNotification");
dependencyEmbedder.AddPackage("Nefarius.ViGEm.Client");
dependencyEmbedder.Initialize();
string exePath = Assembly.GetExecutingAssembly().Location;
string cwd = Path.GetDirectoryName(exePath);
Directory.SetCurrentDirectory(cwd);
ApplicationContext globalContext = ApplicationContext.Global;
globalContext.Resolvers.Add(Resolver.CreateSingleton(Dispatcher));
globalContext.AddFromConfiguration(typeof(ApplicationConfiguration));
globalContext.AddFromConfiguration(typeof(UI.UIConfiguration));
singleInstanceProvider = new SingleInstanceProvider();
argumentParser = globalContext.Resolve <ArgumentParser>();
#if !DEBUG
Dispatcher.UnhandledException += async(object sender, DispatcherUnhandledExceptionEventArgs e) => await UnhandledException(e.Exception);
#endif
}
/// <summary>
/// Registriert ein Delegate zum Erzeugen einer einzelnen Dienstinstanz.
/// </summary>
/// <typeparam name="T">Typ des Dienstes.</typeparam>
/// <param name="provider">Das Delegate, das Registriert werden soll.</param>
/// <param name="addDefaultMultiProvider">
/// Zusätzliches Delegate zum Erzeugen einer Liste von Instanzen
/// hinzufügen oder nicht.
/// </param>
/// <returns>Diese Instanz.</returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="provider" /> ist eine <see langword="null" /> Referenz.
/// </exception>
/// <exception cref="DuplicateWaitObjectException">
/// Ein Delegate wurde bereits registriert.
/// </exception>
public DelegateServiceLocatorWrapper RegisterSingle <T>(SingleInstanceProvider <T> provider,
bool addDefaultMultiProvider)
{
this.InvokeForFactoryLists(
(singleList, multiList, args) =>
{
var factory = singleList.FirstOrDefault(f => args.ServiceType
.Equals(f.SERVICE_TYPE));
if (factory != null)
{
throw new DuplicateWaitObjectException(args.ServiceType
.FullName);
}
singleList.Add(new SingleInstanceFactory <T>(args.InstanceProvider));
}, new
{
InstanceProvider = provider,
ServiceType = typeof(T),
});
if (addDefaultMultiProvider)
{
this.RegisterMulti <T>(SingleToMulti <T>(provider),
false);
}
return(this);
}
/// <summary>
/// Registers a provider for resolving a single instance of a service.
/// </summary>
/// <typeparam name="T">Type of the service.</typeparam>
/// <param name="provider">The provider to register.</param>
/// <param name="registerDefaultMultiProvider">
/// Also register a default multi instance provider or not.
/// </param>
/// <returns>That instance.</returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="provider" /> is <see langword="null" />.
/// </exception>
/// <exception cref="InvalidOperationException">
/// A provider is already registrated for the service type.
/// </exception>
public DelegateServiceLocator RegisterSingleProvider <T>(SingleInstanceProvider <T> provider,
bool registerDefaultMultiProvider)
{
if (provider == null)
{
throw new ArgumentNullException("provider");
}
lock (this._SYNC)
{
Type serviceType = typeof(T);
if (this._SINGLE_PROVIDERS.ContainsKey(serviceType))
{
throw new InvalidOperationException();
}
this._SINGLE_PROVIDERS
.Add(serviceType,
new InstanceProvider(serviceType, provider));
}
if (registerDefaultMultiProvider)
{
this.RegisterMultiProvider <T>(SingleToMulti <T>(provider),
false);
}
return(this);
}
private static MultiInstanceProvider <T> SingleToMulti <T>(SingleInstanceProvider <T> singleProvider)
{
if (singleProvider != null)
{
return(new MultiInstanceProvider <T>(
(sender) =>
{
var instance = singleProvider(sender, null);
if (instance == null)
{
throw new ServiceActivationException(typeof(T),
null);
}
return new T[] { instance };
}));
}
return(null);
}
public IInstanceProvider AddValueProvider(Type bindingType, object value)
{
Type providerType = value.GetType();
// Check if type of value is assignable to target type
if (!bindingType.IsAssignableFrom(providerType))
{
// Handler error
InjectionError error = CreateError(InjectionErrorType.ValueNotAssignableToBindingType, bindingType, providerType, 2);
if (_ShouldThrowException)
{
throw new InjectionException(error.Error, error.Message);
}
return(null);
}
// Check if a provider with given type exist
IInstanceProvider provider;
if (_Providers.TryGetValue(providerType, out provider))
{
// Check if existing provider is same with requested one
if (provider.GetType() != typeof(SingleInstanceProvider))
{
// Handler error
InjectionError error = CreateError(InjectionErrorType.AlreadyAddedTypeWithDifferentProvider, bindingType, providerType, 2);
if (_ShouldThrowException)
{
throw new InjectionException(error.Error, error.Message);
}
}
}
else
{
provider = new SingleInstanceProvider(value);
_Providers.Add(providerType, provider);
}
return(provider);
}
private static MultiInstanceProvider <T> SingleToMulti <T>(SingleInstanceProvider <T> provider)
{
return(new MultiInstanceProvider <T>(delegate(DelegateServiceLocator locator, object key)
{
try
{
T instance = provider(locator, key);
if (instance != null)
{
return new T[] { instance };
}
}
catch (ServiceActivationException saex)
{
if (saex.InnerException != null)
{
throw;
}
}
return CollectionHelper.Empty <T>();
}));
}
private static MultiInstanceProvider <T> SingleToMulti <T>(SingleInstanceProvider <T> provider)
{
return((locator, key) =>
{
try
{
var instance = provider(locator, key);
if (instance != null)
{
return new T[] { instance };
}
}
catch (ServiceActivationException saex)
{
if (saex.InnerException != null)
{
throw;
}
}
return Enumerable.Empty <T>();
});
}
/// <summary>
/// Registriert ein Delegate zum Erzeugen einer einzelnen Dienstinstanz
/// und fügt zusätzlich ein Standard-Delegate zum Erzeugen einer Liste von Instanzen
/// hinzu.
/// </summary>
/// <typeparam name="T">Typ des Dienstes.</typeparam>
/// <param name="provider">Das Delegate, das Registriert werden soll.</param>
/// <returns>Diese Instanz.</returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="provider" /> ist eine <see langword="null" /> Referenz.
/// </exception>
/// <exception cref="DuplicateWaitObjectException">
/// Ein Delegate wurde bereits registriert.
/// </exception>
public DelegateServiceLocatorWrapper RegisterSingle <T>(SingleInstanceProvider <T> provider)
{
return(this.RegisterSingle <T>(provider,
true));
}
internal SingleInstanceFactory(SingleInstanceProvider <T> provider)
: base(typeof(T),
provider)
{
}
