תחומים - פורום חרדי מקצועי

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

אשמח אם מישהו יסביר לי קצת יותר מתי ואיך נכון להשתמש ב-await Task.Run.
כמו"כ קראתי כמה פעמים על משהו שנקרא תנאי תחרות (Race Condition) כשמשתמשים ב-Multithreading - אני חייב לומר שלא בדיוק הבנתי את הנושא.
לעת עתה כל מה שאני יודע שזה נותן לי אפשרות הריץ קוד בלי לחסום את ה-UI. או להריץ כמה דברים בו זמנית (שזה בעצם אותו עיקרון).

שאלותיי הם:
מהם ההדרכות לכתיבת קוד אסינכרוני ב-C# וממה יש להיזהר?

דוגמת קוד:
האם קוד זה טוב או בעייתי או טעון שיפור? אשמח גם לקבל הסבר מדוע:

async Task LoadCommentries(IOrderedEnumerable<LinkItem> commentryList, int lineIndex)
{
    Commentry = await Task.Run(async () =>
    {
        var stringBuilder = new StringBuilder();
        foreach (var commentry in commentryList)
        {
            stringBuilder.AppendLine(await GetCommentryLine(commentry.path_2, lineIndex));
        }
        return stringBuilder.ToString();
    });
}

async Task<string> GetCommentryLine(string path, int lineIndex)
{
    using (var reader = new StreamReader(path))
    {
        int currentIndex = 0;
        while (!reader.EndOfStream && currentIndex < lineIndex)
        {
            await reader.ReadLineAsync();
            currentIndex++;
        }
        return await reader.ReadLineAsync();
    }
}

@Mordechai-0
שוב נתקלתי בבעיה זו והעצה שלך לא עזרה...

כידוע, הדרך הטובה ביותר להתנהל עם TreeView ב-WPF היא עם מבנה נתונים הררכי, ו-HierarchicalDataTemplate ב-WPF נבנה במיוחד למטרה זו.
אחרי שמצאתי את עצמי בפעם השלישית בונה מבנה נתונים עבור Checked TreeView (ראה תמונה), החלטתי לשבת כמה דקות ולבנות משהו יותר גלובלי שיאפשר לי להשתמש בו גם בעתיד. הרעיון הוא לייצר מחלקה בסיסית המכילה את כל מה שדרוש עבור מטרה זו, כך שאוכל לרשת אותה ולהשתמש בה עבור כל מבנה נתונים הררכי באופן כללי עם הדרישה הזו של Checked TreeView.

שימו לב! אני הגדרתי את ה-Default של ה-IsChecked כ-false ייתכן ותרצו לשנות את זה ל-true תלוי באמפלמנטציה שלכם.

אם לא הבנתם את הנושא דיו והוא מעניין אתכם? אנא קיראו כתבה זו כהקדמה:
https://www.codeproject.com/Articles/26288/Simplifying-the-WPF-TreeView-by-Using-the-ViewMode

להלן הקוד:

///sample usage
//public class MyCheckedItem : TreeItemBase<MyCheckedItem>
//{
//    // Custom properties if needed
//}

using System.Collections.Generic;
using System.Linq;

namespace WpfLib.ViewModels
{
    public class CheckedTreeItemBase<T> : TreeItemBase<T> where T : CheckedTreeItemBase<T>
    {
        bool? _isChecked = false;
        public bool? IsChecked { get => _isChecked; set => SetCheckedValue(value, true); }

        public void SetCheckedValue(bool? isChecked, bool updateChildren)
        {
            if (SetProperty(ref _isChecked, isChecked, nameof(IsChecked)))
            {
                if (updateChildren && Items != null)
                {
                    foreach (var child in Items)
                    {
                        if (child.IsChecked != isChecked)
                            child.IsChecked = isChecked == true;
                    }
                }

                if (Parent != null)
                {
                    var siblings = Parent.Items;
                    var parentCheckedValue = siblings.All(c => c.IsChecked == true) ? true :
                                             siblings.All(c => c.IsChecked == false) ? (bool?)false : null;
                    Parent.SetCheckedValue(parentCheckedValue, false);
                }
            }
        }

        public IEnumerable<T> EnumerateCheckedItems()
        {
            if (Items != null)
            {
                foreach (var child in Items)
                {
                    if (child.IsChecked == true)
                        yield return child;

                    foreach (var item in child.EnumerateCheckedItems())
                        yield return item;
                }
            }
        }
    }
}

המודל יורש ממודל treeitembase שמשמש כבסיס לכל מודל היררכי בעץ נתונים

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Text.Json.Serialization;

namespace WpfLib.ViewModels
{
    public class TreeItemBase<T> : ViewModelBase where T : TreeItemBase<T>
    {
        string _name;
        ObservableCollection<T> _items = new ObservableCollection<T>();

        [JsonIgnore] public T Parent { get; set; }
        public virtual string Name { get => _name; set => SetProperty(ref _name, value); }
        public ObservableCollection<T> Items { get => _items; set => SetProperty(ref _items, value); }

        public override string ToString() => Name;

