@חגי
הממ.. מחיקה של תוכן תיקייה זו עזר נראה אם זה צץ שוב

איך להסיר ניקוד וטעמים מטקסט בc#
מצאתי שני דרכים אשמח לקבל המלצות איזה עדיף ולמה.

---

# אפשרות א על ידי רגקס

---

  public static string RemoveDiactricts(string input)
  {
      return Regex.Replace(input, @"\p{M}", "");
  }

---

# אפשרות ב על ידי ספריית Diactricts

---

דרך ה-NuGet התקינו את ספריית Diactricts

לאחמ"כ תוכלו להתשמש עם ה-class דלהלן

 public class HebrewDiacriticsMapping : IAccentMapping
 {
     private readonly Dictionary<char, MappingReplacement> mappings;

     public HebrewDiacriticsMapping()
     {
         mappings = CreateMappings();
     }

     public IDictionary<char, MappingReplacement> Mapping => mappings;

     private Dictionary<char, MappingReplacement> CreateMappings()
     {
         var mappings = new Dictionary<char, MappingReplacement>();

         // Remove all Hebrew diacritics by mapping them to an empty string
         // Diacritics in Hebrew range from U+0591 to U+05BD, U+05C1, U+05C2, U+05C4, U+05C5
         // U+0591 - U+05AF (excluding U+05BE - U+05C0, which are vowels and other symbols)
         // U+05B0 - U+05BD, U+05C1, U+05C2, U+05C4, U+05C5 (including additional diacritics)
         for (int i = 0x0591; i <= 0x05AF; i++)
         {
             char diacriticChar = (char)i;
             mappings[diacriticChar] = new MappingReplacement();
         }
         for (int i = 0x05B0; i <= 0x05BD; i++)
         {
             char diacriticChar = (char)i;
             mappings[diacriticChar] = new MappingReplacement();
         }
         mappings['\u05C1'] = new MappingReplacement();
         mappings['\u05C2'] = new MappingReplacement();
         mappings['\u05C4'] = new MappingReplacement();
         mappings['\u05C5'] = new MappingReplacement();

         return mappings;
     }
 }

 public static class HebrewDiacriticsRemover
 {
     private static readonly DiacriticsMapper mapper = new DiacriticsMapper(new HebrewDiacriticsMapping());
     public static string RemoveHebrewDiacritics(this string input)
     {
         return mapper.RemoveDiacritics(input);
     }
 }

@mekev
קודם כל כבר כתבתי שקראתי ואני מסכים עם כל מה ש-@yossiz אמר
בשנית אני מתקשה להבין למה אתה מביא אנקדוטות מכל מיני חאפרים אא"כ כוונתך להזהיר אנשים שיבדקו טוב לפני שהם נכנסים למשהו?
כמו כן, שים לב שאתה מתעסק עם תכנות כבר כמה שנים ונמצא בעניינים, בעוד שמיודענו "פעם" למד תכנות.

כלומר לאפוקי אם אם משתמשים ב-
net FrameWork.
שמה זה תמיד מראה את המיושן
רק ב-
NET Core 3.1 ומעלה זה מראה את העדכני

יש לכם הערות? אנא כתבו אותם לתועלת כולם!

הערה: אישית אני ראיתי תועלת גדולה ב-mvvm, למרות שביישום של commands לא כל כך ראיתי תועלת בפרוייקטים שלי כי לרוב זה לא היה נצרך ורק הפך את הקוד למסורבל, בכל אופן הדוגמא דלהלן כוללת אותם לצורך ההדגמה ואפשר לראות כיצד הם 'מחליקים' את פעולת התוכנה, כמו"כ הוספתי קיצורי מקשים דרך ה-commands מה שמדגים את השימושיות שלהם.

הדגמה פשוטה של MVVM

עיין כאן להסבר על המושג MVVM:
להרחבה על הנושא עיין כאן

