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

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

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

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

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

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

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

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

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

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

8. מעברי חצייה והולכי רגל:
   הבעיה עם הולכי רגל היא שאין לך שום אינדיקציה מי הוא הבא בתור שיחליט לקפוץ לכביש. אנשים מפטפטים ופתאום מחליטים לעבור. הכלל הוא שכל עוד יש סיכוי שהוא יגיע למעבר חציה לפניך, הוא חשוד בעיניך כקופץ הבא. אם אתה לא בטוח – תאט לקראת המעבר ותגשש. כדאי מאוד לקלוט הולכי רגל מרחוק. אם אתה רחוק 10 מטר מהמעבר והולך הרגל במרחק 2 מטר – מי עלול להגיע ראשון למעבר? קח בחשבון שהוא עלול להחליט לרוץ פתאום. בקיצור, מבחינתך הולכי רגל הם בלתי צפויים לחלוטין.

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

10. חניות:
    חשוב ללמוד את הכללים והטריקים ולהיצמד אליהם – ככה ורק ככה תצליח.

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

מדריך: איך להציג עברית ב-Console APP #C
יש להזין קוד עבור הקידוד

Console.OutputEncoding = Encoding.GetEncoding("Windows-1255");

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

public static class HebrewStringFixer
{
    public static string ReverseHebrewCharacters(this string input)
    {
        Regex hebrewRegex = new Regex(@"\p{IsHebrew}+(\W+\p{IsHebrew}+)?");
        return hebrewRegex.Replace(input, match => new string(match.Value.Reverse().ToArray()));
    }
}

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

@אי-עוד-מלבדו
אם זה לא מאמץ בשבילך תביא כמה דוגמאות על מה פוסלים אותך....

@dovid כתב בקוד עבור ProgressDialog ב-C#:

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

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

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

@dovid כתב בקוד עבור ProgressDialog ב-C#:

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

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

כל זה אני כותב כשאלה!?

@מעלה-ומוריד
תנסה לחפור פה
https://topirzul.co.il/קטגוריה-ראשית-1/מסילות/מסילות-לדלתות-הזזה.html

כיוון אחר למחשבה אולי תשתמש עם תריס?

@אלישע-סוליימנוב
תנסה לפצל את הקובץ אולי כך תבודד את הבעיה

@yossiz
הצלחתי בס"ד לקבל גם את הפסקאות הממוספרות הקוד גם הרבה פחות מסורבל עכשיו
הוספתי גם קוד לחילוץ מקבצי doc ללא השתמשות בוורד למי שרוצה

@yossiz כתב בקוד C# לחילוץ טקסט מקבצי וורד:

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

הוספתי כעת
פיסקאות ממוספרות הצלחתי לסמן רק עם * ולא עם המספרים

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

@yossiz כתב בקוד C# לחילוץ טקסט מקבצי וורד:

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

אבדוק את זה תודה.

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

@yossiz
בעיקר במקרה שהמסמך כבר פתוח ב-office
תכלס שיניתי כעת את הקוד שיעבור לשיטה השניה על כל שגיאה כדי שיכלול את מה ש-DOvid כתב להלן

using DocumentFormat.OpenXml.Packaging;
using System;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;
using System.Xml;
using WordInterop = Microsoft.Office.Interop.Word;

namespace MsWordTextExtractor
{
    public static class DocxTextExtractor
    {
        public static string Extract(string filePath)
        {
            try
            {
                return ReadAllTextParts(filePath);
            }
            catch
            {
                return WordInteropExtractor(filePath);
            }
        }

        static string ReadAllTextParts(string filePath)
        {
            StringBuilder stb = new StringBuilder();
            using (WordprocessingDocument wordprocessingDocument = WordprocessingDocument.Open(filePath, false))
            {
                var mainPart = wordprocessingDocument.MainDocumentPart;
                stb.AppendLine(ReadTextPart(mainPart.GetStream()));

                if (mainPart.FootnotesPart != null)
                {
                    string footNotes = ReadFootnotesPart(mainPart.FootnotesPart.GetStream());
                    if (!string.IsNullOrEmpty(footNotes))
                    {
                        stb.AppendLine();
                        stb.AppendLine(footNotes);
                    }
                }

                if (mainPart.EndnotesPart != null)
                {
                    string footNotes = ReadFootnotesPart(mainPart.FootnotesPart.GetStream());
                    if (!string.IsNullOrEmpty(footNotes))
                    {
                        stb.AppendLine();
                        stb.AppendLine(footNotes);
                    }
                }
            }
            return stb.ToString();
        }

        static string ReadTextPart(Stream partStream)
        {
            NameTable nameTable = new NameTable();
            XmlNamespaceManager xmlNamespaceManager = new XmlNamespaceManager(nameTable);
            xmlNamespaceManager.AddNamespace("w", "http://schemas.openxmlformats.org/wordprocessingml/2006/main");
            StringBuilder stringBuilder = new StringBuilder();

            XmlDocument xmlDocument = new XmlDocument(nameTable);
            xmlDocument.Load(partStream);

            XmlNodeList paragraphNodes = xmlDocument.SelectNodes("//w:p", xmlNamespaceManager);
            foreach (XmlNode paragraphNode in paragraphNodes)
            {
                ReadTextContent(stringBuilder, paragraphNode, xmlNamespaceManager);
                stringBuilder.Append(Environment.NewLine);
            }
            return stringBuilder.ToString().Trim();
        }