        public void AddChild(T item)
        {
            if (Items == null)
                Items = new ObservableCollection<T>();
            Items.Add(item);
            item.Parent = (T)this;
        }

        public IEnumerable<T> EnumerateItems()
        {
            if (_items == null) yield break;

            foreach (var item in _items)
            {
                yield return item;
                foreach (var child in item.EnumerateItems())
                    yield return child;
            }
        }
    }

}

המודל יורש מודל אחר שימושי בשם ViewModelBase המהווה בסיס טוב עבור כל viewModle ב-Wpf

using System.Collections.Generic;
using System.ComponentModel;
using System.Runtime.CompilerServices;

namespace MyModels
{
    public class ViewModelBase : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        protected virtual void OnPropertyChanged(string propertyName)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }

        protected bool SetProperty<T>(ref T field, T value, [CallerMemberName] string propertyName = null)
        {
            if (EqualityComparer<T>.Default.Equals(field, value)) return false;
            field = value;
            OnPropertyChanged(propertyName);
            return true;
        }
    }

}

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

אם נתעלם לרגע מהנקודה ומה-"|", נוכל להשתמש בשילוב של רג'קס וקוד רקורסיבי עם מבנה נתונים פשוט (@dovid רמז לזה כבר).
אבל חשוב לציין שזה בהנחה שהטקסט לא מכיל שגיאות או אי-עקביות – אחרת זה כאב ראש * 20.
להלן דוגמא ב-C# שהזנתי ל-LinqPad, הקוד הינו סקיצה בעלמא תוכל לשפר אותו כיד ה' הטובה עליך:

void Main()
{
    string content = "{{some content{{some more content{{some more content{{some more content}}}}}}}}";
        var root = new NestedContent(content, null);
        root.Dump(); // Dump the root object to view its structure
}

class NestedContent
{
    public string Content { get; set; }
    public NestedContent Child { get; set; }

    public NestedContent(string content, NestedContent parent)
    {
        // Trim only the outermost braces (single pair at start and end)
        if (content.StartsWith("{{") && content.EndsWith("}}"))
        {
            content = content.Substring(2, content.Length - 4);
        }

        var match = Regex.Match(content, @"\{\{.*\}\}");
        if (match.Success)
        {
            string nestedContent = match.Value;
            this.Content = content.Replace(nestedContent, ""); // Replace inner braces content
            Child = new NestedContent(nestedContent, this); // Recursive call for nested content
        }
        else
        {
            this.Content = content; // Set content when no more nested structures
        }
    }
}

והתוצאה:

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

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

@yossiz כתב בDebugging על ViewModel ב-WPF:

אגב, אני לא מפתח WPF אבל יצרתי פרוייקט דמו כדי לבדוק את הנושא
הוספתי לפרוייקט שלי UserControl ובתוך הconstructor זרקתי שגיאה

אכן במקרה כזה אין לי בעיות הבעיות מתחילות כאשר אני משתמש במבנה MVVM ויש בעיה במודל או ב-ViewModel (שם עיקר הכוח של wpf בא לידי ביטוי). נכון אפשר להסתכל על פרטי השגיאה אבל זה די מתסכל לא להגיע ישר לבעיה ולתקן כמו שאני רגיל.
מה שכתבת בהחלט עזר לי להבין יותר. התיעוד בכל הנושא הזה מאוד לא ברור לי. ובפרט מה בדיוק עושה מה ש@Mordechai-0 אמר Enable Just my code. הנסיון שלי הוא ש-visual studio הוא תוכנה מורכבת וכשמתחילים לשנות את ההגדרות אם לא באמת מבינים מה עושים אזי עדיף לא לשנות.

@Mordechai-0
אתה יכול להרחיב קצת על מה האפשרות הזו עושה (ובפרט למה זה לא ה-default?)
תודה

כאשר יש בעיה ב-ViewModel אצלי במקום לעצור על נקודת הבעיה כמו שקורה כרגיל ב-C# הוא עוצר על נקודה זו (שבתמונה דלהלן) יש למישהו עצה?

@NH-LOCAL
כדי להתגבר על חוסר העקביות ברמות הכותרות, אפשר להשתמש במבנה היררכי, כמו Stack, כדי לעקוב אחר ה-parent האחרון. כך ניתן לתקן את רמת הכותרת בהתאם להקשר ולהבטיח זיהוי נכון של המספרים והכותרות.

@ivrtikshoret
תודה שעלית את השאלה הזו
אני מאד אוהב לשתף ולעזור אך תהיתי לעצמי לא פעם אם יש בזה תועלת למישהו
היה חסר לי confirmation תודה.
חוץ מזה אני מאוד נבניתי מהפורום כאן הערה פה הערה שם של אנשים טובים על הקודים שלי נתנו לי המון ידע.

כאשר עובדים עם TextBox ב-WPF, לפעמים נרצה לשפר את חוויית המשתמש על ידי ביצוע פעולות אוטומטיות, כמו בחירת כל הטקסט כאשר הרכיב מקבל פוקוס או קביעה אוטומטית של פוקוס על TextBox בעת הטעינה.

אשמח לקבל הערות והארות.

מצו"ב הקוד:

public class TextBoxFocusBehavior
{
    public static bool GetSelectAll(FrameworkElement frameworkElement)
    {
        return (bool)frameworkElement.GetValue(SelectAllProperty);
    }

    public static void SetSelectAll(FrameworkElement frameworkElement, bool value)
    {
        frameworkElement.SetValue(SelectAllProperty, value);
    }

    public static bool GetCaptureFocus(FrameworkElement frameworkElement)
    {
        return (bool)frameworkElement.GetValue(CaptureFocusProperty);
    }

    public static void SetCaptureFocus(FrameworkElement frameworkElement, bool value)
    {
        frameworkElement.SetValue(CaptureFocusProperty, value);
    }

    public static readonly DependencyProperty CaptureFocusProperty =
        DependencyProperty.RegisterAttached("CaptureFocus",
            typeof(bool), typeof(TextBoxFocusBehavior),
            new FrameworkPropertyMetadata(false, OnCaptureFocusChanged));

    public static readonly DependencyProperty SelectAllProperty =
             DependencyProperty.RegisterAttached("SelectAll",
                typeof(bool), typeof(TextBoxFocusBehavior),
                new FrameworkPropertyMetadata(false, OnSelectAllChanged));

    private static void OnSelectAllChanged
               (DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var frameworkElement = d as FrameworkElement;
        if (frameworkElement == null) return;

        if (e.NewValue is bool == false) return;

        if ((bool)e.NewValue)
        {
            frameworkElement.GotFocus += SelectAll;
            frameworkElement.PreviewMouseDown += IgnoreMouseButton;
        }
        else
        {
            frameworkElement.GotFocus -= SelectAll;
            frameworkElement.PreviewMouseDown -= IgnoreMouseButton;
        }
    }

    private static void OnCaptureFocusChanged
              (DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var frameworkElement = d as FrameworkElement;
        if (frameworkElement == null) return;

        if (e.NewValue is bool == false) return;

        if ((bool)e.NewValue)
        {
            frameworkElement.Loaded += FrameworkElement_Loaded;
        }
        else
        {
            frameworkElement.Loaded -= FrameworkElement_Loaded;
        }
    }

    private static void FrameworkElement_Loaded(object sender, RoutedEventArgs e)
    {
        var frameworkElement = e.OriginalSource as FrameworkElement;
        frameworkElement.Focus();
    }

    private static void SelectAll(object sender, RoutedEventArgs e)
    {
        var frameworkElement = e.OriginalSource as FrameworkElement;
        if (frameworkElement is TextBox)
            ((TextBoxBase)frameworkElement).SelectAll();
        else if (frameworkElement is PasswordBox)
            ((PasswordBox)frameworkElement).SelectAll();
    }

    private static void IgnoreMouseButton
            (object sender, System.Windows.Input.MouseButtonEventArgs e)
    {
        var frameworkElement = sender as FrameworkElement;
        if (frameworkElement == null || frameworkElement.IsKeyboardFocusWithin) return;
        e.Handled = true;
        frameworkElement.Focus();
    }
}

המחלקה TextBoxFocusBehavior מספקת שתי יכולות:

Select All: בחירת כל הטקסט כאשר הרכיב מקבל פוקוס.
Capture Focus: קביעה כי רכיב מסוים יקבל פוקוס אוטומטית בעת טעינת החלון.

דוגמאות שימוש:

<TextBox Text="Hello, World!" 
         local:TextBoxFocusBehavior.SelectAll="True" 
         local:TextBoxFocusBehavior.CaptureFocus="True" />

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

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

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

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

@pcinfogmach
אוקיי מצאתי לכאורה את הדרך האופטימלית (כלומר מודל שימושי כאשר יש צורך לשאול שאילתות על בסיסי נתונים המכילים מבנים מסודרים בצורה היררכית). בכתבה זו (החלק השני):
https://mikehillyer.com/articles/managing-hierarchical-data-in-mysql/
הרעיון נקרא :

The Nested Set Model

---

המודל ההיררכי של ה-Nested Set מבוסס על שימוש בטווחי מספרים לתיאור מבנה היררכי בצורה שטוחה המתאימה למסד sql. כל אלמנט במבנה מוגדר על ידי שני מספרים: ערך "שמאל" (Left) וערך "ימין" (Right), המייצגים את גבולות הטווח שלו בתוך המבנה.

לדוגמה, נניח שיש לנו את המבנה הבא:

ספר: כותרת הספר
    פרק 1
        פסוק 1
        פסוק 2
    פרק 2
        פסוק 1

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

הספר כולו: טווח 1-12
פרק 1: טווח 2-7
    פסוק 1: טווח 3-4
    פסוק 2: טווח 5-6
פרק 2: טווח 8-11
    פסוק 1: טווח 9-10

להלן הייצוג הטבלאי של המסד:

העקרונות המרכזיים במודל זה:

• טווח של כל רכיב כולל את הטווחים של כל תתי-הרכיבים שבתוכו.

• וממילא טווחים שאינם חופפים מצביעים על כך שהרכיבים אינם קשורים ישירות במבנה.

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

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

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

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