title: Bindable Property is not updating view on iOS
body: <p>I am creating a cross platform app on xamarin.forms. I needed a custom renderer with gradient background and i've created it and it works well on both android and ios.
  However, when i want to change the colors of the gradient background, it does not work on iOS.</p>
  
  <p>Test.xaml.cs</p>
  
  <pre><code>namespace KiaiDay
  {
      public class TesteViewModel : INotifyPropertyChanged
      {
          public event PropertyChangedEventHandler PropertyChanged;
  
          private Color _startColor = Color.Green;
          public Color SStartColor
          {
              get =&gt; _startColor;
              set { _startColor = value; OnPropertyChanged(nameof(SStartColor)); }
          }
  
          private Color _endColor = Color.Blue;
          public Color EEndColor
          {
              get =&gt; _endColor;
              set { _endColor = value; OnPropertyChanged(nameof(EEndColor)); }
          }
  
          public ICommand Select
          {
              get =&gt; new Command(() =&gt;
              {
                  SStartColor = Color.Red;
                  EEndColor = Color.Brown;
              });
          }
  
          #region INotifyPropertyChanged Implementation
          void OnPropertyChanged([CallerMemberName] string propertyName = "")
          {
              if (PropertyChanged == null)
                  return;
  
              PropertyChanged.Invoke(this, new PropertyChangedEventArgs(propertyName));
          }
          #endregion
      }
  
      [XamlCompilation(XamlCompilationOptions.Compile)]
      public partial class teste : ContentPage
      {
          public teste()
          {
              BindingContext = new TesteViewModel();
              InitializeComponent();
          }
  
      }
  }
  
  </code></pre>
  
  <p>Test.xaml</p>
  
  <pre><code>    &lt;ContentPage.Content&gt;
          &lt;StackLayout HorizontalOptions="FillAndExpand" VerticalOptions="FillAndExpand"&gt;
              &lt;local:ShadowFrame StartColor="{Binding SStartColor}" EndColor="{Binding EEndColor}" HorizontalOptions="Center" VerticalOptions="Center"&gt;
                  &lt;Label Text="Teste"/&gt;
                  &lt;local:ShadowFrame.GestureRecognizers&gt;
                      &lt;TapGestureRecognizer NumberOfTapsRequired="1" Command="{Binding Select}"/&gt;
                  &lt;/local:ShadowFrame.GestureRecognizers&gt;
              &lt;/local:ShadowFrame&gt;
          &lt;/StackLayout&gt;
      &lt;/ContentPage.Content&gt;
  </code></pre>
  
  <p>Custom Renderer in PCL</p>
  
  <pre><code>public class ShadowFrame : Frame
      {
          public static BindableProperty ElevationProperty = BindableProperty.Create(nameof(Elevation), typeof(float), typeof(ShadowFrame), default(float));
          public static readonly BindableProperty StartColorProperty = BindableProperty.Create(nameof(StartColor), typeof(Color), typeof(ShadowFrame), default(Color));
          public static readonly BindableProperty EndColorProperty = BindableProperty.Create(nameof(EndColor), typeof(Color), typeof(ShadowFrame), default(Color));
  
          public float Elevation
          {
              get { return (float)GetValue(ElevationProperty); }
              set { SetValue(ElevationProperty, value); }
          }
  
          public Color StartColor
          {
              get { return (Color)GetValue(StartColorProperty); }
              set { SetValue(StartColorProperty, value); }
          }
  
          public Color EndColor
          {
              get { return (Color)GetValue(EndColorProperty); }
              set { SetValue(EndColorProperty, value); }
          }
      }
  </code></pre>
  
  <p>iOS Renderer(i think the problem is here)</p>
  
  <pre><code>[assembly: ExportRenderer(typeof(ShadowFrame), typeof(ShadowFrameRenderer))]
  namespace KiaiDay.iOS.Renderers
  {
      public class ShadowFrameRenderer : FrameRenderer
      {
          CAGradientLayer gradientLayer;
          private Color StartColor { get; set; }
          private Color EndColor { get; set; }
          CGRect rect;
  
          public static void Initialize()
          {
  
              // empty, but used for beating the linker
          }
  
          public ShadowFrameRenderer() =&gt; gradientLayer = new CAGradientLayer();
  
          public override void Draw(CGRect rect)
          {
              this.rect = rect;
              var stack = (ShadowFrame)this.Element;
              StartColor = stack.StartColor;
              EndColor = stack.EndColor;
              CGColor startColor = this.StartColor.ToCGColor();
              CGColor endColor = this.EndColor.ToCGColor();
              #region for Vertical Gradient  
              //var gradientLayer = new CAGradientLayer();     
              #endregion
              #region for Horizontal Gradient  
              //var gradientLayer = new CAGradientLayer()
              //{
              //    StartPoint = new CGPoint(0, 0.5),
              //    EndPoint = new CGPoint(1, 0.5)
              //};
              #endregion
              gradientLayer.Frame = rect;
              gradientLayer.Colors = new CGColor[] {
                  startColor,
                  endColor
              };
  
              NativeView.Layer.InsertSublayer(gradientLayer, 0);
              base.Draw(rect);
          }
  
          protected override void OnElementChanged(ElementChangedEventArgs&lt;Frame&gt; e)
          {
              base.OnElementChanged(e);
              var stack = (ShadowFrame)e.NewElement;
  
              if (e.OldElement != null || Element == null)
              {
                  return;
              }
  
              try
              {
                  this.StartColor = stack.StartColor;
                  this.EndColor = stack.EndColor;
                  UpdateShadow();
                  Draw(rect);
              }
  
              catch (Exception ex)
              {
                  System.Diagnostics.Debug.WriteLine("ERROR:", ex.Message);
              }
          }
  
          protected override void OnElementPropertyChanged(object sender, PropertyChangedEventArgs e)
          {
              base.OnElementPropertyChanged(sender, e);
              var stack = (ShadowFrame) sender;
  
              if (e.PropertyName == ShadowFrame.ElevationProperty.PropertyName)
              {
                  UpdateShadow();
              }
              if (e.PropertyName == ShadowFrame.StartColorProperty.PropertyName)
              {
                  this.StartColor = stack.StartColor;
              }
              if (e.PropertyName == ShadowFrame.EndColorProperty.PropertyName)
              {
                  this.EndColor = stack.EndColor;
              }
          }
  
  
          private void UpdateShadow()
          {
  
              var shadowFrame = (ShadowFrame)Element;
  
              // Update shadow to match better material design standards of elevation
              Layer.ShadowRadius = shadowFrame.Elevation;
              Layer.ShadowColor = UIColor.Gray.CGColor;
              Layer.ShadowOffset = new CGSize(2, 2);
              Layer.ShadowOpacity = 0.80f;
              Layer.ShadowPath = UIBezierPath.FromRect(Layer.Bounds).CGPath;
              Layer.MasksToBounds = false;
          }
      }
  }
  </code></pre>
  
  <p>I would like to update iOS view immediatly after i change the color through the command.</p>