היה לי צורך להדגים את המודל mvvm עבור ידיד אז יצרתי את הפרוייקט דלהלן על בסיס כתבה זו (הפרוייקט רחוק מלהיות מושלם אבל הוא מספיק בשביל הדגמה לדעתי):

התוכנה מיישמת מחשבון (כלשהו) שיניתי קצת מהכתבה לצורך ההדגמה.

---

1. קוד ל-view

---

<Window x:Class="WpfTestProject.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:WpfTestProject"
        mc:Ignorable="d"
        Background="WhiteSmoke"
        SizeToContent="WidthAndHeight"
        FocusManager.FocusedElement="{Binding ElementName=FirstValueTextBox}">
    <Window.DataContext>
        <local:CalculatorViewModel/>
    </Window.DataContext>

    <Window.InputBindings>
        <KeyBinding Key="A" Modifiers="Control" Command="{Binding AddCommand}"/>
        <KeyBinding Key="S" Modifiers="Control" Command="{Binding SubTractCommand}"/>
        <KeyBinding Key="T" Modifiers="Control" Command="{Binding TimesCommand}"/>
        <KeyBinding Key="D" Modifiers="Control" Command="{Binding DivideCommand}"/>
        <KeyBinding Key="P" Modifiers="Control" Command="{Binding PercentCommand}"/>
    </Window.InputBindings>
    
    <Window.Resources>
        <Style TargetType="TextBox">
            <Setter Property="Margin" Value="5"/>
            <Setter Property="HorizontalContentAlignment" Value="Center"/>
            <Setter Property="VerticalContentAlignment" Value="Center"/>
            <Setter Property="BorderBrush" Value="LightGray"/>
        </Style>
        <Style TargetType="TextBlock">
            <Setter Property="Margin" Value="5"/>
            <Setter Property="VerticalAlignment" Value="Center"/>
        </Style>
        <Style TargetType="Label">
            <Setter Property="Margin" Value="5"/>
            <Setter Property="HorizontalContentAlignment" Value="Center"/>
            <Setter Property="VerticalContentAlignment" Value="Center"/>
            <Setter Property="BorderBrush" Value="LightGray"/>
            <Setter Property="BorderThickness" Value="1"/>
            <Setter Property="Background" Value="White"/>
        </Style>
        <Style TargetType="Button">
            <Setter Property="Margin" Value="5"/>
            <Setter Property="Background" Value="{x:Null}"/>
            <Setter Property="BorderBrush" Value="LightGray"/>
            <Setter Property="Height" Value="38"/>
            <Setter Property="Width" Value="{Binding Path=Height, RelativeSource={RelativeSource Self}}"/>
           
        </Style>
    </Window.Resources>
    
    <StackPanel>
        <TextBlock Text="Calculator" HorizontalAlignment="Center"
               FontSize="34" Foreground="BlueViolet"/>

        <Grid Margin="5,10,5,5" KeyboardNavigation.TabNavigation="Cycle">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="*"/>
                <ColumnDefinition Width="auto"/>
                <ColumnDefinition Width="*"/>
                <ColumnDefinition Width="auto"/>
                <ColumnDefinition Width="*"/>
            </Grid.ColumnDefinitions>

            <TextBox x:Name="FirstValueTextBox" Grid.Column="0" Text="{Binding FirstValue}" />
            <TextBlock Text="{Binding MathMethod}" Grid.Column="1"/>
            <TextBox x:Name="SecondValueTextBox" Grid.Column="2" Text="{Binding SecondValue}"/>
            <TextBlock Text="=" Grid.Column="3" VerticalAlignment="Center" Margin="5"/>
            <Label  Grid.Column="4" Margin="5"
                   Content="{Binding ResultValue, BindsDirectlyToSource=True}"/>
        </Grid>

        <StackPanel Orientation="Horizontal" Margin="5">
            <Button Content="+" Command="{Binding AddCommand}"/>
            <Button Content="-" Command="{Binding SubTractCommand}"/>
            <Button Content="*" Command="{Binding TimesCommand}"/>
            <Button Content="/" Command="{Binding DivideCommand}"/>
            <Button Content="%" Command="{Binding PercentCommand}"/>
        </StackPanel>
        
    </StackPanel>