        static string ReadFootnotesPart(Stream partStream)
        {
            NameTable nameTable = new NameTable();
            XmlNamespaceManager xmlNamespaceManager = new XmlNamespaceManager(nameTable);
            xmlNamespaceManager.AddNamespace("w", "http://schemas.openxmlformats.org/wordprocessingml/2006/main");
            StringBuilder stringBuilder = new StringBuilder();

            XmlDocument xmlDocument = new XmlDocument(nameTable);
            xmlDocument.Load(partStream);

            XmlNodeList footnoteNodes = xmlDocument.SelectNodes("//w:footnote | .//w:endnote", xmlNamespaceManager);
            foreach (XmlNode footnoteNode in footnoteNodes)
            {
                string footnoteId = footnoteNode.Attributes["w:id"].Value;
                if (footnoteId == "-1" || footnoteId == "0") { continue; }
                stringBuilder.Append($"{footnoteId}");

                ReadTextContent(stringBuilder, footnoteNode, xmlNamespaceManager);

                stringBuilder.AppendLine();
            }
            return stringBuilder.ToString().Trim();
        }

        static void ReadTextContent(StringBuilder stringBuilder, XmlNode xmlNode, XmlNamespaceManager xmlNamespaceManager)
        {
            XmlNodeList textNodes = xmlNode.SelectNodes(".//w:t | .//w:tab | .//w:br | .//w:footnoteReference | .//w:numPr", xmlNamespaceManager);
            foreach (XmlNode textNode in textNodes)
            {
                switch (textNode.Name)
                {
                    case "w:t":
                        stringBuilder.Append(textNode.InnerText);
                        break;

                    case "w:tab":
                        stringBuilder.Append("\t");
                        break;

                    case "w:br":
                        stringBuilder.Append("\v");
                        break;

                    case "w:footnoteReference":
                        string footnoteId = textNode.Attributes["w:id"].Value;
                        stringBuilder.Append($"{footnoteId}");
                        break;

                    case "w:numPr":
                        XmlNode ilvlNode = textNode.SelectSingleNode(".//w:ilvl", xmlNamespaceManager);
                        XmlNode numIdNode = textNode.SelectSingleNode(".//w:numId", xmlNamespaceManager);
                        if (ilvlNode != null && numIdNode != null)
                        {                       
                            stringBuilder.Append("*");
                        }
                        break;
                }
            }
        }

        public static string WordInteropExtractor(string filePath)
        {
            string tempFilePath = Path.Combine(Path.GetTempPath(), Path.GetFileNameWithoutExtension(filePath) + ".txt");


            try
            {
                using (WordApp wordApp = new WordApp())
                {
                    WordInterop.Document doc = null;
                    bool isFileAlreadyOpen = false;

                    foreach (WordInterop.Document openDoc in wordApp.App.Documents)
                    {
                        if (openDoc.FullName.Equals(Path.GetFullPath(filePath), StringComparison.OrdinalIgnoreCase))
                        {
                            doc = openDoc;
                            isFileAlreadyOpen = true;
                            break;
                        }
                    }

                    if (doc == null) doc = wordApp.App.Documents.Open(filePath, ReadOnly: true, Visible: false);

                    var originalFormat = doc.SaveFormat;
                    doc.SaveAs2(tempFilePath, WordInterop.WdSaveFormat.wdFormatUnicodeText, Encoding: 65001, AddToRecentFiles: false);
                    if (isFileAlreadyOpen) doc.SaveAs2(filePath, originalFormat);

                    if (doc != null && !isFileAlreadyOpen) doc.Close(WordInterop.WdSaveOptions.wdDoNotSaveChanges);
                }

                return File.ReadAllText(tempFilePath);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                return string.Empty;
            }
            finally
            {
                if (File.Exists(tempFilePath)) File.Delete(tempFilePath);
            }
        }
    }

    class WordApp : IDisposable
    {
        public Microsoft.Office.Interop.Word.Application App;
        bool isNewApp;

        public WordApp()
        {
            try
            {
                App = (WordInterop.Application)Marshal.GetActiveObject("Word.Application");
            }
            catch (COMException)
            {
                App = new WordInterop.Application();
                isNewApp = true;
            }
        }

        public void Dispose()
        {
            if (isNewApp && App != null)
            {
                App.Quit();
                Marshal.ReleaseComObject(App);
            }
        }
    }
}

עריכה:
מי שרוצה לחלץ טקסט מקבצי doc ללא שימוש באופיס יכול להשתמש בספרייה NPOI.HWPF

עם הקוד דלהלן

internal class NpoiDocExtractor
{
    public static string ExtractTextFromDoc(string filePath)
    {
        using (FileStream fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
        {
            HWPFDocument doc = new HWPFDocument(fileStream);
            WordExtractor extractor = new WordExtractor(doc);
            return extractor.Text;
        }
    }
}

הספרייה עושה עבודה די טובה החסרון היחיד שלה הוא שהיא לא מחלצת את מספרי ההערות

הערה חשובה:
לאחר חקירת הנושא גיליתי שצריך לעבוד עם אחוזים ולא כמו שעשיתי
עיין כאן להסבר מפורט
https://brianlagunas.com/does-reporting-progress-with-task-run-freeze-your-wpf-ui/

עריכה:
בדיקות שעשיתי יוצא שבעל הכתבה איננו צודק לא היה שום שיפור באחוזים לעומת מה שאני עשיתי
מה שכן מצאתי ששימוש ב- אפשרות של -Background ב-Dispathcer מועיל קימעא

Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{
   }), DispatcherPriority.Background);

@dovid
אם הבנתי נכון אזי בקוד שהצגת שמות העמודות הם סטטיים ("Name", Age") רק התוכן הוא דינאמי אני מחפש שגם שמות העמודות יהיו דינאמיים

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

בעצם הפקד לוקח רשימה של מילים ויוצר עמודות של מילים חילופיות עבורם לבחירה על ידי המשתמש

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

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