Fixed perf issues

Toolkit.Avalonia/ImageResizer.cs

@@ -6,48 +6,56 @@ namespace Toolkit.Avalonia;
 public class ImageResizer : 
     IImageResizer
 {
-    public Bitmap Resize(Stream stream, 
-        int targetWidth, 
-        int targetHeight, 
+    public Bitmap Resize(Stream stream,
+        int targetWidth,
+        int targetHeight,
         bool maintainAspectRatio)
     {
-        using SKBitmap original = SKBitmap.Decode(stream);
+        Bitmap bitmap = new(stream);
 
-        float widthRatio = (float)targetWidth / original.Width;
-        float heightRatio = (float)targetHeight / original.Height;
-        float scale = maintainAspectRatio ? Math.Max(widthRatio, heightRatio) : Math.Min(widthRatio, heightRatio);
-
-        int newWidth = (int)(original.Width * scale);
-        int newHeight = (int)(original.Height * scale);
-
-        using SKBitmap resized = new(newWidth, newHeight);
-        using SKCanvas canvas = new(resized);
-
-        canvas.Clear(SKColors.Transparent);
-        canvas.DrawBitmap(original, new SKRect(0, 0, newWidth, newHeight));
-
-        SKBitmap cropped;
-        if (maintainAspectRatio)
+        if (bitmap.Size.Width != targetWidth || bitmap.Size.Height != targetHeight)
         {
-            int cropX = (newWidth - targetWidth) / 2;
-            int cropY = (newHeight - targetHeight) / 2;
+            using SKBitmap sKBitmap = SKBitmap.Decode(stream);
+            SKBitmap? cropped = null;
+            bitmap.Dispose();
 
-            cropped = new SKBitmap(targetWidth, targetHeight);
-            using SKCanvas croppedCanvas = new(cropped);
-            SKRect cropRect = new(cropX, cropY, cropX + targetWidth, cropY + targetHeight);
-            croppedCanvas.Clear(SKColors.Transparent);
-            croppedCanvas.DrawBitmap(resized, cropRect, new SKRect(0, 0, targetWidth, targetHeight));
-        }
-        else
-        {
-            cropped = resized;
+            float widthRatio = (float)targetWidth / sKBitmap.Width;
+            float heightRatio = (float)targetHeight / sKBitmap.Height;
+            float scale = maintainAspectRatio ? Math.Max(widthRatio, heightRatio) : Math.Min(widthRatio, heightRatio);
+
+            int newWidth = (int)(sKBitmap.Width * scale);
+            int newHeight = (int)(sKBitmap.Height * scale);
+
+            using SKBitmap resized = new(newWidth, newHeight);
+            using SKCanvas canvas = new(resized);
+
+            canvas.Clear(SKColors.Transparent);
+            canvas.DrawBitmap(sKBitmap, new SKRect(0, 0, newWidth, newHeight));
+
+            if (maintainAspectRatio)
+            {
+                int cropX = (newWidth - targetWidth) / 2;
+                int cropY = (newHeight - targetHeight) / 2;
+
+                cropped = new SKBitmap(targetWidth, targetHeight);
+                using SKCanvas croppedCanvas = new(cropped);
+                SKRect cropRect = new(cropX, cropY, cropX + targetWidth, cropY + targetHeight);
+                croppedCanvas.Clear(SKColors.Transparent);
+                croppedCanvas.DrawBitmap(resized, cropRect, new SKRect(0, 0, targetWidth, targetHeight));
+            }
+            else
+            {
+                cropped = resized;
+            }
+
+            using SKImage image = SKImage.FromBitmap(cropped);
+            using MemoryStream outputStream = new();
+            image.Encode(SKEncodedImageFormat.Png, 100).SaveTo(outputStream);
+            outputStream.Seek(0, SeekOrigin.Begin);
+
+            return new Bitmap(outputStream);
         }
 
-        using SKImage image = SKImage.FromBitmap(cropped);
-        using MemoryStream outputStream = new();
-        image.Encode(SKEncodedImageFormat.Png, 100).SaveTo(outputStream);
-        outputStream.Seek(0, SeekOrigin.Begin);
-
-        return new Bitmap(outputStream);
+        return bitmap;
     }
 }

Toolkit.Foundation/Activation.cs

@@ -0,0 +1,9 @@
+namespace Toolkit.Foundation;
+
+public record Activation
+{
+    public static ActivationEventArgs<TSender, TValue> As<TSender, TValue>(TValue value) => new(value);
+
+    public static ActivationEventArgs<TSender> As<TSender>() =>
+        new();
+}

Toolkit.Foundation/ActivationBuilder.cs

@@ -0,0 +1,3 @@
+namespace Toolkit.Foundation;
+
+public record ActivationBuilder(IActivation Value, object? Key = null);

Toolkit.Foundation/ActivationEventArgs.cs

@@ -0,0 +1,7 @@
+namespace Toolkit.Foundation;
+
+public record ActivationEventArgs<TSynchronize, TValue>(TValue? Value = default) :
+    IActivation;
+
+public record ActivationEventArgs<TSynchronize>() :
+    IActivation;

Toolkit.Foundation/IActivation.cs

@@ -1,3 +1,3 @@
 namespace Toolkit.Foundation;
 
-public interface ISynchronize;
+public interface IActivation;

Toolkit.Foundation/Observable.cs

@@ -74,6 +74,11 @@ public partial class Observable(IServiceProvider provider,
         Disposer.Dispose(this);
     }
 
+    public virtual void OnInitialize()
+    {
+
+    }
+
     public virtual void Initialize()
     {
         if (IsInitialized)
@@ -83,6 +88,7 @@ public partial class Observable(IServiceProvider provider,
 
         IsInitialized = true;
         Subscriber.Subscribe(this);
+        OnInitialize();
     }
 
     public void Revert()

Toolkit.Foundation/ObservableCollection.cs

@@ -266,7 +266,7 @@ public partial class ObservableCollection<TItem> :
         Disposer.Dispose(this);
     }
 
-    public void Fetch(Func<SynchronizeExpression> aggregateDelegate,
+    public void Activate(Func<ActivationBuilder> aggregateDelegate, 
         bool reset = false)
     {
         if (reset)
@@ -274,8 +274,8 @@ public partial class ObservableCollection<TItem> :
             Clear();
         }
 
-        SynchronizeExpression expression = aggregateDelegate.Invoke();
-        Publisher.PublishUI(expression.Value, expression.Key);
+        ActivationBuilder expression = aggregateDelegate.Invoke();
+        Publisher.Publish(expression.Value, expression.Key);
     }
 
     public IEnumerator<TItem> GetEnumerator() =>
@@ -415,6 +415,11 @@ public partial class ObservableCollection<TItem> :
         IsCompatibleObject(value) ?
         IndexOf((TItem)value!) : -1;
 
+    public virtual void OnInitialize()
+    {
+
+    }
+
     public virtual void Initialize()
     {
         if (IsInitialized)
@@ -423,9 +428,10 @@ public partial class ObservableCollection<TItem> :
         }
 
         IsInitialized = true;
-
         Subscriber.Subscribe(this);
-        Synchronize();
+        OnInitialize();
+
+        Activate();
     }
 
     public TItem Insert<T>(int index = 0,
@@ -570,15 +576,15 @@ public partial class ObservableCollection<TItem> :
         }
     }
 
