/// <summary>
/// WhenLoaded allows you to register a Func to be called OnViewLoaded.
/// </summary>
/// <param name="item">Object that supports loading.</param>
/// <param name="block">
/// The method to be called when the corresponding View is loaded.
/// It returns a list of Disposables that will be cleaned up when the View is unloaded.
/// </param>
/// <param name="view">
/// The IViewFor will ordinarily also host the View Model, but in the event it is not,
/// a class implementing <see cref="IViewFor<T>" /> can be supplied here.
/// </param>
/// <returns>A Disposable that cleans up this registration.</returns>
public static IDisposable WhenLoaded <T>(this IViewFor <T> item, Func <IEnumerable <IDisposable> > block, IViewFor <T> view) where T : class
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
var loadedFetcher = _loadedFetcherCache.Get(item.GetType());
if (loadedFetcher == null)
{
throw new ArgumentException($"Don't know how to detect when {item.GetType().FullName} is loaded/unloaded, you may need to implement {nameof(ILoadedForViewFetcher)}");
}
var viewEvents = loadedFetcher.GetLoadedForView(item);
var vmDisposable = Disposable.Empty;
if ((view ?? item) is IViewFor v)
{
vmDisposable = HandleViewModelOnViewLoaded(v, viewEvents);
}
var viewDisposable =
typeof(IActivate).IsAssignableFrom(typeof(T)) ?
HandleViewOnActivatedAndLoaded((view ?? item), block, viewEvents) :
HandleViewOnLoaded(block, viewEvents);
return(new CompositeDisposable(vmDisposable, viewDisposable));
}
/// <summary>
/// Gets a Type from the specified type name.
/// Uses a cache to avoid having to use Reflection every time.
/// </summary>
/// <param name="type">The name of the type.</param>
/// <param name="throwOnFailure">If we should throw an exception if the type can't be found.</param>
/// <returns>The type that was found or null.</returns>
/// <exception cref="TypeLoadException">If we were unable to find the type.</exception>
public static Type ReallyFindType(string type, bool throwOnFailure)
{
Type ret = typeCache.Get(type);
if (ret != null || !throwOnFailure)
{
return(ret);
}
throw new TypeLoadException();
}
/// <inheritdoc/>
public bool TryConvert(object from, Type toType, object conversionHint, out object result)
{
Contract.Requires(toType != null);
var mi = _referenceCastCache.Get(toType);
try
{
result = mi.Invoke(null, new[] { from, toType });
}
catch (Exception ex)
{
_logger.LogInformation(from, $"Couldn't convert from {from.GetType()} to {toType}\n{ex}\n{ex.Message}");
result = null;
return(false);
}
return(true);
}
public static IDisposable BindCommandToObject(ICommand command, object target, IObservable <object> commandParameter)
{
var type = target.GetType();
var binder = _bindCommandCache.Get(type);
if (binder == null)
{
throw new Exception($"Couldn't find a Command Binder for {type.FullName}");
}
var ret = binder.BindCommandToObject(command, target, commandParameter);
if (ret == null)
{
throw new Exception($"Couldn't bind Command Binder for {type.FullName}");
}
return(ret);
}
public static IDisposable BindCommandToObject(ICommand command, object target, IObservable <object> commandParameter, string eventName)
{
var type = target.GetType();
var binder = _bindCommandEventCache.Get(type);
if (binder == null)
{
throw new Exception($"Couldn't find a Command Binder for {type.FullName} and event {eventName}");
}
var eventArgsType = Reflection.GetEventArgsTypeForEvent(type, eventName);
var mi = binder.GetType().GetTypeInfo().DeclaredMethods.First(x => x.Name == "BindCommandToObject" && x.IsGenericMethod);
mi = mi.MakeGenericMethod(new[] { eventArgsType });
var ret = (IDisposable)mi.Invoke(binder, new[] { command, target, commandParameter, eventName });
if (ret == null)
{
throw new Exception($"Couldn't bind Command Binder for {type.FullName} and event {eventName}");
}
return(ret);
}
