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

אם יצא לכם לעבוד עם TreeView ב-WPF ולהציג בו הרבה נתונים, אולי נתקלתם בהאטה בביצועים — במיוחד כשיש הרבה Nodes טעונים מראש.

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

לכן, יצרתי פתרון פשוט שמדמה את ההתנהגות הזו על ידי טעינה עצלנית (Lazy Loading) של התוכן. זה לא רעיון חדש, אבל שווה להזכיר למי שלא מכיר או שכח שיש דרך לשפר את הביצועים בצורה ניכרת.

איך זה עובד בפועל:
כשפריט נטען לראשונה (Loaded), מוצג רק placeholder כדי להימנע מטעינה מיותרת.
רק בעת פתיחה (Expanded), נטענים בפועל הנתונים מה-ViewModel.
בעת סגירה (Collapsed), הנתונים מתחלפים שוב ב-placeholder — שחרור פשוט של משאבים.

שימו לב! במקרה זה אל תשתמשו ב-itemsource עבור HierarchicalDataTemplate ב- Xaml

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

using System.Windows.Controls;
using System.Windows;
using Otzarnik.FsViewer;
using System.Collections.Generic;

namespace Oztarnik.Helpers
{
    public static class TreeItemVirtualizationBehavior
    {
        public static bool GetEnableVirtualization(DependencyObject obj) =>
            (bool)obj.GetValue(EnableVirtualizationProperty);

        public static void SetEnableVirtualization(DependencyObject obj, bool value) =>
            obj.SetValue(EnableVirtualizationProperty, value);

        public static readonly DependencyProperty EnableVirtualizationProperty =
            DependencyProperty.RegisterAttached("EnableVirtualization", typeof(bool), typeof(TreeItemVirtualizationBehavior),
                new PropertyMetadata(false, OnEnableVirtualizationChanged));

        private static void OnEnableVirtualizationChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (d is TreeViewItem item && e.NewValue is bool enabled)
            {
                if (enabled)
                {
                    item.Expanded += OnItemExpanded;
                    item.Collapsed += OnItemCollapsed;
                    item.Loaded += Item_Loaded;
                }
                else
                {
                    item.Expanded -= OnItemExpanded;
                    item.Collapsed -= OnItemCollapsed;
item.Loaded -= Item_Loaded;
                }
            }
        }

        private static void Item_Loaded(object sender, RoutedEventArgs e)
        {
            if (sender is TreeViewItem treeViewItem &&
                treeViewItem.DataContext is TreeItem treeItem &&
                treeItem.Items?.Count > 0)
                    treeViewItem.ItemsSource = new List<string> { "" };
        }

        private static void OnItemExpanded(object sender, RoutedEventArgs e)
        {
            if (sender is TreeViewItem treeViewItem &&
                 treeViewItem.DataContext is TreeItem treeItem &&
                 treeItem.Items?.Count > 0)
                    treeViewItem.ItemsSource = treeItem.Items;
        }

        private static void OnItemCollapsed(object sender, RoutedEventArgs e)
        {
            if (sender is TreeViewItem treeViewItem &&
                 treeViewItem.DataContext is TreeItem treeItem && 
                 treeItem.Items?.Count > 0)
                    treeViewItem.ItemsSource = new List<string> { ""};
        }
    }

}

@קומפיונט
הבנתי אז זהו הדרך האופטימלית להשתמש עם zlobs תודה - אנסה ליישם זאת.

@קומפיונט כתב במדריך: איך לייצר לוקליזציה ב-wpf בצורה פשוטה וקלילה:

תנסה ליישם משהו שמאפשר לשנות את השפה בצורה דינאמית, מבלי להפעיל מחדש

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

אשמח לקבל משוב

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text.Json;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;

namespace Localization
{
    public static class LocalizationExtension
    {
        private static string _locale = "en";
        private static readonly string _localeFolder = "Locale";
        private static ConcurrentDictionary<string, string> translations;
        private static readonly List<WeakReference<DependencyObject>> RegisteredElements = new List<WeakReference<DependencyObject>>();

        public static string Locale
        {
            get => _locale;
            set
            {
                if (value != _locale) 
                {
                    _locale = value; 
                    UpdateAllRegisteredElements();
                }               
            }
        }

        public static readonly DependencyProperty KeyProperty =
           DependencyProperty.RegisterAttached(
               "Key",
               typeof(string),
               typeof(LocalizationExtension),
               new PropertyMetadata(null, OnKeyChanged));

        public static void SetKey(DependencyObject element, string value) =>
            element.SetValue(KeyProperty, value);

        public static string GetKey(DependencyObject element) =>
            (string)element.GetValue(KeyProperty);

        private static void OnKeyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (d == null) return;
            SetText(d, (string)e.NewValue);

            CleanupRegisteredElements();
            RegisteredElements.Add(new WeakReference<DependencyObject>(d));
            
        }

