<ArrayOfBook xmlns="http://schemas.datacontract.org/2004/07/WcfService2" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
<Book>
<Author>Author_263</Author>
<CategoryName>Science</CategoryName>
<Comment>Comment_263</Comment>
<Content>Content_263</Content>
<ISBN>ISBN_263_dc2eee838c5b48fb8d66d1b99ce5e210</ISBN>
<Id>263</Id>
<Name>Name_263</Name>
<Summary>Summary_263</Summary>
<Title>Title_263</Title>
<Topic>Topic_263</Topic>
</Book>
<Book>
<Author>Author_264</Author>
<CategoryName>Math</CategoryName>
<Comment>Comment_264</Comment>
<Content>Content_264</Content>
<ISBN>ISBN_264_c1c53fbabcee439fa0d7d356bf2ecee9</ISBN>
<Id>264</Id>
<Name>Name_264</Name>
<Summary>Summary_264</Summary>
<Title>Title_264</Title>
<Topic>Topic_264</Topic>
</Book>
</ArrayOfBook>


[XmlRoot("ArrayOfBook", Namespace = "http://schemas.datacontract.org/2004/07/WcfService2")]
public class XmlRootBookList
{
    //[XmlElement("Book")]
    [XmlElement("Book", Namespace = "http://schemas.datacontract.org/2004/07/WcfService2")]
    public List<Book> Bks { get; set; }
}

public class Book
{
    public long Id { get; set; }
    public string Name { get; set; }
    public string CategoryName { get; set; }
    public string Author { get; set; }
    public string Comment { get; set; }
    public string Content { get; set; }
    public string ISBN { get; set; }
    public string Summary { get; set; }
    public string Title { get; set; }
    public string Topic { get; set; }

}


        private List<Book> ParseXmlToList(string xmlStr)
        {
            List<Book> tempList = new List<Book>();
            try
            {
                var serializer = new XmlSerializer(typeof(XmlRootBookList));
                using (var reader = new StringReader(xmlStr))
                {
                    var bks = (XmlRootBookList)serializer.Deserialize(reader);
                    tempList = bks.Bks;
                }
                return tempList;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex?.Message);
                return null;
            }
        }

