ChangeDirector.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / Orcas / NetFXw7 / ndp / fx / src / DLinq / Dlinq / ChangeDirector.cs / 1 / ChangeDirector.cs

                            using System; 
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq.Expressions;
using System.Text; 
using System.Reflection;
using System.Linq; 
using System.Security.Permissions; 
using System.Security;
 
namespace System.Data.Linq {
    using System.Data.Linq.Mapping;
    using System.Data.Linq.Provider;
    using System.Diagnostics.CodeAnalysis; 

    ///  
    /// Controls how inserts, updates and deletes are performed. 
    /// 
    internal abstract class ChangeDirector { 
        internal abstract int Insert(TrackedObject item);
        internal abstract int DynamicInsert(TrackedObject item);
        internal abstract void AppendInsertText(TrackedObject item, StringBuilder appendTo);
 
        internal abstract int Update(TrackedObject item);
        internal abstract int DynamicUpdate(TrackedObject item); 
        internal abstract void AppendUpdateText(TrackedObject item, StringBuilder appendTo); 

        internal abstract int Delete(TrackedObject item); 
        internal abstract int DynamicDelete(TrackedObject item);
        internal abstract void AppendDeleteText(TrackedObject item, StringBuilder appendTo);

        internal static ChangeDirector CreateChangeDirector(DataContext context) { 
            return new StandardChangeDirector(context);
        } 
 
        /// 
        /// Implementation of ChangeDirector which calls user code if possible 
        /// and othewise falls back to creating SQL for 'INSERT', 'UPDATE' and 'DELETE'.
        /// 
        internal class StandardChangeDirector : ChangeDirector {
            internal enum UpdateType { Insert, Update, Delete }; 

            DataContext context; 
 
            internal StandardChangeDirector(DataContext context) {
                this.context = context; 
            }

            internal override int Insert(TrackedObject item) {
                if (item.Type.Table.InsertMethod != null) { 
                    try {
                        item.Type.Table.InsertMethod.Invoke(this.context, new object[] { item.Current }); 
                    } 
                    catch (TargetInvocationException tie) {
                        if (tie.InnerException != null) { 
                            throw tie.InnerException;
                        }
                        throw;
                    } 
                    return 1;
                } 
                else { 
                    return DynamicInsert(item);
                } 
            }

            internal override int DynamicInsert(TrackedObject item) {
                Expression cmd = this.GetInsertCommand(item); 
                if (cmd.Type == typeof(int)) {
                    return (int)this.context.Provider.Execute(cmd).ReturnValue; 
                } 
                else {
                    IEnumerable facts = (IEnumerable)this.context.Provider.Execute(cmd).ReturnValue; 
                    object[] syncResults = (object[])facts.FirstOrDefault();
                    if (syncResults != null) {
                        // [....] any auto gen or computed members
                        AutoSyncMembers(syncResults, item, UpdateType.Insert); 
                        return 1;
                    } 
                    else { 
                        throw Error.InsertAutoSyncFailure();
                    } 
                }
            }

            internal override void AppendInsertText(TrackedObject item, StringBuilder appendTo) { 
                if (item.Type.Table.InsertMethod != null) {
                    appendTo.Append(Strings.InsertCallbackComment); 
                } 
                else {
                    Expression cmd = this.GetInsertCommand(item); 
                    appendTo.Append(this.context.Provider.GetQueryText(cmd));
                    appendTo.AppendLine();
                }
            } 

            ///  
            /// Update the item, returning 0 if the update fails, 1 if it succeeds. 
            /// 
            internal override int Update(TrackedObject item) { 
                if (item.Type.Table.UpdateMethod != null) {
                    // create a copy - don't allow the override to modify our
                    // internal original values
                    try { 
                        item.Type.Table.UpdateMethod.Invoke(this.context, new object[] { item.Current });
                    } 
                    catch (TargetInvocationException tie) { 
                        if (tie.InnerException != null) {
                            throw tie.InnerException; 
                        }
                        throw;
                    }
                    return 1; 
                }
                else { 
                    return DynamicUpdate(item); 
                }
            } 