-    public void Synchronize(bool reset = false)
+    public void Activate(bool reset = false)
     {
         if (reset)
         {
             Clear();
         }
 
-        SynchronizeExpression expression = BuildAggregateExpression();
-        Publisher.PublishUI(expression.Value, expression.Key);
+        ActivationBuilder builder = ActivationBuilder();
+        Publisher.PublishUI(builder.Value, builder.Key);
     }
 
     public void Track<T>(string propertyName, Func<T> getter, Action<T> setter)
@@ -590,8 +596,8 @@ public partial class ObservableCollection<TItem> :
         }
     }
 
-    protected virtual SynchronizeExpression BuildAggregateExpression() =>
-        new(new SynchronizeEventArgs<TItem>());
+    protected virtual ActivationBuilder ActivationBuilder() =>
+        new(new ActivationEventArgs<TItem>());
 
     protected virtual void ClearItems() =>
         collection.Clear();

Toolkit.Foundation/Synchronize.cs

@@ -1,9 +0,0 @@
-namespace Toolkit.Foundation;
-
-public record Synchronize
-{
-    public static SynchronizeEventArgs<TValue, TOptions> As<TValue, TOptions>(TOptions options) => new(options);
-
-    public static SynchronizeEventArgs<TValue> As<TValue>() =>
-        new();
-}

Toolkit.Foundation/SynchronizeEventArgs.cs

@@ -1,7 +0,0 @@
-namespace Toolkit.Foundation;
-
-public record SynchronizeEventArgs<TSynchronize, TValue>(TValue? Value = default) :
-    ISynchronize;
-
-public record SynchronizeEventArgs<TSynchronize>() :
-    ISynchronize;

Toolkit.Foundation/SynchronizeExpression.cs

@@ -1,3 +0,0 @@
-namespace Toolkit.Foundation;
-
-public record SynchronizeExpression(ISynchronize Value, object? Key = null);