        public static RelayCommand<string> ChangeLocaleCommand = new RelayCommand<string>((value) => { Locale = value; } );
        public static RelayCommand NextLocaleCommand = new RelayCommand(() => { NextLocale(); });
        public static void NextLocale()
        {
            string localeFolder = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), _localeFolder);
            if (Directory.Exists(localeFolder))
            {
                var locales = Directory.GetFiles(localeFolder, "*.json")
                                        .Select(Path.GetFileNameWithoutExtension)
                                        .ToList();

                if (locales.Count == 0)
                    return;

                int currentIndex = locales.IndexOf(Locale);

                if (currentIndex == -1 || currentIndex == locales.Count - 1)
                    Locale = locales[0];
                else
                    Locale = locales[currentIndex + 1];
            }
        }



        private static void UpdateAllRegisteredElements()
        {
            LoadTranslations();
            CleanupRegisteredElements();

            foreach (var weakReference in RegisteredElements)
            {
                if (weakReference.TryGetTarget(out var target))
                {
                    var key = GetKey(target);
                    SetText(target, key);
                }
            }
        }

        private static void CleanupRegisteredElements() =>
            RegisteredElements.RemoveAll(wr => !wr.TryGetTarget(out _));

        public static void LoadTranslations()
        {
            string filePath = GetLocaleFilePath();

            try
            {
                string json = File.ReadAllText(filePath);
                translations = JsonSerializer.Deserialize<ConcurrentDictionary<string, string>>(json) ?? new ConcurrentDictionary<string, string>();
            }
            catch
            {
                translations = new ConcurrentDictionary<string, string>();
            }

        }

        static string GetLocaleFilePath()
        {
            string localeFolder = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), _localeFolder);
            string filePath = Path.Combine(localeFolder, _locale + ".json");

            if (!File.Exists(filePath))
            {
                if (Directory.Exists(localeFolder))
                {
                    string[] files = Directory.GetFiles(localeFolder, "*.json");
                    if (files.Length > 0)
                        filePath = filePath = files[0];
                    else
                        filePath = null;
                }
                else
                    filePath = null;
            }

            return filePath;
        }

        public static void SetText(DependencyObject d, string key)
        {
            if (d == null || string.IsNullOrEmpty(key))
                return;

            if (translations == null)
                LoadTranslations();

            if (translations.TryGetValue(key, out var translation))
            {
                switch (d)
                {
                    case ContentControl contentControl:
                        contentControl.Content = translation;
                        break;
                    default:
                        var textProperty = d.GetType().GetProperty("Text");
                        textProperty?.SetValue(d, translation);
                        break;
                }
            }
        }
    }

הקוד משתמש ב-class שנקרא RelayCommand

    public class RelayCommand : ICommand
    {
        private readonly Action _execute;
        private readonly Func<bool> _canExecute;

        public RelayCommand(Action execute, Func<bool> canExecute = null)
        {
            _execute = execute ?? throw new ArgumentNullException(nameof(execute));
            _canExecute = canExecute;
        }

        public bool CanExecute(object parameter) => _canExecute?.Invoke() ?? true;
        public void Execute(object parameter) => _execute();

        public event EventHandler CanExecuteChanged
        {
            add => CommandManager.RequerySuggested += value;
            remove => CommandManager.RequerySuggested -= value;
        }
    }

    public class RelayCommand<T> : ICommand
    {
        private readonly Action<T> _execute;
        private readonly Func<T, bool> _canExecute;

        public RelayCommand(Action<T> execute, Func<T, bool> canExecute = null)
        {
            _execute = execute ?? throw new ArgumentNullException(nameof(execute));
            _canExecute = canExecute;
        }

        public bool CanExecute(object parameter) => _canExecute?.Invoke((T)parameter) ?? true;

        public void Execute(object parameter) => _execute((T)parameter);

        public event EventHandler CanExecuteChanged
        {
            add => CommandManager.RequerySuggested += value;
            remove => CommandManager.RequerySuggested -= value;
        }
    }
}

דוגמת שימוש:

<Button Width="200" Height="50"
        locale:LocalizationExtension.Key="LoginButton"
        Command="{x:Static locale:LocalizationExtension.NextLocaleCommand}"  

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

https://github.com/pcinfogmach/RegexInWordPublish/releases

@קומפיונט
לא הבנתי את השאלה התוספת של ה-gridcolumns היא בין הלחצנים

wpf:GridSetup.Columns="auto,*,auto,*,auto,*,auto,*,auto,*,auto,*,auto,*,auto"

זה עובד נפלא!

תמיד תופס הרבה מקום וזמן להגדיר שורות ועמודות בתוך פקד Grid ב-wpf
ראיתי מה הם עשו ב-Avalonia ותפסתי רעיון לעשות לעצמי Class שיעשה אותו הדבר.

ברגיל צריך לעשות כך:

