remember previous log filter condition

itn3000 · itn3000 · commit 376155190119 · 2024-08-30T02:18:42.000+09:00
diff --git a/WEventViewer.sln b/WEventViewer.sln
@@ -65,7 +65,6 @@ Global
 		{4A68C488-E8DA-4D4E-A299-CC0C78EC5590}.Release|x86.ActiveCfg = Release|Any CPU
 		{4A68C488-E8DA-4D4E-A299-CC0C78EC5590}.Release|x86.Build.0 = Release|Any CPU
 		{61D89AD6-426B-4A48-998D-413309FE3A4D}.Debug|Any CPU.ActiveCfg = Debug|x64
-		{61D89AD6-426B-4A48-998D-413309FE3A4D}.Debug|Any CPU.Build.0 = Debug|x64
 		{61D89AD6-426B-4A48-998D-413309FE3A4D}.Debug|ARM64.ActiveCfg = Debug|ARM64
 		{61D89AD6-426B-4A48-998D-413309FE3A4D}.Debug|ARM64.Build.0 = Debug|ARM64
 		{61D89AD6-426B-4A48-998D-413309FE3A4D}.Debug|x64.ActiveCfg = Debug|x64
diff --git a/src/WEventViewer/App.axaml.cs b/src/WEventViewer/App.axaml.cs
@@ -2,6 +2,7 @@
 using Avalonia.Controls.ApplicationLifetimes;
 using Avalonia.Markup.Xaml;
 using Microsoft.Extensions.DependencyInjection;
+using System.Reflection.Metadata.Ecma335;
 using WEventViewer.Model;
 using WEventViewer.ViewModel;
 
@@ -18,10 +19,18 @@ public override void OnFrameworkInitializationCompleted()
     {
         var collection = new ServiceCollection();
         collection.AddSingleton<EventLogRepository>();
-        collection.AddSingleton<MainWindowViewModel>(provider => new MainWindowViewModel(provider.GetRequiredService<EventLogRepository>()));
-        collection.AddTransient<ErrorWindow>();
+        collection.AddSingleton<IViewModelFactory, ViewModelFactoryServiceProvider>(provider => new ViewModelFactoryServiceProvider(provider));
+        collection.AddSingleton<MainWindowViewModel>();
+        collection.AddSingleton<OpenLogWindowViewModel>();
+        collection.AddSingleton<MainWindow>(provider =>
+        {
+            return new MainWindow(provider.GetRequiredService<IViewModelFactory>())
+            {
+                DataContext = provider.GetRequiredService<MainWindowViewModel>()
+            };
+        });
         collection.AddTransient<ErrorWindowViewModel>();
-        collection.AddTransient<OpenLogWindowViewModel>();
+        collection.AddTransient<ErrorWindow>();
         collection.AddTransient<OpenLogWindow>();
         collection.AddTransient<ProviderNameWindowViewModel>();
         collection.AddTransient<LogNameViewModel>();
@@ -30,11 +39,11 @@ public override void OnFrameworkInitializationCompleted()
         var vm = serviceProvider.GetRequiredService<MainWindowViewModel>();
         if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
         {
-            desktop.MainWindow = new MainWindow(serviceProvider) { DataContext = vm };
+            desktop.MainWindow = serviceProvider.GetRequiredService<MainWindow>();
         }
         else if (ApplicationLifetime is ISingleViewApplicationLifetime singleViewPlatform)
         {
-            singleViewPlatform.MainView = new MainWindow(serviceProvider) { DataContext = vm }; ;
+            singleViewPlatform.MainView = serviceProvider.GetRequiredService<MainWindow>();
         }
 
         base.OnFrameworkInitializationCompleted();
diff --git a/src/WEventViewer/MainWindow.axaml.cs b/src/WEventViewer/MainWindow.axaml.cs
@@ -13,32 +13,35 @@
 namespace WEventViewer;
 
 internal record class OpenErrorLogWindow(string message);
-public partial class MainWindow : Window
+internal partial class MainWindow : Window
 {
     DiagnosticListener _DS = new DiagnosticListener(nameof(MainWindow));
-    IServiceProvider? serviceProvider;
+    IViewModelFactory? _viewModelFactory;
     public MainWindow() : this(null) { }
-    public MainWindow(IServiceProvider? serviceProvider)
+    public MainWindow(IViewModelFactory? viewModelFactory)
     {
-        DataContext = serviceProvider != null ? serviceProvider.GetService<MainWindowViewModel>() : new MainWindowViewModel();
-        this.serviceProvider = serviceProvider;
+        DataContext = viewModelFactory != null ? viewModelFactory.GetMainWindowViewModel() : new MainWindowViewModel(new EventLogRepository(), new StubViewModelFactory());
+        this._viewModelFactory = viewModelFactory;
         InitializeComponent();
         WeakReferenceMessenger.Default.Register<MainWindow, OpenLogRequest>(this, async (recpient, req) =>
         {
-            var vm = new OpenLogWindowViewModel();
-            var dlg = new OpenLogWindow()
+            var vm = _viewModelFactory?.GetOpenLogWindowViewMode();
+            if (vm != null)
             {
-                DataContext = vm
-            };
-            var ret = await dlg.ShowDialog<bool>(this);
-            if(ret && DataContext is MainWindowViewModel mwvm)
-            {
-                WeakReferenceMessenger.Default.Send<LoadLogMessage>(new(vm.LogName, vm.CurrentSelected.PathType, vm.QueryString));
+                var dlg = new OpenLogWindow()
+                {
+                    DataContext = vm
+                };
+                var ret = await dlg.ShowDialog<bool>(this);
+                if (ret && DataContext is MainWindowViewModel mwvm)
+                {
+                    WeakReferenceMessenger.Default.Send<LoadLogMessage>(new(vm.LogName, vm.CurrentSelected.PathType, vm.QueryString));
+                }
             }
         });
         WeakReferenceMessenger.Default.Register<MainWindow, OpenErrorLogWindow>(this, async (mw, msg) =>
         {
-            var vm = new ErrorWindowViewModel(msg.message);
+            var vm = _viewModelFactory?.GetErrorViewWindowModel(msg.message);
             var dlg = new ErrorWindow() { DataContext = vm };
             await dlg.ShowDialog(mw);
         });
@@ -60,7 +63,7 @@ private void DataGrid_DoubleTapped_1(object? sender, Avalonia.Input.TappedEventA
         {
             if (dataGrid.SelectedItem is LogRecord record)
             {
-                var vm = new DetailedLogViewModel(record);
+                var vm = _viewModelFactory?.GetDetailedLogViewModel(record);
                 var w = new DetailedLogMessageWIndow()
                 {
                     DataContext = vm,
@@ -73,9 +76,9 @@ private void DataGrid_DoubleTapped_1(object? sender, Avalonia.Input.TappedEventA
     private void PrintProviderClick(object? sender, Avalonia.Interactivity.RoutedEventArgs e)
     {
         _DS.Write("OnPrintProviderClick", new { e.Source, t = e.GetType() });
-        if (serviceProvider != null)
+        if (_viewModelFactory != null)
         {
-            var vm = serviceProvider.GetService<ProviderNameWindowViewModel>();
+            var vm = _viewModelFactory.GetProviderNameWindowViewModel();
             var w = new ProviderNamesWindow() { DataContext = vm };
             w.Show();
         }
@@ -84,19 +87,19 @@ private void PrintProviderClick(object? sender, Avalonia.Interactivity.RoutedEve
 
     private void PrintLogNamesClick(object? sender, RoutedEventArgs e)
     {
-        if (serviceProvider != null)
+        if (_viewModelFactory != null)
         {
-            var vm = serviceProvider.GetService<LogNameViewModel>();
+            var vm = _viewModelFactory.GetLogNameViewModel();
             var w = new LogNameWindow() { DataContext = vm };
             w.Show();
         }
     }
 
     private void AboutClick(object? sender, RoutedEventArgs e)
     {
-        if (serviceProvider != null)
+        if (_viewModelFactory != null)
         {
-            var vm = serviceProvider.GetService<AboutViewModel>();
+            var vm = _viewModelFactory.GetAboutViewModel();
             var w = new AboutWindow() { DataContext = vm };
             w.Show(this);
         }
diff --git a/src/WEventViewer/ViewModel/DetailedLogViewModel.cs b/src/WEventViewer/ViewModel/DetailedLogViewModel.cs
@@ -31,8 +31,7 @@ public DetailedLogViewModel() : this(null)
         {
         }
         LogRecord? logRecord;
-
-        public DetailedLogViewModel(LogRecord? logRecord)
+        public void Initialize(LogRecord? logRecord)
         {
             this.logRecord = logRecord;
             if (logRecord != null && !string.IsNullOrEmpty(logRecord.XmlString))
@@ -48,7 +47,7 @@ public DetailedLogViewModel(LogRecord? logRecord)
             {
                 _FormattedXmlString = string.Empty;
             }
-            if(logRecord != null)
+            if (logRecord != null)
             {
                 Items = new DetailedLogRecordValue[]
                 {
@@ -68,6 +67,12 @@ public DetailedLogViewModel(LogRecord? logRecord)
                 };
             }
         }
+
+        public DetailedLogViewModel(LogRecord? logRecord)
+        {
+            _FormattedXmlString = string.Empty;
+            Initialize(logRecord);
+        }
         public IEnumerable<DetailedLogRecordValue> Items { get; private set; } = Array.Empty<DetailedLogRecordValue>();
         string _FormattedXmlString;
         public string XmlString => _FormattedXmlString;
diff --git a/src/WEventViewer/ViewModel/IViewModelFactory.cs b/src/WEventViewer/ViewModel/IViewModelFactory.cs
@@ -0,0 +1,54 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Diagnostics.Eventing.Reader;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using WEventViewer.Model;
+
+namespace WEventViewer.ViewModel
+{
+    internal interface IViewModelFactory
+    {
+        MainWindowViewModel GetMainWindowViewModel();
+        OpenLogWindowViewModel GetOpenLogWindowViewMode();
+        ErrorWindowViewModel GetErrorViewWindowModel(string message);
+        LogNameViewModel GetLogNameViewModel();
+        DetailedLogViewModel GetDetailedLogViewModel(LogRecord record);
+        AboutViewModel GetAboutViewModel();
+        ProviderNameWindowViewModel GetProviderNameWindowViewModel();
+    }
+    class StubViewModelFactory : IViewModelFactory
+    {
+        public MainWindowViewModel GetMainWindowViewModel() => new MainWindowViewModel();
+        public AboutViewModel GetAboutViewModel()
+        {
+            return new AboutViewModel();
+        }
+
+        public DetailedLogViewModel GetDetailedLogViewModel(LogRecord record)
+        {
+            return new DetailedLogViewModel(record);
+        }
+
+        public ErrorWindowViewModel GetErrorViewWindowModel(string message)
+        {
+            return new ErrorWindowViewModel();
+        }
+
+        public LogNameViewModel GetLogNameViewModel()
+        {
+            return new LogNameViewModel();
+        }
+
+        public OpenLogWindowViewModel GetOpenLogWindowViewMode()
+        {
+            throw new NotImplementedException();
+        }
+
+        public ProviderNameWindowViewModel GetProviderNameWindowViewModel()
+        {
+            throw new NotImplementedException();
+        }
+    }
+}
diff --git a/src/WEventViewer/ViewModel/MainWindowViewModel.cs b/src/WEventViewer/ViewModel/MainWindowViewModel.cs
@@ -37,14 +37,16 @@ record class OpenDetailedLogMessage();
     internal class MainWindowViewModel : ObservableRecipient
     {
         EventLogRepository _EventLogRepository;
+        IViewModelFactory? _ViewModelFactory;
         Task LoadTask;
-        public MainWindowViewModel() : this(new EventLogRepository()) { }
         CancellationTokenSource LoadCancellationToken = new CancellationTokenSource();
         IDisposable IsLoadingSubscription;
-        public MainWindowViewModel(EventLogRepository eventLogRepository)
+        public MainWindowViewModel() : this(null, null) { }
+        public MainWindowViewModel(EventLogRepository? eventLogRepository, IViewModelFactory? viewModelFactory)
         {
             LoadTask = Task.CompletedTask;
-            _EventLogRepository = eventLogRepository;
+            _EventLogRepository = eventLogRepository != null ? eventLogRepository : new EventLogRepository();
+            _ViewModelFactory = viewModelFactory;
             _Progress = new Progress<long>(l =>
             {
                 Dispatcher.UIThread.Invoke(() =>
diff --git a/src/WEventViewer/ViewModel/ViewModelFactoryServiceProvider.cs b/src/WEventViewer/ViewModel/ViewModelFactoryServiceProvider.cs
@@ -0,0 +1,51 @@
+﻿using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using WEventViewer.Model;
+
+namespace WEventViewer.ViewModel
+{
+    internal class ViewModelFactoryServiceProvider(IServiceProvider provider) : IViewModelFactory
+    {
+        public MainWindowViewModel GetMainWindowViewModel()
+        {
+            return provider.GetRequiredService<MainWindowViewModel>();
+        }
+        public AboutViewModel GetAboutViewModel()
+        {
+            return provider.GetRequiredService<AboutViewModel>();
+        }
+
+        public DetailedLogViewModel GetDetailedLogViewModel(LogRecord record)
+        {
+            var vm = provider.GetRequiredService<DetailedLogViewModel>();
+            vm.Initialize(record);
+            return vm;
+        }
+
+        public ErrorWindowViewModel GetErrorViewWindowModel(string message)
+        {
+            var vm = provider.GetRequiredService<ErrorWindowViewModel>();
+            vm.Message = message;
+            return vm;
+        }
+
+        public LogNameViewModel GetLogNameViewModel()
+        {
+            return provider.GetRequiredService<LogNameViewModel>();
+        }
+
+        public OpenLogWindowViewModel GetOpenLogWindowViewMode()
+        {
+            return provider.GetRequiredService<OpenLogWindowViewModel>();
+        }
+
+        public ProviderNameWindowViewModel GetProviderNameWindowViewModel()
+        {
+            return provider.GetRequiredService<ProviderNameWindowViewModel>();
+        }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -13,32 +13,35 @@`
`13`	`13`	`namespace WEventViewer;`
`14`	`14`
`15`	`15`	`internal record class OpenErrorLogWindow(string message);`
`16`		`-public partial class MainWindow : Window`
	`16`	`+internal partial class MainWindow : Window`
`17`	`17`	`{`
`18`	`18`	`DiagnosticListener _DS = new DiagnosticListener(nameof(MainWindow));`
`19`		`- IServiceProvider? serviceProvider;`
	`19`	`+ IViewModelFactory? _viewModelFactory;`
`20`	`20`	`public MainWindow() : this(null) { }`
`21`		`- public MainWindow(IServiceProvider? serviceProvider)`
	`21`	`+ public MainWindow(IViewModelFactory? viewModelFactory)`
`22`	`22`	`{`
`23`		`- DataContext = serviceProvider != null ? serviceProvider.GetService<MainWindowViewModel>() : new MainWindowViewModel();`
`24`		`- this.serviceProvider = serviceProvider;`
	`23`	`+ DataContext = viewModelFactory != null ? viewModelFactory.GetMainWindowViewModel() : new MainWindowViewModel(new EventLogRepository(), new StubViewModelFactory());`
	`24`	`+ this._viewModelFactory = viewModelFactory;`
`25`	`25`	`InitializeComponent();`
`26`	`26`	`WeakReferenceMessenger.Default.Register<MainWindow, OpenLogRequest>(this, async (recpient, req) =>`
`27`	`27`	`{`
`28`		`- var vm = new OpenLogWindowViewModel();`
`29`		`- var dlg = new OpenLogWindow()`
	`28`	`+ var vm = _viewModelFactory?.GetOpenLogWindowViewMode();`
	`29`	`+ if (vm != null)`
`30`	`30`	`{`
`31`		`- DataContext = vm`
`32`		`- };`
`33`		`- var ret = await dlg.ShowDialog<bool>(this);`
`34`		`- if(ret && DataContext is MainWindowViewModel mwvm)`
`35`		`- {`
`36`		`- WeakReferenceMessenger.Default.Send<LoadLogMessage>(new(vm.LogName, vm.CurrentSelected.PathType, vm.QueryString));`
	`31`	`+ var dlg = new OpenLogWindow()`
	`32`	`+ {`
	`33`	`+ DataContext = vm`
	`34`	`+ };`
	`35`	`+ var ret = await dlg.ShowDialog<bool>(this);`
	`36`	`+ if (ret && DataContext is MainWindowViewModel mwvm)`
	`37`	`+ {`
	`38`	`+ WeakReferenceMessenger.Default.Send<LoadLogMessage>(new(vm.LogName, vm.CurrentSelected.PathType, vm.QueryString));`
	`39`	`+ }`
`37`	`40`	`}`
`38`	`41`	`});`
`39`	`42`	`WeakReferenceMessenger.Default.Register<MainWindow, OpenErrorLogWindow>(this, async (mw, msg) =>`
`40`	`43`	`{`
`41`		`- var vm = new ErrorWindowViewModel(msg.message);`
	`44`	`+ var vm = _viewModelFactory?.GetErrorViewWindowModel(msg.message);`
`42`	`45`	`var dlg = new ErrorWindow() { DataContext = vm };`
`43`	`46`	`await dlg.ShowDialog(mw);`
`44`	`47`	`});`
`@@ -60,7 +63,7 @@ private void DataGrid_DoubleTapped_1(object? sender, Avalonia.Input.TappedEventA`
`60`	`63`	`{`
`61`	`64`	`if (dataGrid.SelectedItem is LogRecord record)`
`62`	`65`	`{`
`63`		`- var vm = new DetailedLogViewModel(record);`
	`66`	`+ var vm = _viewModelFactory?.GetDetailedLogViewModel(record);`
`64`	`67`	`var w = new DetailedLogMessageWIndow()`
`65`	`68`	`{`
`66`	`69`	`DataContext = vm,`
`@@ -73,9 +76,9 @@ private void DataGrid_DoubleTapped_1(object? sender, Avalonia.Input.TappedEventA`
`73`	`76`	`private void PrintProviderClick(object? sender, Avalonia.Interactivity.RoutedEventArgs e)`
`74`	`77`	`{`
`75`	`78`	`_DS.Write("OnPrintProviderClick", new { e.Source, t = e.GetType() });`
`76`		`- if (serviceProvider != null)`
	`79`	`+ if (_viewModelFactory != null)`
`77`	`80`	`{`
`78`		`- var vm = serviceProvider.GetService<ProviderNameWindowViewModel>();`
	`81`	`+ var vm = _viewModelFactory.GetProviderNameWindowViewModel();`
`79`	`82`	`var w = new ProviderNamesWindow() { DataContext = vm };`
`80`	`83`	`w.Show();`
`81`	`84`	`}`
`@@ -84,19 +87,19 @@ private void PrintProviderClick(object? sender, Avalonia.Interactivity.RoutedEve`
`84`	`87`
`85`	`88`	`private void PrintLogNamesClick(object? sender, RoutedEventArgs e)`
`86`	`89`	`{`
`87`		`- if (serviceProvider != null)`
	`90`	`+ if (_viewModelFactory != null)`
`88`	`91`	`{`
`89`		`- var vm = serviceProvider.GetService<LogNameViewModel>();`
	`92`	`+ var vm = _viewModelFactory.GetLogNameViewModel();`
`90`	`93`	`var w = new LogNameWindow() { DataContext = vm };`
`91`	`94`	`w.Show();`
`92`	`95`	`}`
`93`	`96`	`}`
`94`	`97`
`95`	`98`	`private void AboutClick(object? sender, RoutedEventArgs e)`
`96`	`99`	`{`
`97`		`- if (serviceProvider != null)`
	`100`	`+ if (_viewModelFactory != null)`
`98`	`101`	`{`
`99`		`- var vm = serviceProvider.GetService<AboutViewModel>();`
	`102`	`+ var vm = _viewModelFactory.GetAboutViewModel();`
`100`	`103`	`var w = new AboutWindow() { DataContext = vm };`
`101`	`104`	`w.Show(this);`
`102`	`105`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,8 +31,7 @@ public DetailedLogViewModel() : this(null)`
`31`	`31`	`{`
`32`	`32`	`}`
`33`	`33`	`LogRecord? logRecord;`
`34`		`-`
`35`		`- public DetailedLogViewModel(LogRecord? logRecord)`
	`34`	`+ public void Initialize(LogRecord? logRecord)`
`36`	`35`	`{`
`37`	`36`	`this.logRecord = logRecord;`
`38`	`37`	`if (logRecord != null && !string.IsNullOrEmpty(logRecord.XmlString))`
`@@ -48,7 +47,7 @@ public DetailedLogViewModel(LogRecord? logRecord)`
`48`	`47`	`{`
`49`	`48`	`_FormattedXmlString = string.Empty;`
`50`	`49`	`}`
`51`		`- if(logRecord != null)`
	`50`	`+ if (logRecord != null)`
`52`	`51`	`{`
`53`	`52`	`Items = new DetailedLogRecordValue[]`
`54`	`53`	`{`
`@@ -68,6 +67,12 @@ public DetailedLogViewModel(LogRecord? logRecord)`
`68`	`67`	`};`
`69`	`68`	`}`
`70`	`69`	`}`
	`70`	`+`
	`71`	`+ public DetailedLogViewModel(LogRecord? logRecord)`
	`72`	`+ {`
	`73`	`+ _FormattedXmlString = string.Empty;`
	`74`	`+ Initialize(logRecord);`
	`75`	`+ }`
`71`	`76`	`public IEnumerable<DetailedLogRecordValue> Items { get; private set; } = Array.Empty<DetailedLogRecordValue>();`
`72`	`77`	`string _FormattedXmlString;`
`73`	`78`	`public string XmlString => _FormattedXmlString;`