private static object GetListViewSelectedItem(IBindingMemberInfo bindingMemberInfo, ListView listView)
 {
     var items = listView.SelectedItems;
     if (items.Count == 0)
         return null;
     return ViewManager.GetDataContext(items[0]);
 }

 internal static Exception BindingMemberMustBeWriteable(IBindingMemberInfo member)
 {
     return
         new InvalidOperationException(
             string.Format("The binding member must be writeable, if it uses the SetValue method, path '{0}', type '{1}', member type '{2}', underlying member '{3}'",
                 member.Path, member.Type, member.MemberType, member.Member));
 }

 public XamlUnresolvedResource(object target, string key, IBindingMemberInfo rootMember)
 {
     _key = key;
     _value = BindingConstants.UnsetValue;
     _reference = ServiceProvider.WeakReferenceFactory(target);
     _unsubscriber = rootMember.TryObserve(target, this);
 }

 internal static Exception InvalidEventSourceValue(IBindingMemberInfo member, object invalidValue)
 {
     return
         new InvalidOperationException(
             string.Format("The event binding member supports only method or command values, if it uses the SetValue method, path '{0}', type '{1}', member type '{2}', underlying member '{3}', invalid value '{4}'",
                 member.Path, member.Type, member.MemberType, member.Member, invalidValue));
 }

 /// <summary>
 ///     Initializes a new instance of the <see cref="BindingActionValue" /> class.
 /// </summary>
 public BindingActionValue([NotNull] object memberSource, [NotNull] IBindingMemberInfo member)
 {
     Should.NotBeNull(memberSource, "memberSource");
     Should.NotBeNull(member, "member");
     _memberSource = ToolkitExtensions.GetWeakReference(memberSource);
     _member = member;
 }

 public XamlResourceWrapper(object target, string key, IBindingMemberInfo rootMember, ISourceValue globalResource)
 {
     _key = key;
     _value = BindingConstants.UnsetValue;
     _reference = ServiceProvider.WeakReferenceFactory(target);
     _unsubscriber = rootMember.TryObserve(target, this);
     _globalResource = globalResource;
 }

 /// <summary>
 ///     Called once for each element in the time of accession to obtain default values.
 /// </summary>
 private static string TextExtGetDefaultValue(TextView textBlock, IBindingMemberInfo bindingMemberInfo)
 {
     ServiceProvider
         .IocContainer
         .Get<IToastPresenter>()
         .ShowAsync("Invoking TextExtGetDefaultValue on " + textBlock.Id, ToastDuration.Short);
     return "Default value";
 }

 /// <summary>
 ///     Called once for each element in the time of accession to obtain default values.
 /// </summary>
 private static string TextExtGetDefaultValue(Label textBlock, IBindingMemberInfo bindingMemberInfo)
 {
     if (!ServiceProvider.DesignTimeManager.IsDesignMode)
         ServiceProvider
             .IocContainer
             .Get<IToastPresenter>()
             .ShowAsync("Invoking TextExtGetDefaultValue on " + textBlock.ClassId, ToastDuration.Short);
     return "Default value";
 }

 private static LoadingOverlay CreateLoadingOverlay(UIView uiView, IBindingMemberInfo bindingMemberInfo)
 {
     // Determine the correct size to start the overlay (depending on device orientation)
     var bounds = UIScreen.MainScreen.Bounds; // portrait bounds
     if (UIApplication.SharedApplication.StatusBarOrientation == UIInterfaceOrientation.LandscapeLeft ||
         UIApplication.SharedApplication.StatusBarOrientation == UIInterfaceOrientation.LandscapeRight)
     {
         bounds.Size = new CGSize(bounds.Size.Height, bounds.Size.Width);
     }
     return new LoadingOverlay(bounds);
 }

 public BindingPathMembersMock(object source, IBindingPath path, IBindingMemberInfo member)
 {
     Source = source;
     PenultimateValue = source;
     Path = path;
     if (member == null || source == null)
     {
         AllMembersAvailable = false;
         LastMember = BindingMemberInfo.Unset;
         _members = Empty.Array<IBindingMemberInfo>();
     }
     else
     {
         AllMembersAvailable = true;
         LastMember = member;
     }
 }

 private static void SetListViewSelectedItem(IBindingMemberInfo bindingMemberInfo, ListView listView, object value)
 {
     //Clear selection
     foreach (ListViewItem item in listView.SelectedItems)
     {
         item.Focused = false;
         item.Selected = false;
     }
     if (value == null)
         return;
     foreach (ListViewItem item in listView.Items)
     {
         if (Equals(ViewManager.GetDataContext(item), value))
         {
             item.Focused = true;
             item.Selected = true;
             break;
         }
     }
 }

 private object GetTargetValue(IBindingMemberInfo targetMember, IDataContext context, bool throwOnError)
 {
     object value = GetRawValueInternal(targetMember, context, throwOnError);
     if (value.IsUnsetValueOrDoNothing())
         return value;
     if (_parameters.ConverterDelegate != null)
     {
         IBindingValueConverter converter = _parameters.ConverterDelegate(context);
         if (converter != null)
         {
             CultureInfo culture = _parameters.ConverterCultureDelegate.GetValueOrDefault(context, CultureInfo.CurrentCulture);
             object parameter = _parameters.ConverterParameterDelegate.GetValueOrDefault(context);
             value = converter.ConvertBack(value, targetMember.Type, parameter, culture, context);
         }
     }
     if (Equals(value, _parameters.TargetNullValue))
         return null;
     return value;
 }

 private object GetSourceValue(IBindingMemberInfo targetMember, IDataContext context, bool throwOnError)
 {
     object value = GetRawValueInternal(targetMember, context, throwOnError);
     if (value.IsDoNothing())
         return BindingConstants.DoNothing;
     if (_parameters.ConverterDelegate != null && !value.IsUnsetValue())
     {
         IBindingValueConverter converter = _parameters.ConverterDelegate(context);
         if (converter != null)
         {
             CultureInfo culture = _parameters.ConverterCultureDelegate.GetValueOrDefault(context, CultureInfo.CurrentCulture);
             object parameter = _parameters.ConverterParameterDelegate.GetValueOrDefault(context);
             value = converter.Convert(value, targetMember.Type, parameter, culture, context);
         }
     }
     if (value.IsUnsetValue())
         value = _parameters.FallbackDelegate.GetValueOrDefault(context) ?? targetMember.Type.GetDefaultValue();
     if (value == null)
         return _parameters.TargetNullValue;
     return value;
 }

 /// <summary>
 ///     Gets the raw value from source.
 /// </summary>
 protected abstract object GetRawValueInternal(IBindingMemberInfo targetMember, IDataContext context,
     bool throwOnError);

 /// <summary>
 ///     Gets the source value.
 /// </summary>
 protected virtual object GetValueInternal(IBindingMemberInfo targetMember, IDataContext context,
     bool throwOnError)
 {
     if (_parameters == null)
         return GetRawValueInternal(targetMember, context, throwOnError);
     if (_isTarget)
         return GetTargetValue(targetMember, context, throwOnError);
     return GetSourceValue(targetMember, context, throwOnError);
 }

 /// <summary>
 ///     Gets the source value.
 /// </summary>
 /// <param name="targetMember">The specified member to set value.</param>
 /// <param name="context">The specified operation context.</param>
 /// <param name="throwOnError">
 ///     true to throw an exception if the value cannot be obtained; false to return
 ///     <see cref="BindingConstants.InvalidValue" /> if the value cannot be obtained.
 /// </param>
 public object GetValue(IBindingMemberInfo targetMember, IDataContext context, bool throwOnError)
 {
     try
     {
         var value = GetValueInternal(targetMember, context, throwOnError);
         if (value.IsUnsetValue())
             return targetMember.Type.GetDefaultValue();
         return value;
     }
     catch (Exception)
     {
         if (throwOnError)
             throw;
         return BindingConstants.InvalidValue;
     }
 }

        private static IDisposable ObserveTextTextBlock(IBindingMemberInfo bindingMemberInfo, TextBlock textBlock, IEventListener arg3)
        {
#if WINDOWS_UWP
            return DependencyPropertyBindingMember.ObserveProperty(textBlock, TextBlock.TextProperty, arg3);
#else
            return new DependencyPropertyBindingMember.DependencyPropertyListener(textBlock, "Text", arg3);
#endif
        }

 private static IDisposable ObserveParentMember(IBindingMemberInfo bindingMemberInfo, FrameworkElement o, IEventListener arg3)
 {
     return ParentObserver.GetOrAdd(o).AddWithUnsubscriber(arg3);
 }

 private static void SetParentValue(IBindingMemberInfo bindingMemberInfo, FrameworkElement frameworkElement, object arg3)
 {
     ParentObserver.GetOrAdd(frameworkElement).Parent = arg3;
 }

 private static object GetParentValue(IBindingMemberInfo bindingMemberInfo, FrameworkElement target)
 {
     return ParentObserver.GetOrAdd(target).Parent;
 }