            internal override int DynamicUpdate(TrackedObject item) {
                Expression cmd = this.GetUpdateCommand(item);
                if (cmd.Type == typeof(int)) { 
                    return (int)this.context.Provider.Execute(cmd).ReturnValue;
                } 
                else { 
                    IEnumerable facts = (IEnumerable)this.context.Provider.Execute(cmd).ReturnValue;
                    object[] syncResults = (object[])facts.FirstOrDefault(); 
                    if (syncResults != null) {
                        // [....] any auto gen or computed members
                        AutoSyncMembers(syncResults, item, UpdateType.Update);
                        return 1; 
                    }
                    else { 
                        return 0; 
                    }
                } 
            }

            internal override void AppendUpdateText(TrackedObject item, StringBuilder appendTo) {
                if (item.Type.Table.UpdateMethod != null) { 
                    appendTo.Append(Strings.UpdateCallbackComment);
                } 
                else { 
                    Expression cmd = this.GetUpdateCommand(item);
                    appendTo.Append(this.context.Provider.GetQueryText(cmd)); 
                    appendTo.AppendLine();
                }
            }
 
            internal override int Delete(TrackedObject item) {
                if (item.Type.Table.DeleteMethod != null) { 
                    try { 
                        item.Type.Table.DeleteMethod.Invoke(this.context, new object[] { item.Current });
                    } 
                    catch (TargetInvocationException tie) {
                        if (tie.InnerException != null) {
                            throw tie.InnerException;
                        } 
                        throw;
                    } 
                    return 1; 
                }
                else { 
                    return DynamicDelete(item);
                }
            }
 
            internal override int DynamicDelete(TrackedObject item) {
                Expression cmd = this.GetDeleteCommand(item); 
                int ret = (int)this.context.Provider.Execute(cmd).ReturnValue; 
                if (ret == 0) {
                    // we don't yet know if the delete failed because the check constaint did not match 
                    // or item was already deleted.  Verify the item exists
                    cmd = this.GetDeleteVerificationCommand(item);
                    ret = ((int?)this.context.Provider.Execute(cmd).ReturnValue) ?? -1;
                } 
                return ret;
            } 
 
            internal override void AppendDeleteText(TrackedObject item, StringBuilder appendTo) {
                if (item.Type.Table.DeleteMethod != null) { 
                    appendTo.Append(Strings.DeleteCallbackComment);
                }
                else {
                    Expression cmd = this.GetDeleteCommand(item); 
                    appendTo.Append(this.context.Provider.GetQueryText(cmd));
                    appendTo.AppendLine(); 
                } 
            }
 
            private Expression GetInsertCommand(TrackedObject item) {
                MetaType mt = item.Type;

                // bind to InsertFacts if there are any members to syncronize 
                List membersToSync = GetAutoSyncMembers(mt, UpdateType.Insert);
                ParameterExpression p = Expression.Parameter(item.Type.Table.RowType.Type, "p"); 
                if (membersToSync.Count > 0) { 
                    Expression autoSync = this.CreateAutoSync(membersToSync, p);
                    LambdaExpression resultSelector = Expression.Lambda(autoSync, p); 
                    return Expression.Call(typeof(DataManipulation), "Insert", new Type[] { item.Type.InheritanceRoot.Type, resultSelector.Body.Type }, Expression.Constant(item.Current), resultSelector);
                }
                else {
                    return Expression.Call(typeof(DataManipulation), "Insert", new Type[] { item.Type.InheritanceRoot.Type }, Expression.Constant(item.Current)); 
                }
            } 
 
            /// 
            /// For the meta members specified, create an array initializer for each and bind to 
            /// an output array.
            /// 
            private Expression CreateAutoSync(List membersToSync, Expression source) {
                System.Diagnostics.Debug.Assert(membersToSync.Count > 0); 
                int i = 0;
                Expression[] initializers = new Expression[membersToSync.Count]; 
                foreach (MetaDataMember mm in membersToSync) { 
                    initializers[i++] = Expression.Convert(this.GetMemberExpression(source, mm.Member), typeof(object));
                } 
                return Expression.NewArrayInit(typeof(object), initializers);
            }

            internal static List GetAutoSyncMembers(MetaType metaType, UpdateType updateType) { 
                List membersToSync = new List();
                foreach (MetaDataMember metaMember in metaType.PersistentDataMembers.OrderBy(m => m.Ordinal)) { 
                    // add all auto generated members for the specified update type to the auto-[....] list 
                    if ((updateType == UpdateType.Insert && metaMember.AutoSync == AutoSync.OnInsert) ||
                        (updateType == UpdateType.Update && metaMember.AutoSync == AutoSync.OnUpdate) || 
                         metaMember.AutoSync == AutoSync.Always) {
                        membersToSync.Add(metaMember);
                    }
                } 
                return membersToSync;
            } 
 
