WPF

// Make sure you raise the "PropertyChanged" event when the value changes:
public bool SomeBooleanValue
{
    get { return _someBooleanValue; }
    private set { SetProperty(ref _someBooleanValue, value); }
}

<TextBlock>
    <TextBlock.Style>
        <Style TargetType="TextBlock">
            <Style.Triggers>
                <DataTrigger Binding="{Binding Path=SomeBooleanValue}" Value="True">
                    <Setter Property="Foreground" Value="Green" />
                    <Setter Property="Text" Value="Success Message" />
                </DataTrigger>
                <DataTrigger Binding="{Binding Path=SomeBooleanValue}" Value="False">
                    <Setter Property="Foreground" Value="Red" />
                    <Setter Property="Text" Value="Failure Message" />
                </DataTrigger>
            </Style.Triggers>
        </Style>
    </TextBlock.Style>
</TextBlock>

foreach (var item in ToyList)
 {
    if (item.Data is BitmapImage img)
    {
        img.StreamSource.Dispose();
    }
}

// Summary:
//     Releases the unmanaged resources used by the System.IO.MemoryStream class and
//     optionally releases the managed resources.
//
// Parameters:
//   disposing:
//     true to release both managed and unmanaged resources; false to release only unmanaged
//     resources.
protected override void Dispose( bool disposing );

<Image Source="{Binding [0].Data}" Width="100" Height="100"/>

internal sealed class ToyItem : INotifyPropertyChanged, IDisposable
{
    ...
    
    public void Dispose()
    {
        if (Data is BitmapImage image)
        {
            image.StreamSource.Dispose();
        }
        
        Data = null;
    }
}

public class DisposableObservableCollection<T> 
    : ObservableCollection<T>, IDisposable 
    where T : IDisposable
{
    public DisposableObservableCollection(List<T> list) : base(list)
    {
    }
    
    public DisposableObservableCollection(IEnumerable<T> collection) : base(collection)
    {
    }
    
    public DisposableObservableCollection()
    {
    }
    
    protected override void SetItem(int index, T item)
    {
        T oldItem = this[index];
        base.SetItem(index, item);
        oldItem?.Dispose();
    }
    
    protected override void RemoveItem(int index)
    {
        T item = this[index];
        base.RemoveItem(index);
        item?.Dispose();
    }
    
    protected override void ClearItems()
    {
        List<T> itemsToDispose = Items.Where(i => i != null).ToList();
        base.ClearItems();
        foreach (T item in itemsToDispose)
        {
            item.Dispose();
        }
    }
}

ObservableCollection<ToyItem> ToyList = new DisposableObservableCollection<ToyItem>();

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Windows;
using System.Windows.Media;
using System.Windows.Media.Imaging;

namespace Toy
{


	internal class ToyItem : INotifyPropertyChanged, IDisposable
    {
        #region Boilerplate INotifyPropertyChanged

        protected void OnPropertyChanged(PropertyChangedEventArgs e)
        {
            PropertyChanged?.Invoke(this, e);
        }

        public void OnPropertyChanged([CallerMemberName] string propertyName = "")
        {
            OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
        }
        public event PropertyChangedEventHandler? PropertyChanged;

        #endregion

        public void Dispose()
        {
            if (Data is BitmapImage image)
            {
                image.StreamSource.Dispose();
            }

            Data = null;
        }

        /// <summary>
		/// Build an image from Picture bytes
		/// </summary>
		/// <param name="imageData">Picture as array of bytes</param>
		/// <returns>Pictures as BitmapImage</returns>
		public static ImageSource? BitmapFromRaw(byte[]? imageData)
		{
			if (imageData == null) return null;
			var image = new BitmapImage();
            var mem = new MemoryStream(imageData, false);
			//mem.Position = 0;
			image.BeginInit();
			//image.CreateOptions = BitmapCreateOptions.PreservePixelFormat;
			//image.CacheOption = BitmapCacheOption.None;
			//image.UriSource = null;
			image.StreamSource = mem;
			image.EndInit();
            //mem.Close();
            //mem.Dispose();
            image.Freeze();
 
            return image;
		}

		public ImageSource? Data
        {
            get { return _Data; }
            set
            {
                if (value != _Data)
                {
                    _Data = value;
                    OnPropertyChanged();
                }
            }
        }
        private ImageSource? _Data;
        
        public ToyItem ()
        {
            Data = BitmapFromRaw(Properties.Resources.pexels_jonathan_faria_8581946);
            //Data = new BitmapImage(new Uri(@"E:\Downloads\pexels-jonathan-faria-8581946.jpg"));
        }

    }


