WPF Microsoft.Extensions.DependencyInjection, Microsoft.Extensions.

 

Install-Package Microsoft.Extensions.DependencyInjection;
Install-Package Microsoft.Hosting;
Install-Package CommunityToolkit.mvvm;

 

 

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using System.Configuration;
using System.Data;
using System.Windows;

namespace WpfApp24
{
    /// <summary>
    /// Interaction logic for App.xaml
    /// </summary>
    public partial class App : Application
    {
        private IHost host;
        public App()
        {
            host=Host.CreateDefaultBuilder()
                .ConfigureServices((context, services) =>
                {
                    services.AddSingleton<IIDService,IDService>();
                    services.AddSingleton<INameService, NameService>();
                    services.AddSingleton<IISBNService,ISBNService>();
                    services.AddSingleton<MainWindow>();
                    services.AddSingleton<MainVM>();
                }).Build();
        }

        protected override async void OnStartup(StartupEventArgs e)
        {
            await host!.StartAsync();

            var mainWin=host.Services.GetRequiredService<MainWindow>();
            mainWin.Show();
            base.OnStartup(e);
        }

        protected override async void OnExit(ExitEventArgs e)
        {
            using(host)
            {
                await host!.StopAsync(TimeSpan.FromSeconds(5));
            }

            base.OnExit(e);
        }
    }

}



public partial class MainWindow : Window
{
    public MainWindow(MainVM vm)
    {
        InitializeComponent();
        this.DataContext = vm;

        this.Loaded += async (s, e) =>
        {
            try
            {
                await vm.InitBooksCollectionAsync();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        };
    }
}

 

 

 

 

 

 

 

 

 

 

 

//App.xaml
<Application x:Class="WpfApp24.App"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:local="clr-namespace:WpfApp24">
    <Application.Resources>
         
    </Application.Resources>
</Application>


//App.xaml.cs
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using System.Configuration;
using System.Data;
using System.Windows;

namespace WpfApp24
{
    /// <summary>
    /// Interaction logic for App.xaml
    /// </summary>
    public partial class App : Application
    {
        private IHost host;
        public App()
        {
            host=Host.CreateDefaultBuilder()
                .ConfigureServices((context, services) =>
                {
                    services.AddSingleton<IIDService,IDService>();
                    services.AddSingleton<INameService, NameService>();
                    services.AddSingleton<IISBNService,ISBNService>();
                    services.AddSingleton<MainWindow>();
                    services.AddSingleton<MainVM>();
                }).Build();
        }

        protected override async void OnStartup(StartupEventArgs e)
        {
            await host!.StartAsync();

            var mainWin=host.Services.GetRequiredService<MainWindow>();
            mainWin.Show();
            base.OnStartup(e);
        }

        protected override async void OnExit(ExitEventArgs e)
        {
            using(host)
            {
                await host!.StopAsync(TimeSpan.FromSeconds(5));
            }

            base.OnExit(e);
        }
    }

}


//MainWindow.xaml
<Window x:Class="WpfApp24.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:WpfApp24"
        WindowState="Maximized"
        mc:Ignorable="d"
        Title="MainWindow" Height="450" Width="800">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition/>
            <RowDefinition Height="Auto"/>
        </Grid.RowDefinitions>
        <DataGrid Grid.Row="0"
                  ItemsSource="{Binding BooksCollection,Mode=TwoWay,UpdateSourceTrigger=PropertyChanged}"
                  VirtualizingPanel.IsVirtualizing="True"
                  VirtualizingPanel.VirtualizationMode="Recycling"
                  VirtualizingPanel.CacheLength="2,2"
                  VirtualizingPanel.CacheLengthUnit="Item"
                  ScrollViewer.CanContentScroll="True"
                  ScrollViewer.IsDeferredScrollingEnabled="True"
                  AutoGenerateColumns="False">
            <DataGrid.Resources>
                <Style TargetType="DataGridRow">
                    <Setter Property="FontSize" Value="30"/>
                    <!--<Style.Triggers>
                        <Trigger Property="IsMouseOver" Value="True">
                            <Setter Property="FontSize" Value="50"/>
                            <Setter Property="Foreground" Value="Red"/>
                        </Trigger>
                    </Style.Triggers>-->
                </Style>
            </DataGrid.Resources>
            <DataGrid.Columns>
                <DataGridTextColumn Binding="{Binding Id}"/>
                <DataGridTextColumn Binding="{Binding Name}"/>
                <DataGridTextColumn Binding="{Binding Title}"/>
                <DataGridTextColumn Binding="{Binding Topic}"/>
                <DataGridTextColumn Binding="{Binding ISBN}"/>
            </DataGrid.Columns>
        </DataGrid>

