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

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

מדריך: איך להציג עברית ב-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 באופן דינאמי
כל המדריכים שקראתי מתארים איך לייצר את התוכן באופן דינאמי אבל אני לא מצליח לייצר את הכותרות באופן דינאמי ואז למלאות את התאים אשמח לקבל הדרכה בנושא.

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

@yossiz כתב בבאיזה תוכנת אינדקס גוגל משתמשים?:

עיין כתבה זו על האתגרים המיוחדים בעברית

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

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

עריכה: כל זה נכון אם יש לך אמפמינציה אישית של lucene אבל אם אתה משתמש בו כמות שהוא אתה רק מרוויח אם אתה משתמש ב-HEBMORPH למה? כי Lecene הינו מנוע חיפוש ולשכך הוא בנוי על אלגוריתמים שמחשבים רלוונטיות וממילא כל כלי שמתעל את הרלוונטיות מתעל את המנוע.

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

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

@yossiz
הסיבה לסגור את התוכנה מה-debugger הוא במקרה שיש באג שתוקע את ה-UI