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

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

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

dovid

@dovid
ניהול
אודות
פוסטים
10.4k
נושאים
186
שיתופים
0
קבוצות
2
עוקבים
33
עוקב אחרי
0

פוסטים

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

  • Column מותאם אישית בהורשה מ DataGridTemplateColumn
    dovidD dovid

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

    אז בסוף פתחתי את הרפלקטור כדי לראות בדיוק איך נוצרים התאים ובאיזה רמה הקונקסט/בינדינג מוזרקים.
    והמסקנה היא כזו מחלקה:

    Public Class DataGridActiveColumn
        Inherits DataGridBoundColumn
    
        Protected Overrides Function GenerateEditingElement(cell As DataGridCell, dataItem As Object) As FrameworkElement
            Return Nothing
        End Function
    
        Protected Overrides Function GenerateElement(cell As DataGridCell, dataItem As Object) As FrameworkElement
            If Binding IsNot Nothing Then
                BindingOperations.SetBinding(cell, DataGridCell.DataContextProperty, Binding)
            End If
            Return Nothing
        End Function
    End Class
    

    הנה הדגמה:

    <Grid>
        <Grid.Resources>
            <Style TargetType="DataGridCell" >
                <Style.Setters>
                    <Setter Property="Template" >
                        <Setter.Value>
                            <ControlTemplate>
                                <Grid Height="50" Width="50" >
                                    <Path Data="M -1,0 A 1,1 0 1 1 1,0 M -1,0 A 1,1 0 1 0 1,0" Stretch="Fill"  >
                                        <Path.Style>
                                            <Style TargetType="Path">
                                                <Style.Triggers>
                                                    <DataTrigger Binding="{Binding}" Value="1">
                                                        <Setter Property="Fill" Value="Yellow" />
                                                    </DataTrigger>
                                                    <DataTrigger Binding="{Binding}" Value="0">
                                                        <Setter Property="Fill" Value="Green" />
                                                    </DataTrigger>
                                                    <DataTrigger Binding="{Binding}" Value="2">
                                                        <Setter Property="Fill" Value="Red" />
                                                    </DataTrigger>
                                                </Style.Triggers>
                                            </Style>
                                        </Path.Style>
                                    </Path>
                                </Grid>
                            </ControlTemplate>
                        </Setter.Value>
                    </Setter>
                </Style.Setters>
            </Style>
        </Grid.Resources>
        <DataGrid  >
            <DataGrid.Items>
                <Button Width="0"/>
                <Button Width="1" />
                <Button Width="2" />
            </DataGrid.Items>
            <DataGrid.Columns>
                <local:DataGridActiveColumn Binding="{Binding Width}" />
            </DataGrid.Columns>
        </DataGrid>
    </Grid>
    

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

    ארכיון code613m

  • Column מותאם אישית בהורשה מ DataGridTemplateColumn
    dovidD dovid

    יש לך כמה וכמה טעויות.
    דבר ראשון, גם אם היה עובד לך בלי שגיאות, הCellTemplate שטרחת לכתוב לא היה חל על המופע שיצרת בXAML. כלומר בכל פעם שהיית מכריז על הmy:DataGridActiveColumn היית חייב לכתוב בפירוש שוב את כל הטמפלט שכתבת תחת המאפיין CellTemplate. למה? כי הXAML שעשית זה מופע, זה לא חלק מהגדרת האובייקט.
    דבר שני - טיפ'לה מסובך: הBinding בגוף העמודה, לא מתייחס לרמת השורה! כלומר אתה מניח שעבור כל שורה הWPF מחפש אחר מאפיין IsCurrent באובייקט הנוכחי - זה של השורה הזו. אבל זו טעות! כי הרי האובייקט DataColumn לא נוצר בכל שורה. הוא קיים רק ברמת הטבלה. אלא שעל פיו נוצרים תאים כפי מה שהוגדר בטמפלט. זהו. כעת הטמפלט חופשיה לקחת מההקשר ברמת השורה, רק שאצלך הטמפלט נשען על ההקשר של כל העמודה (שיש רק אחד בכל הטבלה, לא אחד לכל שורה!).
    נשאלת השאלה, אז איך עובד המאפיין Binding שעשו מיקרוסופט לעמודות כמו DataGridTextColumn? אז זהו שזה טריקי, ובעצם הם "מעתיקים" את הבינדינג לטמפלט - רמת השורה. אבל לך הכי פשוט זה לעשות את הבינדינג ישירות ברמת הטמפלט.
    דבר שלישי - לכאורה, אתה בכלל לא צריך ליצור קלאס משלך. אולי יש לך סיבה שלא ביטאת באשכול כאן, אבל לפי הנתונים כאן, אתה סה"כ צריך להשתמש בטמפלט.

    לסיכום:
    א. בנוגע לעיצוב, אתה חייב לעבוד עם סטייל/טמפלט. אין כזה דבר (יש אבל עזוב :)) עיצוב ברמת המחלקה. ממילא את כל הCellTemplate שים בResource של האפליקציה/חלון וכדומה, ותאגד לעמודה שלך ע"י StaticReaource.
    ב. את הבינדינג לIsCurrent תעשה אך ורק בטמפלט בלי "גשרים". במקום לאגד את הטריגר שלך למאפיין שמאוגד למקור, אגד את הטריגר ישירות לIsCurrent.
    ג. שקול אם בכלל ליצור DataColumn משלך. לכאורה זה מיותר. אם יש לך סיבה מאוד כדאי שתתייעץ גם על זה כי אני ב99.99% שאין צורך. במידה וכן, עשה זאת בלי שום XAML. סתם מחלקה רגילה, עם הצהרת ירושה. כל העסק של הסטייל תעשה עם סטיילים/טמפלטים כמבואר.

    הנה דוגמה קלילה להמחשה. במקום מקור נתונים של שמתי אוסף בItems. השמשתי בButton סתם בתור מחלקה כל שהיא. במקום IsCurrent (שאינו קיים במחלקה Button...) השתמשתי בWidth.
    הנה, אתה יכול להדביק אצלך ולראות איך זה:

    <Grid>
        <Grid.Resources>
            <DataTemplate x:Key="MyTemplate">
                <Grid  Width="50" Height="50">
                    <Path Data="M -1,0 A 1,1 0 1 1 1,0 M -1,0 A 1,1 0 1 0 1,0" Stretch="Fill" >
                        <Path.Style>
                            <Style TargetType="Path">
                                <Setter Property="Fill" Value="Blue" />
                                <Style.Triggers>
                                    <DataTrigger Binding="{Binding Width}" Value="1">
                                        <Setter Property="Fill" Value="Yellow" />
                                    </DataTrigger>
                                    <DataTrigger Binding="{Binding Width}" Value="0">
                                        <Setter Property="Fill" Value="Green" />
                                    </DataTrigger>
                                    <DataTrigger Binding="{Binding Width}" Value="-1">
                                        <Setter Property="Fill" Value="Red" />
                                    </DataTrigger>
                                </Style.Triggers>
                            </Style>
                        </Path.Style>
                    </Path>
                </Grid>
            </DataTemplate>
        </Grid.Resources>
        <DataGrid  >
            <DataGrid.Items>
                <Button Width="0"/>
                <Button Width="1" />
                <Button Width="0" />
            </DataGrid.Items>
            <DataGrid.Columns>
                <DataGridTemplateColumn CellTemplate="{StaticResource MyTemplate }" />
            </DataGrid.Columns>
        </DataGrid>
    </Grid>
    

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

    ארכיון code613m

  • הוספת מאפינים לקובץ ע"י קוד C#
    dovidD dovid

    אני חושב שאין כזה דבר הוספה דינמית, אתה חייב להשתמש במאפיין קיים.
    חיפשתי באינטרנט איך עושים בc# מצאתי את זה
    http://wiki.terrasynq.net/tutorials/c-add-and-edit-ntfs-custom-properties/

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

    ארכיון code613m

  • התערבות ב- AutoGenereted Code של EF
    dovidD dovid

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

    1. אתה פותח את הקובץ בעל הסיומת tt

    2. מחפש את השורה הזו:

      if (propertiesWithDefaultValues.Any() || collectionNavigationProperties.Any() || complexProperties.Any())

    3. מחליף אותה בזו:

      if (true)

    4. שתי שורות אחרי כן, אחרי השורה עם הסימן "#<", אתה מוסיף שורה זו:

      partial void OnInit();
      זו הצהרה על מתודה חלקית (ניתנת להרחבה בקובץ אחר בפרוייקט).

    5. שתי שורות אחרי כן, אחרי תחילת המתודה הזו public <#=code.Escape(entity)#>(), אתה מוסיף שורה זו:

      OnInit();
      זו קריאה למתודה שיצרנו.

    6. בקובץ כלשהו בפרוייקט אתה חייב ליישם את גוף המתודה OnInit, משהו כזה:

      public partial class EntityNameHer...
      {
      partial void OnInit()
      {
      ...
      }
      }

    נ.ב. אתה יכול להשתמש עם אירוע במקום עם מתודה, ובלי partial.
    בשביל זה יש לשנות בצעדים דעיל' ובמקום שיראה ככה:

    if (true)
        {
    #>
        partial void OnInit();
     
        public <#=code.Escape(entity)#>()
        {
            OnInit();
    

    צריך להיות ככה:

    if (true)
        {
    #>
        public event Action<<#=code.Escape(entity)#>> OnInit;
    
        public <#=code.Escape(entity)#>()
        {
    		if (OnInit!=null) OnInit(this);
    

    ובקוד שלך בזמן כל שהוא בטעינת התוכנה אתה מוסיף אירוע ככה:

    Item.OnInit += Item_OnInit;
    

    הItem זה שם הישות.
    בטיפול באירוע אתה מאתחל מה שאתה רוצה.

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

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

    ארכיון code613m

  • התערבות ב- AutoGenereted Code של EF
    dovidD dovid

    @tchayim

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

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

    עריכה:
    זה קצת שונה מהפשטות בלינק דלעיל, הקוד המקורי נראה משהו כזה:

    if (propertiesWithDefaultValues.Any() || collectionNavigationProperties.Any() || complexProperties.Any())
        {
    #>
        public <#=code.Escape(entity)#>()
    ...
    

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

    if (true)
        {
    #>
    	partial void OnInit();
    
        public <#=code.Escape(entity)#>()
        {
    		OnInit();
    

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

    ארכיון code613m

  • התערבות ב- AutoGenereted Code של EF
    dovidD dovid

    אני מבין שמדובר בModel First או Db First.
    זאת אומרת הפרויקט שלך מכיל קובץ בשם edmx, ועל פיו נוצרים בזמן קמפול כל המחלקות. והשאלה באמצעות איזה כלי זה נעשה. בכלים הישנים זה היה יוצר מחלקות היורשות כולם מEntityObject ובכלים החדשים זה יוצר POCO - מחלקות רגילות לגמרי שלא יורשים מכלום.
    בדוק את חתימת המחלקה שנוצרת אוטומטי, היא מכילה ירושה מEntityObject?
    בכל אופן יש לך מגוון דרכים.

    1. partial class
      כמו שsoft אמר, תוכל ליצור בפרויקט מחלקה ששמה כשם הישות, עם הציון partial, ואז אתה בעצם כאילו כותב קוד במחלקה המקורית רק שקוד זה לא יידרס. soft כתב שעדיין לא תוכל להרחיב את הConstructor, מכיון שזה לא נתמך בינתיים. אציין רק שלעיתים אין בכלל קונסטרקטור בקוד האוטומטי (הסיבה שיש בפעמים אחרות זה בשביל הDefaultValue ואיתחול הCollectionים) וא בהחלט אפשר לכתוב Constructor במחלקה אותה ציינת כpartial.
      בקשר לOnCreate: אני לא יודע לאיזה מתודה התכוון soft, אם היא אכן קיימת זה מצויין לדרוס אותה בירושה או בpartial.

    2. DefaultValue:
      אם לא מדובר בלוגיקה אלא סתם ערך סטטי פשוט, אז יש בסכמת הedmx אפשרות ששמה Default Value. היא איננה מקבלת ערך בחלון העיצוב, אבל אם תיכנס לXML ע"י קליק ימני וOpen With > XML Edtor תוכל לאתר את המאפיין בקובץ ולהוסיף לו "DefaultValue" הנה לדוגמה מאפיין Name שמעתה יכיל בעת יצירתו ערך 123:

      <Property Name="Name" DefaultValue="123" Type="String" Nullable="false" />
      בקוד שנוצר אוטומטי ישנה הצבה של הערך בתוך מתודת הConstructor.

    3. ירושה - של הישות:
      שים לב שהמופעים של הישויות נוצרים בשתי דרכים: או אוטומטי ע"י הEF בעת טעינה מהDB, או ע"י קוד שלך לשם רשומות חדשות. אם הערך האוטומטי הוא בשביל רשומות חדשות, די אם תירש מהמחלקה כמו שהציע soft. זה ממש פשוט, אתה יוצר מחלקה כזו בכל מקום בפרוייקט שלך. נניח לישות שלך קוראים User, אז הנה במחלקה היורשת:

      public class UserCustomize : User
      {
      public UserCustomize()
      {
      //yoyr code.
      }
      }
      ואז במקום כזה קוד:

      var user = new User();
      db.UserSet.Add(user);
      אתה משתמש בתת המחלקה שיצרת, UserCustomize:

      var user = new UserCustomize();
      db.UserSet.Add(user);

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

      public partial class ModelContainer
      {
      public override int SaveChanges()
      {
      var changedEntities = ChangeTracker.Entries();

           foreach (var changedEntity in changedEntities)
           {
               if (changedEntity.State == EntityState.Added)
               {
                   if (changedEntity.Entity is User)     //בודק שמדובר בישות המתאימה
                   {
                       var user = (User)changedEntity.Entity;
                       user.DateCreate = DateTime.Now;   //הערך להצבה
                   }
                   /*  else if (changedEntity.Entity is ...   // פה טיפול בישויות מסוג אחר אם צריך
                       else if (changedEntity.Entity is ...   */
               }
           }
      
           return base.SaveChanges();
       }
      

      }

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

    ארכיון code613m

  • שגיאה בשיאלתת אקסס
    dovidD dovid

    אכן בשאילתת הצלבות חייבים להכריז במפורש על פרמטרים, ראה: https://support.office.com/en-us/article/Make-summary-data-easier-to-read--by-using-a-crosstab-query-8465b89c-2ff2-4cc8-ba60-2cd8484667e8?ui=en-US&rs=en-US&ad=US#bm7
    והנה איך זה נראה בSQL: http://stackoverflow.com/a/1153467/1271037

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

    ארכיון code613m

  • שגיאה בשיאלתת אקסס
    dovidD dovid

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

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

    ארכיון code613m

  • INotifyCollectionChanged עם - DataGrid WPF
    dovidD dovid

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

    1. כשנכנסים לשורה חדשה בDataGrid המחובר למקור נתונים, הDataGrid יוצר מייד אובייקט מהסוג המתאים ומוסיף אותו למקור הנתונים, עוד לפני עדכון שום תא.
    2. כאשר מעדכנים תאים בכל שורה שהיא, אף שאובייקט השורה מממש PropertyChanged הוא לא מוזנק, עד יציאה מהשורה אז מופעל האירוע על כל שדה ושדה (כלומר כמס' השדות).
      התנהגות זו ניתנת לעקיפה בכמה דרכים, ניתן לחפש בגוגל "wpf datagrid cell cell update ~immediately".

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

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

    ארכיון code613m

  • חדשות: התקן החדש של JS, המכונה ES6
    dovidD dovid

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

    יש המון על כך ברשת, הנה מקורות שמצאו חן בעיני:
    ECMAScript 6 – New language improvements in JavaScript
    ECMAScript 6 – New Objects and Updates to Existing Objects

    ECMAScript 6 support in Mozilla
    https://github.com/lukehoban/es6feature

    תמיכה בדפדפנים:
    http://kangax.github.io/compat-table/es6/
    http://www.webbrowsercompatibility.com/es6/desktop/

    הרצה אונליין:
    http://www.es6fiddle.net/

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

    ארכיון code613m

  • חסימה מוחלטת באקסס של כל קיצורי המקשים
    dovidD dovid

    ClickOne, המדובר הוא אחרי הרצת התוכנה, שלא יוכלו לגשת לשום מקום במחשב מלבד חלון האקסס שיכלול (להבנתי) פקד דפדפן אינטרנט.
    צריך לחסום הן (1) קיצורי אקסס כמו ALT+F11 וגם (2) קיצורי מערכת ההפעלה (לחצן WIN, ALT+TA, ועוד כמאה צרופים.

    לדבר הראשון זה קל יחסית נדמה לי ע"י אירוע Application.OnKey.
    הדבר השני לא יודע.

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

    ארכיון code613m

  • טיפ: WPF - Binding Refresh By INotify Externaly
    dovidD dovid

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

    [u:23o4st2z]הקדמה:[/u:23o4st2z]
    כידוע הBinding של WPF עשויים להתעדכן בברירת מחדל ע"י הממשק INotifyPropertyChanged.
    כלומר המחלקה שאליה הBinding מאזין, אם היא מממשת את הממשק הנ"ל + מפעילה בעת עדכון (בדרך כלל, בSet של הProperty), הBinding ישנה באלגנטיות וביעילות את תוכנו של מאפיין היעד.

    אבל...
    א. מאוד מעצבן לכתוב בכל SET את הפעלת האירוע של PropertyChanged. זה ממש לכלוך בעיניים בצד הלוגיקה, שקשורה לצד התצוגה. נכון, לפי מודל הMVVM צריך ליצור מחלקה עוטפת למחלקת הלוגיקה שממנה התצוגה תשאב, והיא זו שצריכה לטפל בGet וSet של כל מאפיין, אבל זה כאב ראש עוד יותר גדול.
    ב. הרבה פעמים המתכנת מתכנן מראש את עת העדכון של מאפיין, כך שזה מגוחך שהוא צריך ליצור אירוע גלובלי. נניח יש חלון שכתוב שם פרטים, ויש אפשרות עדכון. אחרי העדכון הפרטים צריכים להתאים לערכים החדשים. זה מקרה בו המתכנת יודע בזמן הכתיבה בדיוק מתי דרוש לעדן, ומצידו לוותר על שכלול המעקב אחרי שינויים במאפיין ופשוט לבצע ריפרוש ידני בסגנון Binding.Update. או גרוע יותר: TextBox1.Text = NewValue.

    אחרי המחלקה שאציג, הקוד יראה ככה:

    someObject.SomeProperty = 150;
    //כאן דרוש עדכון... בתצוגה
    someObject.ExePropChange();
    //או
    someObject.ExePropChange(new string[] { "SomeProperty" });
    

    [u:23o4st2z]תמצית:[/u:23o4st2z]
    המחלקה בקוד להלן, היא מחלקת הבסיס של כל המחלקות שיש לי בפרוייקט. מכל מקום בו אני יודע שדרוש עדכון, אני קורא חיצונית למחלקה בה השינוי התבצע, ו"מבקש" ממנה להפעיל את PropertyChanged. למתודה שני גירסאות - אחת מפעילה את כל המאפיינים, והשניה מקבלת רשימה.

    [u:23o4st2z]קוד:[/u:23o4st2z]

    public abstract class EnableExtNotify : INotifyPropertyChanged
    {
        public static Dictionary<Type, string[]> dic = new Dictionary<Type, string[]>();
    
        public EnableExtNotify()
        {
            var t = GetType();
            if (!dic.ContainsKey(t))
                dic[t] = t.GetProperties().Select(x => x.Name).ToArray();
        }
    
        public void ExePropChange()
        {
            ExePropChange(dic[GetType()]);
        }
    
        public void ExePropChange(string[] arr)
        {
            if (PropertyChanged != null)
                foreach (var item in arr)
                    PropertyChanged(this, new PropertyChangedEventArgs(item));
        }
    
        public event PropertyChangedEventHandler PropertyChanged;
    }
    

    פורסם במקור בפורום CODE613 ב22/02/2015 18:41 (+02:00)

    ארכיון code613m

  • range Overlap range SQL
    dovidD dovid

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

    select r1.id as id1 , r2.id as id2 from
    @range1 r1, @range2 r2
    WHERE r2.fromyear between r1.fromyear and r1.toyear 
       OR r2.toyear between r1.fromyear and r1.toyear
    

    ככה נראה לי.

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

    ארכיון code613m

  • range Overlap range SQL
    dovidD dovid

    INNER JOIN עושה את העבודה הזאת ללא WHERE.

    רק שכאן אין מפתח להשוות אלא ביטוי שזה לא נתמך בON נראה לי, אז פשוט WHERE מסובך 🙂

    פורסם במקור בפורום CODE613 ב17/02/2015 21:54 (+02:00)

    ארכיון code613m

  • להריץ פקודת Run דרך קוד (עדיף vba)
    dovidD dovid

    מאוד משונה, אבל ככה חייב לעבוד: C:\windows\system32\wfs.exe.
    לא הבנתי את ה"שרת מרכזי".

    פורסם במקור בפורום CODE613 ב18/02/2015 13:33 (+02:00)

    ארכיון code613m

  • איזו שפה מאפשרת?
    dovidD dovid

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

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

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

    ארכיון code613m

  • איך המחשב קורא את הביטים בזכרון?
    dovidD dovid

    @mat

    הוא שאל למה מערכת הפעלה של 32 ביט לא יכולה לקרוא יותר מ4 גיגה זיכרון. +-

    יאהוו. כמה רחוק ממה שחשבתי.

    "מע' 32 בית", חשבתי מערך. ובית צריך להיות ביט (סיבית).
    אבל זה "לדוגמא 32 ביתים בשרשור יכול להכיל ערך עד 4 מליארד." אני כבר לגמרי לא מבין איך זה נכנס לנושא.

    חוץ מזה העובדה שמערכת WIN32 לא מסוגלת היא לא הנחה שצריכה להיות ברורה כ"כ לכל מתכנת שיקרא את השאלה.

    בקיצור, אהרון, הבנת...

    פורסם במקור בפורום CODE613 ב16/02/2015 15:21 (+02:00)

    ארכיון code613m

  • איך המחשב קורא את הביטים בזכרון?
    dovidD dovid

    @אהרן

    לא ברור לי האם גודל הזכרון זה כמות בתים (* 8 ביטים) ממשיים או ערך מקסימלי שהוא יכול לאגור בתוכו.

    לדוגמא 32 ביתים בשרשור יכול להכיל ערך עד 4 מליארד.
    אז מדוע מע' 32 בית יכול לקרוא זכרון "באורך" 4 מליארד בתים?
    כלומר, מדוע זה תלוי אחד בשני? איך זה עובד?

    לא הבנתי לגמרי את השאלות.
    אם השאלה שלך האם הזיכרון מאוכלס או רק תפוס, זה למעשה בדיוק אותו הדבר. זיכרון תפוס זה שריון של זיכרון עבור משתנה כאשר המשתנה פשוט "מראה" את מה שכתוב במקום שנתפס עבורו.
    משתנה מסוג int בשפת C במערכת 32 סיביות, מקבל 32 סיביות רציפים במקום כל שהוא בזיכרון כאשר התוכן שמה הוא "זבל".
    מס' הויראציות של כיבוי/הדלקה ב32 "נורות", זה הנוסחה 2 (כיבוי והדלקה) בחזקת 32 (-1 כי זה אפס) = 4,294,967,296.
    זה לא מובן הביטוי "יכול לקרוא" הוא יכול להכיל מבחינת הקומבינות שתעשה בו - להדליק הכל לכבות הכל וכו', את מס' האפשרויות הזה, וזה מנוצל כע"י המחשב כאשר אתה מורה לו הצבת מספר עשרוני במשתנה INT.

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

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

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

    ארכיון code613m

  • רשימת דיסקים עם הרשאת כתיבה
    dovidD dovid

    משונה לי מאוד הרשאות כתיבה בתיקייה אמורים לכלול יצירת קבצים חדשים. בכל מקרה אני הייתי נשכב על הכביש ולא עושה כזה דבר: לכתוב קובץ ולמחוק רק בשביל לבדוק? נורא. 😞 .

    אם אתה שותף לתחושה הרעה שלי ), בדוק אולי את הקוד הזה: http://stackoverflow.com/a/1281638/1271037

    פורסם במקור בפורום CODE613 ב10/02/2015 19:01 (+02:00)

    ארכיון code613m

  • רשימת דיסקים עם הרשאת כתיבה
    dovidD dovid

    אכן. חיפשתי בגוגל: C# user has directory write permission

    והתוצאות - הדרך הקלאסית זה ללכוד שגיאת הרשאה...
    אז הנה הקוד שלכאורה עושה את זה, צריך לבדוק.

    static void Main(string[] args)
    {
        foreach (var drive in DriveInfo.GetDrives())
        {
            Console.WriteLine("{0} : {1}", drive.Name,  CheckDriveForWrite(drive));
        }
        Console.ReadLine();
    }
    
    static DriveType[] drivesToIngorn = new DriveType[] { DriveType.CDRom, DriveType.Network, DriveType.NoRootDirectory }; 
    
    public static bool CheckDriveForWrite(DriveInfo d)
    {
        return (d.IsReady && !drivesToIngorn.Contains(d.DriveType) && HasFolderWritePermission(d.RootDirectory));
    }
    
    public static bool HasFolderWritePermission(DirectoryInfo destDir)
    {
        try
        {
            var ds = destDir.GetAccessControl();
            return true;
        }
        catch (UnauthorizedAccessException)
        {
            return false;
        }
    }
    

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

    ארכיון code613m
  • 1
  • 2
  • 478
  • 479
  • 480
  • 481
  • 482
  • 518
  • 519
  • 480 / 519
  • התחברות

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

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