WPF datagrid export all data as multiple images

 //Ensures that all visual child elements of this element are properly updated for layout.
 dataGrid.UpdateLayout();

 

 

//xaml
<Window x:Class="WpfApp21.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:local="clr-namespace:WpfApp21"
        mc:Ignorable="d"
        WindowState="Maximized"
        Title="MainWindow" Height="450" Width="800">
    <Grid>
        <DataGrid x:Name="BooksDataGrid"                   
                  EnableRowVirtualization="False"
                  EnableColumnVirtualization="False"
                  VirtualizingPanel.IsVirtualizing="False"
                  ItemsSource="{Binding BooksCollection,Mode=TwoWay,UpdateSourceTrigger=PropertyChanged}"
                  AutoGenerateColumns="True"
                  CanUserAddRows="True"
                  FontSize="30"
                  AlternationCount="2"
                  RowBackground="White"
                  AlternatingRowBackground="LightBlue">
            <DataGrid.ContextMenu>
                <ContextMenu>
                    <MenuItem Header="Export As Pictures"
                              Command="{Binding SaveAsImagesCommand}"
                              CommandParameter="{Binding RelativeSource={RelativeSource Mode=FindAncestor,AncestorType={x:Type ContextMenu}},Path=PlacementTarget}"/>
                </ContextMenu>
            </DataGrid.ContextMenu>
        </DataGrid>
    </Grid>
</Window>


//cs
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.IO;
using System.Runtime.CompilerServices;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Windows.Threading;
using Path = System.IO.Path;

