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

pcinfogmach

@dovid כתב בספריית החיפוש meilisearch ב-בC#:

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

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

pcinfogmach

@dovid
אוקיי אולי קפצתי מדאי מהר מדאי אני קצת מבין יותר טוב עכשיו איך זה עובד בעצם meiliserach הינה "תוכנה" שאני יכול לגשת אליה דרך api ב-C#
אבל לא מדובר בספרייה של C# כלל

pcinfogmach

@sivan22 כתב בספריית החיפוש meilisearch ב-בC#:

להפעיל את הקובץ בסיומת EXE, לא לסגור את החלון השחור.

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

pcinfogmach

@dovid כתב בספריית החיפוש meilisearch ב-בC#:

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

אולי לייצר service?

תכלס השגיאה הנ"ל עדיין קיימת

pcinfogmach

האם אפשר לייצר dll ב-C# ואח"כ להשתמש בן ב-flutter?
אשמח לכל מידע בנושא

pcinfogmach

@dovid כתב בספריית החיפוש meilisearch ב-בC#:

יש בהוראות שמה מקטע בשם run-meilisearch
שמה מבואר שצריך להריץ את המופע של התוכנה העצמאית שלהם, אתה יכול להוריד אותה פה:
https://github.com/meilisearch/meilisearch/releases/tag/v1.9.0
בWindows אתה צריך את meilisearch-windows-amd64.exe.

תודה אבל זה כבר היה בקוד שלי סליחה שלא הדגשתי חלק זה מספיק.

@pcinfogmach כתב בספריית החיפוש meilisearch ב-בC#:

private void StartMeiliSearch()
{
string appDirectory = AppDomain.CurrentDomain.BaseDirectory;
string meiliFileName = Path.Combine(appDirectory, "meilisearch-windows-amd64.exe");
_meiliSearchProcess = new Process
{
StartInfo = new ProcessStartInfo
{
FileName = meiliFileName,
Arguments = " --env production",
UseShellExecute = false,
RedirectStandardOutput = true,
RedirectStandardError = true,
CreateNoWindow = true
}
};
_meiliSearchProcess.Start();
}

pcinfogmach

ניסיתי ליצור פרוייקט דוגמא על פי המופיע כאן:
נתקלתי בשגיאה דלהלן:

מו"ב הקוד שעשיתי

<UserControl x:Class="TesterProject.MeilisearchView"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             xmlns:local="clr-namespace:TesterProject"
             mc:Ignorable="d" 
             d:DesignHeight="450" d:DesignWidth="800">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="auto"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>

        <Grid Grid.Row="0" Margin="5">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="auto"/>
                <ColumnDefinition Width="*"/>
            </Grid.ColumnDefinitions>

            <TextBox Name="SearchBox" Margin="5"
                     Grid.Column="1" Text="ברכות"/>
            <StackPanel Orientation="Horizontal" 
                        Grid.Column="0">
                <Button Content="Search" Click="OnSearchButtonClick" Margin="5"/>
                <Button Content="Index Files"  Click="OnIndexButtonClick" Margin="5"/>
            </StackPanel>

        </Grid>

        <ListBox Name="ResultsListBox" Grid.Row="1"/>
    </Grid>
</UserControl>

using Microsoft.Win32;
using System.Diagnostics;
using System.Windows;
using System.Windows.Controls;
using System.IO;
using Meilisearch;
using System.Linq;
using System.Threading.Tasks;
using System;

namespace TesterProject
{
    /// <summary>
    /// Interaction logic for MeilisearchView.xaml
    /// </summary>
    public partial class MeilisearchView : UserControl
    {
        private readonly MeilisearchClient client;
        Meilisearch.Index index;
        private Process _meiliSearchProcess;
        
        public MeilisearchView()
        {
            InitializeComponent();
            client = new MeilisearchClient("http://localhost:7700");
            index = client.Index("meiliIndex");
            StartMeiliSearch();
            Application.Current.Exit += (s, e) => { _meiliSearchProcess?.Kill(); };
        }

        private async void OnIndexButtonClick(object sender, RoutedEventArgs e)
        {
            await CreateIndex();
        }

        private async void OnSearchButtonClick(object sender, RoutedEventArgs e)
        {
            var searchTerm = SearchBox.Text;
            await Search(searchTerm);
        }

        private void StartMeiliSearch()
        {
            string appDirectory = AppDomain.CurrentDomain.BaseDirectory;
            string meiliFileName = Path.Combine(appDirectory, "meilisearch-windows-amd64.exe");
            _meiliSearchProcess = new Process
            {
                StartInfo = new ProcessStartInfo
                {
                    FileName = meiliFileName,
                    Arguments = " --env production",
                    UseShellExecute = false,
                    RedirectStandardOutput = true,
                    RedirectStandardError = true,
                    CreateNoWindow = true
                }
            };
            _meiliSearchProcess.Start();
        }

        private async Task CreateIndex()
        {
            var openFileDialog = new OpenFileDialog
            {
                Multiselect = true
            };

            if (openFileDialog.ShowDialog() == true)
            {
                var documents = openFileDialog.FileNames.Select(fileName => new MeiliDoc
                {
                    FileName = fileName,
                    Content = File.ReadAllText(fileName)
                }).ToArray();

                var task = await index.AddDocumentsAsync(documents); // # => { "uid": 0 }
                MessageBox.Show("Indexing Done.");
            }
        }

        private async Task Search(string searchTerm)
        {
            var results = await index.SearchAsync<MeiliDoc>(searchTerm);
            ResultsListBox.Items.Clear();
            foreach (var result in results.Hits)
            {
                ResultsListBox.Items.Add(result.FileName);
            }
        }
    }
  

    public class MeiliDoc 
    {
        public string FileName { get; set; }
        public string Content { get; set; }
    }
}

pcinfogmach

מישהו מכיר את ספריית החיפוש meilisearch
האם מישהו יכול להמליץ לי עליה.
כמו:כ הייתי שמח לדעת האם היא מתאימה לתוכנה שלי תורת אמת בוורד

pcinfogmach

דרך xaml מאוד קל לעצב טקסט ב- textblock ב-wpf
כמתואר כאן בטוב טעם

אבל איך עושים binding עבור זה?
ראיתי הרבה כתבות בנושא וכל אחד מציע את הזווית שלו הנה הניסיון שלי (הוא מוגבל כרגע לbold ן-italics אבל אפשר להרחיב את הרעיון, אשמח לקבל משוב:

<Window x:Class="HighlightSample.HighlighterTest"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:HighlightSample"
        mc:Ignorable="d"
        Title="HighlighterTest" 
        Height="250" Width="250">
    <Window.DataContext>
        <local:HighlighterTextViewModel x:Name="vm"/>
    </Window.DataContext>
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="auto"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>
        <Button x:Name="PopulateButton" Command="{Binding PopulateResultsCommand}"
                Content="Populate" Margin="5"/>
        <ListBox ItemsSource="{Binding SearchResults}" Grid.Row="1">
            <ListBox.ItemTemplate>
                <DataTemplate>
                    <local:HighlighterTextBlock
                            HighlightedText="{Binding SearchResult}" 
                            TextWrapping="Wrap"/>
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>
    </Grid>
</Window>

using System;
using System.Text.RegularExpressions;
using System.Windows.Controls;
using System.Windows;
using System.Windows.Documents;
using System.Collections.ObjectModel;
using System.Windows.Input;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using PdfiumViewer.Demo.Annotations;

namespace HighlightSample
{


    internal class HighlighterTextViewModel : ViewModelBase
    {
        private ObservableCollection<TextModel> _searchResults = new ObservableCollection<TextModel> { };

        public ICommand PopulateResultsCommand { get => new RelayCommand(PopulateResults); }
        public void PopulateResults()
        {
            for (int i = 0; i < 100000; i++)
            {
                SearchResults.Add(new TextModel());
            }
        }

        public ObservableCollection<TextModel> SearchResults
        {
            get { return _searchResults; }
            set
            {
                if (_searchResults != value)
                {
                    _searchResults = value;
                    OnPropertyChanged(nameof(SearchResults));
                }
            }
        }


    }

    internal class TextModel : ViewModelBase
    {
        private string _searchResult = "This is a <b>bold</b> and <i>italic</i> example.";

        public string SearchResult
        {
            get { return _searchResult; }
            set
            {
                if (_searchResult != value)
                {
                    _searchResult = value;
                    OnPropertyChanged(nameof(SearchResult));
                }
            }
        }
    }

    public class HighlighterTextBlock : TextBlock
    {
        public static readonly DependencyProperty HighlightedTextProperty =
            DependencyProperty.Register("HighlightedText", typeof(string), typeof(HighlighterTextBlock), new PropertyMetadata(string.Empty, OnHighlightedTextChanged));

        public string HighlightedText
        {
            get { return (string)GetValue(HighlightedTextProperty); }
            set { SetValue(HighlightedTextProperty, value); }
        }

        private static void OnHighlightedTextChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var control = d as HighlighterTextBlock;
            control?.UpdateText();
        }

        private void UpdateText()
        {
            Inlines.Clear();
            if (string.IsNullOrEmpty(HighlightedText))
            {
                return;
            }

            string pattern = @"(<b>(.*?)</b>)|(<i>(.*?)</i>)"; // Example pattern for bold and italic tags

            int lastPos = 0;
            var matches = Regex.Matches(HighlightedText, pattern);

            foreach (Match match in matches)
            {
                // Add text before the match
                if (match.Index > lastPos)
                {
                    Inlines.Add(new Run(HighlightedText.Substring(lastPos, match.Index - lastPos)));
                }

                // Add highlighted or formatted text
                if (match.Groups[1].Success) // Bold tag
                {
                    Inlines.Add(new Bold(new Run(match.Groups[2].Value)));
                }
                else if (match.Groups[3].Success) // Italic tag
                {
                    Inlines.Add(new Italic(new Run(match.Groups[4].Value)));
                }

                lastPos = match.Index + match.Length;
            }

            // Add remaining text after the last match
            if (lastPos < HighlightedText.Length)
            {
                Inlines.Add(new Run(HighlightedText.Substring(lastPos)));
            }
        }
    }

    public abstract class ICommandBase : ICommand
    {
        public event EventHandler CanExecuteChanged;

        public virtual bool CanExecute(object parameter)
        {
            return true;
        }

        public abstract void Execute(object parameter);

        protected void OnCanExecuteChanged()
        {
            CanExecuteChanged?.Invoke(this, new EventArgs());
        }
    }

    public class RelayCommand : ICommandBase
    {
        private Action commandTask;

        public RelayCommand(Action action)
        {
            commandTask = action;
        }
        public override void Execute(object parameter)
        {
            commandTask();
        }
    }

    public abstract class ViewModelBase : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        [NotifyPropertyChangedInvocator]
        protected virtual void OnPropertyChanged([CallerMemberName] string PropertyName = null) => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(PropertyName));

        [NotifyPropertyChangedInvocator]
        protected virtual bool Set<T>(ref T field, T value, [CallerMemberName] string PropertyName = null)
        {
            if (Equals(field, value)) return false;
            field = value;
            OnPropertyChanged(PropertyName);
            return true;
        }
    }
}

pcinfogmach

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

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

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

pcinfogmach

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

pcinfogmach

@dovid
אני מעוניין לעשות זאת בכמה פקדים או יותר נכון בכל הפקדים אבל מה שדחוף לי זה הרשימה דלהלן:
togglebutton
button
listview
listbox
treeview

pcinfogmach

מישהו יודע איך לשנות את הצבע של פקד wpf כאשר העכבר מעליו שלא יהיה כחול אלא צבע אחר?

נסיתי את זה

    <SolidColorBrush x:Key="{x:Static SystemColors.HighlightBrushKey}" Color="LightGray"/>

וגם את זה

<ToggleButton.Style>
    <Style TargetType="ToggleButton">
        <Setter Property="Background" Value="Transparent"/>
        <Setter Property="BorderThickness" Value="0"/>
        <Style.Triggers>
            <Trigger Property="IsChecked" Value="True">
                <Setter Property="Background" Value="LightGray"/>
            </Trigger>
            <Trigger Property="IsMouseOver" Value="True">
                <Setter Property="Background" Value="LightGray"/>
            </Trigger>
        </Style.Triggers>
    </Style>
</ToggleButton.Style>

pcinfogmach

למי שעדיין מעוניין בנושא מצאתי את זה:
https://github.com/majkimester/PdfiumViewer.WPF

pcinfogmach

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

pcinfogmach

@חגי כתב בספרייה להמרת קבצי ורד ל- C# pdf:

ExportAsFixedFormat

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

וזה לא עוזר לשנות את הגדרות הבטיחות של וורד

pcinfogmach

@חגי
תודה
מה זה ExportAsFixedFormat ?

pcinfogmach

מישהו מכיר ספרייה חיניית להמרת קבצי ורד ל-pdf? (ללא צורך בהתקנת וורד במחשב)...
ב- C#
תודה מראש

pcinfogmach

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

pcinfogmach

אשמח לעזרתכם בשאלה בנושא פיתוח מרובה פלטפורמות בשפת C#.

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

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

Lucene.NET
TikaOnDotNet
Docnet

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

בנוסף, אשמח לשמוע על המלצות לפריימוורק שכדאי לי לשקול.

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

pcinfogmach

פוסטים