public EnumerationState_I Enumerate <T>(CollectionContainer_I <T> container) { return(CollectionContainers.Enumerate(container)); }
/// <summary> /// Enumerates through all the items in the collection and attempts to cast the items to the type T. /// </summary> public void Enumerate(CollectionContainer_I container, Action <object> action) { CollectionContainers.Enumerate(container, action); }
/// <summary> /// Enumerates through all the items in the collection and attempts to cast the items to the type T. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="container"></param> /// <param name="action"></param> public void Enumerate <T>(CollectionContainer_I <T> container, Action <T> action) { CollectionContainers.Enumerate(container, action); }
public EnumerationState_I Enumerate <T>(CollectionContainer_I <T> container) { throw new NotImplementedException(); }
/// <summary> /// Removes the object from the collection. /// </summary> /// <remarks>It is up to the collection implementation to determine how this is done. This method should be used for business logic and not for low level collection access.</remarks> /// <typeparam name="T"></typeparam> /// <param name="container"></param> /// <param name="objectToRemove"></param> public void Remove <T>(CollectionContainer_I container, T objectToRemove) { CollectionContainers.Remove(container, objectToRemove); }
public void Enumerate <T>(CollectionContainer_I container, Action <T> action) { throw new NotImplementedException(); }
public T MoveNext <T>(CollectionContainer_I <T> container, EnumerationState_I state) { throw new NotImplementedException(); }
public AddResult_I <T> Add <T>(CollectionContainer_I container, T objectToAdd) { throw new NotImplementedException(); }
public RemoveResult_I <T> Remove <T>(CollectionContainer_I container, T objectToRemove) { throw new NotImplementedException(); }
/// <summary> /// Iterates through all the items in the collection and attempts to cast the items to the type T. This is an alternative to supporting the for-each statement. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="container"></param> /// <param name="action"></param> public static void Enumerate <T>(this CollectionContainer_I <T> container, Action <T> action) { XCollectionContainers.Enumerate(container, action); }
/// <summary> /// Removes the object from the collection. /// </summary> /// <remarks>It is up to the collection implementation to determine how this is done. This method should be used for business logic and not for low level collection access.</remarks> /// <typeparam name="T"></typeparam> /// <param name="container"></param> /// <param name="objectToRemove"></param> public static RemoveResult_I <T> Remove <T>(this CollectionContainer_I container, T objectToRemove) { return(XCollectionContainers.Remove(container, objectToRemove)); }
/// <summary> /// Iterates through all the items in the collection and attempts to cast the items to the type T. This is an alternative to supporting the for-each statement. /// </summary> public static void Enumerate(this CollectionContainer_I container, Action <object> action) { XCollectionContainers.Enumerate(container, action); }
/// <summary> /// Adds the object to the collection. /// </summary> /// <remarks>It is up to the collection implementation to determine how this is done. This method should be used for business logic and not for low level collection access.</remarks> public static AddResult_I <T> Add <T>(this CollectionContainer_I <T> container, T objectToAdd) { return(XCollectionContainers.Add(container, objectToAdd)); }
public static void Enumerate <T>(CollectionContainer_I container, Action <T> action) { Api.Enumerate(container, action); }
public static AddResult_I <T> Add <T>(CollectionContainer_I container, T objectToAdd) { return(Api.Add(container, objectToAdd)); }
/// <summary> /// Removes the object from the collection. /// </summary> /// <remarks>It is up to the collection implementation to determine how this is done. This method should be used for business logic and not for low level collection access.</remarks> /// <typeparam name="T"></typeparam> /// <param name="container"></param> /// <param name="objectToRemove"></param> public static void Remove <T>(this CollectionContainer_I container, T objectToRemove) { Api.Remove(container, objectToRemove); }