            /// 
            /// Syncronize the specified item by copying in data from the [....] results. 
            /// 
            private static void AutoSyncMembers(object[] syncResults, TrackedObject item, UpdateType updateType) {
                System.Diagnostics.Debug.Assert(item != null);
                if (syncResults != null) { 
                    int idx = 0;
                    List membersToSync = GetAutoSyncMembers(item.Type, updateType); 
                    System.Diagnostics.Debug.Assert(syncResults.Length == membersToSync.Count); 
                    foreach (MetaDataMember mm in membersToSync) {
                        object value = syncResults[idx++]; 
                        object current = item.Current;

                        if (mm.Member is PropertyInfo && ((PropertyInfo)mm.Member).CanWrite) {
                            mm.MemberAccessor.SetBoxedValue(ref current, DBConvert.ChangeType(value, mm.Type)); 
                        }
                        else { 
                            mm.StorageAccessor.SetBoxedValue(ref current, DBConvert.ChangeType(value, mm.Type)); 
                        }
                    } 
                }
            }

            private Expression GetUpdateCommand(TrackedObject tracked) { 
                object database = tracked.Original;
                MetaType rowType = tracked.Type.GetInheritanceType(database.GetType()); 
                MetaType rowTypeRoot = rowType.InheritanceRoot; 

                ParameterExpression p = Expression.Parameter(rowTypeRoot.Type, "p"); 
                Expression pv = p;
                if (rowType != rowTypeRoot) {
                    pv = Expression.Convert(p, rowType.Type);
                } 

                Expression check = this.GetUpdateCheck(pv, tracked); 
                if (check != null) { 
                    check = Expression.Lambda(check, p);
                } 

                // bind to out array if there are any members to synchronize
                List membersToSync = GetAutoSyncMembers(rowType, UpdateType.Update);
                if (membersToSync.Count > 0) { 
                    Expression autoSync = this.CreateAutoSync(membersToSync, pv);
                    LambdaExpression resultSelector = Expression.Lambda(autoSync, p); 
                    if (check != null) { 
                        return Expression.Call(typeof(DataManipulation), "Update", new Type[] { rowTypeRoot.Type, resultSelector.Body.Type }, Expression.Constant(tracked.Current), check, resultSelector);
                    } 
                    else {
                        return Expression.Call(typeof(DataManipulation), "Update", new Type[] { rowTypeRoot.Type, resultSelector.Body.Type }, Expression.Constant(tracked.Current), resultSelector);
                    }
                } 
                else if (check != null) {
                    return Expression.Call(typeof(DataManipulation), "Update", new Type[] { rowTypeRoot.Type }, Expression.Constant(tracked.Current), check); 
                } 
                else {
                    return Expression.Call(typeof(DataManipulation), "Update", new Type[] { rowTypeRoot.Type }, Expression.Constant(tracked.Current)); 
                }
            }

            private Expression GetUpdateCheck(Expression serverItem, TrackedObject tracked) { 
                MetaType mt = tracked.Type;
                if (mt.VersionMember != null) { 
                    return Expression.Equal( 
                        this.GetMemberExpression(serverItem, mt.VersionMember.Member),
                        this.GetMemberExpression(Expression.Constant(tracked.Current), mt.VersionMember.Member) 
                        );
                }
                else {
                    Expression expr = null; 
                    foreach (MetaDataMember mm in mt.PersistentDataMembers) {
                        if (!mm.IsPrimaryKey) { 
                            UpdateCheck check = mm.UpdateCheck; 
                            if (check == UpdateCheck.Always ||
                                (check == UpdateCheck.WhenChanged && tracked.HasChangedValue(mm))) { 
                                object memberValue = mm.MemberAccessor.GetBoxedValue(tracked.Original);
                                Expression eq =
                                    Expression.Equal(
                                        this.GetMemberExpression(serverItem, mm.Member), 
                                        Expression.Constant(memberValue, mm.Type)
                                        ); 
                                expr = (expr != null) ? Expression.And(expr, eq) : eq; 
                            }
                        } 
                    }
                    return expr;
                }
            } 