</Window>

---

2. קודים המהווים בסיס ל-viewmodel

---

using System;
using System.Windows.Input;

namespace WpfTestProject
{
    public abstract class ICommandBase : ICommand
    {
        public event EventHandler CanExecuteChanged;

        public virtual bool CanExecute(object parameter)
        {
            return true;
        }

        public abstract void Execute(object parameter);

        protected void OnCanExecuteChanged()
        {
            CanExecuteChanged?.Invoke(this, new EventArgs());
        }
    }

    public class RelayCommand : ICommandBase
    {
        private Action commandTask;

        public RelayCommand(Action action)
        {
            commandTask = action;
        }
        public override void Execute(object parameter)
        {
            commandTask();
        }
    }
}

 public class INotifyPropertyChangedBase : INotifyPropertyChanged
 {
     public event PropertyChangedEventHandler PropertyChanged;
     protected void OnPropertyChanged(string propertyName)
     {
         PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
     }
 }

---

3. ה-viewmodel

---

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Input;

namespace WpfTestProject
{
    public class CalculatorViewModel : INotifyPropertyChangedBase
    {
        #region members
        string _mathMethod;
        double _firstValue;
        double _secondValue;
        double _result;
        #endregion

        #region properties
        public string MathMethod { get => _mathMethod; set { _mathMethod = value; OnPropertyChanged(nameof(MathMethod)); } }
        public double FirstValue { get => _firstValue; set => _firstValue = value; }
        public double SecondValue { get => _secondValue; set => _secondValue = value; }
        public double ResultValue { get => _result; set { _result = value; OnPropertyChanged(nameof(ResultValue)); } }
        #endregion

        #region Commands
        public ICommand AddCommand
        {
            get
            {
                //return plusCommand;
                return new RelayCommand(Add);
            }
        }
        public ICommand SubTractCommand
        {
            get
            {
                return new RelayCommand(SubTract);
            }
        }
        public ICommand TimesCommand
        {
            get
            {
                return new RelayCommand(Times);
            }
        }
        public ICommand PercentCommand
        {
            get
            {
                return new RelayCommand(Percent);
            }
        }
        public ICommand DivideCommand
        {
            get
            {
                return new RelayCommand(Divide);
            }
        }
        #endregion

        #region Methods
        public void Add()
        {
            MathMethod = "+";
            ResultValue = FirstValue + SecondValue;
            return;
        }
        public void SubTract()
        {
            MathMethod = "-";
            ResultValue = FirstValue - SecondValue;
        }
        public void Times()
        {
            MathMethod = "*";
            ResultValue = FirstValue * SecondValue;
        }
        public void Divide()
        {
            MathMethod = "/";
            ResultValue = FirstValue / SecondValue;
        }
        public void Percent()
        {
            MathMethod = "%";
            ResultValue = FirstValue * SecondValue;
        }
        #endregion
    }
}

4. שמתם לב? ה-model חסר.... בתוכנה זו לא היה צורך ב-model בעיקרון ה-model היה יכול להיות אחד משני דברים. או class עם מבנה נתונים. או class עם קוד חיצוני.

DiffPlex השוואת טקסטים.zip

---

Diffplex השוואת טקסטים - נייד.zip

---

או בגיט

https://github.com/pcinfogmach/DiffPlex-/releases/tag/DiffplexSpinOff

@dovid
אה
הייתרון לעניין הסדר הוא העובדה שאני מפריד את המתודות של ה-פעולות משאר המתודות שלא נוגעות לפעולות אלא ל-view
כאשר יש מאות לחצנים זה מאוד משמעותי

@dovid כתב בקוד להצגת שינויים בין טקסטים ב-C# (השוואת טקסטים):