<Grid>
    <Grid.ColumnDefinitions>
        <ColumnDefinition Width="Auto"/>
        <ColumnDefinition Width="*"/>
        <ColumnDefinition Width="2*"/>
    </Grid.ColumnDefinitions>
    <Grid.RowDefinitions>
        <RowDefinition Height="Auto"/>
        <RowDefinition Height="*"/>
        <RowDefinition Height="Auto"/>
    </Grid.RowDefinitions>
<\Grid>

עם ה-class שיצרתי אפשר לעשות כך:

 <Grid local:GridSetup.Columns="Auto,*,2*" local:GridSetup.Rows="Auto,*,Auto">

מצו"ב סקיצה אשמח לקבל משוב

namespace RegexInWord.UI.Wpf
{
    using System;
    using System.Windows.Controls;
    using System.Windows;
    public class GridSetup
    {
        private static GridLengthConverter _gridLengthConverter = new GridLengthConverter();

        public static readonly DependencyProperty ColumnsProperty =
           DependencyProperty.RegisterAttached(
               "Columns",
               typeof(string),
               typeof(GridSetup),
               new PropertyMetadata(null, OnColumnsChanged));

        public static void SetColumns(DependencyObject element, string value) =>
            element.SetValue(ColumnsProperty, value);

        public static string GetColumns(DependencyObject element) =>
            (string)element.GetValue(ColumnsProperty);

        private static void OnColumnsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (d is Grid grid && e.NewValue is string definition)
            {
                grid.ColumnDefinitions.Clear();
                foreach (var item in definition.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
                {
                    grid.ColumnDefinitions.Add(new ColumnDefinition { Width = ParseGridLength(item.Trim()) });
                }
            }
        }

        public static readonly DependencyProperty RowsProperty =
            DependencyProperty.RegisterAttached(
                "Rows",
                typeof(string),
                typeof(GridSetup),
                new PropertyMetadata(null, OnRowsChanged));

        public static void SetRows(DependencyObject element, string value) =>
            element.SetValue(RowsProperty, value);

        public static string GetRows(DependencyObject element) =>
            (string)element.GetValue(RowsProperty);

        private static void OnRowsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (d is Grid grid && e.NewValue is string definition)
            {
                grid.RowDefinitions.Clear();
                foreach (var item in definition.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
                {
                    grid.RowDefinitions.Add(new RowDefinition { Height = ParseGridLength(item.Trim()) });
                }
            }
        }

        private static GridLength ParseGridLength(string value)
        {
            return (GridLength)_gridLengthConverter.ConvertFromString(value);
        }
    }
}

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

@dovid כתב במראה יותר אחיד ויפה לפקד ב-wpf:

אתה צריך להשתמש בtheme שמוצא חן בעיניך באינטרנט.

הוי אומר הבעיה הוא לא מחמת ה-layout לדעתך?

כמו"כ רציתי לשאול מכיוון שבהרבה מהתוספים שלי יש לי פקדים שאני יוצר באופן מותאם אישית, שלא כלולים בכל ה-themes הללו אז בעצם זה לא יעזור לי כל כך? לא?

כמו"כ ניתקלתי בבעיות בהרבה מה-thems או שהם לא מעודכנים (אנשים מתחילים עם wpf וזנחים אותו בהמשך זה מה שהם כותבים ב-repo שלהם מעניין)

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

@אוריי
נראה ברפרוף שסה"כ מדובר ב-html
אם אני צודק אזי ברור שאפשר

openTag = "<font style=""background-color:#FFFF00; font-size:80%"">"

@one1010 כתב בקודים של אתר שנבנה ללקוח, האם הוא ציבורי?:

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

גם זה בחוגים מסויימים מאוד מקובל. בשאר העולם ממש לא!

מה הבעיה בלעודד יוצר לקבל מה שמגיע לו?

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

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

@dovid
תודה הוספתי תיקון לראשי תיבות על ידי הגדרת טווח

\bword\b\W+(?:[\w""]+\W+){0,5}\bword\b

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

@dovid
ככה טוב?

\bword\b\W+(?:\w+\W+){0,5}\bword\b

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

מקווה שהובנתי:

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

אולי כדאי להציג את הרשימה בתוך חלונית דיאולוג וחסל?
או שזה יפריע לנוחות של המשתמש?

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

@dovid

הוא מוגבל כמות פעמים בכל תוסף כמה פעמים אפשר להשתמש בו כל פעם שפותחים את וורד מחדש.
כך שאם הבן אדם הריץ 15 פקודות (אינני זוכר את המספר המדוייק) מהתוסף שלי שיש בהם את הפקודה של undorecord הוא ייתקל בשגיאה אם ירצה להריץ עוד פעם אחד מן הפקודות הללו.
הוי אומר מספר ההקלטות מוגבל (אבל מספר הפעולות במסמך עבור כל הקלטה איננו מוגבל). ואם מגיעים לתיקרה של מספר ההקלטות נתקלים בשגיאה. כך שצריך להשתמש בהקלטות של undorecord בהשכלה וגם ליצצר לוגיקה למקרה שהגיע לתקרת ההקלטות .