            private Expression GetDeleteCommand(TrackedObject tracked) { 
                MetaType rowType = tracked.Type; 
                MetaType rowTypeRoot = rowType.InheritanceRoot;
                ParameterExpression p = Expression.Parameter(rowTypeRoot.Type, "p"); 
                Expression pv = p;
                if (rowType != rowTypeRoot) {
                    pv = Expression.Convert(p, rowType.Type);
                } 
                object original = tracked.CreateDataCopy(tracked.Original);
                Expression check = this.GetUpdateCheck(pv, tracked); 
                if (check != null) { 
                    check = Expression.Lambda(check, p);
                    return Expression.Call(typeof(DataManipulation), "Delete", new Type[] { rowTypeRoot.Type }, Expression.Constant(original), check); 
                }
                else {
                    return Expression.Call(typeof(DataManipulation), "Delete", new Type[] { rowTypeRoot.Type }, Expression.Constant(original));
                } 
            }
 
            private Expression GetDeleteVerificationCommand(TrackedObject tracked) { 
                ITable table = this.context.GetTable(tracked.Type.InheritanceRoot.Type);
                System.Diagnostics.Debug.Assert(table != null); 
                ParameterExpression p = Expression.Parameter(table.ElementType, "p");
                Expression pred = Expression.Lambda(Expression.Equal(p, Expression.Constant(tracked.Current)), p);
                Expression where = Expression.Call(typeof(Queryable), "Where", new Type[] { table.ElementType }, table.Expression, pred);
                Expression selector = Expression.Lambda(Expression.Constant(0, typeof(int?)), p); 
                Expression select = Expression.Call(typeof(Queryable), "Select", new Type[] { table.ElementType, typeof(int?) }, where, selector);
                Expression singleOrDefault = Expression.Call(typeof(Queryable), "SingleOrDefault", new Type[] { typeof(int?) }, select); 
                return singleOrDefault; 
            }
 
            [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification="Unknown reason.")]
            private Expression GetMemberExpression(Expression exp, MemberInfo mi) {
                FieldInfo fi = mi as FieldInfo;
                if (fi != null) 
                    return Expression.Field(exp, fi);
                PropertyInfo pi = (PropertyInfo)mi; 
                return Expression.Property(exp, pi); 
            }
        } 
    }
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
using System; 
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq.Expressions;
using System.Text; 
using System.Reflection;
using System.Linq; 
using System.Security.Permissions; 
using System.Security;
 
namespace System.Data.Linq {
    using System.Data.Linq.Mapping;
    using System.Data.Linq.Provider;
    using System.Diagnostics.CodeAnalysis; 

    ///  
    /// Controls how inserts, updates and deletes are performed. 
    /// 
    internal abstract class ChangeDirector { 
        internal abstract int Insert(TrackedObject item);
        internal abstract int DynamicInsert(TrackedObject item);
        internal abstract void AppendInsertText(TrackedObject item, StringBuilder appendTo);
 
        internal abstract int Update(TrackedObject item);
        internal abstract int DynamicUpdate(TrackedObject item); 
        internal abstract void AppendUpdateText(TrackedObject item, StringBuilder appendTo); 

        internal abstract int Delete(TrackedObject item); 
        internal abstract int DynamicDelete(TrackedObject item);
        internal abstract void AppendDeleteText(TrackedObject item, StringBuilder appendTo);

        internal static ChangeDirector CreateChangeDirector(DataContext context) { 
            return new StandardChangeDirector(context);
        } 
 
        /// 
        /// Implementation of ChangeDirector which calls user code if possible 
        /// and othewise falls back to creating SQL for 'INSERT', 'UPDATE' and 'DELETE'.
        /// 
        internal class StandardChangeDirector : ChangeDirector {
            internal enum UpdateType { Insert, Update, Delete }; 

            DataContext context; 
 
            internal StandardChangeDirector(DataContext context) {
                this.context = context; 
            }

            internal override int Insert(TrackedObject item) {
                if (item.Type.Table.InsertMethod != null) { 
                    try {
                        item.Type.Table.InsertMethod.Invoke(this.context, new object[] { item.Current }); 
                    } 
                    catch (TargetInvocationException tie) {
                        if (tie.InnerException != null) { 
                            throw tie.InnerException;
                        }
                        throw;
                    } 
                    return 1;
                } 
                else { 
                    return DynamicInsert(item);
                } 
            }

