דילוג לתוכן
  • דף הבית
  • קטגוריות
  • פוסטים אחרונים
  • משתמשים
  • חיפוש
  • חוקי הפורום
כיווץ
תחומים

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

💡 רוצה לזכור קריאת שמע בזמן? לחץ כאן!
A

avr416

@avr416
אודות
פוסטים
1.0k
נושאים
203
שיתופים
0
קבוצות
0
עוקבים
2
עוקב אחרי
0

פוסטים

פוסטים אחרונים הגבוה ביותר שנוי במחלוקת

  • WPF: בינדינג בזאמל לדטה גריד
    A avr416

    כתבתי את הקוד הבא:

    <DataGrid ItemsSource="{Binding Source={StaticResource addTorem},Path=Donations}" AutoGenerateColumns="False" >
                        <DataGrid.Columns>
                            <DataGridTextColumn Header="ID" IsReadOnly="True" Binding="{Binding IdDonation}" />
                            <DataGridTextColumn Header="שם התורם" Binding="{Binding Converter={StaticResource converterId}, Path=IdDonor}"/>
                        </DataGrid.Columns>
                    </DataGrid>
    

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

    <DataGrid ItemsSource="{Binding}" AutoGenerateColumns="False" >
    

    ובמקום זאת כתבתי בקוד כך:

    previewDonations.DataContext = AddTorem.donations;
    

    והכל עובד מצויין!!
    השאלה שלי מדוע זה לא עובד דרך הזאמל? הרי לכאו' מספיק לכתוב בזאמל את הבינדינג..

    תודה רבה!

    פורסם במקור בפורום CODE613 ב05/08/2015 15:34 (+03:00)

    ארכיון code613m

  • WPF: הפניה קבועה לעצם מחלון מסוים
    A avr416

    כתבתי בwindows.rescources את הקוד הבא:

    <local:AddTorem x:Key="addToremWindow" DataContext="{Binding Source={StaticResource addToremWindow}, Path=Donors}"/>
    

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

    פורסם במקור בפורום CODE613 ב05/08/2015 13:38 (+03:00)

    ארכיון code613m

  • WPF: שימוש בCompositeCollection עם בינידינג מורכב
    A avr416

    דוד תודה רבה על כל ניסיונות העזרה!!
    קודם כל הייתי צריך להוסיף הפניה למחלקה של Person בהגדרות של החלון (xmlns: וכו') ואח"כ בdataType יכלתי לבחור את הסוג הנ"ל והוא הפסיק לומר לי שהוא לא מכיר אותו..
    אבל עדיין אני לא מצליח לעשות זאת.. אם כי נראה לי שאני קצת מצליח לעלות על הכיוון לבעיה.
    כשאני כותב כך:

    <ComboBox>
    <ComboBox.ItemTemplate>
                                    <DataTemplate DataType="{x:Type Person:Donor}">
                                        <TextBlock>
                                            <Run Text="{Binding FirstName}"/>
                                            <Run Text="{Binding LastName}"/>
                                        </TextBlock>
                                    </DataTemplate>
                                </ComboBox.ItemTemplate>
                                <ComboBox.ItemsSource>
                                    <CompositeCollection>
                                        <ComboBoxItem Selected="ComboBoxItem_Selected">צור חדש...</ComboBoxItem>
                                        <CollectionContainer Collection="{Binding Source={x:Static local:AddTorem.donors}}"/>                                    
                                    </CompositeCollection>
                                </ComboBox.ItemsSource>                           
                            </ComboBox>
    

    אז הכל עובד מצויין!! ומלבד "צור חדש" אני מקבל את רשימת שמות שאר התורמים (שם פרטי+משפחה).
    אולם, הבעיה שלי היא שאני רוצה שכאשר המשתמש יבחר באחד מהתורמים זה ישמור את הID שלו כדי שזה ישמר בנתונים של התרומה החדשה שהוא מזין. ולכן בבינדינג קונקשיין אני רוצה להוסיף path=Id. אלא שכאשר אני מוסיף את זה אז הוא לא מציג לי שום דבר מלבד הערך "צור חדש". וכן אם אני כותב path=FirstName וכדו' אז אני מקבל מלבד הערך של צור חדש עוד רשימה עם תאים ריקים (שזה כבר התקדמות :lol: ) בדומה למה שתיארתי למעלה.
    נמצא שרק כאשר אני לא כותב לו path אז הוא עובד מצויין. אך מה זה שווה לי??
    לכן, השאלה שלי היא היכן אני עושה את הבינדינג לID האם יש מקום אחר? או שלעשות את זה בקוד כאשר הוא לוחץ על הלחצן "שמור תרומה"?
    תודה רבה!

    פורסם במקור בפורום CODE613 ב17/08/2015 18:13 (+03:00)

    ארכיון code613m

  • WPF: שימוש בCompositeCollection עם בינידינג מורכב
    A avr416

    @דוד ל.ט.

    אכן בעיה. מה שאני חושב זה לעשות בריסורס (של הקומבו, למשל) DataTemplate ללא Key, ובמאפיין הType שלו לשים את הסוג של הdonors.

    ניסיתי בכמה אפשרויות ולא הצלחתי..
    כשאני כותב כך:

    <ComboBoxItem Selected="ComboBoxItem_Selected">צור חדש...</ComboBoxItem>
                                        <CollectionContainer Collection="{Binding Source={x:Static local:AddTorem.donors}}"/>
    

    אז באמת הוא מציג לי בקומבו חוץ מ"צור חדש" גם עוד "person.donor" כמספר האובייקטים הקיימים.
    אולם ברגע אני מוסיף לבידינג גם path=Id אז משום מה לא מוצג כלום.. עוד לפני שאני מנסה לעשות את הבינדינג המורכב.. ולכן זה קצת מעורר בי תהיות שאולי כבר כאן יש לי בעיה.
    כמו כן, אם אני כותב path=FirstName אז הוא מציג לי את השם של המשתמש הראשון בלבד אך בצורה של רשימה, כלומר את "אברהם" הוא מציג "א" ובשורה מתחת "ב" וכן על זה הדרך. ואותו דבר בLastName.

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

    <ComboBox.Resources>
                                    <DataTemplate DataType="Id">
                                        <TextBlock>
                                            <Run Text="{Binding FirstName}"/>
                                            <Run Text="{Binding LastName}"/>
                                        </TextBlock>
                                    </DataTemplate>
                                </ComboBox.Resources>
    

    וזה לא עבד..
    שיניתי ל:
    <DataTemplate DataType="{x:Static local:AddTorem.donors}">
    ואז אני מקבל את הודעת השגיאה הנ"ל:
    All objects added to an IDictionary must have a Key attribute or some other type of key associated with them.
    ניסיתי גם כך (שזהו הנתיב המלא למאפיין ID)

    <DataTemplate DataType="{x:Static local:AddTorem.donors.Id}">
    

    וקיבלתי את ההודעה הנ"ל:

    addDonor.png

    מה לעשות :?: :?:
    תודה רבה!

    פורסם במקור בפורום CODE613 ב16/08/2015 17:10 (+03:00)

    ארכיון code613m

  • WPF: שימוש בCompositeCollection עם בינידינג מורכב
    A avr416

    ניסיתי עכשיו.. כתבתי כך:

    <ComboBox>                           
                                <ComboBox.ItemsSource>
                                    <CompositeCollection>
                                        <ComboBoxItem>צור חדש...</ComboBoxItem>
                                        <CollectionContainer Collection="{Binding Source={x:Static local:AddTorem.donors}, Path=Id}"/>                                    
                                    </CompositeCollection>
                                </ComboBox.ItemsSource>                           
                            </ComboBox>
    

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

    פורסם במקור בפורום CODE613 ב12/08/2015 18:33 (+03:00)

    ארכיון code613m

  • WPF: שימוש בCompositeCollection עם בינידינג מורכב
    A avr416

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

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

    הנה הקוד:

    <HeaderedContentControl Header="בחר תורם" >
                            <ComboBox>
                                <ComboBox.ItemsSource>
                                    <CompositeCollection>
                                        <ComboBoxItem>צור חדש...</ComboBoxItem>
                                        <CollectionContainer Collection="{Binding Source={StaticResource addToremWindow}path=Donors}"/>
                                    </CompositeCollection>
                                </ComboBox.ItemsSource>
                            </ComboBox>
                        </HeaderedContentControl>
    

    תודה רבה!!

    פורסם במקור בפורום CODE613 ב05/08/2015 13:17 (+03:00)

    ארכיון code613m

  • הגדרת תיקיית יעד
    A avr416

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

    sFD.InitialDirectory = @"C:\Users\Latitude E7240\Documents";
    

    אולם לכל אחד יש שם מחשב שונה, א"כ כיצד אני כותב את היעד באופן שהוא ידע למצוא באופן אוט' את הנתיב הנכון?
    תודה רבה!

    פורסם במקור בפורום CODE613 ב30/07/2015 12:29 (+03:00)

    ארכיון code613m

  • serilization לכל התוכנה
    A avr416

    הנה הקוד המלא של המחלקה אחרי כל התיקונים:

    public static class SerilizationAll
        {        
            //סריליזציה של כל התכנית
            public static void Serilization()
            {
                FolderBrowserDialog folderBrowser = new FolderBrowserDialog();
    
                if (folderBrowser.ShowDialog() == DialogResult.OK)
                {
                    string folder = folderBrowser.SelectedPath;
    
                    folder += @"\userData\data\";//מוסיף לנתיב תיקיית משנה לשמירת הנתונים
                    DirectoryInfo directoryInfo = new DirectoryInfo(folder);
                    directoryInfo.Create();//יוצר את ספריות המשנה
                                           //קורא למתודה שמבצעת את הסריליזציה  
                    Serialize(AddTorem.donations,folder+AddTorem.donations.GetType().GenericTypeArguments[0].Name);
                    Serialize(AddTorem.donors,folder+AddTorem.donors.GetType().GenericTypeArguments[0].Name);
                    Serialize(AddTorem.credits,folder+AddTorem.credits.GetType().GenericTypeArguments[0].Name);
                    Serialize(AddTorem.accounts,folder+AddTorem.accounts.GetType().GenericTypeArguments[0].Name);
                }
            }
            // מתודה גנרית לסריליזציה שמקבלת את סוג האובייקט והנתיב לשמירה
            private static void Serialize<T>(T obj,string path)
            {                        
                 using (FileStream fs = new FileStream(path, FileMode.Create))
                {
                    XmlSerializer donorXmlS = new XmlSerializer(typeof(T));
                    donorXmlS.Serialize(fs, obj);
                }            
            }
    
            //deserilization for all program
            public static void Deserilization()
            {
                FolderBrowserDialog folderBrowser = new FolderBrowserDialog();
                if (folderBrowser.ShowDialog() == DialogResult.OK)
                {
                    string folders = folderBrowser.SelectedPath;
                    folders += @"\userData\data\";//מוסיף לנתיב את הנתיב לתיקיית משנה בה קיימים הנתונים
                                                 //קורא למתודות שמבצעות את הסריליזציה על התיקייה שנבחרה
                 AddTorem.donors = Deserilization(AddTorem.donors, folders + AddTorem.donors.GetType().GenericTypeArguments[0].Name);
                 AddTorem.donations = Deserilization(AddTorem.donations, folders + AddTorem.donations.GetType().GenericTypeArguments[0].Name);
                 AddTorem.accounts = Deserilization(AddTorem.accounts, folders + AddTorem.accounts.GetType().GenericTypeArguments[0].Name);
                 AddTorem.credits = Deserilization(AddTorem.credits,folders+AddTorem.credits.GetType().GenericTypeArguments[0].Name);
                }
            }
    
           //מתודה גנרית לדיסריליזציה שמקבלת את סוג האובייקט והנתיב לפתיחה
            private static T Deserilization<T>(T returnObj,string path)
            {        
                using (FileStream fs = new FileStream(path, FileMode.Open))
                {
                    XmlSerializer xmlser = new XmlSerializer(typeof(T));
                    return returnObj= (T)xmlser.Deserialize(fs);                
                }
            }
        }
    }
    

    הקוד עושה אותו דבר, יותר יעיל והרבה הרבה יותר קצר!!
    תודה לכולם על כל העצות!!! אין על הפורום שלנו :lol: :lol:

    פורסם במקור בפורום CODE613 ב02/08/2015 16:32 (+03:00)

    ארכיון code613m

  • serilization לכל התוכנה
    A avr416

    @דוד ל.ט.

    תוכל גם במקום להקצות שם לקובץ אחד אחד להשתמש בשם הקלאס ע"י GetType().Name

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

    public static void Serialize<T>(T obj)
            {                        
                 using (FileStream fs = new FileStream(obj.GetType().Name, FileMode.Create))
                {
                    XmlSerializer donorXmlS = new XmlSerializer(typeof(T));
                    donorXmlS.Serialize(fs, obj);
                }       
            }
    

    אני מצרף כאן את כל הקבצים של התכנה.. אם זה יעזור למישהו..
    AppDonorNew.rar
    שכוייח!!

    פורסם במקור בפורום CODE613 ב02/08/2015 00:08 (+03:00)

    ארכיון code613m

  • serilization לכל התוכנה
    A avr416

    @רחמים

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

    צודק!! התכוונתי להשתמש..
    התבלבלתי במונח :lol: :lol:

    פורסם במקור בפורום CODE613 ב01/08/2015 23:20 (+03:00)

    ארכיון code613m

  • serilization לכל התוכנה
    A avr416

    @רחמים

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

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

    פורסם במקור בפורום CODE613 ב31/07/2015 16:39 (+03:00)

    ארכיון code613m

  • serilization לכל התוכנה
    A avr416

    @דוד ל.ט.

    אם זה לא קשה (זה כן) אז תגיד לי בדיוק איפה השגיאה ומה והאם היא בזמן כתיבה - קומפילציה, או זמן ריצה.

    דווקא לא קשה כי השגיאה בזמן כתיבה.
    הודעת השגיאה היא:
    (?Cannot implicitly convert type 'object' to 'T'. An explicit conversion exists (are you missing a cast

    פורסם במקור בפורום CODE613 ב31/07/2015 16:21 (+03:00)

    ארכיון code613m

  • serilization לכל התוכנה
    A avr416

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

    AddTorem.donors = Deserilization(AddTorem.donors, folders + fileDonor);
                 AddTorem.donations = Deserilization(AddTorem.donations, folders + fileDonation);
                 AddTorem.accounts = Deserilization(AddTorem.accounts, folders + fileBank);
                 AddTorem.credits = Deserilization(AddTorem.credits, folders + fileCredit);
    

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

    ארכיון code613m

  • serilization לכל התוכנה
    A avr416

    @דוד ל.ט.

    תוכל גם במקום להקצות שם לקובץ אחד אחד להשתמש בשם הקלאס ע"י GetType().Name

    תיזהר פעם הבאה שאתה מבקש עצות, סכנת הצפה 🙂

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

    @רחמים

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

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

    תודה רבה רבה על כל העצות!! מה הייתי עושה בלעדיכם :lol:

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

    ארכיון code613m

  • serilization לכל התוכנה
    A avr416

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

    כתבתי את הקוד הבא: (אזהרה - קצת ארוך :lol: )

    public static class SerilizationAll
        {
            //סריליזציה של כל התכנית
            public static void Serilization()
            {
                FolderBrowserDialog folderBrowser = new FolderBrowserDialog();
    
                if (folderBrowser.ShowDialog() == DialogResult.OK)
                {
                    string folder = folderBrowser.SelectedPath;
    
                    folder += @"\userData\data";//מוסיף לנתיב תיקיית משנה לשמירת הנתונים
                    DirectoryInfo directoryInfo = new DirectoryInfo(folder);
                    directoryInfo.Create();//יוצר את ספריות המשנה
                    serilizationList(folder);//קורא למתודה שמבצעת את הסריליזציה                
                }
            }
            //סריליזציה של כל הליסטים מקבלת את הערך של התיקייה לשמירת הנתונים
            public static void serilizationList(string folder)
            {
                //יוצר את שמות הקבצים עבור כל הליסטים
                string fileDonor = folder;
                string fileDonation = folder;
                string fileCredit = folder;
                string fileBank = folder;
                fileDonor += @"\donorList";
                fileDonation += @"\donationList";
                fileCredit += @"\creditCardList";
                fileBank += @"\bankAccountList";
                //יוצר אובייקטים המקבלים את רשימות הליסטים הקיימים בתוכנית
                var donationObject = AddTorem.donations;
                var donorsObject = AddTorem.donors;
                var creditObject = AddTorem.credits;
                var bankObjects = AddTorem.accounts;
                //סריאליזציה עבור כל ליסט לקובץ נפרד
                using (FileStream fs = new FileStream(fileDonor, FileMode.Create))
                {
                    XmlSerializer donorXmlS = new XmlSerializer(typeof(List<Donor>));
                    donorXmlS.Serialize(fs, donorsObject);
                }
                using (FileStream donatStr = new FileStream(fileDonation, FileMode.Create))
                {
                    XmlSerializer donationXmlS = new XmlSerializer(typeof(List<Donation>));
                    donationXmlS.Serialize(donatStr, donationObject);
                }
                using (FileStream creditStream = new FileStream(fileCredit, FileMode.Create))
                {
                    XmlSerializer creditXmlS = new XmlSerializer(typeof(List<CreditCard>));
                    creditXmlS.Serialize(creditStream, creditObject);
                }
                using (FileStream bankStream = new FileStream(fileBank, FileMode.Create))
                {
                    XmlSerializer bankXMLs = new XmlSerializer(typeof(List<BankAccount>));
                    bankXMLs.Serialize(bankStream, bankObjects);
                }
            }
            //deserilization for all program
            public static void Deserilization()
            {
                FolderBrowserDialog folderBrowser = new FolderBrowserDialog();
                if (folderBrowser.ShowDialog() == DialogResult.OK)
                {
                    string folders = folderBrowser.SelectedPath;
                    folders += @"\userData\data";//מוסיף לנתיב את הנתיב לתיקיית משנה בה קיימים הנתונים
                   //קורא למתודות שמבצעות את הסריליזציה על התיקייה שנבחרה ומציב את הערך שמתקבל בליסטים הקיימים בתכנית
                    AddTorem.donors=  DeserilizationDonor(folders);
                   AddTorem.donations = DeserilizationDonation(folders);
                   AddTorem.credits = DeserilizationCreditCard(folders);
                   AddTorem.accounts = DeserilizationBankAccount(folders);
                }
            }
    
            private static List<BankAccount> DeserilizationBankAccount(string folders)
            {
                string fileBank = folders;
                fileBank += @"\bankAccountList";//בוחר בקובץ הדרוש
                var myObject = new List<BankAccount>();
                using (FileStream fs = new FileStream(fileBank, FileMode.Open))
                {
                    XmlSerializer xmlser = new XmlSerializer(typeof(List<BankAccount>));
                    myObject = (List<BankAccount>)xmlser.Deserialize(fs);
                    return myObject;
                }
            }
    
            private static List<CreditCard> DeserilizationCreditCard(string folders)
            {
                string fileCredit = folders;
                fileCredit += @"\creditCardList";
                var myObject = new List<CreditCard>();
                using (FileStream fs = new FileStream(fileCredit, FileMode.Open))
                {
                    XmlSerializer xmlser = new XmlSerializer(typeof(List<CreditCard>));
                    myObject = (List<CreditCard>)xmlser.Deserialize(fs);
                    return myObject;
                }
            }
    
            private static List<Donation> DeserilizationDonation(string folders)
            {
                string fileDonation = folders;
                fileDonation += @"\donationList";
    
                var myObject = new List<Donation>();
                using (FileStream fs = new FileStream(fileDonation, FileMode.Open))
                {
                    XmlSerializer xmlser = new XmlSerializer(typeof(List<Donation>));
                    myObject = (List<Donation>)xmlser.Deserialize(fs);
                    return myObject;
                }
            }
            private static List<Donor> DeserilizationDonor(string folders)
            {
                string fileDonor = folders;            
                fileDonor += @"\donorList";
                var myObject = new List<Donor>();
                using (FileStream fs = new FileStream(fileDonor, FileMode.Open))
                {
                    XmlSerializer xmlser = new XmlSerializer(typeof(List<Donor>));
                    myObject = (List<Donor>)xmlser.Deserialize(fs);
                    return myObject;
                }
            }
        }
    

    הכל עובד חלק!!! תודה רבה על העזרה והתמיכה!!
    השאלה שלי היא האם אי אפשר לייעל את זה, כיון שבסוף נאלצתי לכתוב מתודה נפרדת לפתיחת כל ליסט. האם אי אפשר לכתוב מתודה גנרית שתדע לזהות לבד את הערך של כל ליסט הנשלח אליה ולחלץ אותו?
    בטח זה אפשרי, אבל לא הצלחתי.. ניסיתי לכתוב במתודה List<T> אבל זה לא הצליח לי.. אז נאלצתי לכתוב 4 מתודות שבעצם עושות אותו דבר..

    פורסם במקור בפורום CODE613 ב30/07/2015 15:50 (+03:00)

    ארכיון code613m

  • serilization לכל התוכנה
    A avr416

    @רחמים

    יש את זה Windows.Forms.FolderBrowserDialog זה לא נכלל בברירת מחדל ב WPF אלא בוינפורמס
    אתה גם יכול ליצור לבד, למה לא אני בעד.

    יש אפשרות לעשות לזה רפרנס מWPF? כי לא הצלחתי..

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

    פורסם במקור בפורום CODE613 ב30/07/2015 14:22 (+03:00)

    ארכיון code613m

  • serilization לכל התוכנה
    A avr416

    @ClickOne

    כמה פשוטים חייהם של מי שכותב עם DB.

    אני מניח שאתה רק רוצה ללמוד איך עובדים עם קבצים + serilization.
    כי אם לא, אני עדיין חושב שיהיה לך יותר קל לחזור / לעבור לDB

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

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

    ארכיון code613m

  • serilization לכל התוכנה
    A avr416

    אני ממש בור בנושא הזה, ולכן יש לי כמה שאלות פשוטות, אבל אני מסתבך בזה כבר הרבה זמן..
    @רחמים

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

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

    אם אתה דווקא רוצה לתת לו לבחור, תן לו לבחור תיקיה שבה ישמרו כל הגדרות המשתמש שלו

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

    בכל אופן תיצור תיקייה של יוזר-דטה כנל ובתוכה עוד תיקיה של 'נתונים'

    למה ליצור שתי תיקיות של נתונים?
    תודה רבה רבה!

    פורסם במקור בפורום CODE613 ב30/07/2015 12:55 (+03:00)

    ארכיון code613m

  • serilization לכל התוכנה
    A avr416

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

    פורסם במקור בפורום CODE613 ב30/07/2015 10:24 (+03:00)

    ארכיון code613m

  • serilization לכל התוכנה
    A avr416

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

    public static void SaveDonorsOfXml(string fileName, List<Donation> donats)//serialization of XML
            {
                var myObject = donats;
                using (FileStream outStream = new FileStream(fileName, FileMode.Create))
                {
                    XmlSerializer xmlser = new XmlSerializer(typeof(List<Donation>));
                    xmlser.Serialize(outStream, myObject);
                }
            }
    

    אולם, מה אעשה כשאני צריך לעשות זאת למס' ליסטים (רשימה של התורמים והתרומות ופרטי האשראי וכו')?
    האם לשלוח למתודה את כל הליסטים, ואח"כ להפעיל את הפונקציה:

    XmlSerializer xmlser = new XmlSerializer(typeof(List<Donation>));
    

    על כל אחד בנפרד ואז לשלוח לקובץ ע"י המתודה הבאה:

    xmlser.Serialize(outStream, myObject);
    

    אך השאלה האם זה לא ידרוס לי את הנתונים שנשמרו בו בקריאה הקודמת אליו (דהיינו בשורה הקודמת שקראתי לו..) שהרי אני רוצה לשמור את כל הנתונים בקובץ אחד?
    תודה רבה!
    השאלה הנ"ל נכונה גם לגבי סליזציה לבינארי..

    פורסם במקור בפורום CODE613 ב30/07/2015 00:18 (+03:00)

    ארכיון code613m
  • 1
  • 2
  • 40
  • 41
  • 42
  • 43
  • 44
  • 50
  • 51
  • 42 / 51
  • התחברות

  • אין לך חשבון עדיין? הרשמה

  • התחברו או הירשמו כדי לחפש.
  • פוסט ראשון
    פוסט אחרון
0
  • דף הבית
  • קטגוריות
  • פוסטים אחרונים
  • משתמשים
  • חיפוש
  • חוקי הפורום