        <TextBlock Text="{Binding StatusMsg}" Grid.Row="1" FontSize="30"/>
    </Grid>
</Window>


//MainWindow.xaml.cs
using CommunityToolkit.Mvvm.ComponentModel;
using System.Collections.ObjectModel;
using System.Text;
using System.Windows;
using System.Windows.Controls;
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;

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

            this.Loaded += async (s, e) =>
            {
                try
                {
                    await vm.InitBooksCollectionAsync();
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message);
                }
            };
        }
    }

    public class MainVM : ObservableObject
    {
        IIDService iDService;
        INameService nameService;
        IISBNService isbnService;
        public MainVM(IIDService iDServiceValue, INameService nameService, IISBNService isbnService)
        {
            this.iDService = iDServiceValue;
            this.nameService = nameService;
            this.isbnService = isbnService;
        }

        public async Task InitBooksCollectionAsync()
        {
            BooksCollection = new ObservableCollection<Book>();
            List<Book> booksList = new List<Book>();

            await Task.Run(async () =>
            {
                for (int i = 1; i < 100000001; i++)
                {
                    booksList.Add(new Book()
                    {
                        Id = iDService.GetID(),
                        Name = nameService.GetName(),
                        ISBN = isbnService.GetISBN(),
                        Title = $"Title_{i}",
                        Topic = $"Topic_{i}"
                    });

                    if (i % 100000 == 0)
                    {
                        await PopulateBooksCollectionAsync(booksList);
                    }
                }
                if (booksList.Any())
                {
                    await PopulateBooksCollectionAsync(booksList);
                }
            });
        }

        private async Task PopulateBooksCollectionAsync(List<Book> booksList)
        {
            await Application.Current.Dispatcher.InvokeAsync(() =>
            {
                var tempList = booksList.ToList();
                booksList.Clear();
                foreach (var bk in tempList)
                {
                    BooksCollection.Add(bk);
                }
                StatusMsg = $"Loaded {BooksCollection.Count} items";
            }, System.Windows.Threading.DispatcherPriority.Background);
        }

        private ObservableCollection<Book> booksCollection;
        public ObservableCollection<Book> BooksCollection
        {
            get
            {
                return booksCollection;
            }
            set
            {
                SetProperty(ref booksCollection, value);
            }
        }

        private string statusMsg;
        public string StatusMsg
        {
            get
            {
                return statusMsg;
            }
            set
            {
                SetProperty(ref statusMsg, value);
            }
        }
    }

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

        public string Title { get; set; }

        public string Topic { get; set; }

        public string ISBN { get; set; }
    }

    public interface IIDService
    {
        int GetID();
    }

    public class IDService : IIDService
    {
        int id = 0;

        public int GetID()
        {
            return Interlocked.Increment(ref id);
        }
    }
    public interface INameService
    {
        string GetName();
    }

    public class NameService : INameService
    {
        int idx = 0;
        public string GetName()
        {
            return $"Name_{Interlocked.Increment(ref idx)}";
        }
    }

    public interface IISBNService
    {
        string GetISBN();
    }

    public class ISBNService : IISBNService
    {
        int idx = 0;

        public string GetISBN()
        {
            return $"ISBN_{Interlocked.Increment(ref idx)}_{Guid.NewGuid():N}";
        }
    }
}