            internal override int DynamicInsert(TrackedObject item) {
                Expression cmd = this.GetInsertCommand(item); 
                if (cmd.Type == typeof(int)) {
                    return (int)this.context.Provider.Execute(cmd).ReturnValue; 
                } 
                else {
                    IEnumerable facts = (IEnumerable)this.context.Provider.Execute(cmd).ReturnValue; 
                    object[] syncResults = (object[])facts.FirstOrDefault();
                    if (syncResults != null) {
                        // [....] any auto gen or computed members
                        AutoSyncMembers(syncResults, item, UpdateType.Insert); 
                        return 1;
                    } 
                    else { 
                        throw Error.InsertAutoSyncFailure();
                    } 
                }
            }

            internal override void AppendInsertText(TrackedObject item, StringBuilder appendTo) { 
                if (item.Type.Table.InsertMethod != null) {
                    appendTo.Append(Strings.InsertCallbackComment); 
                } 
                else {
                    Expression cmd = this.GetInsertCommand(item); 
                    appendTo.Append(this.context.Provider.GetQueryText(cmd));
                    appendTo.AppendLine();
                }
            } 

            ///  
            /// Update the item, returning 0 if the update fails, 1 if it succeeds. 
            /// 
            internal override int Update(TrackedObject item) { 
                if (item.Type.Table.UpdateMethod != null) {
                    // create a copy - don't allow the override to modify our
                    // internal original values
                    try { 
                        item.Type.Table.UpdateMethod.Invoke(this.context, new object[] { item.Current });
                    } 
                    catch (TargetInvocationException tie) { 
                        if (tie.InnerException != null) {
                            throw tie.InnerException; 
                        }
                        throw;
                    }
                    return 1; 
                }
                else { 
                    return DynamicUpdate(item); 
                }
            } 

            internal override int DynamicUpdate(TrackedObject item) {
                Expression cmd = this.GetUpdateCommand(item);
                if (cmd.Type == typeof(int)) { 
                    return (int)this.context.Provider.Execute(cmd).ReturnValue;
                } 
                else { 
                    IEnumerable facts = (IEnumerable)this.context.Provider.Execute(cmd).ReturnValue;
                    object[] syncResults = (object[])facts.FirstOrDefault(); 
                    if (syncResults != null) {
                        // [....] any auto gen or computed members
                        AutoSyncMembers(syncResults, item, UpdateType.Update);
                        return 1; 
                    }
                    else { 
                        return 0; 
                    }
                } 
            }

            internal override void AppendUpdateText(TrackedObject item, StringBuilder appendTo) {
                if (item.Type.Table.UpdateMethod != null) { 
                    appendTo.Append(Strings.UpdateCallbackComment);
                } 
                else { 
                    Expression cmd = this.GetUpdateCommand(item);
                    appendTo.Append(this.context.Provider.GetQueryText(cmd)); 
                    appendTo.AppendLine();
                }
            }
 
            internal override int Delete(TrackedObject item) {
                if (item.Type.Table.DeleteMethod != null) { 
                    try { 
                        item.Type.Table.DeleteMethod.Invoke(this.context, new object[] { item.Current });
                    } 
                    catch (TargetInvocationException tie) {
                        if (tie.InnerException != null) {
                            throw tie.InnerException;
                        } 
                        throw;
                    } 
                    return 1; 
                }
                else { 
                    return DynamicDelete(item);
                }
            }
 
            internal override int DynamicDelete(TrackedObject item) {
                Expression cmd = this.GetDeleteCommand(item); 
                int ret = (int)this.context.Provider.Execute(cmd).ReturnValue; 
                if (ret == 0) {
                    // we don't yet know if the delete failed because the check constaint did not match 
                    // or item was already deleted.  Verify the item exists
                    cmd = this.GetDeleteVerificationCommand(item);
                    ret = ((int?)this.context.Provider.Execute(cmd).ReturnValue) ?? -1;
                } 
                return ret;
            } 
 
            internal override void AppendDeleteText(TrackedObject item, StringBuilder appendTo) {
                if (item.Type.Table.DeleteMethod != null) { 
                    appendTo.Append(Strings.DeleteCallbackComment);
                }
                else {
                    Expression cmd = this.GetDeleteCommand(item); 
                    appendTo.Append(this.context.Provider.GetQueryText(cmd));
                    appendTo.AppendLine(); 
                } 
            }
 
