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

pcinfogmach

@ששא
לא יודע כל כך מה אתה מתכווין הכל אבל זה נתן לי תמונה איך לבנות אתר יפה.
יש לו שם כמה פרוייקטים (15) תצפה בפרוייקט הראשון ותראה אם זה מתאים לך.

pcinfogmach

@eido
התכוונת לזה?
https://dotnet.microsoft.com/en-us/apps/aspnet/mvc
מסתמא כדאי לציין קצת יותר פרטים מזה מה חשבת והיאך גילית את הטעות שלך.
ומה בעצם אתה רוצה מ-mvc או שזה שאלה של נטו ידע

pcinfogmach

@eido
לכאורה זה מפריך לפחות חלק מהטענות שלך:

https://tchumim.com/topic/17086/שיתוף-להערות-mapraqti-תוכנה-ליצירת-מפת-מקומות-בבית-כנסת

https://tchumim.com/topic/17164/mapraqti-תובנות-על-vibe-coding-בבקשה/32

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

pcinfogmach

@אף-אחד-3
אני מבין שאתה מחפש משהו בתשלום אבל יש לתוכנת אוצריא צורך במשהו ממין זה (ללא תשלום - אבל זיכוי הרבים גדול) אם תרצה תיצור איתי קשר במייל.

pcinfogmach

@אף-אחד-3 כתב בעזרה בתכנון ארכיטקטורת אתר:

אנשים שלקחו את הסקריפט שלי עושים עליו כסף

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

pcinfogmach

אולי זה יכול לעניין אתכם
https://mitmachim.top/post/997358

pcinfogmach

@NH.LOCAL כתב בMaPraqti: תובנות על vibe coding בבקשה :

ביחס להכנסת כל הקוד לתוך חלון ההקשר של AI Studio.

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

pcinfogmach

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

pcinfogmach

אם יצא לכם לעבוד עם 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> { ""};
        }
    }

}

pcinfogmach

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

pcinfogmach

@קומפיונט כתב במדריך: איך לייצר לוקליזציה ב-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}"

pcinfogmach

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

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

pcinfogmach

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

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

זה עובד נפלא!

pcinfogmach

תמיד תופס הרבה מקום וזמן להגדיר שורות ועמודות בתוך פקד 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);
        }
    }
}

pcinfogmach

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

pcinfogmach

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

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

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

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

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

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

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

pcinfogmach

פוסטים