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

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

הנה המחשה חיה:

<Button x:Name="Bt1" HorizontalAlignment="Left" Margin="269,194,0,0" VerticalAlignment="Top" Width="75">
     <TextBlock Text="123" />
</Button>
<Button Content="{Binding Content, ElementName=Bt1}" HorizontalAlignment="Left" Margin="269,219,0,0" VerticalAlignment="Top" Width="75" />

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

<TabItem.HeaderTemplate>
    <DataTemplate>
        <StackPanel Orientation="Horizontal">
            <Image Source="..\Images\questionnare.ico"/>
            <TextBlock Text="{TemplateBinding Content}"/>
        </StackPanel>
    </DataTemplate>
</TabItem.HeaderTemplate>

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

פורסם במקור בפורום CODE613 ב08/07/2013 13:37 (+03:00)

נכון, אני טעיתי מה פתאום ToolTip בControlTemplate.
אבל באלמנט הגריד (שורה מתחת) זה אמור לעבוד.
תחליפי את <Grid> ב

<Grid ToolTip="{TemplateBinding Header}">

פורסם במקור בפורום CODE613 ב08/07/2013 11:49 (+03:00)

איפה ניסית לשים את השורה הזו:

ToolTip="{TemplateBinding Header}"

?

נסי לשים אותה בתוך שורת הפתיחה של הControlTemplate (שורה רביעית).
קשה לי להבין מה קורה שם בדיוק, אולי אני צריך לבדוק את הChromTab הזה.
מחר אולי יהיה לי זמן.

פורסם במקור בפורום CODE613 ב07/07/2013 16:54 (+03:00)

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

פורסם במקור בפורום CODE613 ב07/07/2013 12:44 (+03:00)

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

פורסם במקור בפורום CODE613 ב08/07/2013 14:26 (+03:00)

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

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

פורסם במקור בפורום CODE613 ב07/07/2013 11:55 (+03:00)

ניסית להוסיף את הDLL שבתיקיה הזו: C:\WINDOWS\Microsoft.NET\Framework\v4.0.30319 ?
שם הקובץ הוא System.Data.Entity.DLL.
זה אמור לעבוד.

פורסם במקור בפורום CODE613 ב04/07/2013 18:15 (+03:00)

@דוד ל.ט.

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

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

זו הצורה הבסיסית:

Class MyComparer
    Implements System.Collections.IComparer
    Public Function Compare(x As Object, y As Object) As Integer Implements IComparer.Compare
        Dim xStr As String = x
        Dim yStr As String = y
        If (xStr < yStr) Then
            Return 1
        End If
        If (xStr > yStr) Then
            Return -1
        Else
            Return 0
        End If
    End Function
End Class

ואח"כ משתמשים ככה:

Array.BinarySearch(coll, 0, coll.Length, "אחד", New MyComparer)

פורסם במקור בפורום CODE613 ב07/07/2013 13:35 (+03:00)

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

פורסם במקור בפורום CODE613 ב07/07/2013 13:07 (+03:00)

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

פורסם במקור בפורום CODE613 ב07/07/2013 12:49 (+03:00)

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

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

פורסם במקור בפורום CODE613 ב07/07/2013 11:40 (+03:00)

@רחמים

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

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

פורסם במקור בפורום CODE613 ב04/07/2013 17:30 (+03:00)

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

פורסם במקור בפורום CODE613 ב04/07/2013 14:53 (+03:00)

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

אני לא הדבקתי את הקוד קודם, אדביק אותו כאן

Sub SerachInIndex(WordsCodes() As Byte, fileIndex As String)
        Using Stream As New IO.FileStream(fileIndex, IO.FileMode.Open, IO.FileAccess.Read)
            Dim bytes(4095) As Byte
            Dim numBytesToRead As Integer = Stream.Length
            Dim numBytesRead As Integer = 0

            While numBytesRead < numBytesToRead
                numBytesRead = Stream.Read(bytes, 0, 4096)
                For i As Integer = 0 To 1023
                    For Each WordCheck In WordsCodes
                        If bytes.Skip(i).Take(4).SequenceEqual(WordsCodes) Then
                            'החזרת המיקום והמילה שנמצאה
                        End If
                    Next
                Next
            End While
        End Using
    End Sub

פורסם במקור בפורום CODE613 ב04/07/2013 14:18 (+03:00)

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

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

לדעתי צריך להיות:
[u:2hxx37a7]א. מילון[/u:2hxx37a7]
קובץ אחד שהוא מילון של כל המילים, והוא אמור להיות כולו בזיכרון מתחילת חיי היישום עד סופו. זה הכי פחות חשוב האופן בו הוא נכתב לדיסק ונטען ממנו.
כל מילה מופיעה פעם אחת, ומיקומה ביחס לתחילת המילון (לדוגמא המילה ה27) היא הזיהוי שלה.
[u:2hxx37a7]ב. אינדקס דחוס (+ כל ערך באורך קבוע)[/u:2hxx37a7]
האינדקס בעצם זה עותק של קובץ המקור אבל במקום לכתוב "פעם היה איש" לדוגמה, לכתוב (ע"פ המילון) שלושה קודי Integer שכל אחד לוקח ארבעה בתים תמיד.
אז יש לנו קובץ בינארי שאנו יודעים שהוא מורכב מ4 בתים * מספר המילים בקובץ.
[u:2hxx37a7]ג. חיפוש תוך כדי הקריאה[/u:2hxx37a7]
כשמחפשים לדוגמה את המילים: שלום {30} ברה {11} הצלה {22} שמח,
אז דבר ראשון נשיג מהמילון את קודי הזיהוי שלהם. לא בצורת מספר, אלא מספר מומר למערך בתים בגודל 4 (עדיף כבר במילון בזיכרון, אבל אם לא עכשיו).
דבר שני נעבור בלולאה של Stream על קובץ האינדקס שמורכב כאמור מסטים של ארבע ארבע בתים.
אז במהלך הלולאה שעוברת על בתי הקובץ (של האינדקס), לבדוק התאמה בין הקטע הנקרא כעת לבין אחד מאבעת הקודים אותם אנו מחפשים.
**[size=85:2hxx37a7]אפשר לעשות את זה תוך כדי (שהקריאה לא תחכה לבדיקה, והבדיקה לא תחכה לקריאה) אבל זה כבר מורכב יותר. אם תאחז בזה אשמח להראות לך איך.[/size:2hxx37a7]**אם נמצאה התאמה פותחים מונה שיבדוק את המרחק בין ההתאמה הזו לזו שאחריה, במידה וזה התאמה לא ראושנה נבדוק את המרחק ונחליט אם יש בהתאמה הוקדמת רלוונטיות לאור המרחק.

כדי להבהיר את כוונתי אראה כאן קוד דוגמה:

בקשר לשאילתה שמרשה תווים מיוחדים כמו כוכבית זה מאוד קל ליישם זאת גם, אבל זה שלב נוסף.

פורסם במקור בפורום CODE613 ב04/07/2013 11:57 (+03:00)

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

@רחמים

אבל זה בדיוק מה שעשיתי עד כעת!
וכמו שהסברתי לעיל שיש קובץ אינדקס שבו 200 אלף ביטים ראשונים שייכים לאוביקט סיכום של קובץ א' ואח''כ 150 אלף ביטים שייכים לאובייקט סיכום של קובץ ב' וכן על זה הדרך מאות ואלפי אובייקטים של סיכומי קבצים, וכשאני רוצה לחפש מילים בקובץ א' אני ניגש לתחילת המערך וקורא עד 200 אלף וכשאני צריך לחפש בקובץ ב' אני קורא מביט 200001 עד 350000 וכך מאתחל את האובייקט. וכן על זה הדרך.
ואם רוב הזמן הולך לא על קריאת הביטים מהדיסק אלא בהמרה של ביטים למחרוזות איך הם עושים את ההמרה מהר?

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

פורסם במקור בפורום CODE613 ב03/07/2013 12:04 (+03:00)

@רחמים

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

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

פורסם במקור בפורום CODE613 ב03/07/2013 11:31 (+03:00)

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

עדיין אני בטוח שהDataTable כן ייתן תוצאות טובות מבחינת מהירות, תעדכן.
מבחינת גודל בדיסק הוא גם לוקח הרבה יותר מהגודל שאתה מצפה כי הוא כותב הכל בXML.
אם תרצה לחסוך גם את זה אולי מסד נתונים קומפקטי יעזור (Access, SqlIite, SqlCompact). במקרה כזה גם הקריאה/כתיבה וגם נפח הדיסק עוברים לשליטת מסד הנתונים (בדרך כלל הוא מטפל בזה מצויין).

פורסם במקור בפורום CODE613 ב02/07/2013 20:39 (+03:00)

עוד אפשרות מובנית בדוט נט זה הסריאליזציה המובנית.

הנה קטע קוד שעתקתי מהאינטרנט להמחשה:

Imports System.IO
Imports System.Runtime.Serialization.Formatters
Module Module1
	Sub Main()
		Dim rnd As New Random
		Dim intArr(5, 5) As Int32
		For i As Int32 = 0 To 5
			For j As Int32 = 0 To 5
				intArr(i, j) = rnd.Next(10, 100)
			Next
		Next
		Dim f As New Binary.BinaryFormatter()
		Dim ms As New MemoryStream()
		f.Serialize(ms, intArr)
		Dim byArr As Byte() = ms.ToArray()
		Dim str_b64 As String = Convert.ToBase64String(byArr)
		Dim ms2 As New MemoryStream(Convert.FromBase64String(str_b64))
		Dim intArr2(,) As Int32 = f.Deserialize(ms2)
	End Sub
End Module

פורסם במקור בפורום CODE613 ב02/07/2013 18:50 (+03:00)

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

זאת אומרת הנקודה היא הדקדוקי עניות של קריאת הדיסק וההמרה לאובייקטים.

תנסה לתת את העבודה השחורה למחלקות קיימות, תבדוק אם זה משפר את המהירות.
לדוגמא, DataTable של דוט נט.
תוסיף לפרוייקט דטהסט (קליק ימני על הפרוייקט Add New Item...>DataSet)
תבנה בתוך חלון העיצוב DataTable חדש. תוסיף עמודות ותגדיר את שמם והטיפוס שלהם (בחלון המאפיינים).

אח"כ אתה משתמש בDataTable ככה בערך:

Dim dt As New MyDataSet.TavlaDataTable

'קראה מהדיסק
dt.ReadXml("data.xml")
'כתיבה לדיסק
dt.WriteXml("data.xml")

'****************
'הוספת שורה לטבלה
Dim NewRow = dt.NewTavlaRow()
'גישה לתא כמאפיין
NewRow.ColumnNane = 5265
'גישה לתא באינדקס נומרי
NewRow(0) = ""
'גישה לתא באינדקס שם העמודה
NewRow("תאריך") = #1/1/2013#
'הוספת השורה החדשה שיצרנו
dt.AddTavlaRow(NewRow)


'לולאה על כל השורות
For Each r In dt
    Console.WriteLine(r.ColumnName)
Next

בדוגמא הראיתי כמה גישות לתא בטבלה, המועדפת זו הראשונה ע"י מאפיין.

פורסם במקור בפורום CODE613 ב02/07/2013 18:36 (+03:00)