WPF

/// <summary>
/// Apparently this is not supported by Xamarin and/or PCL, hence provide custom simplistic implementation
/// </summary>
public abstract class ValidationAttribute : Attribute
{
    public abstract void Validate(ModelBase model, FastMember member, object value);

    public string ErrorMessage { get; set; }
}
/// <summary>
/// Base class for Model and ViewModel used in WPF, just basic <see cref="INotifyPropertyChanged"/>
/// and <see cref="INotifyDataErrorInfo"/> plumbing
/// </summary>
public class ModelBase : INotifyPropertyChanged, INotifyDataErrorInfo
{
    #region INotifyPropertyChanged

    public virtual void OnPropertyChanged([CallerMemberName]string name = "")
    {
        if (ValidatePropertyOnNotifyChanged)
        {
            if (string.IsNullOrEmpty(name))
            {
                Validate();
            }
            else
            {
                Validate(name);
            }
        }

        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
    }
    public event PropertyChangedEventHandler PropertyChanged;

    #endregion

    #region ValidatePropertyOnNotifyChanged Validate()

    public bool ValidatePropertyOnNotifyChanged
    {
        get { return mValidatePropertyOnNotifyChanged; }
        set
        {
            if (value == mValidatePropertyOnNotifyChanged)
                return;

            mValidatePropertyOnNotifyChanged = value;

            if (value)
                Validate();
        }
    }
    bool mValidatePropertyOnNotifyChanged;

    public bool Validate()
    {
        ClearErrors();
        foreach (var p in GetFastType().GetRuntimeMembers())
            Validate(p);
        return !HasErrors;
    }

    #endregion

    #region Errors (databinding error friend)

    public ErrorIndex Errors
    {
        get
        {
            if (eInfos == null)
                eInfos = new ErrorIndex(this);
            return eInfos;
        }
    }
    ErrorIndex eInfos;

    public class ErrorIndex : INotifyPropertyChanged
    {
        ModelBase model;
        internal ErrorIndex(ModelBase model)
        {
            this.model = model;
        }

        public ErrorData this[string property]
        {
            get
            {
                var errs = model.GetErrors(property).Cast<object>();
                return new ErrorData
                {
                    HasError = errs.Any(),
                    Error = errs.FirstOrDefault(),
                    Errors = errs,
                };
            }
        }
        internal void Updated(string pName) { PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(pName)); }
        public event PropertyChangedEventHandler PropertyChanged;
    }
    public class ErrorData
    {
        public bool HasError { get; set; }
        public object Error { get; set; }
        public System.Collections.IEnumerable Errors { get; set; }
    }

    #endregion

    #region INotifyDataErrorInfo

    // make 'errors field' an auto initialize field, to get around deserialization issue
    List<Tuple<string, object>> errors
    {
        get
        {
            if (_errors == null)
                _errors = new List<Tuple<string, object>>();
            return _errors;
        }
    }
    List<Tuple<string, object>> _errors;

    public event EventHandler<DataErrorsChangedEventArgs> ErrorsChanged;

    void RaiseErrorChanged(string pName)
    {
        pName = '[' + pName + ']';
        ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(pName));
        OnPropertyChanged(nameof(HasErrors));
        eInfos?.Updated(pName);
    }

    public System.Collections.IEnumerable GetErrors(string propertyName)
    {
        return errors.Where(x => x.Item1 == propertyName).Select(x => x.Item2);
    }

    public bool HasErrors { get { return errors.Count > 0; } }

    public void UpdateErrors(string propertyName, params object[] errors) { UpdateErrors(propertyName, (IEnumerable<object>)errors); }
    public void UpdateErrors(string propertyName, IEnumerable<object> errors)
    {
        bool had = false;
        for (int i = this.errors.Count - 1; i >= 0; i--)
        {
            if (this.errors[i].Item1 == propertyName)
            {
                had = true;
                this.errors.RemoveAt(i);
            }
        }
        bool will = false;
        if (errors != null)
        {
            errors.ForEach(x =>
            {
                will = true;
                this.errors.Add(Tuple.Create(propertyName, x));
            });
        }
        if (had || will)
        {
            RaiseErrorChanged(propertyName);
        }
    }

    public void AddErrors(string propertyName, params object[] errors) { AddErrors(propertyName, (IEnumerable<object>)errors); }
    public void AddErrors(string propertyName, IEnumerable<object> errors)
    {
        if (errors == null || errors.Count() == 0)
            return;

        errors.ForEach(x => this.errors.Add(Tuple.Create(propertyName, x)));

        RaiseErrorChanged(propertyName);
    }

    public void ClearErrors(string propertyName)
    {
        int count = 0;
        for (int i = errors.Count - 1; i >= 0; i--)
        {
            if (errors[i].Item1 == propertyName)
            {
                errors.RemoveAt(i);
                count++;
            }
        }
        if (count > 0)
            RaiseErrorChanged(propertyName);
    }
    public void ClearErrors()
    {
        var names = errors.Select(x => x.Item1).Distinct().ToList();
        errors.Clear();
        names.ForEach(x => RaiseErrorChanged(x));
    }

    /// <summary>
    /// Run attribute validation on a given property
    /// </summary>
    public bool Validate([CallerMemberName]string propertyName = null)
    {
        if (propertyName == null)
            return Validate();

        var m = GetFastType().GetRuntimeMembers().First(x => x.Name == propertyName);
        ClearErrors(propertyName);
        Validate(m);
        return !GetErrors(propertyName).Cast<object>().Any();
    }

    FastType GetFastType() { return meType ?? (meType = FastType.GetType((GetType()))); }
    FastType meType;

    protected virtual void Validate(FastMember pi)
    {
        if (pi == null)
            return;

        var value = pi.GetValue(this);
        var attrs = pi.GetAttributes().OfType<ValidationAttribute>();
        foreach (var attr in attrs)
            attr.Validate(this, pi, value);
    }

    #endregion

    #region extra utilities: GetLazyCommand() AddWatch()

    public DelegateCommand GetLazyCommand(Action onAction, [CallerMemberName]string name = null)
    {
        if (mCommands == null)
            mCommands = new Dictionary<string, DelegateCommand>();
        if (!mCommands.TryGetValue(name, out var result))
            mCommands[name] = result = new DelegateCommand(onAction);
        return result;
    }

    public DelegateCommand GetLazyCommand(Action<object> onAction, [CallerMemberName]string name = null)
    {
        if (mCommands == null)
            mCommands = new Dictionary<string, DelegateCommand>();
        if (!mCommands.TryGetValue(name, out var result))
            mCommands[name] = result = new DelegateCommand(onAction);
        return result;
    }

    public DelegateCommand GetLazyCommandAsync(Func<Task> onAction, [CallerMemberName]string name = null)
    {
        if (mCommands == null)
            mCommands = new Dictionary<string, DelegateCommand>();
        if (!mCommands.TryGetValue(name, out var result))
        {
            var cmd = new DelegateCommand();
            cmd.Action = async (o) =>
            {
                try
                {
                    cmd.IsEnabled = false;
                    await onAction();
                }
                finally { cmd.IsEnabled = true; }
            };
            mCommands[name] = result = cmd;
        }
        return result;
    }

    Dictionary<string, DelegateCommand> mCommands;

    public void AddWatch<TP>(Expression<Func<TP>> e, Action<TP> onChange)
    {
        if (watchers == null)
            watchers = new List<PropertyPath>();
        var w = PropertyPath.Create(e);
        watchers.Add(w);
        w.PropertyChanged += delegate { onChange(w.Value); };
    }
    List<PropertyPath> watchers;

    #endregion
}