            private Expression GetInsertCommand(TrackedObject item) {
                MetaType mt = item.Type;

                // bind to InsertFacts if there are any members to syncronize 
                List membersToSync = GetAutoSyncMembers(mt, UpdateType.Insert);
                ParameterExpression p = Expression.Parameter(item.Type.Table.RowType.Type, "p"); 
                if (membersToSync.Count > 0) { 
                    Expression autoSync = this.CreateAutoSync(membersToSync, p);
                    LambdaExpression resultSelector = Expression.Lambda(autoSync, p); 
                    return Expression.Call(typeof(DataManipulation), "Insert", new Type[] { item.Type.InheritanceRoot.Type, resultSelector.Body.Type }, Expression.Constant(item.Current), resultSelector);
                }
                else {
                    return Expression.Call(typeof(DataManipulation), "Insert", new Type[] { item.Type.InheritanceRoot.Type }, Expression.Constant(item.Current)); 
                }
            } 
 
            /// 
            /// For the meta members specified, create an array initializer for each and bind to 
            /// an output array.
            /// 
            private Expression CreateAutoSync(List membersToSync, Expression source) {
                System.Diagnostics.Debug.Assert(membersToSync.Count > 0); 
                int i = 0;
                Expression[] initializers = new Expression[membersToSync.Count]; 
                foreach (MetaDataMember mm in membersToSync) { 
                    initializers[i++] = Expression.Convert(this.GetMemberExpression(source, mm.Member), typeof(object));
                } 
                return Expression.NewArrayInit(typeof(object), initializers);
            }

            internal static List GetAutoSyncMembers(MetaType metaType, UpdateType updateType) { 
                List membersToSync = new List();
                foreach (MetaDataMember metaMember in metaType.PersistentDataMembers.OrderBy(m => m.Ordinal)) { 
                    // add all auto generated members for the specified update type to the auto-[....] list 
                    if ((updateType == UpdateType.Insert && metaMember.AutoSync == AutoSync.OnInsert) ||
                        (updateType == UpdateType.Update && metaMember.AutoSync == AutoSync.OnUpdate) || 
                         metaMember.AutoSync == AutoSync.Always) {
                        membersToSync.Add(metaMember);
                    }
                } 
                return membersToSync;
            } 
 
            /// 
            /// Syncronize the specified item by copying in data from the [....] results. 
            /// 
            private static void AutoSyncMembers(object[] syncResults, TrackedObject item, UpdateType updateType) {
                System.Diagnostics.Debug.Assert(item != null);
                if (syncResults != null) { 
                    int idx = 0;
                    List membersToSync = GetAutoSyncMembers(item.Type, updateType); 
                    System.Diagnostics.Debug.Assert(syncResults.Length == membersToSync.Count); 
                    foreach (MetaDataMember mm in membersToSync) {
                        object value = syncResults[idx++]; 
                        object current = item.Current;

                        if (mm.Member is PropertyInfo && ((PropertyInfo)mm.Member).CanWrite) {
                            mm.MemberAccessor.SetBoxedValue(ref current, DBConvert.ChangeType(value, mm.Type)); 
                        }
                        else { 
                            mm.StorageAccessor.SetBoxedValue(ref current, DBConvert.ChangeType(value, mm.Type)); 
                        }
                    } 
                }
            }

            private Expression GetUpdateCommand(TrackedObject tracked) { 
                object database = tracked.Original;
                MetaType rowType = tracked.Type.GetInheritanceType(database.GetType()); 
                MetaType rowTypeRoot = rowType.InheritanceRoot; 

                ParameterExpression p = Expression.Parameter(rowTypeRoot.Type, "p"); 
                Expression pv = p;
                if (rowType != rowTypeRoot) {
                    pv = Expression.Convert(p, rowType.Type);
                } 

                Expression check = this.GetUpdateCheck(pv, tracked); 
                if (check != null) { 
                    check = Expression.Lambda(check, p);
                } 

                // bind to out array if there are any members to synchronize
                List membersToSync = GetAutoSyncMembers(rowType, UpdateType.Update);
                if (membersToSync.Count > 0) { 
                    Expression autoSync = this.CreateAutoSync(membersToSync, pv);
                    LambdaExpression resultSelector = Expression.Lambda(autoSync, p); 
                    if (check != null) { 
                        return Expression.Call(typeof(DataManipulation), "Update", new Type[] { rowTypeRoot.Type, resultSelector.Body.Type }, Expression.Constant(tracked.Current), check, resultSelector);
                    } 
                    else {
                        return Expression.Call(typeof(DataManipulation), "Update", new Type[] { rowTypeRoot.Type, resultSelector.Body.Type }, Expression.Constant(tracked.Current), resultSelector);
                    }
                } 
                else if (check != null) {
                    return Expression.Call(typeof(DataManipulation), "Update", new Type[] { rowTypeRoot.Type }, Expression.Constant(tracked.Current), check); 
                } 
                else {
                    return Expression.Call(typeof(DataManipulation), "Update", new Type[] { rowTypeRoot.Type }, Expression.Constant(tracked.Current)); 
                }
            }

