public static void SetValue(
            object instance, 
            MutableMember member, 
            object value,
            IValueContext context)
        {
            var perspexProperty = FindPerspexProperty(instance, member);

            if (value is IBinding)
            {
                SetBinding(instance, member, perspexProperty, (IBinding)value);
            }
            else if (perspexProperty != null)
            {
                ((PerspexObject)instance).SetValue(perspexProperty, value);
            }
            else if (instance is Setter && member.Name == "Value")
            {
                // TODO: Make this more generic somehow.
                var setter = (Setter)instance;
                var targetType = setter.Property.PropertyType;
                var xamlType = member.TypeRepository.GetByType(targetType);
                var convertedValue = default(object);

                if (CommonValueConversion.TryConvert(value, xamlType, context, out convertedValue))
                {
                    SetClrProperty(instance, member, convertedValue);
                }
            }
            else
            {
                SetClrProperty(instance, member, value);
            }
        }

 public object ConvertFrom(IValueContext context, CultureInfo culture, object value)
 {
     return new MemberSelector
     {
         MemberName = (string)value,
     };
 }

 public IEnumerable<string> GetValues(IValueContext currentContext) {
     
         return GetValue(currentContext).Split(new[] {
             ','
         }, StringSplitOptions.RemoveEmptyEntries).Select( each => each.Trim());
     
 }

 public ObjectAssembler(StackingLinkedList<Level> state,
     IRuntimeTypeSource typeSource,
     IInstanceLifeCycleListener listener,
     IValueContext context)
 {
     StateCommuter = new StateCommuter(state, typeSource, listener, context);
     LifecycleListener = listener;
 }

 public object ConvertTo(
     IValueContext context,
     CultureInfo culture,
     object value,
     Type destinationType)
 {
     throw new NotImplementedException();
 }

        public object ConvertFrom(IValueContext context, CultureInfo culture, object value)
        {
            if (value is string)
            {
                return value;
            }

            return null;
        }

        public bool CanConvertTo(IValueContext context, Type destinationType)
        {
            if (destinationType == typeof(string) || destinationType == typeof(int))
            {
                return true;
            }

            return false;
        }

 public virtual void SetValue(object instance, object value, IValueContext valueContext)
 {
     if (ValueSetter.IsStatic)
     {
         ValueSetter.Invoke(null, new[] { instance, value });
     }
     else
     {
         member.Setter.Invoke(instance, new[] { value });
     }
 }

 public object ConvertFrom(IValueContext context, CultureInfo culture, object value)
 {
     string strValue = (string)value;
     string[] pointStrs = strValue.Split(new[] { ' ', '\t', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
     var result = new List<Point>(pointStrs.Length);
     foreach (var pointStr in pointStrs)
     {
         result.Add(Point.Parse(pointStr, culture));
     }
     return result;
 }

        public StateCommuter(StackingLinkedList<Level> stack,
            IRuntimeTypeSource typeSource,
            IInstanceLifeCycleListener lifecycleListener,
            IValueContext valueContext)
        {
            Guard.ThrowIfNull(stack, nameof(stack));
            Guard.ThrowIfNull(typeSource, nameof(typeSource));

            Stack = stack;
            this.lifecycleListener = lifecycleListener;
            this.valueContext = valueContext;
        }

        public object ConvertFrom(IValueContext context, CultureInfo culture, object value)
        {
            var valueStr = (string)value;
            if (!valueStr.Contains(":"))
            {
                // shorthand seconds format (ie. "0.25")
                var secs = double.Parse(valueStr, CultureInfo.InvariantCulture);
                return TimeSpan.FromSeconds(secs);
            }

            return TimeSpan.Parse(valueStr);
        }

 public object ConvertFrom(IValueContext context, CultureInfo culture, object value)
 {
     FontWeight result;
     
     if (Enum.TryParse(value as string, out result))
     {
         return result;
     }
     else
     {
         throw new ArgumentException("unable to convert parameter to FontWeight");
     }
 }

        public static bool TryConvert(object value, XamlType targetType, IValueContext valueContext, out object result)
        {
            result = null;
            foreach (var step in ValueConverters)
            {
                if (step.TryConvert(value, targetType, valueContext, out result))
                {
                    return true;
                }
            }

            return false;
        }

        public object ConvertFrom(IValueContext context, CultureInfo culture, object value)
        {
            var uri = new Uri((string)value, UriKind.RelativeOrAbsolute);
            var scheme = uri.IsAbsoluteUri ? uri.Scheme : "file";

            switch (scheme)
            {
                case "file":
                    return new Bitmap((string)value);
                default:
                    var assets = PerspexLocator.Current.GetService<IAssetLoader>();
                    return new Bitmap(assets.Open(uri));
            }
        }

 private static void SetBinding(
     object instance,
     MutableMember member, 
     AvaloniaProperty property, 
     IValueContext context,
     IBinding binding)
 {
     if (!(AssignBinding(instance, member, binding) || 
           ApplyBinding(instance, property, context, binding)))
     {
         throw new InvalidOperationException(
             $"Cannot assign to '{member.Name}' on '{instance.GetType()}");
     }
 }

 public object ConvertFrom(IValueContext context, CultureInfo culture, object value)
 {
     var path = value as string;
     if (path != null)
     {
         return CreateIconFromPath(context, path); 
     }
     var bitmap = value as IBitmap;
     if (bitmap != null)
     {
         return new WindowIcon(bitmap);
     }
     throw new NotSupportedException();
 }

        private WindowIcon CreateIconFromPath(IValueContext context, string path)
        {
            var uri = new Uri(path, UriKind.RelativeOrAbsolute);
            var baseUri = GetBaseUri(context);
            var scheme = uri.IsAbsoluteUri ? uri.Scheme : "file";

            switch (scheme)
            {
                case "file":
                    return new WindowIcon(path);
                default:
                    var assets = AvaloniaLocator.Current.GetService<IAssetLoader>();
                    return new WindowIcon(assets.Open(uri, baseUri));
            }
        }

        public object ConvertFrom(IValueContext context, CultureInfo culture, object value)
        {
            if (culture == null)
            {
                throw new ArgumentNullException("culture");
            }

            if (value == null)
            {
                throw new ArgumentNullException("value");
            }

            DateTimeFormatInfo dateTimeFormatInfo = (DateTimeFormatInfo)culture.GetFormat(typeof(DateTimeFormatInfo));
            DateTime d = DateTime.ParseExact(value.ToString(), dateTimeFormatInfo.ShortDatePattern, culture);
            return d;
        }

        public object ConvertFrom(IValueContext context, CultureInfo culture, object value)
        {
            var s = (string)value;

            string typeName;
            string propertyName;
            Type type;

            ParseProperty(s, out typeName, out propertyName);

            if (typeName == null)
            {
                var styleType = context.TypeRepository.GetByType(typeof(Style));
                var style = (Style)context.TopDownValueContext.GetLastInstance(styleType);
                type = style.Selector.TargetType;

                if (type == null)
                {
                    throw new ParseException(
                        "Could not determine the target type. Please fully qualify the property name.");
                }
            }
            else
            {
                type = context.TypeRepository.GetByQualifiedName(typeName)?.UnderlyingType;

                if (type == null)
                {
                    throw new ParseException($"Could not find type '{typeName}'.");
                }
            }

            // First look for non-attached property on the type and then look for an attached property.
            var property = PerspexPropertyRegistry.Instance.FindRegistered(type, s) ??
                           PerspexPropertyRegistry.Instance.GetAttached(type)
                           .FirstOrDefault(x => x.Name == propertyName);

            if (property == null)
            {
                throw new ParseException(
                    $"Could not find PerspexProperty '{type.Name}.{propertyName}'.");
            }

            return property;
        }

        public object ConvertTo(IValueContext context, CultureInfo culture, object value, Type destinationType)
        {
            if (destinationType == null)
            {
                throw new ArgumentNullException("destinationType");
            }

            if (culture == null)
            {
                throw new ArgumentNullException("culture");
            }

            DateTime? d = value as DateTime?;

            if (!d.HasValue || destinationType != typeof(string))
            {
                throw new NotSupportedException();
            }
            DateTimeFormatInfo dateTimeFormatInfo = (DateTimeFormatInfo)culture.GetFormat(typeof(DateTimeFormatInfo));
            return d.Value.ToString(dateTimeFormatInfo.ShortDatePattern, culture);
        }