Install-Package Microsoft.Xaml.Behaviros.WPF
Install-Package Newtonsoft.json

public class ItemsControlBehavior:Behavior<ItemsControl>
{
    private ContextMenu ctxMenu;
    private MenuItem saveItem;
    public ItemsControlBehavior()
    {
        
    }

    protected override void OnAttached()
    {
        base.OnAttached();
        CreateContextMenu();
    }

    private void CreateContextMenu()
    {
        ctxMenu=new ContextMenu();
        saveItem = new MenuItem()
        {
            Header = "Save All Items"
        };

        saveItem.Click += SaveItem_Click;
        ctxMenu.Items.Add(saveItem);
        AssociatedObject.ContextMenu= ctxMenu;
    }

    private void SaveItem_Click(object sender, RoutedEventArgs e)
    {
        SaveCommand?.Execute(CmdPara);
    }

    protected override void OnDetaching()
    {
        base.OnDetaching();
        if(saveItem!=null)
        {
            saveItem.Click -= SaveItem_Click;
            saveItem = null;
        }

        if(ctxMenu!=null)
        {
            ctxMenu.Items.Clear();
            ctxMenu = null;
        }

        AssociatedObject.ContextMenu = null;
    }

    public ICommand SaveCommand
    {
        get { return (ICommand)GetValue(SaveCommandProperty); }
        set { SetValue(SaveCommandProperty, value); }
    }

    // Using a DependencyProperty as the backing store for SaveCommand.  This enables animation, styling, binding, etc...
    public static readonly DependencyProperty SaveCommandProperty =
        DependencyProperty.Register(nameof(SaveCommand), typeof(ICommand), typeof(ItemsControlBehavior),
            new PropertyMetadata(null));




    public object CmdPara
    {
        get { return (object)GetValue(CmdParaProperty); }
        set { SetValue(CmdParaProperty, value); }
    }

    // Using a DependencyProperty as the backing store for CmdPara.  This enables animation, styling, binding, etc...
    public static readonly DependencyProperty CmdParaProperty =
        DependencyProperty.Register(nameof(CmdPara), typeof(object), typeof(ItemsControlBehavior),
            new PropertyMetadata(null));

}


  <behavior:Interaction.Behaviors>
      <local:ItemsControlBehavior SaveCommand="{Binding DataContext.SaveCmd,RelativeSource={RelativeSource AncestorType=Window}}"
                                  CmdPara="{Binding Path=ItemsSource,RelativeSource={RelativeSource AncestorType=ItemsControl}}"/>
  </behavior:Interaction.Behaviors>

<Window x:Class="WpfApp20.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:behavior="http://schemas.microsoft.com/xaml/behaviors"
        xmlns:local="clr-namespace:WpfApp20"
        mc:Ignorable="d"
        WindowState="Maximized"
        Title="{Binding MainTitle}">
    <Window.DataContext>
        <local:MainVM/>
    </Window.DataContext>
    <Window.Resources>
        <local:ImgUrlConverter x:Key="ImgUrlConverter"/>
    </Window.Resources>
    <Grid>
        <ItemsControl ItemsSource="{Binding BooksCollection}">
            <ItemsControl.Template>
                <ControlTemplate>
                    <ScrollViewer CanContentScroll="True">
                        <VirtualizingStackPanel IsItemsHost="True"
                                                VirtualizingPanel.IsVirtualizing="True"
                                                VirtualizingPanel.VirtualizationMode="Recycling"
                                                VirtualizingPanel.CacheLength="2,2"
                                                VirtualizingPanel.CacheLengthUnit="Item"
                                                ScrollViewer.IsDeferredScrollingEnabled="True"
                                                ScrollViewer.CanContentScroll="True"
                                                UseLayoutRounding="True"
                                                SnapsToDevicePixels="True"/>
                    </ScrollViewer>
                </ControlTemplate>
            </ItemsControl.Template>
            <ItemsControl.ItemTemplate>
                <DataTemplate>
                    <Grid Width="{x:Static SystemParameters.FullPrimaryScreenWidth}"
                          Height="{x:Static SystemParameters.FullPrimaryScreenHeight}">
                        <Grid.Resources>
                            <Style TargetType="TextBlock">
                                <Setter Property="FontSize" Value="50"/>
                                <Style.Triggers>
                                    <Trigger Property="IsMouseOver" Value="True">
                                        <Setter Property="FontSize" Value="100"/>
                                        <Setter Property="Foreground" Value="Red"/>
                                    </Trigger>
                                </Style.Triggers>
                            </Style>
                        </Grid.Resources>
                        <Grid.RowDefinitions>
                            <RowDefinition/>
                            <RowDefinition/>
                        </Grid.RowDefinitions>
                        <Grid.ColumnDefinitions>
                            <ColumnDefinition/>
                            <ColumnDefinition/>
                        </Grid.ColumnDefinitions>
                        <Image Source="{Binding ImgUrl,Converter={StaticResource ImgUrlConverter}}"
                               Stretch="Uniform"
                               Grid.Row="0" Grid.RowSpan="2"
                               Grid.Column="0" Grid.ColumnSpan="2"/>
                        <TextBlock Text="{Binding Id}" Grid.Row="0" Grid.Column="0"/>
                        <TextBlock Text="{Binding Name}" Grid.Row="0" Grid.Column="1"/>
                        <TextBlock Text="{Binding ISBN}" Grid.Row="1" Grid.Column="0" Grid.ColumnSpan="2"/>
                    </Grid>
                </DataTemplate>               
            </ItemsControl.ItemTemplate>
            <behavior:Interaction.Behaviors>
                <local:ItemsControlBehavior SaveCommand="{Binding DataContext.SaveCmd,RelativeSource={RelativeSource AncestorType=Window}}"
                                            CmdPara="{Binding Path=ItemsSource,RelativeSource={RelativeSource AncestorType=ItemsControl}}"/>
            </behavior:Interaction.Behaviors>
        </ItemsControl>
    </Grid>