namespace WpfApp21
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
            var vm = new MainVM(this);
            this.DataContext=vm;
        }
    }

    public class MainVM : INotifyPropertyChanged
    {
        private Window win;
        private FrameworkElement fe;
        private double actualDpi = 0;
        private double singlePageHeight = 0;

        public MainVM(Window winValue)
        {
            this.win= winValue;
            if (win!=null)
            {
                win.Loaded+=Win_Loaded;
            }
        }

        private void Win_Loaded(object sender, RoutedEventArgs e)
        {
            var tempFe = win.Content as FrameworkElement;
            if (tempFe!=null)
            {
                fe=tempFe;
                GridWidth = fe.ActualWidth;
                actualDpi=GetDpi(win).DpiX;
                singlePageHeight=fe.ActualHeight;
            }
            InitData();
        }

        private void InitData()
        {
            BooksCollection=new ObservableCollection<Book>();
            var dir = @"../../../Images";
            if (Directory.Exists(dir))
            {
                var imgs = Directory.GetFiles(dir);
                int imgsCount = imgs.Count();
                for (int i = 0; i<1000; i++)
                {
                    BooksCollection.Add(new Book()
                    {
                        Id=i+1,
                        Name=$"Name_{i+1}",
                        ISBN=$"ISBN_{Guid.NewGuid().ToString("N")}",
                        ISBN2=$"ISBN2_{Guid.NewGuid().ToString("N")}",
                        ISBN3=$"ISBN3_{Guid.NewGuid().ToString("N")}",
                        ISBN4=$"ISBN4_{Guid.NewGuid().ToString("N")}",
                        ISBN5=$"ISBN5_{Guid.NewGuid().ToString("N")}",
                        ISBN6=$"ISBN6_{Guid.NewGuid().ToString("N")}"
                    });
                }
            }
        }

        private ImageSource GetImgSourceFromUrl(string imgUrl)
        {
            BitmapImage bmi = new BitmapImage();
            bmi.BeginInit();
            bmi.UriSource=new Uri(imgUrl, UriKind.RelativeOrAbsolute);
            bmi.EndInit();
            if (bmi.CanFreeze)
            {
                bmi.Freeze();
            }
            return bmi;
        }

        private DelCommand saveAsImagesCommand;
        public DelCommand SaveAsImagesCommand
        {
            get
            {
                if (saveAsImagesCommand == null)
                {
                    saveAsImagesCommand=new DelCommand(SaveAsImagesCommandExecuted);
                }
                return saveAsImagesCommand;
            }
        }

        private void SaveAsImagesCommandExecuted(object? obj)
        {
            var bookDg = obj as DataGrid;
            if (bookDg!=null)
            {
                string bookDir = $"{bookDg.Name}_{DateTime.Now.ToString("yyyyMMddHHmmss")}";
                SaveDataGridAsImages(bookDg, bookDir, singlePageHeight, actualDpi);
                string showMsg = $"{bookDg.Name} saved in {bookDir}\n";
                MessageBox.Show(showMsg);
            }
        }

        public void SaveDataGridAsImages(DataGrid dataGrid, string dir = "", double pageHeight = 800, double dpi = 96*2)
        {
            double actualWidth = 0, totalHeight = 0;
            Application.Current.Dispatcher.Invoke(() =>
            {
                //Ensures that all visual child elements of this element are properly updated for layout.
                dataGrid.UpdateLayout();
                actualWidth= Math.Max(GetFullDatagridActualWidth(dataGrid), win.ActualWidth);
                totalHeight =GetFullDatagridActualHeight(dataGrid);
            }, DispatcherPriority.Render);

            if (!Directory.Exists(dir))
            {
                Directory.CreateDirectory(dir);
            }

            dataGrid.UpdateLayout();

            // Measure and Arrange for full height
            System.Windows.Size fullSize = new System.Windows.Size(actualWidth, double.PositiveInfinity);
            dataGrid.Measure(fullSize);
            dataGrid.Arrange(new Rect(0, 0, fullSize.Width, dataGrid.DesiredSize.Height));

            int pageCount = (int)Math.Ceiling(totalHeight / pageHeight);

            for (int i = 0; i < pageCount; i++)
            {
                double offsetY = i * pageHeight;
                double renderHeight = Math.Min(pageHeight, totalHeight - offsetY);

                RenderTargetBitmap rtb = new RenderTargetBitmap(
                    (int)(actualWidth * dpi / 96),
                    (int)(renderHeight * dpi / 96),
                    dpi, dpi, PixelFormats.Pbgra32);

                // Create a visual wrapper with clipping for each page
                DrawingVisual visual = new DrawingVisual();
                using (DrawingContext dc = visual.RenderOpen())
                {
                    VisualBrush brush = new VisualBrush(dataGrid)
                    {
                        Stretch = Stretch.None,
                        AlignmentY = AlignmentY.Top,
                        ViewboxUnits = BrushMappingMode.Absolute,
                        Viewbox = new Rect(0, offsetY, actualWidth, renderHeight)
                    };

                    dc.DrawRectangle(brush, null, new Rect(0, 0, actualWidth, renderHeight));
                }

                rtb.Render(visual);

                // Save to file
                JpegBitmapEncoder encoder = new JpegBitmapEncoder();
                encoder.Frames.Add(BitmapFrame.Create(rtb));
                string fileName = System.IO.Path.Combine(dir, $"{dataGrid.Name}_{i + 1}.jpg");
                using (FileStream stream = new FileStream(fileName, FileMode.Create))
                {
                    encoder.Save(stream);
                }
            }
            //MessageBox.Show($"{dataGrid.Name} saved in {dir}");
        }
        public static double GetFullDatagridActualWidth(DataGrid dataGrid)
        {
            double total = 0;
            foreach (var col in dataGrid.Columns)
            {
                total += col.ActualWidth;
            }
            return total;
        }

        public static double GetFullDatagridActualHeight(DataGrid dg)
        {
            double totalHeight = 0;

            foreach (var item in dg.Items)
            {
                var row = (DataGridRow)dg.ItemContainerGenerator.ContainerFromItem(item);
                if (row == null)
                {
                    dg.UpdateLayout();
                    //dg.ScrollIntoView(item);
                    row = (DataGridRow)dg.ItemContainerGenerator.ContainerFromItem(item);
                }

                if (row != null)
                {
                    totalHeight += row.ActualHeight;
                }
            }
            return totalHeight;
        }

        public static (double DpiX, double DpiY) GetDpi(Visual visual)
        {
            var source = PresentationSource.FromVisual(visual);
            if (source?.CompositionTarget != null)
            {
                Matrix matrix = source.CompositionTarget.TransformToDevice;
                //MessageBox.Show($"XScaleFactor:{matrix.M11},YScaleFactor:{matrix.M22}");
                return (96.0 * matrix.M11, 96.0 * matrix.M22); // DPI = 96 * scale factor
            }

            return (96.0, 96.0); // default DPI
        }

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

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

        private double gridWidth;
        public double GridWidth
        {
            get
            {
                return gridWidth;
            }
            set
            {
                gridWidth = value;
                OnPropertyChanged(nameof(GridWidth));
            }
        }
    }

    public class Book
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string ISBN { get; set; }
        public string ISBN2 { get; set; }
        public string ISBN3 { get; set; }
        public string ISBN4 { get; set; }
        public string ISBN5 { get; set; }
        public string ISBN6 { get; set; }
    }

    public class DelCommand : ICommand
    {
        private Action<object?> execute;
        private Predicate<object?> canExecute;
        public DelCommand(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(parameter);
        }
    }

}

 

 

//Disable virtualization
 EnableRowVirtualization="False"
 EnableColumnVirtualization="False"
 VirtualizingPanel.IsVirtualizing="False"

 

 

// 
double actualWidth = 0, totalHeight = 0;
 Application.Current.Dispatcher.Invoke(() =>
 {
     //Ensures that all visual child elements of this element are properly updated for layout.
     dataGrid.UpdateLayout();
     actualWidth= Math.Max(GetFullDatagridActualWidth(dataGrid), win.ActualWidth);
     totalHeight =GetFullDatagridActualHeight(dataGrid);
 }, DispatcherPriority.Render);

public static double GetFullDatagridActualHeight(DataGrid dg)
{
    double totalHeight = 0;

    foreach (var item in dg.Items)
    {
        var row = (DataGridRow)dg.ItemContainerGenerator.ContainerFromItem(item);
        if (row == null)
        {
            dg.UpdateLayout();
            //dg.ScrollIntoView(item);
            row = (DataGridRow)dg.ItemContainerGenerator.ContainerFromItem(item);
        }

        if (row != null)
        {
            totalHeight += row.ActualHeight;
        }
    }
    return totalHeight;
}