/// <summary>
/// Extension method for IDataErrorInfo.
///
/// Uses reflection to get the properties that can be modified,
/// and validates them using the IDataErrorInfo interface.
///
/// Returns false if no errors.
/// </summary>
public static bool HasErrors( this IDataErrorInfo dataObject ) {

   Type dataObjectType = dataObject.GetType();
   PropertyInfo[] pInfo = dataObjectType.GetProperties( BindingFlags.Public | BindingFlags.Instance );

   foreach ( PropertyInfo p in pInfo ) {
      if ( p.CanWrite ) {
         if ( string.IsNullOrEmpty( dataObject[ p.Name ] ) == false ) {
            return true;   // Error detected.
         }
      }
   }  // end foreach.

   return false;     // No error detected.
}

/// <summary>
/// Validates a single property.
/// </summary>
public static bool HasErrors( this IDataErrorInfo dataObject, string name ) {

   if ( string.IsNullOrEmpty( dataObject[ name ] ) == false ) {
      return true;
   }

   return false;     // No error detected.
}

public class PulsedBrush
{
    public PulsedBrush()
    {
        Brush = new SolidColorBrush();
    }
    public PulsedBrush(Func<double, Color> get)
        : this()
    {
        GetColor = get;
        Update();
    }

    /// <summary>
    /// Function to get the color for the time.
    /// </summary>
    public Func<double, Color> GetColor { get; set; }

    public SolidColorBrush Brush { get; private set; }

    public static double DaySeconds
    {
        get
        {
            return DateTime.Now.TimeOfDay.Ticks / (double)TimeSpan.TicksPerSecond;
        }
    }

    public void Update()
    {
        if (GetColor != null)
        {
            Brush.Color = GetColor(DaySeconds);
        }
    }
}

public partial class SomeControl : UserControl
{
    public SomeControl()
    {
        InitializeComponent();
        for (int i = 0; i < 20; i++)
        {
            OnOffValues.Add(true);
        }
    }

    public List<bool> OnOffValues
    {
        get { return (List<bool>)GetValue(OnOffValuesProperty); }
        set { SetValue(OnOffValuesProperty, value); }
    }

    public static readonly DependencyProperty OnOffValuesProperty =
        DependencyProperty.Register("OnOffValues", typeof(List<bool>),
            typeof(SomeControl), new PropertyMetadata(new List<bool>()));

}

<CheckBox IsChecked="{Binding Path=OnOffValues[0], RelativeSource={RelativeSource FindAncestor, AncestorType=UserControl}}"/>