private IViewFor AttemptViewResolution(string viewTypeName, string contract)
{
try
{
var viewType = Reflection.ReallyFindType(viewTypeName, throwOnFailure: false);
if (viewType == null)
{
return(null);
}
var service = Locator.Current.GetService(viewType, contract);
if (service == null)
{
return(null);
}
var view = service as IViewFor;
if (view == null)
{
return(null);
}
this.Log().Debug("Resolved service type '{0}'", viewType.FullName);
return(view);
}
catch (Exception ex)
{
this.Log().ErrorException($"Exception occurred whilst attempting to resolve type {viewTypeName} into a view.", ex);
throw;
}
}
private IViewFor AttemptViewResolution(string viewTypeName, string contract)
{
try {
var viewType = Reflection.ReallyFindType(viewTypeName, throwOnFailure: false);
if (viewType == null)
{
this.Log().Debug("Failed to find type named '{0}'.", viewTypeName);
return(null);
}
var service = Locator.Current.GetService(viewType, contract);
if (service == null)
{
this.Log().Debug("Failed to resolve service for type '{0}'.", viewType.FullName);
return(null);
}
var view = service as IViewFor;
if (view == null)
{
this.Log().Debug("Resolve service type '{0}' does not implement '{1}'.", viewType.FullName, typeof(IViewFor).FullName);
return(null);
}
return(view);
} catch (Exception ex) {
this.Log().ErrorException("Exception occurred whilst attempting to resolve type '" + viewTypeName + "' into a view.", ex);
throw;
}
}
private static Type?ToggleViewModelType(Type?viewModelType)
{
if (viewModelType == null)
{
return(null);
}
var viewModelTypeName = viewModelType.AssemblyQualifiedName;
if (viewModelTypeName == null)
{
return(null);
}
if (viewModelType.GetTypeInfo().IsInterface)
{
if (viewModelType.Name.StartsWith("I", StringComparison.InvariantCulture))
{
var toggledTypeName = DeinterfaceifyTypeName(viewModelTypeName);
return(Reflection.ReallyFindType(toggledTypeName, throwOnFailure: false));
}
}
else
{
var toggledTypeName = InterfaceifyTypeName(viewModelTypeName);
return(Reflection.ReallyFindType(toggledTypeName, throwOnFailure: false));
}
return(null);
}
/// <summary>
/// Returns the View associated with a ViewModel, deriving the name of
/// the Type via ViewModelToViewFunc, then discovering it via
/// ServiceLocator.
/// </summary>
/// <param name="viewModel">The ViewModel for which to find the
/// associated View.</param>
/// <returns>The View for the ViewModel.</returns>
public IViewFor ResolveView <T>(T viewModel, string contract = null)
where T : class
{
// Given IFooBarViewModel (whose name we derive from T), we'll look
// for a few things:
// * IFooBarView that implements IViewFor
// * IViewFor<IFooBarViewModel>
// * IViewFor<FooBarViewModel> (the original behavior in RxUI 3.1)
var attrs = viewModel.GetType().GetCustomAttributes(typeof(ViewContractAttribute), true);
if (attrs.Any())
{
contract = contract ?? ((ViewContractAttribute)attrs.First()).Contract;
}
// IFooBarView that implements IViewFor (or custom ViewModelToViewFunc)
var typeToFind = ViewModelToViewFunc(viewModel.GetType().AssemblyQualifiedName);
var ret = attemptToResolveView(Reflection.ReallyFindType(typeToFind, false), contract);
if (ret != null)
{
return(ret);
}
// IViewFor<FooBarViewModel> (the original behavior in RxUI 3.1)
var viewType = typeof(IViewFor <>);
return(attemptToResolveView(viewType.MakeGenericType(viewModel.GetType()), contract));
}
static void processRegistrationForNamespace(string ns, AssemblyName assmName, IMutableDependencyResolver resolver)
{
var targetType = ns + ".Registrations";
var fullName = targetType + ", " + assmName.FullName.Replace(assmName.Name, ns);
var registerTypeClass = Reflection.ReallyFindType(fullName, false);
if (registerTypeClass != null)
{
var registerer = (IWantsToRegisterStuff)Activator.CreateInstance(registerTypeClass);
registerer.Register((f, t) => resolver.RegisterConstant(f(), t));
}
}
private static Type ToggleViewModelType(Type viewModelType)
{
var viewModelTypeName = viewModelType.AssemblyQualifiedName;
if (viewModelType.GetTypeInfo().IsInterface)
{
if (viewModelType.Name.StartsWith("I"))
{
var toggledTypeName = DeinterfaceifyTypeName(viewModelTypeName);
var toggledType = Reflection.ReallyFindType(toggledTypeName, throwOnFailure: false);
return(toggledType);
}
}
else
{
var toggledTypeName = InterfaceifyTypeName(viewModelTypeName);
var toggledType = Reflection.ReallyFindType(toggledTypeName, throwOnFailure: false);
return(toggledType);
}
return(null);
}
/// <summary>
/// This method allows you to initialize resolvers with the default
/// ReactiveUI types. All resolvers used as the default
/// RxApp.DependencyResolver
/// </summary>
/// <param name="resolver">The resolver to initialize.</param>
public static void InitializeResolver(this IMutableDependencyResolver resolver)
{
var namespaces = new[] {
"ReactiveUI",
"ReactiveUI.Xaml",
"ReactiveUI.Winforms",
"ReactiveUI.Mobile",
"ReactiveUI.NLog",
"ReactiveUI.Gtk",
"ReactiveUI.Cocoa",
"ReactiveUI.Android",
};
var fdr = typeof(ModernDependencyResolver);
var assmName = new AssemblyName(
fdr.AssemblyQualifiedName.Replace(fdr.FullName + ", ", ""));
RxApp.suppressLogging = true;
namespaces.ForEach(ns => {
var targetType = ns + ".Registrations";
string fullName = targetType + ", " + assmName.FullName.Replace(assmName.Name, ns);
var registerTypeClass = Reflection.ReallyFindType(fullName, false);
if (registerTypeClass == null)
{
return;
}
var registerer = (IWantsToRegisterStuff)Activator.CreateInstance(registerTypeClass);
registerer.Register((f, t) => resolver.Register(f, t));
});
RxApp.suppressLogging = false;
}
static RxApp()
{
// Default name for the field backing the "Foo" property => "_Foo"
// This is used for ReactiveObject's RaiseAndSetIfChanged mixin
GetFieldNameForPropertyNameFunc = new Func <string, string>(x => "_" + x);
#if WP7
TaskpoolScheduler = new EventLoopScheduler();
#elif WP8
//TaskpoolScheduler = Scheduler.TaskPool;
TaskpoolScheduler = Scheduler.ThreadPool;
#elif SILVERLIGHT || DOTNETISOLDANDSAD
TaskpoolScheduler = Scheduler.ThreadPool;
#elif WINRT
TaskpoolScheduler = System.Reactive.Concurrency.ThreadPoolScheduler.Default;
#else
TaskpoolScheduler = Scheduler.TaskPool;
#endif
DefaultExceptionHandler = Observer.Create <Exception>(ex => {
// NB: If you're seeing this, it means that an
// ObservableAsPropertyHelper or the CanExecute of a
// ReactiveCommand ended in an OnError. Instead of silently
// breaking, ReactiveUI will halt here if a debugger is attached.
if (Debugger.IsAttached)
{
Debugger.Break();
}
RxApp.DeferredScheduler.Schedule(() => {
throw new Exception(
"An OnError occurred on an object (usually ObservableAsPropertyHelper) that would break a binding or command. To prevent this, Subscribe to the ThrownExceptions property of your objects",
ex);
});
});
MessageBus = new MessageBus();
LoggerFactory = t => new DebugLogger();
RxApp.Register(typeof(INPCObservableForProperty), typeof(ICreatesObservableForProperty));
RxApp.Register(typeof(IRNPCObservableForProperty), typeof(ICreatesObservableForProperty));
RxApp.Register(typeof(POCOObservableForProperty), typeof(ICreatesObservableForProperty));
RxApp.Register(typeof(NullDefaultPropertyBindingProvider), typeof(IDefaultPropertyBindingProvider));
RxApp.Register(typeof(EqualityTypeConverter), typeof(IBindingTypeConverter));
RxApp.Register(typeof(StringConverter), typeof(IBindingTypeConverter));
#if !SILVERLIGHT && !WINRT
RxApp.Register(typeof(ComponentModelTypeConverter), typeof(IBindingTypeConverter));
#endif
var namespaces = attemptToEarlyLoadReactiveUIDLLs();
namespaces.ForEach(ns => {
#if WINRT
var assm = typeof(RxApp).GetTypeInfo().Assembly;
#else
var assm = Assembly.GetExecutingAssembly();
#endif
var fullName = typeof(RxApp).AssemblyQualifiedName;
var targetType = ns + ".ServiceLocationRegistration";
fullName = fullName.Replace("ReactiveUI.RxApp", targetType);
fullName = fullName.Replace(assm.FullName, assm.FullName.Replace("ReactiveUI", ns));
var registerTypeClass = Reflection.ReallyFindType(fullName, false);
if (registerTypeClass != null)
{
var registerer = (IWantsToRegisterStuff)Activator.CreateInstance(registerTypeClass);
registerer.Register();
}
});
if (InUnitTestRunner())
{
LogHost.Default.Warn("*** Detected Unit Test Runner, setting Scheduler to Immediate ***");
LogHost.Default.Warn("If we are not actually in a test runner, please file a bug\n");
DeferredScheduler = Scheduler.Immediate;
}
else
{
LogHost.Default.Info("Initializing to normal mode");
}
if (DeferredScheduler == null)
{
LogHost.Default.Error("*** ReactiveUI.Xaml DLL reference not added - using Event Loop *** ");
LogHost.Default.Error("Add a reference to ReactiveUI.Xaml if you're using WPF / SL5 / WP7 / WinRT");
LogHost.Default.Error("or consider explicitly setting RxApp.DeferredScheduler if not");
RxApp.DeferredScheduler = new EventLoopScheduler();
}
}