            private Expression GetUpdateCheck(Expression serverItem, TrackedObject tracked) { 
                MetaType mt = tracked.Type;
                if (mt.VersionMember != null) { 
                    return Expression.Equal( 
                        this.GetMemberExpression(serverItem, mt.VersionMember.Member),
                        this.GetMemberExpression(Expression.Constant(tracked.Current), mt.VersionMember.Member) 
                        );
                }
                else {
                    Expression expr = null; 
                    foreach (MetaDataMember mm in mt.PersistentDataMembers) {
                        if (!mm.IsPrimaryKey) { 
                            UpdateCheck check = mm.UpdateCheck; 
                            if (check == UpdateCheck.Always ||
                                (check == UpdateCheck.WhenChanged && tracked.HasChangedValue(mm))) { 
                                object memberValue = mm.MemberAccessor.GetBoxedValue(tracked.Original);
                                Expression eq =
                                    Expression.Equal(
                                        this.GetMemberExpression(serverItem, mm.Member), 
                                        Expression.Constant(memberValue, mm.Type)
                                        ); 
                                expr = (expr != null) ? Expression.And(expr, eq) : eq; 
                            }
                        } 
                    }
                    return expr;
                }
            } 

            private Expression GetDeleteCommand(TrackedObject tracked) { 
                MetaType rowType = tracked.Type; 
                MetaType rowTypeRoot = rowType.InheritanceRoot;
                ParameterExpression p = Expression.Parameter(rowTypeRoot.Type, "p"); 
                Expression pv = p;
                if (rowType != rowTypeRoot) {
                    pv = Expression.Convert(p, rowType.Type);
                } 
                object original = tracked.CreateDataCopy(tracked.Original);
                Expression check = this.GetUpdateCheck(pv, tracked); 
                if (check != null) { 
                    check = Expression.Lambda(check, p);
                    return Expression.Call(typeof(DataManipulation), "Delete", new Type[] { rowTypeRoot.Type }, Expression.Constant(original), check); 
                }
                else {
                    return Expression.Call(typeof(DataManipulation), "Delete", new Type[] { rowTypeRoot.Type }, Expression.Constant(original));
                } 
            }
 
            private Expression GetDeleteVerificationCommand(TrackedObject tracked) { 
                ITable table = this.context.GetTable(tracked.Type.InheritanceRoot.Type);
                System.Diagnostics.Debug.Assert(table != null); 
                ParameterExpression p = Expression.Parameter(table.ElementType, "p");
                Expression pred = Expression.Lambda(Expression.Equal(p, Expression.Constant(tracked.Current)), p);
                Expression where = Expression.Call(typeof(Queryable), "Where", new Type[] { table.ElementType }, table.Expression, pred);
                Expression selector = Expression.Lambda(Expression.Constant(0, typeof(int?)), p); 
                Expression select = Expression.Call(typeof(Queryable), "Select", new Type[] { table.ElementType, typeof(int?) }, where, selector);
                Expression singleOrDefault = Expression.Call(typeof(Queryable), "SingleOrDefault", new Type[] { typeof(int?) }, select); 
                return singleOrDefault; 
            }
 
            [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification="Unknown reason.")]
            private Expression GetMemberExpression(Expression exp, MemberInfo mi) {
                FieldInfo fi = mi as FieldInfo;
                if (fi != null) 
                    return Expression.Field(exp, fi);
                PropertyInfo pi = (PropertyInfo)mi; 
                return Expression.Property(exp, pi); 
            }
        } 
    }
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK