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

@סמינר-דוד
הרץ תיקון שגיאות
היכנס ללוח הבקרה > התקנים
מצא את המדפסת ולחץ לחיצה ימנית והרץ תיקון שגיאות

@קומפיונט כתב בעיצוב ממשק שכתוב ב C#:

אם אתה ב - dotnet 9, יש theme מובנה יותר יפה

בשורה של ממש! ייש"כ!

@nigun כתב באבטחת חשבונות:

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

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

@nigun כתב באבטחת חשבונות:

תנסה לכתוב משהו בעברית על המקלדת באנגלית ואולי תכתוב vcbeakh123!

מעניין אם זה יעיל ההצעה הזו.

@nigun כתב באבטחת חשבונות:

זהו שאם תשתמש רק במילים ומספרים לסיסמאות שלך

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

אבל התיאוריה שלי עדיין בעינה עומדת לייצר סימן זו מסימה קלה למי שרגיל בכך. ודם מי שלא רגיל לזה עושה את זה בתת מודע - למשל: כל מי שזוכר מספר טלפון יוצר לעצמו קצב בדקלום של המספר שעוזר לו לשלוף אותו בקלות למרות שהמספר לכאורה רנדומלי. הסימנים שקל לנו לזכור משתנם מאדם לאדם - ישנם שסימן חזותי יותר מועיל להם, וישנם שסימן תחושתי, וישנם סימן דמיוני וכן הלאה. איך מחליטים מהו סימן טוב או לא? פשוט אם זה סימן שאיננו משתמש בתבנית ידועה.
רוב האנשים משתמשים במה שהזכרתי במספרי הטלפון - בקצב: כך שהסיסמה: tbd - *! - 52 - jsd מהווה דוגמא טובה לעיקרון זה (המקפים והרווחים לא חלק מהסיסמה) - לישראלים קצת יותר קשה עם האותיות אנגלית אז אפשר לעשות מה שאתה הצעת להקליד בעברית במקלדת מצב אנגלית וככה לזכור בקלות למשל: hkn - ! - pmo - !7. (ילמ - ! - פצם - 7!) פה יש גם חרוזים שעוזרים עוד יותר לזיכרון.

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

במאמר המוסגר: מסקרן אותי מאוד אם האקרים משתמשים היום ב-ai לניחוש סיסמאות.

@dovid כתב באבטחת חשבונות:

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

מסכים עם כל מילה אציתי להוסיף כמה מילים משלי

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

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

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

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

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

 public static void ReportProgress(string actionDescription, int Currentvalue, int maxValue, int timePerIteration)
 {
     var progressPercent = (int)((double)(100 * Currentvalue) / maxValue);
     string timeLeft = TimeSpan.FromSeconds((maxValue - Currentvalue) * timePerIteration).ToString(@"hh\:mm\:ss");
     string[] progressBars = new string[] { "●○○○○○○○○○", "●●○○○○○○○○", "●●●○○○○○○○", "●●●●○○○○○○", "●●●●●○○○○○", "●●●●●●○○○○", "●●●●●●●○○○", "●●●●●●●●○○", "●●●●●●●●●○", "●●●●●●●●●●", };
     Globals.ThisAddIn.Application.StatusBar = $"- {timeLeft} -     {progressPercent}%  {progressBars[Math.Max((progressPercent / 10) - 1, 0)]}     {actionDescription} {Currentvalue} \\ {maxValue}";
 }

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

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

@dovid
מסתמא אתה צודק מצאתי משהו כאן אבל העצה שלהם לא תמיד פותרת את הבעיה:
https://wordmvp.com/FAQs/MacrosVBA/GetPosRelToPage.htm

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

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

אם מריצים את הקוד הזה ב-vba בוורד

Sub VerticalPos()
    Debug.Print ("position: " & Selection.Information(wdVerticalPositionRelativeToPage) & " | Zoom: " & ActiveWindow.View.Zoom.Percentage)
End Sub

התוצאה משתנית לפי המצב של הזום - בכל אופן אצלי.

position: 753 | Zoom: 50
position: 754 | Zoom: 100
position: 753.75 | Zoom: 200
position: 753.75 | Zoom: 385
position: 753.8 | Zoom: 500

יש למישהו רעיון איך להתגבר על זה?
או בכל אופן איך אני מגדיר מהו הposition האמיתי?

מישהו יודע איך לזהות אם פונט תומך עברית דרך C#?

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

