SkiaSharp Xamarin问题：InvalidateSurface()在Android生效但iOS设备无效

Hey there! I’ve run into similar iOS-specific quirks with SkiaSharp in Xamarin before, so let’s break down what might be going on and how to fix it. Your setup works on Android and simulators, which points to either a thread issue, a dependency property implementation gap, or an iOS-specific SkiaSharp behavior.

1. Fix Your Dependency Property Implementation #

First up, your PointCoordinates property isn’t using the dependency property system correctly right now. When you define a bindable property, you should always use GetValue() and SetValue() instead of backing it with a private field directly. This is critical because iOS’s binding system relies on the dependency property infrastructure to propagate changes properly.

Here’s how to correct it:

public class CoordAxesControl : SKCanvasView {
    private float _absoluteMinXOfCoord;
    private float _absoluteMaxXOfCoord;
    private float _absoluteMinYOfCoord;
    private float _absoluteMaxYOfCoord;
    private SKPaint _blackPaint;

    #region DependencyProperties
    public static readonly BindableProperty PointCoordinatesProperty = 
        BindableProperty.Create(
            propertyName: nameof(PointCoordinates),
            returnType: typeof(IEnumerable<Tuple<int,int>>),
            defaultValue: new List<Tuple<int,int>>(),
            declaringType: typeof(CoordAxesControl),
            propertyChanged: DependencyPropertiesChanged);

    public IEnumerable<Tuple<int,int>> PointCoordinates {
        get { return (IEnumerable<Tuple<int,int>>)GetValue(PointCoordinatesProperty); }
        set { SetValue(PointCoordinatesProperty, value); }
    }
    #endregion

    private static void DependencyPropertiesChanged(BindableObject bindable, object oldValue, object newValue) {
        var control = (CoordAxesControl)bindable;
        if (oldValue != newValue) {
            // Ensure we're on the UI thread for iOS (strict thread requirements!)
            Device.BeginInvokeOnMainThread(() => {
                control.InvalidateSurface();
            });
        }
    }

    protected override void OnPaintSurface(SKPaintSurfaceEventArgs e) {
        if (PointCoordinates == null) return;
        var canvas = e.Surface.Canvas;
        canvas.Clear();
        _blackPaint = new SKPaint();
        _blackPaint.Color = SKColors.Black;
        _blackPaint.StrokeWidth = 5;
        // Your drawing logic here
    }
}

The key fixes here:

• Removed the redundant private _pointCoordinates field (the dependency property system manages the value internally)
• Updated the property getter/setter to use GetValue()/SetValue() to align with Xamarin’s binding rules
• Wrapped InvalidateSurface() in Device.BeginInvokeOnMainThread() — iOS strictly requires UI updates to happen on the main thread, and dependency property changes can sometimes fire on background threads depending on your binding setup.

2. Update SkiaSharp to the Latest Stable Version #

Older versions of SkiaSharp had known bugs related to InvalidateSurface() on iOS 13.x. Head to your NuGet packages and update SkiaSharp and SkiaSharp.Views.Xamarin.Forms to the latest stable release (at least v2.88.x or newer). This alone can resolve many iOS-specific rendering inconsistencies.

3. Verify the SKCanvasView Has a Valid Size #

If your CoordAxesControl has zero width/height on iOS, OnPaintSurface() might not fire at all. Double-check that you’ve applied proper layout constraints or set explicit dimensions for the control. iOS views won’t render if they’re not sized correctly, even if the code logic is sound.

4. Add Base.OnPaintSurface(e) (Edge Case Fix) #

While the default SKCanvasView.OnPaintSurface() is empty, adding a call to the base method can sometimes resolve edge cases where iOS’s view lifecycle expects it. Update your override:

protected override void OnPaintSurface(SKPaintSurfaceEventArgs e) {
    base.OnPaintSurface(e); // Add this line
    if (PointCoordinates == null) return;
    // Rest of your drawing logic
}

5. Debug with Console Logs #

To confirm what’s happening, add debug logs to both methods to track execution flow:

private static void DependencyPropertiesChanged(BindableObject bindable, object oldValue, object newValue) {
    var control = (CoordAxesControl)bindable;
    if (oldValue != newValue) {
        Console.WriteLine($"PointCoordinates updated: {newValue?.Cast<object>().Count()} points");
        Device.BeginInvokeOnMainThread(() => {
            Console.WriteLine("Calling InvalidateSurface() on main thread");
            control.InvalidateSurface();
        });
    }
}

protected override void OnPaintSurface(SKPaintSurfaceEventArgs e) {
    Console.WriteLine("OnPaintSurface triggered!");
    // Rest of your code
}

Check the Xamarin debug output for iOS to see if the property change log appears but the OnPaintSurface log doesn’t. If that’s the case, the issue is definitely tied to how iOS handles the invalidation call.

In my experience, fixing the dependency property implementation and enforcing main thread execution for InvalidateSurface() resolves this issue 9 times out of 10. iOS is far stricter about UI thread safety than Android, which is why the problem only shows up on iOS devices.

内容的提问来源于stack exchange，提问作者CJ Thiele