//xaml
<Window x:Class="WpfApp4.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:WpfApp4"
        mc:Ignorable="d"
        Title="MainWindow" WindowState="Maximized">
    <Window.DataContext>
        <local:MainVM/>
    </Window.DataContext>
    <Window.Resources>
        <Style TargetType="TextBlock" x:Key="TbkStyle">
            <Setter Property="FontSize" Value="30"/>
            <Style.Triggers>
                <Trigger Property="IsMouseOver" Value="True">
                    <Setter Property="Foreground" Value="Red"/>
                </Trigger>
            </Style.Triggers>
        </Style>

        <DataTemplate DataType="{x:Type local:Book}"
                      x:Key="RowDataTemplate">
            <Border BorderBrush="LightBlue" 
                    BorderThickness="2"
                    Margin="2">
                <Grid Margin="2">
                    <Grid.Resources>
                        <Style TargetType="TextBlock" BasedOn="{StaticResource TbkStyle}"/>
                    </Grid.Resources>
                    <Grid.RowDefinitions>
                        <RowDefinition/>
                        <RowDefinition/>
                        <RowDefinition/>
                        <RowDefinition/>
                        <RowDefinition/>
                    </Grid.RowDefinitions>
                    <Grid.ColumnDefinitions>
                        <ColumnDefinition/>
                        <ColumnDefinition/>
                    </Grid.ColumnDefinitions>
                    <TextBlock Text="{Binding Id}" Grid.Row="0" Grid.Column="0"/>
                    <TextBlock Text="{Binding Name}" Grid.Row="0" Grid.Column="1"/>
                    <TextBlock Text="{Binding CategoryName}" Grid.Row="1" Grid.Column="0"/>
                    <TextBlock Text="{Binding Author}" Grid.Row="1" Grid.Column="1"/>
                    <TextBlock Text="{Binding Comment}" Grid.Row="2" Grid.Column="0"/>
                    <TextBlock Text="{Binding Content}" Grid.Row="2" Grid.Column="1"/>
                    <TextBlock Text="{Binding ISBN}" Grid.Row="3" Grid.Column="0"/>
                    <TextBlock Text="{Binding Summary}" Grid.Row="3" Grid.Column="1"/>
                    <TextBlock Text="{Binding Title}" Grid.Row="4" Grid.Column="0"/>
                    <TextBlock Text="{Binding Topic}" Grid.Row="4" Grid.Column="1"/>
                </Grid>
            </Border>
        </DataTemplate>

        <ControlTemplate TargetType="ContentControl"
                         x:Key="ContentControlTemplate">
            <ScrollViewer>
                <ItemsControl ItemsSource="{Binding Books}"                              
                              ItemTemplate="{StaticResource ResourceKey=RowDataTemplate}"
                              VirtualizingPanel.IsVirtualizing="True"
                              VirtualizingPanel.VirtualizationMode="Recycling"
                              VirtualizingPanel.CacheLength="5,5"
                              VirtualizingPanel.CacheLengthUnit="Item"
                              ScrollViewer.CanContentScroll="True"
                              ScrollViewer.IsDeferredScrollingEnabled="True"
                              SnapsToDevicePixels="True"
                              UseLayoutRounding="True">
                    <ItemsControl.ItemsPanel>
                        <ItemsPanelTemplate>
                            <VirtualizingStackPanel/>
                        </ItemsPanelTemplate>
                    </ItemsControl.ItemsPanel>
                    <ItemsControl.ContextMenu>
                        <ContextMenu>
                            <MenuItem Header="Refresh"
                                      FontSize="30"
                                      Width="200"
                                      Command="{Binding RefreshDataCmd}"
                                      CommandParameter="100"/>
                        </ContextMenu>
                    </ItemsControl.ContextMenu>
                </ItemsControl>
            </ScrollViewer>
        </ControlTemplate>
    </Window.Resources>
    <Grid>
        <ContentControl Template="{StaticResource ContentControlTemplate}"/>
    </Grid>
</Window>


