perf: optimize ImageDifferenceControl with RenderTargetBitmap caching

- Add intelligent caching to reduce memory allocations during alpha slider dragging
- Implement proper disposal in OnUnloaded to prevent memory leaks
- Add bounds checking with 8K max dimensions to prevent integer overflow
- Invalidate cache when images change via OnPropertyChanged
- Fix missing Avalonia using directive in DoubleConverters.cs

These optimizations significantly improve performance for large image diffs
while maintaining proper resource management and safety.

Author: biancode

src/Converters/DoubleConverters.cs

@@ -1,4 +1,5 @@
-using Avalonia.Data.Converters;
+using Avalonia;
+using Avalonia.Data.Converters;
 
 namespace SourceGit.Converters
 {

src/Views/ImageContainer.cs

@@ -397,6 +397,12 @@ static ImageDifferenceControl()
             AffectsRender<ImageDifferenceControl>(AlphaProperty);
         }
 
+        // Cached render target for performance optimization
+        private RenderTargetBitmap _cachedRenderTarget;
+        private Size _cachedSize;
+        private Bitmap _cachedOldImage;
+        private Bitmap _cachedNewImage;
+
         public override void Render(DrawingContext context)
         {
             base.Render(context);
@@ -409,19 +415,45 @@ public override void Render(DrawingContext context)
 
             if (drawLeft && drawRight)
             {
-                using (var rt = new RenderTargetBitmap(new PixelSize((int)Bounds.Width, (int)Bounds.Height), right.Dpi))
+                // Bounds checking for safe integer casting
+                var width = Math.Min(Math.Max(1, Bounds.Width), 8192);  // Max 8K width
+                var height = Math.Min(Math.Max(1, Bounds.Height), 8192); // Max 8K height
+                var pixelWidth = (int)Math.Ceiling(width);
+                var pixelHeight = (int)Math.Ceiling(height);
+
+                // Check if we need to recreate the cached render target
+                var currentSize = new Size(pixelWidth, pixelHeight);
+                var needsRecreate = _cachedRenderTarget == null ||
+                                   _cachedSize != currentSize ||
+                                   _cachedOldImage != left ||
+                                   _cachedNewImage != right;
+
+                if (needsRecreate)
                 {
-                    using (var dc = rt.CreateDrawingContext())
-                    {
-                        using (dc.PushRenderOptions(RO_SRC))
-                            RenderSingleSide(dc, left, rt.Size.Width, rt.Size.Height, Math.Min(1.0, 2.0 - 2.0 * alpha));
+                    // Dispose old cached render target
+                    _cachedRenderTarget?.Dispose();
+
+                    // Create new render target with bounds checking
+                    _cachedRenderTarget = new RenderTargetBitmap(new PixelSize(pixelWidth, pixelHeight), right.Dpi);
+                    _cachedSize = currentSize;
+                    _cachedOldImage = left;
+                    _cachedNewImage = right;
+                }
 
-                        using (dc.PushRenderOptions(RO_DST))
-                            RenderSingleSide(dc, right, rt.Size.Width, rt.Size.Height, Math.Min(1.0, 2.0 * alpha));
-                    }
+                // Render to the cached target
+                using (var dc = _cachedRenderTarget.CreateDrawingContext())
+                {
+                    // Clear the render target first
+                    dc.DrawRectangle(Brushes.Transparent, null, new Rect(0, 0, pixelWidth, pixelHeight));
 
-                    context.DrawImage(rt, new Rect(0, 0, Bounds.Width, Bounds.Height));
+                    using (dc.PushRenderOptions(RO_SRC))
+                        RenderSingleSide(dc, left, pixelWidth, pixelHeight, Math.Min(1.0, 2.0 - 2.0 * alpha));
+
+                    using (dc.PushRenderOptions(RO_DST))
+                        RenderSingleSide(dc, right, pixelWidth, pixelHeight, Math.Min(1.0, 2.0 * alpha));
                 }
+
+                context.DrawImage(_cachedRenderTarget, new Rect(0, 0, Bounds.Width, Bounds.Height));
             }
             else if (drawLeft)
             {
@@ -475,5 +507,30 @@ private void RenderSingleSide(DrawingContext context, Bitmap img, double w, doub
 
         private static readonly RenderOptions RO_SRC = new RenderOptions() { BitmapBlendingMode = BitmapBlendingMode.Source, BitmapInterpolationMode = BitmapInterpolationMode.HighQuality };
         private static readonly RenderOptions RO_DST = new RenderOptions() { BitmapBlendingMode = BitmapBlendingMode.Difference, BitmapInterpolationMode = BitmapInterpolationMode.HighQuality };
+
+        protected override void OnUnloaded(Avalonia.Interactivity.RoutedEventArgs e)
+        {
+            base.OnUnloaded(e);
+
+            // Clean up cached render target to prevent memory leaks
+            _cachedRenderTarget?.Dispose();
+            _cachedRenderTarget = null;
+            _cachedOldImage = null;
+            _cachedNewImage = null;
+        }
+
+        protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
+        {
+            base.OnPropertyChanged(change);
+
+            // Invalidate cache when images change
+            if (change.Property == OldImageProperty || change.Property == NewImageProperty)
+            {
+                _cachedRenderTarget?.Dispose();
+                _cachedRenderTarget = null;
+                _cachedOldImage = null;
+                _cachedNewImage = null;
+            }
+        }
     }
 }