בינתיים ריק...

עודכן
תודה!

@קומפיונט
תודה רבה!
עזרת לי מאוד!

בגדול אם אני יכול לזהות שם ספר בצורה נכונה זזה כבר ייעל את זה בהרבה - איפה הסיבוך:
יש ספרים עם שמות זהים: לדוגמא - ברכות
יכול הליות בבלי ברכות או משנה ברכות
או יותר גרוע בראשית
יש המון ספרים שכוללים בתוך השם שלהם את המילה בראשית (בהצחלה בסוף או באמצע). איך התוכנה תידע באיזה בראשית מדובר?? במקרה הזה כמובן אפשר לעשות ברירת מחדל שיצביע לחומש אבל שוב זה אומר הרבה hardcoding אני מחפש צורה דינאמית שתחפה על המקרים שלא עשיתי בצורה ישירה

לפעמים כאשר בונים תוכנה באקסס והגדרת האיזור של המערכת הוא ישראל עברית מה שקורה הוא שאם מישהו עם מחשב אמריקאי מנסה להריץ אותה - הוא יראה גיבריש - המחשב מתבלבל ולא מצליח להציג את העברית.

ההצעה שלי תתכנתו עם מחשב עם הגדרת איזור באנגלית אולי זה יעזור.

@Whenever
יש פה מורכבות מסויימת שלא חשבתי עליה.
מכיון שהתוכנה שבניתי היא דינאמית - אין לה מסד נתונים כלל - הכל נבנה במקום עם פתיחת הקובץ. כך שאין לי כותרות מוכנות להשוות אליהם מראש. (שמות ספרים יש לי רשימה כי הם נטענים עם טעינת התוכנה אבל לא כותרות)

@Whenever
רגקס בהחלט עוזר אבל איזה רגקס אולי למישהו יש רעיון בתור התחלה?
אומר את האמת אני לא מוצא את ידי ורגלי למרות שכרגיל אני די טוב עם רגקס משהו פה מבלבל אותי

בעיקרון אם מדובר בקישור פשוט כמו בראשית א יג לא משנה איך זה אמור להיות קל לזהות
אבל לא תמיד שם הספר הוא רק מילה אחת לדוגמא דברי הימים א
כאן יש כבר מורכבות נוספת כי איך התוכנה תדע שמדובר בא של שם הספר ולא של הפרק.

מכיוון שהנושא לכשעצמו לא ברור לי דיו אני כותב שאלה לא ברורה בתקוה שמתוך הדיון לכשעצמו הדברים יתבהרו - מה ריאלי ומה לא - תודה מראש.

אני מחפש עצה איך ניתן לזהות קשורים בשביל התוכנה שלי - תורת אמת בוורד
בדומה למה שיש בבר אילן ומה שנקרא בלעז "קשוריות" - שאם לוחצים על קישור |(מראה מקום) זה יוביל לפתיחת ספר במיקום הזה.

הקושי שלי הוא בעצם איך להשוות קישורים שאינם מדוייקים:

כלומר פורמט הכותרות בתוכנה שלי הוא מתתמיד על ידי הפרדה של פסיקים
לדוגמא: בראשית, פרשת בראשית, פרק ד, טו
בספרי תורת אמת הקישורים מופיעים בכל מיני פורמטים:
לבינתיים אני עובר אחד אחד ומנסה לזהות את הפורמט השאלה שלי אפ יש משהו יותר כללי שאפשר ליישם שתחסוך לי את כל הטירחה הזו? או שלכה"פ ישמש אותי כאשר לא הצלחתי לדמות בצורה מרובעת את הקישורים.