ארחות צדיקים - שער הגאוה.docx

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

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

סתם ככה היה לי הרגשה של "כמעט" כשהתעסקתי עם avalonia לא באתי ללכלך אבל מסקרן אותי כמה ההרגשה הזו אישית והאם יש בה ממש.

אם כבר אנחנו מדברים על spinoff של wpf מה אתה אומר על uno? לא ניסיתי את זה מעניין לשמוע ממישהו שכן ניסה אם יש?

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

הרעיון שלי איך ליישם theming ב- wpf בצורה קלה

---

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

בבסיס האתגר הזה יש שני נושאים עיקריים:
א. חלון WPF אינו מאפשר שינוי צבע ה-Title Bar.
ב. יצירת Binding שיכול לשמש את כל התוכנה בצורה גלובלית.

את עיצוב החלון כבר יצרתי בעבר, וכעת הפכתי אותו ל-Style. לדעתי, זו גישה הרבה יותר נוחה מאשר ליצור פקד חלון עם Theming, כיוון שהתעסקות עם ירושת פקד חלון ב-WPF היא קצת מורכבת. ישנם מדריכים רבים (עם הרבה באגים) בנושא, תכלס, חסכתי לכם הרבה עבודה אם זה מה שאתם מחפשים ה-style המצורף נקי ועובד חלק.

כמה פרטים חשובים:
ה-Style משתמש במחלקה סטטית שמארחת פקודות לסגירת חלון וכו', וגם מארחת ViewModel גלובלי. זהו פתרון קל ונוח לשימוש לצורך שינוי Theme.
מכיוון שהצורך שלי היה ב-Dark Mode, יצרתי קוד שמזהה באופן אוטומטי אם המערכת מוגדרת ל-Dark Theme.
בנוסף, הוספתי כפתור שמאפשר מעבר בין Dark Mode ל-Light Mode.
עיצוב ה-Theme

יצרתי מחלקה עם שני מאפיינים בסיסיים: Background ו-Foreground. לצרכים שלי זה היה מספיק, אבל אם אתם מחפשים משהו מורחב יותר, פשוט הוסיפו רכיבים למחלקה כיד ה' עליכם.
Theme חדש ניתן להוסיף ל-Dictionary שנמצא ב-ViewModel, והיישום שלו אינטואיטיבי וקל.
בנוסף, תוכלו לעשות Binding על ה-Dictionary ל-ListBox או ComboBox, ולאפשר למשתמש לבחור Theme בקלות.
מכיוון שהמחלקה המארחת היא סטטית, תהיה לכם גישה נוחה ופשוטה ל-Themes מכל מקום בקוד.

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

