Entity framework supports creating an entity type that holds binary data (byte[]), this is useful if you need your entity to hold things like file streams, photos etc.

But there is a problem when your entity has a property of type binary.

If you’ve worked with EF and N-tier applications, you know that you can serialize your entity and pass it to the client, deserialize it the client-side, change it and the send it to the server to be updated.

MS suggests using the ApplyPropertyChanges method of the ObjectContext to apply the changes made to the entity onto the current entity, thus making sure that no unnecessary updates will run in the DB unless something has changed in the entity.

The way the method does this is simply by comparing each property with its original value (call the Equals method on both properties) – this works for almost every primitive type (string, int, boolean, datetime) but not on binary types, because it uses Equals to compare the two arrays instead of comparing its data, so actually every time you use this method on an entity that has a binary field the entity is marked as changed.

Until the EF team fixes this bug (probably in V2), here’s a simple method you can call after calling ApplyPropertyChanges, in order to reset the state of entities which weren’t really changed.

static HashAlgorithm hash = new MD5CryptoServiceProvider();

private static void ApplyBinaryProperyChanges(ObjectContext model, EntityObject entity)
{
    bool entityModified = false;
    // Get the state of the entity and its metadata (to find the type of the changed properties)
    ObjectStateEntry state = model.ObjectStateManager.GetObjectStateEntry(entity.EntityKey);
    ReadOnlyMetadataCollection<EdmProperty> entityProperties = (state.EntitySet.ElementType as EntityType).Properties;

    if (state.State == EntityState.Modified)
    {                
        foreach (string property in state.GetModifiedProperties())
        {
            // Find the primitive type that describes this property
            PrimitiveType propertyMetadata = entityProperties[property].TypeUsage.EdmType as PrimitiveType;
            if (propertyMetadata != null && propertyMetadata.PrimitiveTypeKind == PrimitiveTypeKind.Binary)
            {
                // Get the byte array from the entity (current & original)
                byte[] newArr = state.CurrentValues[property] as byte[];
                byte[] orgArr = state.OriginalValues[property] as byte[];

                // Init null values since hash needs to work on initiated arrays
                if (newArr == null)
                    newArr = new byte[0];
                if (orgArr == null)
                    orgArr = new byte[0];

                // Compare hashes for both arrays 
                // (if both null, they will return same hash because both arrays are 0 length arrays)
                if (Convert.ToBase64String(hash.ComputeHash(newArr)) !=
                    Convert.ToBase64String(hash.ComputeHash(orgArr)))
                {
                    // Checksum isn't the same - entity was modified
                    entityModified = true;
                    break;
                }
            }
            else
            {
                // Some other primitive property was modified - no need to check further
                entityModified = true;
                break;
            }
        }

        if (!entityModified)
        {
            // entity wasn't modified (all modified properties are actually binary data which wasn't modified)
            state.AcceptChanges();
        }
    }
}

לא פעם יצא לי לעבוד עם מערכות asp.net אשר צריכות לאפשר שמירה והצגה של קבצים מצורפים (attachments) – לפעמים מדובר בתמונות נלוות לפריט מידע, לפעמים במסמכים או בכל קובץ אחר.

במקרים בהם עובדים במערכת WEB, לא נהוג שהמערכת תחזיר UNC למיקום הקובץ ברשת, אלא המערכת צריכה להחזיר את הקובץ עצמו, באמצעות URL חד-ערכי שמזהה את הקובץ.

אבל, במרבית המערכות הקובץ לא ישמר על שרת ה-IIS, ככה שניתן לו URL משלו, אלא הקובץ ישב בשרת קבצים של-IIS יש גישה אליו, או אף אולי ב-DB, ויש צורך ליצור HTTP Handler על-מנת לאחזר את הקובץ.

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

טיפ 1 – על-מנת לקבוע את השם שיוצג בדפדפן כשם הקובץ, יש להוסיף את השורה הבאה

context.Response.AddHeader(
    "content-disposition", 
    "attachment; filename=\"" + fileName + "\"");    

השורה הזו עובדת מצויין על שמות קבצים באנגלית, לדוגמה:

אבל אם ננסה לתת שם בעברית, ההודעה תראה כך (שימו לב לשם הקובץ):

טיפ 2 – על-מנת לאפשר הצגה של שמות הקבצים בעברית, יש להפעיל על המשתנה את המתודה UrlPathEncode באופן הבא:

fileName = context.Server.UrlPathEncode(fileName);

ואז השם יופיע טוב:

If you've used DataTemplates in Silverlight 2, you've noticed that when defining it in a resource of a control, the attached event should be placed in the .cs file containing that control.

If it's a UserControl, it is logical for it to be in the usercontrol's .cs file, usually either coding for that event in the user control itself or exposing the event as an event exposed by the user control.

So far so good, but what happens if we have a general DataTemplate that is used in multiple control / user controls / pages ... ? the obvious answer is place it the app.xaml, but what will happen if we want to catch events from the contained controls in the DataTemplate? putting the event code in the app.xaml.cs is the only way to do it, but it isn't logical to put event code in the app.xaml.cs which will refer to a usercontro/page, isn't it so?

One way we can solve this problem is to define the DataTemplate in a new user control, wrap the event with a new event of the usercontrol's raise that event accordingly.

If you choose to create a UserControl for every DataTemplate or create a “Templates” UserControl for all DataTemplates that have a common usage, it's up to you.

I've attached an example demonstrating this