בC# קיימת הפונקציה contains שבודקת האם מחרוזת טקסט מכיל בתוכו מחרוזת טקסט אחרת
אבל מה קורה אם המחרוזת השניה מבולגנת (כלומר המילים אינם לפי הסדר) ואתה רוצה לבדוק אם היא קיימת בתוך מחרוזת הראשונה (לדוגמא אם נחפש את "כי זרע יקרא לך ביצחק" בתוך חומש בראשית).
בניתי לזה קוד והייתי שמח לקבל משוב - תודה מראש

 public static bool StringContains(this string line, string[] searchPatternArray, int maxDistance)
 {
     maxDistance = maxDistance - searchPatternArray[searchPatternArray.Length - 1].Length;
     List<List<int>> wordIndexesList = new List<List<int>>();

     // Get indexes of each word in the line
     foreach (string word in searchPatternArray)
     {
         var indexes = AllIndexesOf(line, word).ToList();
         wordIndexesList.Add(indexes);
     }

     if (wordIndexesList.Any(list => list.Count == 0))
         return false;

     // Calculate if there is an occurrence of all words within the max distance
     return IsWithinMaxDistance(wordIndexesList, maxDistance);
 }

 static IEnumerable<int> AllIndexesOf(string str, string value)
 {
     if (string.IsNullOrEmpty(value))
         throw new ArgumentException("The string to find may not be empty", nameof(value));

     int index = 0;
     while (index < str.Length)
     {
         index = str.IndexOf(value, index);
         if (index == -1)
             break;
         yield return index;
         index += value.Length;
     }
 }

 static bool IsWithinMaxDistance(List<List<int>> wordIndexesList, int maxDistance)
 {
     // Check if all words occur within the maximum distance
     for (int i = 0; i < wordIndexesList[0].Count; i++)
     {
         int startIndex = wordIndexesList[0][i];
         if (IsWithinMaxDistanceForIndex(wordIndexesList, maxDistance, 1, startIndex))
         {
             return true;
         }
     }
     return false;
 }

 static bool IsWithinMaxDistanceForIndex(List<List<int>> wordIndexesList, int maxDistance, int wordIndex, int startIndex)
 {
     if (wordIndex >= wordIndexesList.Count)
         return true; // All words checked within max distance

     for (int j = 0; j < wordIndexesList[wordIndex].Count; j++)
     {
         int endIndex = wordIndexesList[wordIndex][j];
         int distance = Math.Abs(endIndex - startIndex);
         if (distance <= maxDistance)
         {
             if (IsWithinMaxDistanceForIndex(wordIndexesList, maxDistance, wordIndex + 1, endIndex))
             {
                 return true;
             }
         }
         else if (endIndex > startIndex)
         {
             // No need to check further as the indexes are sorted
             break;
         }
     }

     return false;
 }

@חגי
תודה רבה הפוסט עצמו גם היה מאוד אינפורמטיבי
כלומר התגובה הזו
https://stackoverflow.com/a/44118559/23343154

@חגי
אין כמוך!
אני מצרף לינק לתשובה המדוייקת שם שעזרה לי
https://stackoverflow.com/a/67373337/23343154

@חגי
תודה
גם זה לא עובד לי עדכנתי את הפוסט למעלה עם מה שקרה

מצו"ב קוד לפרוייקט שלי עבור יצירת
wpf Checked-TreeView עם Binding
אשמח לקבל משוב. תודה

כמו"כ לא הצלחתי לעשות BInding ל itemsorce ישירות מה-xaml רק דרך הקוד זה עובד - אשמח לקבל הדרכה בנושא ממי שיכול.
תודה מראש.
עשיתי את זה בעיקר ללימוד - מקווה שיהיה שימושי בעז"ה לעוד מישהו חוץ ממני.

<Window x:Class="Wpf_Checked_TreeView.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:Wpf_Checked_TreeView"
        mc:Ignorable="d"
        Title="MainWindow" Height="450" Width="800"
        DataContext="{Binding RelativeSource={RelativeSource Self}}"
        >
    <Grid>
        <TreeView x:Name="treeView" ItemsSource="{Binding treeItemsList}"> 
            <TreeView.Resources>
                <HierarchicalDataTemplate DataType="{x:Type local:CheckedTreeItem}" ItemsSource="{Binding Children}">
                    <StackPanel Orientation="Horizontal">
                        <CheckBox Content="{Binding Name}" IsChecked="{Binding IsChecked, Mode=TwoWay}"/>
                    </StackPanel>
                </HierarchicalDataTemplate>
            </TreeView.Resources>
        </TreeView>
    </Grid>