//cs
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.IO;
using System.Net.Http;
using System.Runtime.CompilerServices;
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;
using System.Xml.Serialization;

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

        protected override void OnClosed(EventArgs e)
        {
            base.OnClosed(e);
            var vm = this.DataContext as MainVM;
            if (vm != null)
            {
                vm.Dispose();
            }
        }
    }

    public class MainVM : INotifyPropertyChanged, IDisposable
    {
        private static HttpClient client = new HttpClient();
        private static string originUrl = "http://localhost:56293/BookService.svc/getbooks?cnt=";
        private CancellationTokenSource cts = new CancellationTokenSource();
        private bool isDisposed = false;
        Task _loadTask;
        public bool IsLoading => _loadTask != null && !_loadTask.IsCompleted;

        public ICommand RefreshDataCmd { get; set; }
        public MainVM()
        {
            if (!DesignerProperties.GetIsInDesignMode(new DependencyObject()))
            {
                client.Timeout = TimeSpan.FromMinutes(10);
                _loadTask = LoadBooksAsync(10, cts.Token);
                RefreshDataCmd = new DelegateCmd(async (s) =>
                {
                    if (int.TryParse(s?.ToString(), out int num))
                    {
                        await RefreshDataCmdExecuted(num);
                    }
                });                
            }
        }        

        private async Task RefreshDataCmdExecuted(int cnt)
        {
            if (IsLoading)
            {
                return;
            }

            var refreshCts = new CancellationTokenSource();
            _loadTask = LoadBooksAsync(cnt, refreshCts.Token);

        }

        private async Task LoadBooksAsync(int cnt, CancellationToken token)
        {
            try
            {
                if (token.IsCancellationRequested)
                {
                    return;
                }
                string url = $"{originUrl}{cnt}";
                var request = new HttpRequestMessage(HttpMethod.Get, url);
                var resp = await client.SendAsync(request, token);
                resp.EnsureSuccessStatusCode();

                string xmlStr = await resp.Content.ReadAsStringAsync(token);
                var bks = ParseXmlToList(xmlStr);
                if (bks != null && bks.Any() && !token.IsCancellationRequested)
                {
                    Application.Current.Dispatcher.Invoke(() =>
                    {
                        Books = new ObservableCollection<Book>(bks);
                    }, System.Windows.Threading.DispatcherPriority.Background, token);
                }
            }
            catch (OperationCanceledException)
            {

            }
            catch (Exception ex)
            {
                MessageBox.Show($"In InitBooksAsync,{ex?.Message}");
            }
        }

        private List<Book> ParseXmlToList(string xmlStr)
        {
            List<Book> tempList = new List<Book>();
            try
            {
                var serializer = new XmlSerializer(typeof(XmlRootBookList));
                using (var reader = new StringReader(xmlStr))
                {
                    var bks = (XmlRootBookList)serializer.Deserialize(reader);
                    tempList = bks.Bks;
                }
                return tempList;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex?.Message);
                return null;
            }
        }


        private ObservableCollection<Book> books;
        public ObservableCollection<Book> Books
        {
            get
            {
                return books;
            }
            set
            {
                if (value != books)
                {
                    books = value;
                    OnPropertyChanged();
                }
            }
        }
        public event PropertyChangedEventHandler? PropertyChanged;
        private void OnPropertyChanged([CallerMemberName] string propName = "")
        {
            var handler = Volatile.Read(ref PropertyChanged);
            if (handler == null)
            {
                return;
            }
            handler(this, new PropertyChangedEventArgs(propName));
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool isDisposing)
        {
            if (isDisposed)
            {
                return;
            }

            if (isDisposing)
            {
                cts.Cancel();
                cts.Dispose();
            }
            isDisposed = true;
        }
    }

    [XmlRoot("ArrayOfBook", Namespace = "http://schemas.datacontract.org/2004/07/WcfService2")]
    public class XmlRootBookList
    {
        //[XmlElement("Book")]
        [XmlElement("Book", Namespace = "http://schemas.datacontract.org/2004/07/WcfService2")]
        public List<Book> Bks { get; set; }
    }

    public class Book
    {
        public long Id { get; set; }
        public string Name { get; set; }
        public string CategoryName { get; set; }
        public string Author { get; set; }
        public string Comment { get; set; }
        public string Content { get; set; }
        public string ISBN { get; set; }
        public string Summary { get; set; }
        public string Title { get; set; }
        public string Topic { get; set; }

    }

    public class DelegateCmd : ICommand
    {
        private readonly Action<object?> _execute;
        private readonly Func<object?, bool>? _canExecute;
        public DelegateCmd(Action<object?> execute, Func<object?, bool>? canExecute = null)
        {
            _execute = execute ?? throw new ArgumentNullException(nameof(execute));
            _canExecute = canExecute;
        }

        public event EventHandler? CanExecuteChanged;

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

        public void Execute(object? parameter)
        {
            _execute(parameter);
        }

        public void RaiseCanExecuteChanged(object? sender, EventArgs e)
        {
            var handler = Volatile.Read(ref CanExecuteChanged);
            if (handler == null)
            {
                return;
            }

            var dispather = Application.Current?.Dispatcher;
            if (dispather != null)
            {
                if (dispather.CheckAccess())
                {
                    handler(this, e);
                }
                else
                {
                    dispather.Invoke(() =>
                    {
                        handler(this, e);
                    }, System.Windows.Threading.DispatcherPriority.Background);
                }
            }
        }
    }
}