<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                    xmlns:mscorlib="clr-namespace:System;assembly=mscorlib"
                    xmlns:window="clr-namespace:MyWpf.Themes.Window;assembly=MyWpf"
                    xmlns:Converters="clr-namespace:MyWpf.Converters">

    <SolidColorBrush x:Key="HoverBackGroundBrush" Color="#ff646464" Opacity="0.2"/>
    <SolidColorBrush x:Key="SelectedBackGroundBrush" Color="#ff646464" Opacity="0.3"/>
    <SolidColorBrush x:Key="WindowBorderBrush" Color="#ff646464"/>
    <SolidColorBrush x:Key="TitlebarBrush" Color="#ff646464" Opacity="0.1"/>
    <mscorlib:Double x:Key="CaptionHieght">36</mscorlib:Double>

    <Style x:Key="TitleBarButton" TargetType="Button">
        <Setter Property="Width" Value="{Binding ActualHeight, RelativeSource={RelativeSource Mode=Self}}"/>
        <Setter Property="WindowChrome.IsHitTestVisibleInChrome" Value="True"/>
        <Setter Property="Background" Value="Transparent"/>
        <Setter Property="Template">
            <Setter.Value>
                <ControlTemplate TargetType="{x:Type Button}">
                    <Border x:Name="border" Background="{TemplateBinding Background}"
                        Padding="10">
                        <ContentPresenter x:Name="contentPresenter"/>
                    </Border>
                    <ControlTemplate.Triggers>
                        <Trigger Property="IsMouseOver" Value="true">
                            <Setter Property="Background" Value="{StaticResource HoverBackGroundBrush}"/>
                        </Trigger>
                        <Trigger Property="AreAnyTouchesOver" Value="true">
                            <Setter Property="Background" Value="{StaticResource HoverBackGroundBrush}" />
                        </Trigger>
                        <Trigger Property="IsPressed" Value="true">
                            <Setter Property="Background" Value="{StaticResource SelectedBackGroundBrush}" />
                        </Trigger>
                    </ControlTemplate.Triggers>
                </ControlTemplate>
            </Setter.Value>
        </Setter>
    </Style>

    <Style x:Key="TitleBarPathIcon" TargetType="Path">
        <Setter Property="Stroke" Value="{Binding Foreground, RelativeSource={RelativeSource AncestorType=Window}}"/>
        <Setter Property="StrokeThickness" Value="1"/>
        <Setter Property="Stretch" Value="Uniform"/>
    </Style>

    <Style x:Key="DarkModeIconPath" TargetType="Path">
        <Setter Property="Fill" Value="{Binding Foreground, RelativeSource={RelativeSource AncestorType=Window}}"/>
        <Setter Property="Stretch" Value="Uniform"/>
    </Style>

    <Style x:Key="MaximizeRestorePath" TargetType="Path" BasedOn="{StaticResource TitleBarPathIcon}">
        <Style.Triggers>
            <!-- Trigger when Window is Maximized -->
            <DataTrigger Binding="{Binding WindowState, RelativeSource={RelativeSource AncestorType=Window}}" Value="Maximized">
                <Setter Property="Data" Value="M 13.5,12.5 H 20.5 V 19.5 H 13.5 Z M 15.5,12.5 V 10.5 H 22.5 V 17.5 H 20.5"/>
            </DataTrigger>

            <!-- Trigger when Window is Normal (Not Maximized) -->
            <DataTrigger Binding="{Binding WindowState, RelativeSource={RelativeSource AncestorType=Window}}"   Value="Normal">
                <Setter Property="Data" Value="M 13.5,10.5 H 22.5 V 19.5 H 13.5 Z"/>
            </DataTrigger>
        </Style.Triggers>
    </Style>

    <Style TargetType="Window" x:Key="ThemedWindow">
        <Setter Property="WindowChrome.WindowChrome">
            <Setter.Value>
                <WindowChrome
                CornerRadius="{x:Static SystemParameters.WindowCornerRadius}"
                UseAeroCaptionButtons="False"
                CaptionHeight="{StaticResource CaptionHieght}"/>
            </Setter.Value>
        </Setter>

        <!--<Setter Property="FlowDirection" Value="{Binding Path=(window:ThemeHelper.FlowDirection)}" />-->
        <Setter Property="Background" Value="{Binding Source={x:Static window:ThemeHelper.ThemeModel}, Path=CurrentTheme.Background}"/>
        <Setter Property="Foreground" Value="{Binding Source={x:Static window:ThemeHelper.ThemeModel}, Path=CurrentTheme.Foreground}"/>

        <Setter Property="Template">
            <Setter.Value>
                <ControlTemplate TargetType="Window">
                    <Border  BorderBrush="{StaticResource WindowBorderBrush}" 
                             BorderThickness="0.8"
                             Background="{TemplateBinding Background}">
                        <Grid x:Name="RootGrid">
                            <Grid.RowDefinitions>
                                <RowDefinition x:Name="TitleBarRow" Height="auto"/>
                                <RowDefinition x:Name="ContentRow" Height="*"/>
                            </Grid.RowDefinitions>

                            <Grid x:Name="TitleBarGrid"
                                  Height="{StaticResource CaptionHieght}"
                                  Background="{StaticResource TitlebarBrush}">
                                <Grid.ColumnDefinitions>
                                    <ColumnDefinition Width="auto" x:Name="CaptionColumn"/>
                                    <ColumnDefinition Width="*" x:Name="PlaceHolderColumn"/>
                                    <ColumnDefinition Width="auto" x:Name="TitleBarButtonsColumn"/>
                                </Grid.ColumnDefinitions>

                                <TextBlock x:Name="WindowTitle" Padding="10" VerticalAlignment="Center" IsHitTestVisible="False"
                                           Text="{TemplateBinding Title}"/>

                                <StackPanel x:Name="TitleBarButtonsPanel" Orientation="Horizontal" Grid.Column="2" Margin="1">
                                    <Button Style="{StaticResource TitleBarButton}"
                                            Command="{Binding Source={x:Static window:ThemeHelper.ThemeModel}, Path=ToggleThemeCommand}"
                                            CommandParameter="{Binding RelativeSource={RelativeSource AncestorType=Window}}">
                                        <Path Style="{StaticResource DarkModeIconPath}"
                                              Data="M7.5,2C5.71,3.15 4.5,5.18 4.5,7.5C4.5,9.82 5.71,11.85 7.53,13C4.46,13 2,10.54 2,7.5A5.5,5.5 0 0,1 7.5,2M19.07,3.5L20.5,4.93L4.93,20.5L3.5,19.07L19.07,3.5M12.89,5.93L11.41,5L9.97,6L10.39,4.3L9,3.24L10.75,3.12L11.33,1.47L12,3.1L13.73,3.13L12.38,4.26L12.89,5.93M9.59,9.54L8.43,8.81L7.31,9.59L7.65,8.27L6.56,7.44L7.92,7.35L8.37,6.06L8.88,7.33L10.24,7.36L9.19,8.23L9.59,9.54M19,13.5A5.5,5.5 0 0,1 13.5,19C12.28,19 11.15,18.6 10.24,17.93L17.93,10.24C18.6,11.15 19,12.28 19,13.5M14.6,20.08L17.37,18.93L17.13,22.28L14.6,20.08M18.93,17.38L20.08,14.61L22.28,17.15L18.93,17.38M20.08,12.42L18.94,9.64L22.28,9.88L20.08,12.42M9.63,18.93L12.4,20.08L9.87,22.27L9.63,18.93Z"/>
                                    </Button>

                                    <Button Style="{StaticResource TitleBarButton}"
                                         Command="{Binding Source={x:Static window:ThemeHelper.MinimizeCommand}}"
                                         CommandParameter="{Binding RelativeSource={RelativeSource AncestorType=Window}}">
                                        <Path Style="{StaticResource TitleBarPathIcon}" Data="M 13,15 H 23"/>
                                    </Button>

                                    <Button Style="{StaticResource TitleBarButton}"
                                         Command="{Binding Source={x:Static window:ThemeHelper.MaximizeRestoreCommand}}"
                                         CommandParameter="{Binding RelativeSource={RelativeSource AncestorType=Window}}">
                                        <Path Style="{StaticResource MaximizeRestorePath}"/>
                                    </Button>

                                    <Button Style="{StaticResource TitleBarButton}"
                                          Command="{Binding Source={x:Static window:ThemeHelper.CloseWindowCommand}}"
                                          CommandParameter="{Binding RelativeSource={RelativeSource AncestorType=Window}}">
                                        <Path Style="{StaticResource TitleBarPathIcon}" Data="M 13,11 22,20 M 13,20 22,11"/>
                                    </Button>

                                </StackPanel>
                            </Grid>

                            <ContentPresenter x:Name="PART_MainContentPresenter"  Grid.Row="1"/>
                        </Grid>
                    </Border>

                    <ControlTemplate.Triggers>
                        <Trigger Property="WindowState" Value="Maximized">
                            <Setter TargetName="RootGrid" Property="Margin" Value="7.5"/>
                        </Trigger>
                    </ControlTemplate.Triggers>
                </ControlTemplate>
            </Setter.Value>
        </Setter>
    </Style>