    public class DisposableObservableCollection<T> : ObservableCollection<T>, IDisposable
    where T : IDisposable
    {
        public DisposableObservableCollection(List<T> list) : base(list)
        {
        }

        public DisposableObservableCollection(IEnumerable<T> collection) : base(collection)
        {
        }

        public DisposableObservableCollection() : base ()
        {
        }

        protected override void SetItem(int index, T item)
        {
            T oldItem = this[index];
            base.SetItem(index, item);
            oldItem?.Dispose();
        }

        protected override void RemoveItem(int index)
        {
            T item = this[index];
            base.RemoveItem(index);
            item?.Dispose();
        }

        protected override void ClearItems()
        {
            List<T> itemsToDispose = Items.Where(i => i != null).ToList();
            base.ClearItems();
            foreach (T item in itemsToDispose)
            {
                item.Dispose();
            }
        }


        public void Dispose()
        {
            ClearItems();
        }

    }

    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {

        DisposableObservableCollection<ToyItem> ToyList = new DisposableObservableCollection<ToyItem>();

        int Counter = 0;

        public MainWindow()
        {
            InitializeComponent();

            wxToy.DataContext = ToyList;
            wxButton.Content = Counter;
        }

        private void gcButton_Click(object sender, RoutedEventArgs e)
        {
            GC.Collect();
        }

        private void wxButton_Click(object sender, RoutedEventArgs e)
        {
            wxButton.Content = ++Counter;

            //foreach (var item in ToyList)
            //{
            //    item.Data = null;
            //}

            ToyList.Clear();

            for (int i = 0; i < 5; i++)
            {
                ToyList.Add(new ToyItem());
            }
        }
    }

}

stream.Length = 0;
stream.Capacity = 0;

public class ManagedMemoryStream : Stream
 {
     private int Id;
     private static int Index = 0;
     private static int Counter = 0;

     private byte[]? Buffer;

     public override bool CanRead => true;

     public override bool CanSeek => false;

     public override bool CanWrite => false;

     public override long Length => _Length;
     private long _Length;

     public override long Position { get; set; }

     public override void Close()
     {
         System.Diagnostics.Debug.WriteLine($"ManagedMemoryStream: Close {Id} / {Counter}");
         base.Close();
         Dispose(true);
         Buffer = null;
     }

     public ManagedMemoryStream(byte[] buffer)
     {
         Id = Index++;
         System.Diagnostics.Debug.WriteLine($"ManagedMemoryStream: Construct {Id} / {++Counter}");

         Buffer = buffer;
         _Length = Buffer.Length;

     }


     ~ManagedMemoryStream()
     {
         System.Diagnostics.Debug.WriteLine($"ManagedMemoryStream: Finalize {Id} / {--Counter}");
         Dispose(false);
     }

     public override void Flush()
     {
         System.Diagnostics.Debug.WriteLine($"ManagedMemoryStream: Flush {Id} / {Counter}");
     }

     public override int Read(byte[] buffer, int offset, int count)
     {
         //System.Diagnostics.Debug.WriteLine($"ManagedMemoryStream: Read {Id}, {offset}, {count} / {Counter}");
         if (count == 0 || Buffer is null) return 0;
         int remaining = (int)(Buffer.Length - Position);
         if (count > remaining) count = remaining;

         Array.Copy(Buffer, Position, buffer, offset, count);
         Position += count;
         _Length -= count;

         return count;
     }

     public override long Seek(long offset, SeekOrigin origin)
     {
         throw new NotImplementedException();
     }

     public override void SetLength(long value)
     {
         throw new InvalidOperationException();
     }

     public override void Write(byte[] buffer, int offset, int count)
     {
         throw new InvalidOperationException();
     }
 }

public static ImageSource? BitmapFromRawNoLeak(byte[]? imageData)
{
    if (imageData == null) return null;
    ImageSource? image = null;

    // byte[] to Bitmap
    TypeConverter tc = TypeDescriptor.GetConverter(typeof(Bitmap));
    using (Bitmap? bmp = (Bitmap?)tc.ConvertFrom(imageData))
    {
        if (bmp == null) return null;

        // Force DPI to normal (96 DPI = no rescale) to avoid ugly rescaling in WPF when image comes from format with DPI
        bmp.SetResolution(96, 96);

        using (Bitmap source = new Bitmap(bmp.Width, bmp.Height))
        {
            if (source == null) return null;
            using (Graphics g = Graphics.FromImage(source))
            {
                g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
                g.DrawImage(bmp, 0, 0, bmp.Width, bmp.Height);

            }

            ImageConverter converter = new ImageConverter();
            var vect = (byte[])converter.ConvertTo(source, typeof(byte[]));
            image = BitmapFromRaw(vect);
            image?.Freeze();
        }
    }

    return image;
}

Starwer wrote:

C#

using (Bitmap source = new Bitmap(bmp.Width, bmp.Height))
{
    if (source == null) return null;