C# Objects.ObjectStateEntry类代码示例

        public virtual bool IsTargetEntity(ObjectStateEntry item)
        {

            return item.State != EntityState.Detached &&
                   TargetType.IsInstanceOfType(item.Entity);

        }

 /// <summary>
 /// Gets the identifier value for the entity in the ObjectStateEntry.
 /// </summary>
 /// <param name="objectStateEntry">The ObjectStateEntry.</param>
 /// <returns>The identifier value.</returns>
 /// <remarks>
 /// When auditing Adds, this needs to be called AFTER SaveChanges, or else it will return null.
 /// </remarks>
 public static string GetIdentifierValue(ObjectStateEntry objectStateEntry)
 {
     if (objectStateEntry == null)
     {
         throw new ArgumentNullException("objectStateEntry");
     }
     string id = null;
     var entityKey = objectStateEntry.EntityKey;
     if (entityKey != null)
     {
         var keyValues = entityKey.EntityKeyValues;
         if (keyValues != null)
         {
             if (keyValues.Length == 1)
             {
                 id = keyValues[0].Value.ToString();
             }
             else if (keyValues.Length > 1)
             {
                 id = string.Join(_composikeKeySeparator, keyValues.OrderBy(k => k.Key).Select(k => k.Value.ToString()).ToArray());
             }
         }
     }
     return id;
 }

 /// <summary>
 /// Tracks the original value.
 /// </summary>
 /// <param name="objectStateEntry">The object state entry.</param>
 private void TrackOriginalValue(ObjectStateEntry objectStateEntry)
 {
     object propertyValue = objectStateEntry.OriginalValues[PropertyName];
     if (propertyValue != null)
     {
         OriginalValue = propertyValue.ToString();
     }
 }

 /// <summary>
 /// Tracks the new value.
 /// </summary>
 /// <param name="objectStateEntry">The object state entry.</param>
 private void TrackNewValue(ObjectStateEntry objectStateEntry)
 {
     object propertyValue = objectStateEntry.CurrentValues[PropertyName];
     if (propertyValue != null)
     {
         NewValue = propertyValue.ToString();
     }
 }

 private static IEnumerable<Tuple<string, object, object>> GetUpdatedEntityValues(ObjectStateEntry entry)
 {
     foreach (string propname in entry.GetModifiedProperties())
     {
         object newval = entry.CurrentValues[propname];
         object oldval = entry.OriginalValues[propname];
         yield return Tuple.Create(propname, newval, oldval);
     }
 }

 /// <summary>
 /// Tracks the delete.
 /// </summary>
 /// <param name="objectStateEntry">The object state entry.</param>
 public void TrackDelete(ObjectStateEntry objectStateEntry)
 {
     if (objectStateEntry == null)
     {
         throw new ArgumentNullException("objectStateEntry");
     }
     AuditEntities.Add(new EntityDeletedAudit(objectStateEntry));
     RemoveReads();
 }

 public TrackingAuditEntity(ObjectStateEntry objectStateEntry, AuditEntityAction action)
 {
     if (objectStateEntry == null)
     {
         throw new ArgumentNullException("objectStateEntry");
     }
     EntityType = EntityTypeResolver.ResolveActualEntityType(objectStateEntry.Entity).Name;
     EntityIdentifier = IdentifierUtility.GetIdentifierValue(objectStateEntry);
     AuditEntityAction = action;
     AuditEntityProperties = new Collection<AuditEntityProperty>();
 }

 private static IEnumerable<Tuple<string, object, object>> GetAddedEntityValues(ObjectStateEntry entry)
 {
     foreach (var propinfo in entry.CurrentValues.DataRecordInfo.FieldMetadata)
     {
         object newval = entry.CurrentValues[propinfo.FieldType.Name];
         if (newval.GetType() == typeof(EntityKey))
         {
             newval = ((EntityKey)newval).EntityKeyValues.Select(k => k.Value).FirstOrDefault();    
         }
         yield return Tuple.Create(propinfo.FieldType.Name, newval, (object)null);
     }
 }

 /// <summary>
 /// Tracks the properties.
 /// </summary>
 /// <param name="objectStateEntry">The object state entry.</param>
 protected void TrackProperties(ObjectStateEntry objectStateEntry)
 {
     var currentValues = objectStateEntry.CurrentValues;
     for (int ordinal = 0; ordinal < currentValues.FieldCount; ordinal++)
     {
         var propertyName = currentValues.GetName(ordinal);
         if (!IsStoreGenerated(propertyName, objectStateEntry))
         {
             AuditEntityProperties.Add(new TrackingAuditEntityProperty(propertyName, objectStateEntry));
         }
     }
 }

 private static AuditAction GetAction(ObjectStateEntry entity)
 {
     switch (entity.State)
     {
         case EntityState.Added:
             return AuditAction.Added;
         case EntityState.Deleted:
             return AuditAction.Deleted;
         default:
             return AuditAction.Modified;
     }
 }

 /// <summary>
 /// Tracks the properties.
 /// </summary>
 /// <param name="objectStateEntry">The object state entry.</param>
 protected void TrackProperties(ObjectStateEntry objectStateEntry)
 {
     foreach (string propertyName in objectStateEntry.GetModifiedProperties())
     {
         if (!IsStoreGenerated(propertyName, objectStateEntry))
         {
             var auditProperty = new TrackingAuditEntityProperty(propertyName, objectStateEntry);
             if (auditProperty.HasChanges)
             {
                 AuditEntityProperties.Add(auditProperty);
             }
         }
     }
 }

 internal ObjectStateEntryDbDataRecord(RelationshipEntry cacheEntry)
 {
     EntityUtil.CheckArgumentNull(cacheEntry, "cacheEntry");
     Debug.Assert(!cacheEntry.IsKeyEntry, "Cannot create an ObjectStateEntryDbDataRecord for a key entry");
     switch (cacheEntry.State)
     {
         case EntityState.Unchanged:
         case EntityState.Modified:
         case EntityState.Deleted:
             _cacheEntry = cacheEntry;
             break;
         default:
             Debug.Assert(false, "A DbDataRecord cannot be created for an entity object that is in an added or detached state.");
             break;
     }
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="TrackingAuditEntityProperty"/> class.
 /// </summary>
 /// <param name="propertyName">Name of the property.</param>
 /// <param name="objectStateEntry">The object state entry.</param>
 public TrackingAuditEntityProperty(string propertyName, ObjectStateEntry objectStateEntry)
 {
     if (objectStateEntry == null)
     {
         throw new ArgumentNullException("objectStateEntry");
     }
     if (string.IsNullOrEmpty(propertyName))
     {
         throw new ArgumentNullException("propertyName");
     }
     PropertyName = propertyName;
     TrackNewValue(objectStateEntry);
     if (objectStateEntry.State == EntityState.Modified)
     {
         TrackOriginalValue(objectStateEntry);
     }
 }

		static void ValidateBelongsTo(this AssociationEndMember end, ObjectStateEntry entry)
		{
			if (!entry.IsRelationship)
			{
				throw new ArgumentException("is not a relationship entry", "entry");
			}

			var fieldMetadata =
					entry.UsableValues().DataRecordInfo.FieldMetadata;
			if (fieldMetadata[0].FieldType as AssociationEndMember != end &&
				fieldMetadata[1].FieldType as AssociationEndMember != end)
			{
				throw new InvalidOperationException(string.Format(
						"association end {0} does not participate in the " +
						"relationship {1}", end, entry));
			}
		}

 internal ObjectStateEntryDbDataRecord(EntityEntry cacheEntry, StateManagerTypeMetadata metadata, object userObject)
 {
     //Contract.Requires(cacheEntry != null);
     //Contract.Requires(userObject != null);
     //Contract.Requires(metadata != null);
     Debug.Assert(!cacheEntry.IsKeyEntry, "Cannot create an ObjectStateEntryDbDataRecord for a key entry");
     switch (cacheEntry.State)
     {
         case EntityState.Unchanged:
         case EntityState.Modified:
         case EntityState.Deleted:
             _cacheEntry = cacheEntry;
             _userObject = userObject;
             _metadata = metadata;
             break;
         default:
             Debug.Assert(false, "A DbDataRecord cannot be created for an entity object that is in an added or detached state.");
             break;
     }
 }