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

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

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

לדעתי צריך להיות:
[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)

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

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

באיזה פלטפורמה כתבת ע"י BinaryReader וBinaryWriter? בסי שארפ או ג'אוה?
וקראת בבת אחת או גוש גוש?

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

תודה על השיתוף.
יפה מאוד הקוד.
אגב, יש בו טעות: המאפיין FileName של הדיאלוג מחזיר את כל הFull Name כלומר השם כולל הPath.
אז במקום הdialog.InitialDirectory + dialog.FileName, צריך להיות רק dialog.FileName.

בהצלחה.
[size=85:33h4gybf]נ.ב. לעיצוב קטעי קוד בפוסטים בפורום, במקום להשתמש בלחצן code השתמשי בתיבת "בחר תחביר", זה מעצב לפי השפה הנבחרת.[/size:33h4gybf]

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

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

private void dataGrid1_BeginningEdit(object sender, DataGridBeginningEditEventArgs e)
{
    if (e.Column == ColumnHL)
    {
        var foDialog = new System.Windows.Forms.FolderBrowserDialog();
        if (foDialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
        {
            var o = e.Row.DataContext as YourObjectType;
            o.SavedPath = foDialog.SelectedPath ;                
        }
        e.Cancel = true;
    }
}

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

פורסם במקור בפורום CODE613 ב27/06/2013 20:16 (+03:00)

אתה מצד אחד בונה מחלקה ומצד שני אומר שDataSet יותר קל.
הלינקים שהבאתי ברובם לא במקום דטה סט אלא כותבים את הקוד שכתבת אוטומטית.

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

פורסם במקור בפורום CODE613 ב23/12/2013 17:08 (+02:00)

@שמואל

כמו"כ אולי כל העניין הינו באמת 'בית חולים מתחת לגשר' ועדיף לעבוד עם אנטיטי

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

יש כלים אוטומטיים שעושים אוטומטית מחלקות מכל המסד נתונים, כלומר כותבים את הקוד הזה פחות או יותר.
חלךק עושים רק מחלקות חלק גם מטפלים בתקשורת ובכל הDAL.
הנה חלק:
זה אונליין: http://www.pureobjects.com/dbCode.aspx
זה כלי קוד פתוח, כך שתוכלו לשנותו http://www.codeproject.com/Articles/8776/Automated-Class-Builder-for-Database-Tables

עוד כלים:
http://www.codeproject.com/Articles/36217/Generate-Classes-and-CRUD-Procedures
http://oxmlibrary.codeplex.com/ הוא יצור מתוך DataSet קיים. נשמע גם חזק.
http://salardbcodegenerator.codeplex.com/ שווה בדיקה עמוקה.
http://datatiergenerator.codeplex.com/ יוצר מחלקות קוראות וכותבות גם בצד המסד וגם באפליקציה שכל התקשורת בנוייה תוך דקות.

זה פיתרון פשוט ומפליא http://stackoverflow.com/a/7863480/1271037 זו שאילתת SQL על מבנה המסד

פורסם במקור בפורום CODE613 ב23/12/2013 13:48 (+02:00)

אני עובד עם DataSet & DataAdapters.

הטכנלוגיות LinqToSql והחדשה יותר EntityFramwork, דורשות "טיפוח" והתערבות קבועה במיפוי הואטומטי. אחרת, יש בעיות איטיות משמעותיות לרוב.
כמו"כ הDB רגיש מאוד לשינויים במידה הוא כבר מלא בנתונים.

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

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

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

@מאיר_מהתוכנה

יש איזה שהוא קשר בין קינון של תיקיות של קבצים ממשיים בפרוייקט בויזואל סטודיו, לבין namespace???

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

namespace System.Collection.הקולקשיןשלי
{
    class Dugma
    {
    }
}

@מאיר_מהתוכנה

דבר נוסף האם ייעול ניהול פרוייקט באמצעות namespaces מקוננים הוא מצוה מדאורייתא, מדברי סופרים, או מנהג גרידא

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

@מאיר_מהתוכנה

מה רע במחלקות???

כל המושג הזה שכותבים קלאס בתוך קלאס, זה אמנם עובד, אבל ע"פ רוב לא חכם.
בתור Namespace זה ודאי לא מתאים בגלל הרבה סיבות:
[list:3rs9ovl3]מחלקות בעלי שמות שווים "מסתירים" אחת את השנייה, לעומת Namespace שמתמזגים.
א"א לכתוב לתוך מחלקה של קובץ אחר וכו', אלא ע"י partial וכתיבה חוזרת של שורת ההצהרה. ודאי שא"א לתוך אסמבלי אחר.
זה מיותר ליצור מחלקה שלא עושה מאומה מלבד היותה כותרת וקטגורייה לכמה מחלקות.
מחלקה נכתבת לתוך האסמבלי, ולא משמשת רק לנוחות בזמן הכתיבה כמו Namespace . [/list:u:3rs9ovl3]

@מאיר_מהתוכנה

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

נכון לגמרי.

פורסם במקור בפורום CODE613 ב20/06/2013 16:45 (+03:00)

@מאיר_מהתוכנה

שלום

1. ה scroll הוא אופקי בלבד, ואני מעוניין שהגלגול ישפיע עליו, אין לי scroll אנכי.

זה תלוי באובייקט בו אתה נמצא, בעיקרון יש לScrollViewer יש שתי מאפיינים:
HorizontalScrollBarVisibility
VerticalScrollBarVisibility

הם מקבלים אחת מארבע אפשרויות:
Auto
Disabled
Hidden
Visible

בד"כ auto זה הכי טוב, אם צריך יש אם לא לא.

פורסם במקור בפורום CODE613 ב20/06/2013 18:37 (+03:00)

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

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

יש אפשרות לאסוף לItemsSource כמה מקורות ע"י CompositeCollection.
בתוך הCompositeCollection אפשר לשים גם קולקשנים וגם פריטים בודדים.

משתמשים בזה ככה:

<ComboBox.ItemsSource>
    <CompositeCollection>
        <ComboBoxItem>צור חדש...</ComboBoxItem>
        <CollectionContainer Collection="{Binding Source={StaticResource Coll}}" />
        <CollectionContainer Collection="{Binding Source={StaticResource Coll1}}" />
    </CompositeCollection>
</ComboBox.ItemsSource>

פורסם במקור בפורום CODE613 ב20/06/2013 14:48 (+03:00)

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

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

לשם כך יש MultiTrigger. הנה דוגמא:

<Style TargetType="TextBox">
    <Style.Triggers>
        <MultiTrigger>
            <MultiTrigger.Conditions>
                <Condition Property="Text" Value="" />
                <Condition Property="IsFocused" Value="False" />
            </MultiTrigger.Conditions>
            <MultiTrigger.Setters>
                <Setter Property="Background" Value="Red" />
            </MultiTrigger.Setters>
        </MultiTrigger>
    </Style.Triggers>
</Style>

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

בנוסף לMultiTrigger שהוא בא לריבוי טריגרים רגילים, יש MultiDataTrigger לריבוי DataTrigger.

פורסם במקור בפורום CODE613 ב25/06/2013 21:40 (+03:00)

מהו דטה טריגר?

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

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

הנה דוגמא:

<Button Content="Button" HorizontalAlignment="Left" Name="button1" VerticalAlignment="Top" Width="75" Margin="50,50">
    <Button.Style>
        <Style TargetType="Button">
            <Style.Triggers>
                <DataTrigger Binding="{Binding ElementName=textBox1, Path=Text}" Value="">
                    <Setter Property="IsEnabled" Value="False" />
                </DataTrigger>
            </Style.Triggers>
        </Style>
    </Button.Style>
</Button>
<TextBox Height="23" HorizontalAlignment="Left" Margin="50,80" Name="textBox1" VerticalAlignment="Top" Width="75" />

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

פורסם במקור בפורום CODE613 ב24/06/2013 14:00 (+03:00)

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

המקום לכתיבת טריגר זה רק בתוך סטייל (אמנם בכל אלמנט WPF יש מאפיין בשם Triggers אבל הוא מקבל רק EventTrigger, ולא שימושי בד"כ).

אז הטריגר נחלק לשלוש חלקים:
[list:ottwv6w1]א. מאפיין למעקב אחרי ערכו,
ב. הערך ש"מקפיץ" את החלת הסגנון
ג. הסגנון שיוחל במידה וההמאפיין מאוכלס בערך הנכון.[/list:u:ottwv6w1]

בטריגר רגיל, המאפיין שאנו עוקבים אחריו חייב להיות מאפיין מקומי = חבר במאפייני האובייקט עליו בו אנו נמצאים.

נתחיל בדוגמא:

<TextBox Height="23" Width="120">
    <TextBox.Style>
        <Style TargetType="TextBox">
            <Style.Triggers>
                <Trigger Property="Text" Value="שלום">
                    <Setter Property="Background" Value="Red" />
                </Trigger>
            </Style.Triggers>
        </Style>
    </TextBox.Style>
</TextBox>

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

<Trigger Property="IsMouseOver" Value="True">
    <Setter Property="Background" Value="Red" />
</Trigger>

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

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

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

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