</Window>

using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Windows;

namespace Wpf_Checked_TreeView
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public ObservableCollection<object> treeItemsList = new ObservableCollection<object>();
        public MainWindow()
        {
            InitializeComponent();

            CheckedTreeItem rootItem1 = new CheckedTreeItem { Name = "root item 1" };
            CheckedTreeItem child1 = new CheckedTreeItem { Name = "child item 1"};
            CheckedTreeItem child2 = new CheckedTreeItem { Name = "child item 2" };
            rootItem1.AddChild(child1);
            rootItem1.AddChild(child2);
            child1.AddChild(new CheckedTreeItem { Name = "sub child item 1" });
            child1.AddChild(new CheckedTreeItem { Name = "sub child item 2" });
            child2.AddChild(new CheckedTreeItem { Name = "sub child item 1" });
            child2.AddChild(new CheckedTreeItem { Name = "sub child item 2" });

            CheckedTreeItem rootItem2 = new CheckedTreeItem { Name = "root item 1" };
            rootItem2.AddChild(new CheckedTreeItem { Name = "child item 1" });
            rootItem2.AddChild(new CheckedTreeItem { Name = "child item 1" });

            treeItemsList.Add(rootItem1);
            treeItemsList.Add(rootItem2);

            treeView.ItemsSource = treeItemsList;
        }
    }



    public class CheckedTreeItem : INotifyPropertyChanged
    {
        private ObservableCollection<CheckedTreeItem> _children = new ObservableCollection<CheckedTreeItem>();
        public ObservableCollection<CheckedTreeItem> Children
        {
            get { return _children; }
            set
            {
                _children = value;
                OnPropertyChanged(nameof(Children));
            }
        }
        
        private CheckedTreeItem _parent;
        public CheckedTreeItem Parent
        {
            get { return _parent; }
            set
            {
                _parent = value;
                OnPropertyChanged(nameof(Parent));
            }
        }

        private string _name;
        public string Name
        {
            get { return _name; }
            set
            {
                if (_name != value)
                {
                    _name = value;
                    OnPropertyChanged(nameof(Name));
                }
            }
        }

        private bool? _isChecked = false;
        public bool? IsChecked
        {
            get { return _isChecked; }
            set
            {
                if (_isChecked != value)
                {
                    _isChecked = value;
                    OnPropertyChanged(nameof(IsChecked));
                    UpdateChildCheckSatus(value);
                    UpdateParentCheckSatus(value);
                }
            }
        }
        void UpdateChildCheckSatus(bool? value)
        {
            foreach (CheckedTreeItem child in Children)
            {
                if (value != null){   child.IsChecked = value;  }
            }
        }
        void UpdateParentCheckSatus(bool? value)
        {
            if (Parent != null)
            {
                bool allChecked = Parent.Children.OfType<CheckedTreeItem>().All(child => child.IsChecked == true);
                bool allUnchecked = Parent.Children.OfType<CheckedTreeItem>().All(child => child.IsChecked == false);

                if (allChecked) { Parent.IsChecked = true; }
                else if (allUnchecked) { Parent.IsChecked = false; }
                else { Parent.IsChecked = null; }
            }
        }

        public event PropertyChangedEventHandler PropertyChanged;
        protected void OnPropertyChanged(string propertyName)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
        public void AddChild(CheckedTreeItem child)
        {
            if (child is CheckedTreeItem CheckedTreeItem)
            {
                CheckedTreeItem.Parent = this;
                Children.Add(child);
            }
        }
    }


}