|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Diagnostics;
namespace System.Data.Linq {
using System.Data.Linq.Mapping;
using System.Data.Linq.Provider;
/// <summary>
/// Describes the type of change the entity will undergo when submitted to the database.
/// </summary>
public enum ChangeAction {
/// <summary>
/// The entity will not be submitted.
/// </summary>
None = 0,
/// <summary>
/// The entity will be deleted.
/// </summary>
Delete,
/// <summary>
/// The entity will be inserted.
/// </summary>
Insert,
/// <summary>
/// The entity will be updated.
/// </summary>
Update
}
internal class ChangeProcessor {
CommonDataServices services;
DataContext context;
ChangeTracker tracker;
ChangeDirector changeDirector;
EdgeMap currentParentEdges;
EdgeMap originalChildEdges;
ReferenceMap originalChildReferences;
internal ChangeProcessor(CommonDataServices services, DataContext context) {
this.services = services;
this.context = context;
this.tracker = services.ChangeTracker;
this.changeDirector = services.ChangeDirector;
this.currentParentEdges = new EdgeMap();
this.originalChildEdges = new EdgeMap();
this.originalChildReferences = new ReferenceMap();
}
internal void SubmitChanges(ConflictMode failureMode) {
this.TrackUntrackedObjects();
// Must apply inferred deletions only after any untracked objects
// are tracked
this.ApplyInferredDeletions();
this.BuildEdgeMaps();
var list = this.GetOrderedList();
ValidateAll(list);
int numUpdatesAttempted = 0;
ChangeConflictSession conflictSession = new ChangeConflictSession(this.context);
List<ObjectChangeConflict> conflicts = new List<ObjectChangeConflict>();
List<TrackedObject> deletedItems = new List<TrackedObject>();
List<TrackedObject> insertedItems = new List<TrackedObject>();
List<TrackedObject> syncDependentItems = new List<TrackedObject>();
foreach (TrackedObject item in list) {
try {
if (item.IsNew) {
if (item.SynchDependentData()) {
syncDependentItems.Add(item);
}
changeDirector.Insert(item);
// store all inserted items for post processing
insertedItems.Add(item);
}
else if (item.IsDeleted) {
// Delete returns 1 if the delete was successfull, 0 if the row exists
// but wasn't deleted due to an OC conflict, or -1 if the row was
// deleted by another context (no OC conflict in this case)
numUpdatesAttempted++;
int ret = changeDirector.Delete(item);
if (ret == 0) {
conflicts.Add(new ObjectChangeConflict(conflictSession, item, false));
}
else {
// store all deleted items for post processing
deletedItems.Add(item);
}
}
else if (item.IsPossiblyModified) {
if (item.SynchDependentData()) {
syncDependentItems.Add(item);
}
if (item.IsModified) {
CheckForInvalidChanges(item);
numUpdatesAttempted++;
if (changeDirector.Update(item) <= 0) {
conflicts.Add(new ObjectChangeConflict(conflictSession, item));
}
}
}
}
catch (ChangeConflictException) {
conflicts.Add(new ObjectChangeConflict(conflictSession, item));
}
if (conflicts.Count > 0 && failureMode == ConflictMode.FailOnFirstConflict) {
break;
}
}
// if we have accumulated any failed updates, throw the exception now
if (conflicts.Count > 0) {
// First we need to rollback any value that have already been auto-sync'd, since the values are no longer valid on the server
changeDirector.RollbackAutoSync();
// Also rollback any dependent items that were sync'd, since their parent values may have been rolled back
foreach (TrackedObject syncDependentItem in syncDependentItems) {
Debug.Assert(syncDependentItem.IsNew || syncDependentItem.IsPossiblyModified, "SynchDependent data should only be rolled back for new and modified objects.");
syncDependentItem.SynchDependentData();
}
this.context.ChangeConflicts.Fill(conflicts);
throw CreateChangeConflictException(numUpdatesAttempted, conflicts.Count);
}
else {
// No conflicts occurred, so we don't need to save the rollback values anymore
changeDirector.ClearAutoSyncRollback();
}
// Only after all updates have been sucessfully processed do we want to make
// post processing modifications to the objects and/or cache state.
PostProcessUpdates(insertedItems, deletedItems);
}
private void PostProcessUpdates(List<TrackedObject> insertedItems, List<TrackedObject> deletedItems) {
// perform post delete processing
foreach (TrackedObject deletedItem in deletedItems) {
// remove deleted item from identity cache
this.services.RemoveCachedObjectLike(deletedItem.Type, deletedItem.Original);
ClearForeignKeyReferences(deletedItem);
}
// perform post insert processing
foreach (TrackedObject insertedItem in insertedItems) {
object lookup = this.services.InsertLookupCachedObject(insertedItem.Type, insertedItem.Current);
if (lookup != insertedItem.Current) {
throw new DuplicateKeyException(insertedItem.Current, Strings.DatabaseGeneratedAlreadyExistingKey);
}
insertedItem.InitializeDeferredLoaders();
}
}
/// <summary>
/// Clears out the foreign key values and parent object references for deleted objects on the child side of a relationship.
/// For bi-directional relationships, also performs the following fixup:
/// - for 1:N we remove the deleted entity from the opposite EntitySet or collection
/// - for 1:1 we null out the back reference
/// </summary>
private void ClearForeignKeyReferences(TrackedObject to) {
Debug.Assert(to.IsDeleted, "Foreign key reference cleanup should only happen on Deleted objects.");
foreach (MetaAssociation assoc in to.Type.Associations) {
if (assoc.IsForeignKey) {
// If there is a member on the other side referring back to us (i.e. this is a bi-directional relationship),
// we want to do a cache lookup to find the other side, then will remove ourselves from that collection.
// This cache lookup is only possible if the other key is the primary key, since that is the only way items can be found in the cache.
if (assoc.OtherMember != null && assoc.OtherKeyIsPrimaryKey) {
Debug.Assert(assoc.OtherMember.IsAssociation, "OtherMember of the association is expected to also be an association.");
// Search the cache for the target of the association, since
// it might not be loaded on the object being deleted, and we
// don't want to force a load.
object[] keyValues = CommonDataServices.GetForeignKeyValues(assoc, to.Current);
object cached = this.services.IdentityManager.Find(assoc.OtherType, keyValues);
if (cached != null) {
if (assoc.OtherMember.Association.IsMany) {
// Note that going through the IList interface handles
// EntitySet as well as POCO collections that implement IList
// and are not FixedSize.
System.Collections.IList collection = assoc.OtherMember.MemberAccessor.GetBoxedValue(cached) as System.Collections.IList;
if (collection != null && !collection.IsFixedSize) {
collection.Remove(to.Current);
// Explicitly clear the foreign key values and parent object reference
ClearForeignKeysHelper(assoc, to.Current);
}
}
else {
// Null out the other association. Since this is a 1:1 association,
// we're not concerned here with causing a deferred load, since the
// target is already cached (since we're deleting it).
assoc.OtherMember.MemberAccessor.SetBoxedValue(ref cached, null);
// Explicitly clear the foreign key values and parent object reference
ClearForeignKeysHelper(assoc, to.Current);
}
}
// else the item was not found in the cache, so there is no fixup that has to be done
// We are explicitly not calling ClearForeignKeysHelper because it breaks existing shipped behavior and we want to maintain backward compatibility
}
else {
// This is a unidirectional relationship or we have no way to look up the other side in the cache, so just clear our own side
ClearForeignKeysHelper(assoc, to.Current);
}
}
// else this is not the 1-side (foreign key) of the relationship, so there is nothing for us to do
}
}
// Ensure the the member and foreign keys are nulled so that after trackedInstance is deleted,
// the object does not appear to be associated with the other side anymore. This prevents the deleted object
// from referencing objects still in the cache, but also will prevent the related object from being implicitly loaded
private static void ClearForeignKeysHelper(MetaAssociation assoc, object trackedInstance) {
Debug.Assert(assoc.IsForeignKey, "Foreign key clearing should only happen on foreign key side of the association.");
Debug.Assert(assoc.ThisMember.IsAssociation, "Expected ThisMember of an association to always be an association.");
// If this member is one of our deferred loaders, and it does not already have a value, explicitly set the deferred source to
// null so that when we set the association member itself to null later, it doesn't trigger an implicit load.
// This is only necessary if the value has not already been assigned or set, because otherwise we won't implicitly load anyway when the member is accessed.
MetaDataMember thisMember = assoc.ThisMember;
if (thisMember.IsDeferred &&
!(thisMember.StorageAccessor.HasAssignedValue(trackedInstance) || thisMember.StorageAccessor.HasLoadedValue(trackedInstance)))
{
// If this is a deferred member, set the value directly in the deferred accessor instead of going
// through the normal member accessor, so that we don't trigger an implicit load.
thisMember.DeferredSourceAccessor.SetBoxedValue(ref trackedInstance, null);
}
// Notify the object that the relationship should be considered deleted.
// This allows the object to do its own fixup even when we can't do it automatically.
thisMember.MemberAccessor.SetBoxedValue(ref trackedInstance, null);
// Also set the foreign key values to null if possible
for (int i = 0, n = assoc.ThisKey.Count; i < n; i++) {
MetaDataMember thisKey = assoc.ThisKey[i];
if (thisKey.CanBeNull) {
thisKey.StorageAccessor.SetBoxedValue(ref trackedInstance, null);
}
}
}
private static void ValidateAll(IEnumerable<TrackedObject> list) {
foreach (var item in list) {
if (item.IsNew) {
item.SynchDependentData();
if (item.Type.HasAnyValidateMethod) {
SendOnValidate(item.Type, item, ChangeAction.Insert);
}
} else if (item.IsDeleted) {
if (item.Type.HasAnyValidateMethod) {
SendOnValidate(item.Type, item, ChangeAction.Delete);
}
} else if (item.IsPossiblyModified) {
item.SynchDependentData();
if (item.IsModified && item.Type.HasAnyValidateMethod) {
SendOnValidate(item.Type, item, ChangeAction.Update);
}
}
}
}
private static void SendOnValidate(MetaType type, TrackedObject item, ChangeAction changeAction) {
if (type != null) {
SendOnValidate(type.InheritanceBase, item, changeAction);
if (type.OnValidateMethod != null) {
try {
type.OnValidateMethod.Invoke(item.Current, new object[] { changeAction });
} catch (TargetInvocationException tie) {
if (tie.InnerException != null) {
throw tie.InnerException;
}
throw;
}
}
}
}
internal string GetChangeText() {
this.ObserveUntrackedObjects();
// Must apply inferred deletions only after any untracked objects
// are tracked
this.ApplyInferredDeletions();
this.BuildEdgeMaps();
// append change text only
StringBuilder changeText = new StringBuilder();
foreach (TrackedObject item in this.GetOrderedList()) {
if (item.IsNew) {
item.SynchDependentData();
changeDirector.AppendInsertText(item, changeText);
}
else if (item.IsDeleted) {
changeDirector.AppendDeleteText(item, changeText);
}
else if (item.IsPossiblyModified) {
item.SynchDependentData();
if (item.IsModified) {
changeDirector.AppendUpdateText(item, changeText);
}
}
}
return changeText.ToString();
}
internal ChangeSet GetChangeSet() {
List<object> newEntities = new List<object>();
List<object> deletedEntities = new List<object>();
List<object> changedEntities = new List<object>();
this.ObserveUntrackedObjects();
// Must apply inferred deletions only after any untracked objects
// are tracked
this.ApplyInferredDeletions();
foreach (TrackedObject item in this.tracker.GetInterestingObjects()) {
if (item.IsNew) {
item.SynchDependentData();
newEntities.Add(item.Current);
}
else if (item.IsDeleted) {
deletedEntities.Add(item.Current);
}
else if (item.IsPossiblyModified) {
item.SynchDependentData();
if (item.IsModified) {
changedEntities.Add(item.Current);
}
}
}
return new ChangeSet(newEntities.AsReadOnly(), deletedEntities.AsReadOnly(), changedEntities.AsReadOnly());
}
// verify that primary key and db-generated values have not changed
private static void CheckForInvalidChanges(TrackedObject tracked) {
foreach (MetaDataMember mem in tracked.Type.PersistentDataMembers) {
if (mem.IsPrimaryKey || mem.IsDbGenerated || mem.IsVersion) {
if (tracked.HasChangedValue(mem)) {
if (mem.IsPrimaryKey) {
throw Error.IdentityChangeNotAllowed(mem.Name, tracked.Type.Name);
}
else {
throw Error.DbGeneratedChangeNotAllowed(mem.Name, tracked.Type.Name);
}
}
}
}
}
/// <summary>
/// Create an ChangeConflictException with the best message
/// </summary>
static private ChangeConflictException CreateChangeConflictException(int totalUpdatesAttempted, int failedUpdates) {
string msg = Strings.RowNotFoundOrChanged;
if (totalUpdatesAttempted > 1) {
msg = Strings.UpdatesFailedMessage(failedUpdates, totalUpdatesAttempted);
}
return new ChangeConflictException(msg);
}
internal void TrackUntrackedObjects() {
Dictionary<object, object> visited = new Dictionary<object, object>();
// search for untracked new objects
List<TrackedObject> items = new List<TrackedObject>(this.tracker.GetInterestingObjects());
foreach (TrackedObject item in items) {
this.TrackUntrackedObjects(item.Type, item.Current, visited);
}
}
internal void ApplyInferredDeletions() {
foreach (TrackedObject item in this.tracker.GetInterestingObjects()) {
if (item.CanInferDelete()) {
// based on DeleteOnNull specifications on the item's associations,
// a deletion can be inferred for this item. The actual state transition
// is dependent on the current item state.
if (item.IsNew) {
item.ConvertToRemoved();
}
else if (item.IsPossiblyModified || item.IsModified) {
item.ConvertToDeleted();
}
}
}
}
private void TrackUntrackedObjects(MetaType type, object item, Dictionary<object, object> visited) {
if (!visited.ContainsKey(item)) {
visited.Add(item, item);
TrackedObject tracked = this.tracker.GetTrackedObject(item);
if (tracked == null) {
tracked = this.tracker.Track(item);
tracked.ConvertToNew();
}
else if (tracked.IsDead || tracked.IsRemoved) {
// ignore
return;
}
// search parents (objects we are dependent on)
foreach (RelatedItem parent in this.services.GetParents(type, item)) {
this.TrackUntrackedObjects(parent.Type, parent.Item, visited);
}
// synch up primary key
if (tracked.IsNew) {
tracked.InitializeDeferredLoaders();
if (!tracked.IsPendingGeneration(tracked.Type.IdentityMembers)) {
tracked.SynchDependentData();
object cached = this.services.InsertLookupCachedObject(tracked.Type, item);
if (cached != item) {
TrackedObject cachedTracked = this.tracker.GetTrackedObject(cached);
Debug.Assert(cachedTracked != null);
if (cachedTracked.IsDeleted || cachedTracked.CanInferDelete()) {
// adding new object with same ID as object being deleted.. turn into modified
tracked.ConvertToPossiblyModified(cachedTracked.Original);
// turn deleted to dead...
cachedTracked.ConvertToDead();
this.services.RemoveCachedObjectLike(tracked.Type, item);
this.services.InsertLookupCachedObject(tracked.Type, item);
}
else if (!cachedTracked.IsDead) {
throw new DuplicateKeyException(item, Strings.CantAddAlreadyExistingKey);
}
}
}
else {
// we may have a generated PK, however we set the PK on this new item to
// match a deleted item
object cached = this.services.GetCachedObjectLike(tracked.Type, item);
if (cached != null) {
TrackedObject cachedTracked = this.tracker.GetTrackedObject(cached);
Debug.Assert(cachedTracked != null);
if (cachedTracked.IsDeleted || cachedTracked.CanInferDelete()) {
// adding new object with same ID as object being deleted.. turn into modified
tracked.ConvertToPossiblyModified(cachedTracked.Original);
// turn deleted to dead...
cachedTracked.ConvertToDead();
this.services.RemoveCachedObjectLike(tracked.Type, item);
this.services.InsertLookupCachedObject(tracked.Type, item);
}
}
}
}
// search children (objects that are dependent on us)
foreach (RelatedItem child in this.services.GetChildren(type, item)) {
this.TrackUntrackedObjects(child.Type, child.Item, visited);
}
}
}
internal void ObserveUntrackedObjects() {
Dictionary<object, object> visited = new Dictionary<object, object>();
List<TrackedObject> items = new List<TrackedObject>(this.tracker.GetInterestingObjects());
foreach (TrackedObject item in items) {
this.ObserveUntrackedObjects(item.Type, item.Current, visited);
}
}
private void ObserveUntrackedObjects(MetaType type, object item, Dictionary<object, object> visited) {
if (!visited.ContainsKey(item)) {
visited.Add(item, item);
TrackedObject tracked = this.tracker.GetTrackedObject(item);
if (tracked == null) {
tracked = this.tracker.Track(item);
tracked.ConvertToNew();
} else if (tracked.IsDead || tracked.IsRemoved) {
// ignore
return;
}
// search parents (objects we are dependent on)
foreach (RelatedItem parent in this.services.GetParents(type, item)) {
this.ObserveUntrackedObjects(parent.Type, parent.Item, visited);
}
// synch up primary key unless its generated.
if (tracked.IsNew) {
if (!tracked.IsPendingGeneration(tracked.Type.IdentityMembers)) {
tracked.SynchDependentData();
}
}
// search children (objects that are dependent on us)
foreach (RelatedItem child in this.services.GetChildren(type, item)) {
this.ObserveUntrackedObjects(child.Type, child.Item, visited);
}
}
}
private TrackedObject GetOtherItem(MetaAssociation assoc, object instance) {
if (instance == null)
return null;
object other = null;
// Don't load unloaded references
if (assoc.ThisMember.StorageAccessor.HasAssignedValue(instance) ||
assoc.ThisMember.StorageAccessor.HasLoadedValue(instance)
) {
other = assoc.ThisMember.MemberAccessor.GetBoxedValue(instance);
}
else if (assoc.OtherKeyIsPrimaryKey) {
// Maybe it's in the cache, but not yet attached through reference.
object[] foreignKeys = CommonDataServices.GetForeignKeyValues(assoc, instance);
other = this.services.GetCachedObject(assoc.OtherType, foreignKeys);
}
// else the other key is not the primary key so there is no way to try to look it up
return (other != null) ? this.tracker.GetTrackedObject(other) : null;
}
private bool HasAssociationChanged(MetaAssociation assoc, TrackedObject item) {
if (item.Original != null && item.Current != null) {
if (assoc.ThisMember.StorageAccessor.HasAssignedValue(item.Current) ||
assoc.ThisMember.StorageAccessor.HasLoadedValue(item.Current)
) {
return this.GetOtherItem(assoc, item.Current) != this.GetOtherItem(assoc, item.Original);
}
else {
object[] currentFKs = CommonDataServices.GetForeignKeyValues(assoc, item.Current);
object[] originaFKs = CommonDataServices.GetForeignKeyValues(assoc, item.Original);
for (int i = 0, n = currentFKs.Length; i < n; i++) {
if (!object.Equals(currentFKs[i], originaFKs[i]))
return true;
}
}
}
return false;
}
private void BuildEdgeMaps() {
this.currentParentEdges.Clear();
this.originalChildEdges.Clear();
this.originalChildReferences.Clear();
List<TrackedObject> list = new List<TrackedObject>(this.tracker.GetInterestingObjects());
foreach (TrackedObject item in list) {
bool isNew = item.IsNew;
MetaType mt = item.Type;
foreach (MetaAssociation assoc in mt.Associations) {
if (assoc.IsForeignKey) {
TrackedObject otherItem = this.GetOtherItem(assoc, item.Current);
TrackedObject dbOtherItem = this.GetOtherItem(assoc, item.Original);
bool pointsToDeleted = (otherItem != null && otherItem.IsDeleted) || (dbOtherItem != null && dbOtherItem.IsDeleted);
bool pointsToNew = (otherItem != null && otherItem.IsNew);
if (isNew || pointsToDeleted || pointsToNew || this.HasAssociationChanged(assoc, item)) {
if (otherItem != null) {
this.currentParentEdges.Add(assoc, item, otherItem);
}
if (dbOtherItem != null) {
if (assoc.IsUnique) {
this.originalChildEdges.Add(assoc, dbOtherItem, item);
}
this.originalChildReferences.Add(dbOtherItem, item);
}
}
}
}
}
}
enum VisitState {
Before,
After
}
private List<TrackedObject> GetOrderedList() {
var objects = this.tracker.GetInterestingObjects().ToList();
// give list an initial order (most likely correct order) to avoid deadlocks in server
var range = Enumerable.Range(0, objects.Count).ToList();
range.Sort((int x, int y) => Compare(objects[x], x, objects[y], y));
var ordered = range.Select(i => objects[i]).ToList();
// permute order if constraint dependencies requires some changes to come before others
var visited = new Dictionary<TrackedObject, VisitState>();
var list = new List<TrackedObject>();
foreach (TrackedObject item in ordered) {
this.BuildDependencyOrderedList(item, list, visited);
}
return list;
}
private static int Compare(TrackedObject x, int xOrdinal, TrackedObject y, int yOrdinal) {
// deal with possible nulls
if (x == y) {
return 0;
}
if (x == null) {
return -1;
}
else if (y == null) {
return 1;
}
// first order by action: Inserts first, Updates, Deletes last
int xAction = x.IsNew ? 0 : x.IsDeleted ? 2 : 1;
int yAction = y.IsNew ? 0 : y.IsDeleted ? 2 : 1;
if (xAction < yAction) {
return -1;
}
else if (xAction > yAction) {
return 1;
}
// no need to order inserts (PK's may not even exist)
if (x.IsNew) {
// keep original order
return xOrdinal.CompareTo(yOrdinal);
}
// second order by type
if (x.Type != y.Type) {
return string.CompareOrdinal(x.Type.Type.FullName, y.Type.Type.FullName);
}
// lastly, order by PK values
int result = 0;
foreach (MetaDataMember mm in x.Type.IdentityMembers) {
object xValue = mm.StorageAccessor.GetBoxedValue(x.Current);
object yValue = mm.StorageAccessor.GetBoxedValue(y.Current);
if (xValue == null) {
if (yValue != null) {
return -1;
}
}
else {
IComparable xc = xValue as IComparable;
if (xc != null) {
result = xc.CompareTo(yValue);
if (result != 0) {
return result;
}
}
}
}
// they are the same? leave in original order
return xOrdinal.CompareTo(yOrdinal);
}
private void BuildDependencyOrderedList(TrackedObject item, List<TrackedObject> list, Dictionary<TrackedObject, VisitState> visited) {
VisitState state;
if (visited.TryGetValue(item, out state)) {
if (state == VisitState.Before) {
throw Error.CycleDetected();
}
return;
}
visited[item] = VisitState.Before;
if (item.IsInteresting) {
if (item.IsDeleted) {
// if 'item' is deleted
// all objects that used to refer to 'item' must be ordered before item
foreach (TrackedObject other in this.originalChildReferences[item]) {
if (other != item) {
this.BuildDependencyOrderedList(other, list, visited);
}
}
}
else {
// if 'item' is new or changed
// for all objects 'other' that 'item' refers to along association 'assoc'
// if 'other' is new then 'other' must be ordered before 'item'
// if 'assoc' is pure one-to-one and some other item 'prevItem' used to refer to 'other'
// then 'prevItem' must be ordered before 'item'
foreach (MetaAssociation assoc in item.Type.Associations) {
if (assoc.IsForeignKey) {
TrackedObject other = this.currentParentEdges[assoc, item];
if (other != null) {
if (other.IsNew) {
// if other is new, visit other first (since item's FK depends on it)
if (other != item || item.Type.DBGeneratedIdentityMember != null) {
this.BuildDependencyOrderedList(other, list, visited);
}
}
else if ((assoc.IsUnique || assoc.ThisKeyIsPrimaryKey)) {
TrackedObject prevItem = this.originalChildEdges[assoc, other];
if (prevItem != null && other != item) {
this.BuildDependencyOrderedList(prevItem, list, visited);
}
}
}
}
}
}
list.Add(item);
}
visited[item] = VisitState.After;
}
class EdgeMap {
Dictionary<MetaAssociation, Dictionary<TrackedObject, TrackedObject>> associations;
internal EdgeMap() {
this.associations = new Dictionary<MetaAssociation, Dictionary<TrackedObject, TrackedObject>>();
}
internal void Add(MetaAssociation assoc, TrackedObject from, TrackedObject to) {
Dictionary<TrackedObject, TrackedObject> pairs;
if (!associations.TryGetValue(assoc, out pairs)) {
pairs = new Dictionary<TrackedObject, TrackedObject>();
associations.Add(assoc, pairs);
}
pairs.Add(from, to);
}
internal TrackedObject this[MetaAssociation assoc, TrackedObject from] {
get {
Dictionary<TrackedObject, TrackedObject> pairs;
if (associations.TryGetValue(assoc, out pairs)) {
TrackedObject to;
if (pairs.TryGetValue(from, out to)) {
return to;
}
}
return null;
}
}
internal void Clear() {
this.associations.Clear();
}
}
class ReferenceMap {
Dictionary<TrackedObject, List<TrackedObject>> references;
internal ReferenceMap() {
this.references = new Dictionary<TrackedObject, List<TrackedObject>>();
}
internal void Add(TrackedObject from, TrackedObject to) {
List<TrackedObject> refs;
if (!references.TryGetValue(from, out refs)) {
refs = new List<TrackedObject>();
references.Add(from, refs);
}
if (!refs.Contains(to))
refs.Add(to);
}
internal IEnumerable<TrackedObject> this[TrackedObject from] {
get {
List<TrackedObject> refs;
if (references.TryGetValue(from, out refs)) {
return refs;
}
return Empty;
}
}
internal void Clear() {
this.references.Clear();
}
private static TrackedObject[] Empty = new TrackedObject[] { };
}
}
}
|