Refactor naming rule and optimize (#245)

shibayan · web-flow · commit 4544d1999cae · 2022-11-16T01:54:03.000+09:00
diff --git a/Sharprompt.Tests/PaginatorTests.cs b/Sharprompt.Tests/PaginatorTests.cs
@@ -13,17 +13,17 @@ public void Basic()
     {
         var paginator = new Paginator<int>(Enumerable.Range(0, 20), 5, Optional<int>.Empty, x => x.ToString());
 
-        var subset1 = paginator.ToSubset();
+        var currentItems1 = paginator.CurrentItems;
 
-        Assert.Equal(5, subset1.Count);
-        Assert.Equal(new[] { 0, 1, 2, 3, 4 }, subset1);
+        Assert.Equal(5, currentItems1.Length);
+        Assert.Equal(new[] { 0, 1, 2, 3, 4 }, currentItems1.ToArray());
 
         paginator.NextPage();
 
-        var subset2 = paginator.ToSubset();
+        var currentItems2 = paginator.CurrentItems;
 
-        Assert.Equal(5, subset2.Count);
-        Assert.Equal(new[] { 5, 6, 7, 8, 9 }, subset2);
+        Assert.Equal(5, currentItems2.Length);
+        Assert.Equal(new[] { 5, 6, 7, 8, 9 }, currentItems2.ToArray());
     }
 
     [Fact]
@@ -33,10 +33,10 @@ public void Filter_NotEmpty()
 
         paginator.UpdateFilter("0");
 
-        var subset = paginator.ToSubset();
+        var currentItems = paginator.CurrentItems;
 
-        Assert.Equal(2, subset.Count);
-        Assert.Equal(new[] { 0, 10 }, subset);
+        Assert.Equal(2, currentItems.Length);
+        Assert.Equal(new[] { 0, 10 }, currentItems.ToArray());
     }
 
     [Fact]
@@ -46,9 +46,9 @@ public void Filter_Empty()
 
         paginator.UpdateFilter("x");
 
-        var subset = paginator.ToSubset();
+        var subset = paginator.CurrentItems;
 
-        Assert.Empty(subset);
+        Assert.True(subset.IsEmpty);
     }
 
     [Fact]
diff --git a/Sharprompt/Forms/FormBase.cs b/Sharprompt/Forms/FormBase.cs
@@ -50,38 +50,6 @@ public T Start()
         }
     }
 
-    protected bool TryGetResult([NotNullWhen(true)] out T? result)
-    {
-        do
-        {
-            var keyInfo = _consoleDriver.ReadKey();
-
-            if (keyInfo.Key == ConsoleKey.Enter)
-            {
-                return HandleEnter(out result);
-            }
-
-            if (KeyHandlerMaps.TryGetValue(keyInfo.Key, out var keyHandler) && keyHandler(keyInfo))
-            {
-                continue;
-            }
-
-            if (!char.IsControl(keyInfo.KeyChar))
-            {
-                HandleTextInput(keyInfo);
-            }
-            else
-            {
-                _consoleDriver.Beep();
-            }
-
-        } while (_consoleDriver.KeyAvailable);
-
-        result = default;
-
-        return false;
-    }
-
     protected abstract void InputTemplate(OffscreenBuffer offscreenBuffer);
 
     protected abstract void FinishTemplate(OffscreenBuffer offscreenBuffer, T result);
@@ -116,6 +84,38 @@ protected bool TryValidate([NotNullWhen(true)] object? input, IList<Func<object?
         return true;
     }
 
+    private bool TryGetResult([NotNullWhen(true)] out T? result)
+    {
+        do
+        {
+            var keyInfo = _consoleDriver.ReadKey();
+
+            if (keyInfo.Key == ConsoleKey.Enter)
+            {
+                return HandleEnter(out result);
+            }
+
+            if (KeyHandlerMaps.TryGetValue(keyInfo.Key, out var keyHandler) && keyHandler(keyInfo))
+            {
+                continue;
+            }
+
+            if (!char.IsControl(keyInfo.KeyChar))
+            {
+                HandleTextInput(keyInfo);
+            }
+            else
+            {
+                _consoleDriver.Beep();
+            }
+
+        } while (_consoleDriver.KeyAvailable);
+
+        result = default;
+
+        return false;
+    }
+
     private void CancellationHandler()
     {
         _formRenderer.Cancel();
diff --git a/Sharprompt/Forms/InputForm.cs b/Sharprompt/Forms/InputForm.cs
@@ -56,7 +56,7 @@ protected override bool HandleEnter([NotNullWhen(true)] out T? result)
         {
             if (string.IsNullOrEmpty(input))
             {
-                if (TypeHelper<T>.IsValueType && !_defaultValue.HasValue)
+                if (!TypeHelper<T>.IsNullable && !_defaultValue.HasValue)
                 {
                     SetError(Resource.Validation_Required);
 
diff --git a/Sharprompt/Forms/MultiSelectForm.cs b/Sharprompt/Forms/MultiSelectForm.cs
@@ -43,18 +43,16 @@ public MultiSelectForm(MultiSelectOptions<T> options)
     protected override void InputTemplate(OffscreenBuffer offscreenBuffer)
     {
         offscreenBuffer.WritePrompt(_options.Message);
-        offscreenBuffer.Write(_paginator.FilterTerm);
+        offscreenBuffer.Write(_paginator.FilterKeyword);
 
         offscreenBuffer.PushCursor();
 
-        if (string.IsNullOrEmpty(_paginator.FilterTerm))
+        if (string.IsNullOrEmpty(_paginator.FilterKeyword))
         {
             offscreenBuffer.WriteHint(Resource.MultiSelectForm_Message_Hint);
         }
 
-        var subset = _paginator.ToSubset();
-
-        foreach (var item in subset)
+        foreach (var item in _paginator.CurrentItems)
         {
             var value = _options.TextSelector(item);
 
@@ -80,7 +78,7 @@ protected override void InputTemplate(OffscreenBuffer offscreenBuffer)
         if (_paginator.PageCount > 1)
         {
             offscreenBuffer.WriteLine();
-            offscreenBuffer.WriteHint(_options.Pagination(_paginator.TotalCount, _paginator.SelectedPage + 1, _paginator.PageCount));
+            offscreenBuffer.WriteHint(_options.Pagination(_paginator.TotalCount, _paginator.CurrentPage + 1, _paginator.PageCount));
         }
     }
 
@@ -197,7 +195,7 @@ private bool HandleAWithControl(ConsoleKeyInfo keyInfo)
         }
         else
         {
-            foreach (var item in _paginator.FilteredItems)
+            foreach (var item in _paginator)
             {
                 _selectedItems.Add(item);
             }
@@ -213,7 +211,7 @@ private bool HandleIWithControl(ConsoleKeyInfo keyInfo)
             return false;
         }
 
-        var invertedItems = _paginator.FilteredItems.Except(_selectedItems).ToArray();
+        var invertedItems = _paginator.Except(_selectedItems).ToArray();
 
         _selectedItems.Clear();
 
diff --git a/Sharprompt/Forms/SelectForm.cs b/Sharprompt/Forms/SelectForm.cs
@@ -32,13 +32,11 @@ public SelectForm(SelectOptions<T> options)
     protected override void InputTemplate(OffscreenBuffer offscreenBuffer)
     {
         offscreenBuffer.WritePrompt(_options.Message);
-        offscreenBuffer.Write(_paginator.FilterTerm);
+        offscreenBuffer.Write(_paginator.FilterKeyword);
 
         offscreenBuffer.PushCursor();
 
-        var subset = _paginator.ToSubset();
-
-        foreach (var item in subset)
+        foreach (var item in _paginator.CurrentItems)
         {
             var value = _options.TextSelector(item);
 
@@ -57,7 +55,7 @@ protected override void InputTemplate(OffscreenBuffer offscreenBuffer)
         if (_paginator.PageCount > 1)
         {
             offscreenBuffer.WriteLine();
-            offscreenBuffer.WriteHint(_options.Pagination(_paginator.TotalCount, _paginator.SelectedPage + 1, _paginator.PageCount));
+            offscreenBuffer.WriteHint(_options.Pagination(_paginator.TotalCount, _paginator.CurrentPage + 1, _paginator.PageCount));
         }
     }
 
diff --git a/Sharprompt/Internal/Paginator.cs b/Sharprompt/Internal/Paginator.cs
@@ -1,11 +1,12 @@
 ﻿using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 
 namespace Sharprompt.Internal;
 
-internal class Paginator<T> where T : notnull
+internal class Paginator<T> : IEnumerable<T> where T : notnull
 {
     public Paginator(IEnumerable<T> items, int pageSize, Optional<T> defaultValue, Func<T, string> textSelector)
     {
@@ -20,37 +21,38 @@ public Paginator(IEnumerable<T> items, int pageSize, Optional<T> defaultValue, F
     private readonly int _pageSize;
     private readonly Func<T, string> _textSelector;
 
+    private T[] _filteredItems = Array.Empty<T>();
     private int _selectedIndex = -1;
 
-    public T[] FilteredItems { get; private set; } = Array.Empty<T>();
+    public ReadOnlySpan<T> CurrentItems => new(_filteredItems, _pageSize * CurrentPage, Count);
 
     public int PageCount { get; private set; }
 
-    public int SelectedPage { get; private set; }
+    public int CurrentPage { get; private set; }
 
-    public int Count => Math.Min(FilteredItems.Length - (_pageSize * SelectedPage), _pageSize);
+    public int Count => Math.Min(_filteredItems.Length - (_pageSize * CurrentPage), _pageSize);
 
-    public int TotalCount => FilteredItems.Length;
+    public int TotalCount => _filteredItems.Length;
 
-    public string FilterTerm { get; private set; } = "";
+    public string FilterKeyword { get; private set; } = "";
 
     public bool TryGetSelectedItem([NotNullWhen(true)] out T? selectedItem)
     {
-        if (FilteredItems.Length == 1)
+        if (_filteredItems.Length == 1)
         {
-            selectedItem = FilteredItems[0];
+            selectedItem = _filteredItems[0];
 
             return true;
         }
 
-        if (_selectedIndex == -1 || FilteredItems.Length == 0)
+        if (_selectedIndex == -1 || _filteredItems.Length == 0)
         {
             selectedItem = default;
 
             return false;
         }
 
-        selectedItem = FilteredItems[(_pageSize * SelectedPage) + _selectedIndex];
+        selectedItem = _filteredItems[(_pageSize * CurrentPage) + _selectedIndex];
 
         return true;
     }
@@ -72,8 +74,8 @@ public void NextPage()
             return;
         }
 
-        SelectedPage = SelectedPage >= PageCount - 1 ? 0 : SelectedPage + 1;
         _selectedIndex = -1;
+        CurrentPage = CurrentPage >= PageCount - 1 ? 0 : CurrentPage + 1;
     }
 
     public void PreviousPage()
@@ -83,45 +85,47 @@ public void PreviousPage()
             return;
         }
 
-        SelectedPage = SelectedPage <= 0 ? PageCount - 1 : SelectedPage - 1;
         _selectedIndex = -1;
+        CurrentPage = CurrentPage <= 0 ? PageCount - 1 : CurrentPage - 1;
     }
 
-    public void UpdateFilter(string term)
+    public void UpdateFilter(string keyword)
     {
-        FilterTerm = term;
+        FilterKeyword = keyword;
 
         _selectedIndex = -1;
-        SelectedPage = 0;
+        CurrentPage = 0;
 
-        UpdateItems();
+        UpdateFilteredItems();
     }
 
-    public ArraySegment<T> ToSubset() => new(FilteredItems, _pageSize * SelectedPage, Count);
+    public IEnumerator<T> GetEnumerator() => (IEnumerator<T>)_filteredItems.GetEnumerator();
 
-    private void UpdateItems()
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+    private void UpdateFilteredItems()
     {
-        FilteredItems = _items.Where(x => _textSelector(x).IndexOf(FilterTerm, StringComparison.OrdinalIgnoreCase) != -1)
-                              .ToArray();
+        _filteredItems = _items.Where(x => _textSelector(x).IndexOf(FilterKeyword, StringComparison.OrdinalIgnoreCase) != -1)
+                               .ToArray();
 
-        PageCount = (FilteredItems.Length - 1) / _pageSize + 1;
+        PageCount = (_filteredItems.Length - 1) / _pageSize + 1;
     }
 
     private void InitializeDefaults(Optional<T> defaultValue)
     {
-        UpdateItems();
+        UpdateFilteredItems();
 
         if (!defaultValue.HasValue)
         {
             return;
         }
 
-        for (var i = 0; i < FilteredItems.Length; i++)
+        for (var i = 0; i < _filteredItems.Length; i++)
         {
-            if (EqualityComparer<T>.Default.Equals(FilteredItems[i], defaultValue))
+            if (EqualityComparer<T>.Default.Equals(_filteredItems[i], defaultValue))
             {
                 _selectedIndex = i % _pageSize;
-                SelectedPage = i / _pageSize;
+                CurrentPage = i / _pageSize;
 
                 break;
             }
diff --git a/Sharprompt/Internal/PropertyMetadata.cs b/Sharprompt/Internal/PropertyMetadata.cs
@@ -30,7 +30,6 @@ public PropertyMetadata(object model, PropertyInfo propertyInfo)
                                  .Select(x => new ValidationAttributeAdapter(x).GetValidator(propertyInfo.Name, model))
                                  .ToArray();
         ItemsProvider = GetItemsProvider(propertyInfo);
-        BindIgnore = propertyInfo.GetCustomAttribute<BindIgnoreAttribute>() is not null;
     }
 
     public PropertyInfo PropertyInfo { get; }
@@ -45,7 +44,6 @@ public PropertyMetadata(object model, PropertyInfo propertyInfo)
     public object? DefaultValue { get; }
     public IReadOnlyList<Func<object?, ValidationResult?>> Validators { get; }
     public IItemsProvider ItemsProvider { get; }
-    public bool BindIgnore { get; set; }
 
     public FormType DetermineFormType()
     {
@@ -59,22 +57,12 @@ public FormType DetermineFormType()
             return FormType.Confirm;
         }
 
-        if (!IsCollection && ItemsProvider is not NullItemsProvider)
+        if (ItemsProvider is not NullItemsProvider)
         {
-            return FormType.Select;
+            return IsCollection ? FormType.MultiSelect : FormType.Select;
         }
 
-        if (IsCollection && ItemsProvider is not NullItemsProvider)
-        {
-            return FormType.MultiSelect;
-        }
-
-        if (IsCollection && ItemsProvider is NullItemsProvider)
-        {
-            return FormType.List;
-        }
-
-        return FormType.Input;
+        return IsCollection ? FormType.List : FormType.Input;
     }
 
     private IItemsProvider GetItemsProvider(PropertyInfo propertyInfo)
diff --git a/Sharprompt/Internal/PropertyMetadataFactory.cs b/Sharprompt/Internal/PropertyMetadataFactory.cs
@@ -9,9 +9,8 @@ internal static class PropertyMetadataFactory
     public static IReadOnlyList<PropertyMetadata> Create<T>(T model) where T : notnull
     {
         return typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance)
-                        .Where(x => x.CanWrite)
+                        .Where(x => x.CanWrite && x.GetCustomAttribute<BindIgnoreAttribute>() is null)
                         .Select(x => new PropertyMetadata(model, x))
-                        .Where(x => !x.BindIgnore)
                         .OrderBy(x => x.Order)
                         .ToArray();
     }
diff --git a/Sharprompt/Internal/TypeHelper.cs b/Sharprompt/Internal/TypeHelper.cs
diff --git a/Sharprompt/Prompt.Configuration.cs b/Sharprompt/Prompt.Configuration.cs

Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ protected override bool HandleEnter([NotNullWhen(true)] out T? result)`
`56`	`56`	`{`
`57`	`57`	`if (string.IsNullOrEmpty(input))`
`58`	`58`	`{`
`59`		`- if (TypeHelper<T>.IsValueType && !_defaultValue.HasValue)`
	`59`	`+ if (!TypeHelper<T>.IsNullable && !_defaultValue.HasValue)`
`60`	`60`	`{`
`61`	`61`	`SetError(Resource.Validation_Required);`
`62`	`62`
Original file line number	Diff line number	Diff line change
`@@ -43,18 +43,16 @@ public MultiSelectForm(MultiSelectOptions<T> options)`
`43`	`43`	`protected override void InputTemplate(OffscreenBuffer offscreenBuffer)`
`44`	`44`	`{`
`45`	`45`	`offscreenBuffer.WritePrompt(_options.Message);`
`46`		`- offscreenBuffer.Write(_paginator.FilterTerm);`
	`46`	`+ offscreenBuffer.Write(_paginator.FilterKeyword);`
`47`	`47`
`48`	`48`	`offscreenBuffer.PushCursor();`
`49`	`49`
`50`		`- if (string.IsNullOrEmpty(_paginator.FilterTerm))`
	`50`	`+ if (string.IsNullOrEmpty(_paginator.FilterKeyword))`
`51`	`51`	`{`
`52`	`52`	`offscreenBuffer.WriteHint(Resource.MultiSelectForm_Message_Hint);`
`53`	`53`	`}`
`54`	`54`
`55`		`- var subset = _paginator.ToSubset();`
`56`		`-`
`57`		`- foreach (var item in subset)`
	`55`	`+ foreach (var item in _paginator.CurrentItems)`
`58`	`56`	`{`
`59`	`57`	`var value = _options.TextSelector(item);`
`60`	`58`
`@@ -80,7 +78,7 @@ protected override void InputTemplate(OffscreenBuffer offscreenBuffer)`
`80`	`78`	`if (_paginator.PageCount > 1)`
`81`	`79`	`{`
`82`	`80`	`offscreenBuffer.WriteLine();`
`83`		`- offscreenBuffer.WriteHint(_options.Pagination(_paginator.TotalCount, _paginator.SelectedPage + 1, _paginator.PageCount));`
	`81`	`+ offscreenBuffer.WriteHint(_options.Pagination(_paginator.TotalCount, _paginator.CurrentPage + 1, _paginator.PageCount));`
`84`	`82`	`}`
`85`	`83`	`}`
`86`	`84`
`@@ -197,7 +195,7 @@ private bool HandleAWithControl(ConsoleKeyInfo keyInfo)`
`197`	`195`	`}`
`198`	`196`	`else`
`199`	`197`	`{`
`200`		`- foreach (var item in _paginator.FilteredItems)`
	`198`	`+ foreach (var item in _paginator)`
`201`	`199`	`{`
`202`	`200`	`_selectedItems.Add(item);`
`203`	`201`	`}`
`@@ -213,7 +211,7 @@ private bool HandleIWithControl(ConsoleKeyInfo keyInfo)`
`213`	`211`	`return false;`
`214`	`212`	`}`
`215`	`213`
`216`		`- var invertedItems = _paginator.FilteredItems.Except(_selectedItems).ToArray();`
	`214`	`+ var invertedItems = _paginator.Except(_selectedItems).ToArray();`
`217`	`215`
`218`	`216`	`_selectedItems.Clear();`
`219`	`217`
Original file line number	Diff line number	Diff line change
`@@ -32,13 +32,11 @@ public SelectForm(SelectOptions<T> options)`
`32`	`32`	`protected override void InputTemplate(OffscreenBuffer offscreenBuffer)`
`33`	`33`	`{`
`34`	`34`	`offscreenBuffer.WritePrompt(_options.Message);`
`35`		`- offscreenBuffer.Write(_paginator.FilterTerm);`
	`35`	`+ offscreenBuffer.Write(_paginator.FilterKeyword);`
`36`	`36`
`37`	`37`	`offscreenBuffer.PushCursor();`
`38`	`38`
`39`		`- var subset = _paginator.ToSubset();`
`40`		`-`
`41`		`- foreach (var item in subset)`
	`39`	`+ foreach (var item in _paginator.CurrentItems)`
`42`	`40`	`{`
`43`	`41`	`var value = _options.TextSelector(item);`
`44`	`42`
`@@ -57,7 +55,7 @@ protected override void InputTemplate(OffscreenBuffer offscreenBuffer)`
`57`	`55`	`if (_paginator.PageCount > 1)`
`58`	`56`	`{`
`59`	`57`	`offscreenBuffer.WriteLine();`
`60`		`- offscreenBuffer.WriteHint(_options.Pagination(_paginator.TotalCount, _paginator.SelectedPage + 1, _paginator.PageCount));`
	`58`	`+ offscreenBuffer.WriteHint(_options.Pagination(_paginator.TotalCount, _paginator.CurrentPage + 1, _paginator.PageCount));`
`61`	`59`	`}`
`62`	`60`	`}`
`63`	`61`
Original file line number	Diff line number	Diff line change
`@@ -1,11 +1,12 @@`
`1`	`1`	`using System;`
	`2`	`+using System.Collections;`
`2`	`3`	`using System.Collections.Generic;`
`3`	`4`	`using System.Diagnostics.CodeAnalysis;`
`4`	`5`	`using System.Linq;`
`5`	`6`
`6`	`7`	`namespace Sharprompt.Internal;`
`7`	`8`
`8`		`-internal class Paginator<T> where T : notnull`
	`9`	`+internal class Paginator<T> : IEnumerable<T> where T : notnull`
`9`	`10`	`{`
`10`	`11`	`public Paginator(IEnumerable<T> items, int pageSize, Optional<T> defaultValue, Func<T, string> textSelector)`
`11`	`12`	`{`
`@@ -20,37 +21,38 @@ public Paginator(IEnumerable<T> items, int pageSize, Optional<T> defaultValue, F`
`20`	`21`	`private readonly int _pageSize;`
`21`	`22`	`private readonly Func<T, string> _textSelector;`
`22`	`23`
	`24`	`+ private T[] _filteredItems = Array.Empty<T>();`
`23`	`25`	`private int _selectedIndex = -1;`
`24`	`26`
`25`		`- public T[] FilteredItems { get; private set; } = Array.Empty<T>();`
	`27`	`+ public ReadOnlySpan<T> CurrentItems => new(_filteredItems, _pageSize * CurrentPage, Count);`
`26`	`28`
`27`	`29`	`public int PageCount { get; private set; }`
`28`	`30`
`29`		`- public int SelectedPage { get; private set; }`
	`31`	`+ public int CurrentPage { get; private set; }`
`30`	`32`
`31`		`- public int Count => Math.Min(FilteredItems.Length - (_pageSize * SelectedPage), _pageSize);`
	`33`	`+ public int Count => Math.Min(_filteredItems.Length - (_pageSize * CurrentPage), _pageSize);`
`32`	`34`
`33`		`- public int TotalCount => FilteredItems.Length;`
	`35`	`+ public int TotalCount => _filteredItems.Length;`
`34`	`36`
`35`		`- public string FilterTerm { get; private set; } = "";`
	`37`	`+ public string FilterKeyword { get; private set; } = "";`
`36`	`38`
`37`	`39`	`public bool TryGetSelectedItem([NotNullWhen(true)] out T? selectedItem)`
`38`	`40`	`{`
`39`		`- if (FilteredItems.Length == 1)`
	`41`	`+ if (_filteredItems.Length == 1)`
`40`	`42`	`{`
`41`		`- selectedItem = FilteredItems[0];`
	`43`	`+ selectedItem = _filteredItems[0];`
`42`	`44`
`43`	`45`	`return true;`
`44`	`46`	`}`
`45`	`47`
`46`		`- if (_selectedIndex == -1 \|\| FilteredItems.Length == 0)`
	`48`	`+ if (_selectedIndex == -1 \|\| _filteredItems.Length == 0)`
`47`	`49`	`{`
`48`	`50`	`selectedItem = default;`
`49`	`51`
`50`	`52`	`return false;`
`51`	`53`	`}`
`52`	`54`
`53`		`- selectedItem = FilteredItems[(_pageSize * SelectedPage) + _selectedIndex];`
	`55`	`+ selectedItem = _filteredItems[(_pageSize * CurrentPage) + _selectedIndex];`
`54`	`56`
`55`	`57`	`return true;`
`56`	`58`	`}`
`@@ -72,8 +74,8 @@ public void NextPage()`
`72`	`74`	`return;`
`73`	`75`	`}`
`74`	`76`
`75`		`- SelectedPage = SelectedPage >= PageCount - 1 ? 0 : SelectedPage + 1;`
`76`	`77`	`_selectedIndex = -1;`
	`78`	`+ CurrentPage = CurrentPage >= PageCount - 1 ? 0 : CurrentPage + 1;`
`77`	`79`	`}`
`78`	`80`
`79`	`81`	`public void PreviousPage()`
`@@ -83,45 +85,47 @@ public void PreviousPage()`
`83`	`85`	`return;`
`84`	`86`	`}`
`85`	`87`
`86`		`- SelectedPage = SelectedPage <= 0 ? PageCount - 1 : SelectedPage - 1;`
`87`	`88`	`_selectedIndex = -1;`
	`89`	`+ CurrentPage = CurrentPage <= 0 ? PageCount - 1 : CurrentPage - 1;`
`88`	`90`	`}`
`89`	`91`
`90`		`- public void UpdateFilter(string term)`
	`92`	`+ public void UpdateFilter(string keyword)`
`91`	`93`	`{`
`92`		`- FilterTerm = term;`
	`94`	`+ FilterKeyword = keyword;`
`93`	`95`
`94`	`96`	`_selectedIndex = -1;`
`95`		`- SelectedPage = 0;`
	`97`	`+ CurrentPage = 0;`
`96`	`98`
`97`		`- UpdateItems();`
	`99`	`+ UpdateFilteredItems();`
`98`	`100`	`}`
`99`	`101`
`100`		`- public ArraySegment<T> ToSubset() => new(FilteredItems, _pageSize * SelectedPage, Count);`
	`102`	`+ public IEnumerator<T> GetEnumerator() => (IEnumerator<T>)_filteredItems.GetEnumerator();`
`101`	`103`
`102`		`- private void UpdateItems()`
	`104`	`+ IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();`
	`105`	`+`
	`106`	`+ private void UpdateFilteredItems()`
`103`	`107`	`{`
`104`		`- FilteredItems = _items.Where(x => _textSelector(x).IndexOf(FilterTerm, StringComparison.OrdinalIgnoreCase) != -1)`
`105`		`- .ToArray();`
	`108`	`+ _filteredItems = _items.Where(x => _textSelector(x).IndexOf(FilterKeyword, StringComparison.OrdinalIgnoreCase) != -1)`
	`109`	`+ .ToArray();`
`106`	`110`
`107`		`- PageCount = (FilteredItems.Length - 1) / _pageSize + 1;`
	`111`	`+ PageCount = (_filteredItems.Length - 1) / _pageSize + 1;`
`108`	`112`	`}`
`109`	`113`
`110`	`114`	`private void InitializeDefaults(Optional<T> defaultValue)`
`111`	`115`	`{`
`112`		`- UpdateItems();`
	`116`	`+ UpdateFilteredItems();`
`113`	`117`
`114`	`118`	`if (!defaultValue.HasValue)`
`115`	`119`	`{`
`116`	`120`	`return;`
`117`	`121`	`}`
`118`	`122`
`119`		`- for (var i = 0; i < FilteredItems.Length; i++)`
	`123`	`+ for (var i = 0; i < _filteredItems.Length; i++)`
`120`	`124`	`{`
`121`		`- if (EqualityComparer<T>.Default.Equals(FilteredItems[i], defaultValue))`
	`125`	`+ if (EqualityComparer<T>.Default.Equals(_filteredItems[i], defaultValue))`
`122`	`126`	`{`
`123`	`127`	`_selectedIndex = i % _pageSize;`
`124`		`- SelectedPage = i / _pageSize;`
	`128`	`+ CurrentPage = i / _pageSize;`
`125`	`129`
`126`	`130`	`break;`
`127`	`131`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,9 +9,8 @@ internal static class PropertyMetadataFactory`
`9`	`9`	`public static IReadOnlyList<PropertyMetadata> Create<T>(T model) where T : notnull`
`10`	`10`	`{`
`11`	`11`	`return typeof(T).GetProperties(BindingFlags.Public \| BindingFlags.Instance)`
`12`		`- .Where(x => x.CanWrite)`
	`12`	`+ .Where(x => x.CanWrite && x.GetCustomAttribute<BindIgnoreAttribute>() is null)`
`13`	`13`	`.Select(x => new PropertyMetadata(model, x))`
`14`		`- .Where(x => !x.BindIgnore)`
`15`	`14`	`.OrderBy(x => x.Order)`
`16`	`15`	`.ToArray();`
`17`	`16`	`}`