</Window>


using Microsoft.Xaml.Behaviors;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Globalization;
using System.IO;
using System.Runtime.CompilerServices;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;

namespace WpfApp20
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }
    }

    public class MainVM : INotifyPropertyChanged
    {
        public ICommand SaveCmd { get; set; }
        public object CmdPara {  get; set; }
        public MainVM()
        {
            SaveCmd = new DelCmd(SaveCmdExecuted);
            Task.Run(async () =>
            {
                await InitBooksCollectionAsync();
            });
        }

        private void SaveCmdExecuted(object? obj)
        {
            var items = ((System.Collections.IList)obj)?.Cast<Book>()?.ToList();
            if(items!=null && items.Any())
            {
                string jsonStr = Newtonsoft.Json.JsonConvert.SerializeObject(items, Newtonsoft.Json.Formatting.Indented);
                string jsonFile = $"{DateTime.Now.ToString("yyyyMMddHHmmssffff")}.json";
                using(StreamWriter sw=new StreamWriter(jsonFile,false,Encoding.UTF8))
                {
                    sw.WriteLine(jsonStr);
                    MessageBox.Show($"Save {items.Count()} items in {jsonFile}", $"{DateTime.Now}");
                }
            }
        }

        private async Task InitBooksCollectionAsync(int cnt=5000000)
        {
            var imgDir = @"../../../Images";
            if(!Directory.Exists(imgDir))
            {
                return;
            }

            var imgs=Directory.GetFiles(imgDir);
            if(imgs==null ||!imgs.Any())
            {
                return;
            }

            int imgsCnt = imgs.Count();
            BooksCollection = new ObservableCollection<Book>();
            List<Book> bksList=new List<Book>();

            for(int i=1;i<cnt+1;i++)
            {
                bksList.Add(new Book()
                {
                    Id = i,
                    Name = $"Name_{i}",
                    ISBN = $"ISBN_{i}_{Guid.NewGuid():N}",
                    ImgUrl = $"{imgs[i % imgsCnt]}"
                });

                if(i%100000==0)
                {
                    await PopulateBooksCollectionAsync(bksList);
                }
            }

            if(bksList.Any())
            {
                await PopulateBooksCollectionAsync(bksList);
            }
        }

        private async Task PopulateBooksCollectionAsync(List<Book> bksList)
        {
            await Application.Current.Dispatcher.InvokeAsync(() =>
            {
                var tempList = bksList.ToList();
                bksList.Clear();
                foreach (var bk in tempList)
                {
                    BooksCollection.Add(bk);
                }
                MainTitle = $"{DateTime.Now},loaded {BooksCollection.Count} items,{GetMem()}";
            });
        }

        private string GetMem()
        {
            return $"memory {System.Diagnostics.Process.GetCurrentProcess().PrivateMemorySize64 / 1024 / 1024:N2} M";
        }

        private string mainTitle = $"{DateTime.Now},loading...";
        public string MainTitle
        {
            get
            {
                return mainTitle;
            }
            set
            {
                if(value!=mainTitle)
                {
                    mainTitle = value;
                    OnPropertyChanged();
                }
            }
        }

        private ObservableCollection<Book> booksCollection;
        public ObservableCollection<Book> BooksCollection
        {
            get
            {
                return booksCollection;
            }
            set
            {
                if(value!=booksCollection)
                {
                    booksCollection = value;
                    OnPropertyChanged();
                }
            }
        }

        public event PropertyChangedEventHandler? PropertyChanged;
        private void OnPropertyChanged([CallerMemberName] string propName="")
        {
            var handler = PropertyChanged;
            handler?.Invoke(this, new PropertyChangedEventArgs(propName));
        }
    }

    public class DelCmd : ICommand
    {
        private Action<object?>? execute;
        private Predicate<object?>? canExecute;
        public DelCmd(Action<object?>? executeValue, Predicate<object?>? canExecuteValue=null)
        {
            execute= executeValue;
            canExecute= canExecuteValue;
        }

        public event EventHandler? CanExecuteChanged
        {
            add
            {
                CommandManager.RequerySuggested += value;
            }
            remove
            {
                CommandManager.RequerySuggested -= value;
            }
        }

        public bool CanExecute(object? parameter)
        {
            return canExecute == null ? true : canExecute(parameter);
        }

        public void Execute(object? parameter)
        {
            execute?.Invoke(parameter);
        }
    }

    public class ItemsControlBehavior:Behavior<ItemsControl>
    {
        private ContextMenu ctxMenu;
        private MenuItem saveItem;
        public ItemsControlBehavior()
        {
            
        }

        protected override void OnAttached()
        {
            base.OnAttached();
            CreateContextMenu();
        }

        private void CreateContextMenu()
        {
            ctxMenu=new ContextMenu();
            saveItem = new MenuItem()
            {
                Header = "Save All Items"
            };

            saveItem.Click += SaveItem_Click;
            ctxMenu.Items.Add(saveItem);
            AssociatedObject.ContextMenu= ctxMenu;
        }

        private void SaveItem_Click(object sender, RoutedEventArgs e)
        {
            SaveCommand?.Execute(CmdPara);
        }

        protected override void OnDetaching()
        {
            base.OnDetaching();
            if(saveItem!=null)
            {
                saveItem.Click -= SaveItem_Click;
                saveItem = null;
            }

            if(ctxMenu!=null)
            {
                ctxMenu.Items.Clear();
                ctxMenu = null;
            }

            AssociatedObject.ContextMenu = null;
        }

        public ICommand SaveCommand
        {
            get { return (ICommand)GetValue(SaveCommandProperty); }
            set { SetValue(SaveCommandProperty, value); }
        }

        // Using a DependencyProperty as the backing store for SaveCommand.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty SaveCommandProperty =
            DependencyProperty.Register(nameof(SaveCommand), typeof(ICommand), typeof(ItemsControlBehavior),
                new PropertyMetadata(null));




        public object CmdPara
        {
            get { return (object)GetValue(CmdParaProperty); }
            set { SetValue(CmdParaProperty, value); }
        }

        // Using a DependencyProperty as the backing store for CmdPara.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty CmdParaProperty =
            DependencyProperty.Register(nameof(CmdPara), typeof(object), typeof(ItemsControlBehavior),
                new PropertyMetadata(null));

    }

    public class Book
    {
        public int Id { get; set; }
        public string Name { get; set;  }
        public string ISBN { get; set; }
        public string ImgUrl { get; set;  }

        public override string ToString()
        {
            return $"{DateTime.Now},Id:{Id},Name:{Name},ISBN:{ISBN},ImgUrl:{ImgUrl}";
        }
    }


    public class ImgUrlConverter : IValueConverter
    {
        private readonly object objLock = new object();
        private Dictionary<string,ImageSource> imgCache=new Dictionary<string,ImageSource>();
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            string imgUrl = value?.ToString();
            if(string.IsNullOrWhiteSpace(imgUrl) || !File.Exists(imgUrl))
            {
                return null;
            }

            lock (objLock)
            {
                if (imgCache.TryGetValue(imgUrl, out ImageSource img))
                {
                    return img;
                }

                using (FileStream fs = new FileStream(imgUrl, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    BitmapImage bmi = new BitmapImage();
                    bmi.BeginInit();
                    bmi.StreamSource= fs;
                    bmi.CacheOption= BitmapCacheOption.OnLoad;
                    bmi.EndInit();
                    if(bmi.CanFreeze)
                    {
                        bmi.Freeze();
                    }

                    imgCache.TryAdd(imgUrl, bmi);
                    return bmi;
                }
            }
        }

        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            throw new NotImplementedException();
        }
    }
}