/// <summary> /// Checks whether a <see cref="DomainObjectCollection"/> matches a sequence of <see cref="DomainObject"/> items by reference. /// The comparison takes the order of elements into account. /// </summary> /// <param name="collection">The <see cref="DomainObjectCollection"/> to check.</param> /// <param name="comparedSequence">The sequence of elements to check against.</param> /// <returns><see langword="true"/> if the collection contains the same items as the comparedCollection in the same order; otherwise, <see langword="false"/>.</returns> public static bool SequenceEqual(this DomainObjectCollection collection, IEnumerable <DomainObject> comparedSequence) { ArgumentUtility.CheckNotNull("collection", collection); ArgumentUtility.CheckNotNull("comparedSequence", comparedSequence); return(collection.Cast <DomainObject> ().SequenceEqual(comparedSequence)); }
/// <summary> /// Returns all items of a given <see cref="DomainObjectCollection"/> that are not part of another <see cref="DomainObjectCollection"/>. The /// comparison is made by <see cref="DomainObject.ID"/>, not by reference. /// </summary> /// <param name="collection">The collection to return items from.</param> /// <param name="exceptedDomainObjects">A collection containing items that should not be returned.</param> /// <returns> /// An enumeration of all items from <paramref name="collection"/> that are not part of <paramref name="exceptedDomainObjects"/>. /// </returns> /// <remarks> /// <para>The method does not modify the given <see cref="DomainObjectCollection"/> istances.</para> /// </remarks> public static IEnumerable <DomainObject> GetItemsExcept(this DomainObjectCollection collection, HashSet <DomainObject> exceptedDomainObjects) { ArgumentUtility.CheckNotNull("collection", collection); ArgumentUtility.CheckNotNull("exceptedDomainObjects", exceptedDomainObjects); return(collection.Cast <DomainObject>().Where(domainObject => !exceptedDomainObjects.Contains(domainObject))); }
/// <summary> /// Adapts the given <see cref="DomainObjectCollection"/> as an <see cref="IList{T}"/>. /// </summary> /// <typeparam name="T">The desired item type. This must be assignable from the <see cref="DomainObjectCollection"/>'s /// <see cref="DomainObjectCollection.RequiredItemType"/>. If it is more general than the item type, the <see cref="DomainObjectCollection"/>'s /// runtime checks will ensure that only compatible items are inserted into the list.</typeparam> /// <param name="collection">The collection to be wrapped..</param> /// <returns>An implementation of <see cref="IList{T}"/> that wraps the given <paramref name="collection"/>.</returns> public static IList <T> AsList <T> (this DomainObjectCollection collection) where T : DomainObject { ArgumentUtility.CheckNotNull("collection", collection); return(new DomainObjectCollectionWrapper <T> (collection)); }
/// <summary> /// Returns a <see cref="ReadOnlyCollection{T}"/> representing the data of the <see cref="DomainObjectCollection"/>. /// The data is not copied; instead, the returned collection holds the same data store as the original collection and will therefore reflect /// any changes made to the original. /// </summary> /// <returns>A <see cref="ReadOnlyCollection{T}"/> representing the data of the <see cref="DomainObjectCollection"/>.</returns> public static ReadOnlyCollection <DomainObject> AsReadOnlyCollection(this DomainObjectCollection collection) { ArgumentUtility.CheckNotNull("collection", collection); var listAdapter = collection.AsList <DomainObject> (); return(new ReadOnlyCollection <DomainObject> (listAdapter)); }
/// <summary> /// Adds all items of the given <see cref="DomainObjectCollection"/> to the <see cref="DomainObjectCollection"/>, that are not already part of it. /// This method is a convenience method combining <see cref="DomainObjectCollection.Contains"/> and <see cref="DomainObjectCollection.AddRange"/>. If there are no changes made to this /// collection, the <see cref="DomainObjectCollection"/> method does not touch the associated end point (if any). /// </summary> /// <param name="collection">The collection to add items to.</param> /// <param name="sourceCollection">The collection to add items from. Must not be <see langword="null"/>.</param> /// <remarks> /// <para> /// To check if an item is already part of the <see cref="DomainObject.ID"/> its <see cref="DomainObject"/> is used. /// <see cref="DomainObject.ID"/> does not check if the item references are identical. In case the two <see cref="DomainObject"/> contain /// different items with the same <see cref="DomainObjectCollection"/>, <see cref="System"/> will thus ignore those items. /// </para> /// <para> /// This method calls <see cref="DomainObjectCollection.AddRange"/> and might throw any of the exceptions that can be thrown by /// <see cref="DomainObjectCollection.AddRange"/>- /// </para> /// </remarks> public static void UnionWith(this DomainObjectCollection collection, DomainObjectCollection sourceCollection) { ArgumentUtility.CheckNotNull("collection", collection); ArgumentUtility.CheckNotNull("sourceCollection", sourceCollection); collection.CheckNotReadOnly("A read-only collection cannot be combined with another collection."); collection.AddRange(sourceCollection.Cast <DomainObject> ().Where(obj => !collection.Contains(obj.ID))); }
/// <summary> /// Checks that the given <see cref="DomainObjectCollection"/> is not read only, throwing a <see cref="NotSupportedException"/> if it is. /// </summary> /// <param name="collection">The collection to check.</param> /// <param name="message">The message the exception should have if one is thrown.</param> public static void CheckNotReadOnly(this DomainObjectCollection collection, string message) { ArgumentUtility.CheckNotNull("collection", collection); ArgumentUtility.CheckNotNullOrEmpty("message", message); if (collection.IsReadOnly) { throw new NotSupportedException(message); } }
internal void CopyEventHandlersFrom(DomainObjectCollection source) { ArgumentUtility.CheckNotNull("source", source); Adding += source.Adding; Added += source.Added; Removing += source.Removing; Removed += source.Removed; Deleting += source.Deleting; Deleted += source.Deleted; }
public DomainObjectCollectionWrapper(DomainObjectCollection wrappedCollection) { ArgumentUtility.CheckNotNull("wrappedCollection", wrappedCollection); var requiredItemType = wrappedCollection.RequiredItemType ?? typeof(DomainObject); if (!typeof(T).IsAssignableFrom(requiredItemType)) { var message = string.Format( "Cannot implement 'IList<{0}>' for a DomainObjectCollection with required item type '{1}'. The IList<T>'s item type must be assignable " + "from the required item type.", typeof(T), requiredItemType); throw new ArgumentException(message, "wrappedCollection"); } _wrappedCollection = wrappedCollection; }
/// <summary> /// Checks whether a <see cref="DomainObjectCollection"/> matches another set of <see cref="DomainObject"/> items by reference. /// The comparison does not take the order of elements into account. /// </summary> /// <param name="collection">The <see cref="DomainObjectCollection"/> to check.</param> /// <param name="comparedSet">The set of elements to check against.</param> /// <returns><see langword="true"/> if the collection contains the same items as the set in any order; otherwise, <see langword="false"/>.</returns> public static bool SetEquals(this DomainObjectCollection collection, IEnumerable <DomainObject> comparedSet) { ArgumentUtility.CheckNotNull("collection", collection); ArgumentUtility.CheckNotNull("comparedSet", comparedSet); var setOfComparedObjects = new HashSet <DomainObject> (); // this is used to get rid of all duplicates to get a correct result foreach (var domainObject in comparedSet) { if (!collection.ContainsObject(domainObject)) { return(false); } setOfComparedObjects.Add(domainObject); } return(collection.Count == setOfComparedObjects.Count); // the collection must contain exactly the number of items in the comparedSet - without dups }
public static bool Compare(DomainObjectCollection collection1, DomainObjectCollection collection2, bool ignoreItemOrder) { throw new NotImplementedException(); }
protected internal virtual void Rollback(DomainObjectCollection originalDomainObjects) { throw new NotImplementedException(); }
public ReadOnlyDomainObjectCollectionAdapter(DomainObjectCollection wrappedData) { ArgumentUtility.CheckNotNull("wrappedData", wrappedData); _wrappedData = wrappedData; }
public void Combine(DomainObjectCollection domainObjects) { throw new NotImplementedException(); }
public DomainObjectCollection GetItemsNotInCollection(DomainObjectCollection domainObjects) { throw new NotImplementedException(); }
public DomainObjectCollection(DomainObjectCollection collection, bool makeCollectionReadOnly) { throw new NotImplementedException(); }
public static bool Compare(DomainObjectCollection collection1, DomainObjectCollection collection2) { throw new NotImplementedException(); }
protected internal virtual void ReplaceItems(DomainObjectCollection domainObjects) { throw new NotImplementedException(); }