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);
}
