/// <summary>
/// Tries to invoke the specified member.
/// </summary>
/// <param name="binder">The binder.</param>
/// <param name="args">The member's arguments.</param>
/// <param name="result">The result, if any.</param>
/// <returns><see langword="true"/> if the member is invoked; otherwise, <see langword="false"/>.</returns>
public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
{
Contract.Ensures(!Contract.Result <bool>() || Contract.ValueAtReturn(out result) != null);
Contract.Assume(binder != null);
Contract.Assume(args != null);
#if PORT_40
var method = source.GetType().GetMethod(binder.Name, args.Select(a => a.GetType()).ToArray());
#elif WINDOWS_PHONE || PORT_45
var argTypes = args.Select(a => a.GetType()).ToList();
var method = source.GetType().GetTypeInfo().GetDeclaredMethods(binder.Name).SingleOrDefault(
m => m.GetParameters().Length == argTypes.Count &&
m.GetParameters().Zip(argTypes, (p, arg) => p.ParameterType.GetTypeInfo().IsAssignableFrom(arg.GetTypeInfo())).All(b => b));
#else
var method = source.GetType().GetMethod(
binder.Name,
BindingFlags.Public | BindingFlags.Instance,
Type.DefaultBinder,
args.Select(a => a.GetType()).ToArray(),
null);
#endif
if (method == null)
{
result = null;
return(false);
}
Func <object, object[], object> invoke = method.Invoke;
var invokeAsync = invoke.ToAsync();
IObservable <object> observable = invokeAsync(source, args);
Contract.Assume(observable != null);
if (method.ReturnType == typeof(void))
{
result = observable.Coerce(typeof(Unit));
}
else
{
result = observable.Coerce(method.ReturnType);
}
return(true);
}
private bool TryGetPropertyObservable(string propertyName, StringComparison comparison, out object result)
{
Contract.Requires(propertyName != null);
Contract.Ensures(!Contract.Result <bool>() || Contract.ValueAtReturn(out result) != null);
var property = ComponentReflection.GetProperty(source, propertyName, comparison);
if (property == null)
{
result = null;
return(false);
}
var changed = property.PropertyChanged(source).Select(_ => property.GetValue(source));
#if !SILVERLIGHT
Contract.Assume(property.PropertyType != null);
#endif
result = changed.Coerce(property.PropertyType);
return(true);
}
private bool TryGetEventObservable(string eventName, StringComparison comparison, out object result)
{
Contract.Requires(eventName != null);
Contract.Ensures(!Contract.Result <bool>() || Contract.ValueAtReturn(out result) != null);
var @event = ComponentReflection.GetEvent(source, eventName, comparison);
if (@event == null)
{
result = null;
return(false);
}
#if !SILVERLIGHT
Contract.Assume(@event.EventType != null);
#endif
#if WINDOWS_PHONE || PORT_45
var isGeneric = @event.EventType.GetTypeInfo().IsGenericType;
#else
var isGeneric = @event.EventType.IsGenericType;
#endif
Type eventArgsType;
if (@event.EventType == typeof(EventHandler))
{
eventArgsType = typeof(EventArgs);
}
else if (!isGeneric || @event.EventType.GetGenericTypeDefinition() != typeof(EventHandler <>))
{
throw new ArgumentException(
string.Format(CultureInfo.CurrentCulture, Errors.EventIsNotCompatibleWithEventHandler, eventName),
"eventName");
}
else
{
#if WINDOWS_PHONE || PORT_45
eventArgsType = @event.EventType.GetTypeInfo().GenericTypeArguments[0];
#else
eventArgsType = @event.EventType.GetGenericArguments()[0];
#endif
Contract.Assume(eventArgsType != null);
#if WINDOWS_PHONE || PORT_45
var assignable = typeof(EventArgs).GetTypeInfo().IsAssignableFrom(eventArgsType.GetTypeInfo());
#else
var assignable = typeof(EventArgs).IsAssignableFrom(eventArgsType);
#endif
if (!assignable)
{
throw new ArgumentException(
string.Format(CultureInfo.CurrentCulture, Errors.EventIsNotCompatibleWithEventArgs, eventName),
"eventName");
}
}
result = @event.EventRaised(source).Coerce(eventArgsType);
return(true);
}
//
// Summary:
// Initializes a new instance of the System.Nullable<T> structure to the specified
// value.
//
// Parameters:
// value:
// A value type.
public Nullable(T value)
{
Contract.Ensures(Contract.ValueAtReturn(out this).HasValue);
}