</ResourceDictionary>

using MyWpf.Models;
using System.Diagnostics;
using System.Windows;
using System.Windows.Input;
using System.Windows.Media;

namespace MyWpf.Themes.Window
{
    public static class ThemeHelper
    {
        private static ThemeModel _themeModel;
        public static ThemeModel ThemeModel
        {  
            get { if (_themeModel == null)
                    _themeModel = new ThemeModel();
                return _themeModel; } 
        }

        //public static double CaptionHeight { get => SystemParameters.WindowCaptionHeight + 10;} 
        //public static FlowDirection FlowDirection { get => CultureInfo.CurrentUICulture.TwoLetterISOLanguageName == "he" ? FlowDirection.RightToLeft : FlowDirection.LeftToRight; } 

        public static ICommand CloseWindowCommand = new RelayCommand<System.Windows.Window>((window) => window.Close(), (window) => window != null);
        public static ICommand MaximizeRestoreCommand = new RelayCommand<System.Windows.Window>((window) => window.WindowState = window.WindowState == WindowState.Maximized ? WindowState.Normal : WindowState.Maximized, (window) => window != null);
        public static ICommand MinimizeCommand = new RelayCommand<System.Windows.Window>((window) => window.WindowState = WindowState.Minimized, (window) => window != null);
    }

    public class ThemeModel : ViewModelBase
    {
        private bool _isDarkTheme;
        private ThemeObject _currentTheme;

        public Dictionary<string, ThemeObject> ThemeCollection = new Dictionary<string, ThemeObject>
        {
            { "DarkTheme", new ThemeObject{ Background = new SolidColorBrush(Color.FromRgb(34, 34, 34)),
                                            Foreground = new SolidColorBrush(Color.FromRgb(200, 200, 200))} },
            { "LightTheme", new ThemeObject{ Background = new SolidColorBrush(Colors.White),
                             Foreground = new SolidColorBrush(Colors.Black)} },
        };

        public ThemeObject CurrentTheme { get => _currentTheme; set => SetProperty(ref _currentTheme, value); }

        public ICommand ToggleThemeCommand => new RelayCommand<System.Windows.Window>(ToggleTheme, (window) => window != null);

        public ThemeModel() 
        {
            _isDarkTheme = GetSystemTheme;
            _currentTheme = _isDarkTheme ? ThemeCollection["DarkTheme"] : ThemeCollection["LightTheme"];
        }

        public void ToggleTheme(System.Windows.Window window)
        {
            CurrentTheme = _isDarkTheme ? ThemeCollection["LightTheme"] : ThemeCollection["DarkTheme"];
            _isDarkTheme = !_isDarkTheme;
        }

        static bool GetSystemTheme
        {
            get
            {
                string registryKeyPath = @"Software\Microsoft\Windows\CurrentVersion\Themes\Personalize";
                string registryValueName = "AppsUseLightTheme";

                try
                {
                    using (var key = Microsoft.Win32.Registry.CurrentUser.OpenSubKey(registryKeyPath))
                        if (key?.GetValue(registryValueName) is int value)
                            return value == 0; // 0 means Dark Theme is enabled, 1 means Light Theme
                }
                catch (Exception ex)
                {
                    Debug.WriteLine(ex.ToString());
                }
                return false;
            }
        }

        public class ThemeObject
        {
            public SolidColorBrush Background { get; set; }
            public SolidColorBrush Foreground { get; set; }
        }

    }
}

הקוד משתמש בשני מחלקות שימושיות המהוות בסיס טוב עבור כל viewmodel

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

namespace MyWpf.Models
{
    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;
        }
    }

}

using System;
using System.Windows.Input;

namespace MyWpf.Models
{
    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;
        }
    }
}

@dovid
נגיד אני רוצה מבנה נתונים של תיקייות ומסמכים ב-treeview ואני בונה לזה מודל ו style יפה שאמור לשמש אותי בכמה תוכנות
לצרף גם קוד דוגמא?

לאחרונה חקרתי רבות את איך לשפר את השימושיות (Reusability) והניידות (Portability) בקודים שלי. מחקר זה הוביל אותי להעדיף שימוש מוגבר ב-ResourceDictionary במקום עיצובים ישירים בתוך הפקדים עצמם מה שהופך את הקוד שלי ליותר מודולרי וניתן לשימוש חוזר.
כתוצאה מכך, אני מעדיף גם שה-Binding עבור פקדים מסוימים יוגדר מראש בתוך ה-ResourceDictionary.

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

שוין כנראה זה לא הכיוון תכלס אפשר לבנות פקדים ב-wpf ואז ה-binding שלהם זמין אבל יש לזה מחיר מסויים. מצד maintanenace זה לא כמו השגר ושלח של style שמחובר ל-viemodel.

מישהו יודע איך ליישם dataconext עבור style בתוך resource dictionary
הדרך הרגילה לא עובד לי

<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                    xmlns:mscorlib="clr-namespace:System;assembly=mscorlib"
                    xmlns:window="clr-namespace:MyWpf.Themes.Window;assembly=MyWpf"
                    xmlns:Converters="clr-namespace:MyWpf.Converters">

    <Style TargetType="Window" x:Key="ThemedWindow">
        <Setter Property="DataContext">
            <Setter.Value>
                <window:WindowThemingHelper
         </Setter.Value>
        </Setter>

@קומפיונט
תודה
אני מודע לזה שאפשר לזהות את הבעיה ככה
זה מתסכל אותי אבל שאני לא יכול לדבג בצורה ישירה כמו בקוד רגיל של 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();
    }
}