/// <summary> /// Returns a ReadOnlyEnumerableOfT that is the result of <paramref name="source"/> plus <paramref name="item"/>. /// </summary> /// <typeparam name="T">The element type of the enumerable.</typeparam> /// <param name="source">The source enumerable to concat.</param> /// <param name="collectionName">The name of the collection to report in case there's an error.</param> /// <param name="item">Item to concat to the source enumerable.</param> /// <returns>Returns a ReadOnlyEnumerableOfT that is the result of <paramref name="source"/> plus <paramref name="item"/>.</returns> internal static ReadOnlyEnumerable <T> ConcatToReadOnlyEnumerable <T>(this IEnumerable <T> source, string collectionName, T item) { ReadOnlyEnumerable <T> readOnlyEnumerable = source.GetOrCreateReadOnlyEnumerable(collectionName); readOnlyEnumerable.AddToSourceList(item); return(readOnlyEnumerable); }
public void AddToSourceListShouldAddToTheSourceList() { ReadOnlyEnumerable<int> enumerable = new ReadOnlyEnumerable<int>(); enumerable.Should().BeEmpty(); enumerable.AddToSourceList(1); enumerable.Count().Should().Be(1); enumerable.Should().OnlyContain(i => i == 1); }
/// <summary> /// Creates a new instance of ATOM feed metadata. /// </summary> /// <returns>The newly created ATOM feed metadata.</returns> internal static AtomFeedMetadata CreateNewAtomFeedMetadata() { return(new AtomFeedMetadata { Authors = ReadOnlyEnumerable <AtomPersonMetadata> .Empty(), Categories = ReadOnlyEnumerable <AtomCategoryMetadata> .Empty(), Contributors = ReadOnlyEnumerable <AtomPersonMetadata> .Empty(), Links = ReadOnlyEnumerable <AtomLinkMetadata> .Empty(), }); }
/// <summary> /// Casts an IEnumerableOfT to ReadOnlyEnumerableOfT. /// </summary> /// <typeparam name="T">The element type of the enumerable.</typeparam> /// <param name="source">The source enumerable.</param> /// <param name="collectionName">The name of the collection to report in case there's an error.</param> /// <returns>The casted ReadOnlyEnumerableOfT.</returns> internal static ReadOnlyEnumerable <T> ToReadOnlyEnumerable <T>(this IEnumerable <T> source, string collectionName) { Debug.Assert(!String.IsNullOrEmpty(collectionName), "!string.IsNullOrEmpty(collectionName)"); ReadOnlyEnumerable <T> readonlyCollection = source as ReadOnlyEnumerable <T>; if (readonlyCollection == null) { throw new ODataException(Strings.ReaderUtils_EnumerableModified(collectionName)); } return(readonlyCollection); }
public void ConcatToReadOnlyEnumerableShouldAddForReadOnlyEnumerableSource() { var enumerable = new ReadOnlyEnumerable<ODataProperty>(); enumerable.Count().Should().Be(0); enumerable.ConcatToReadOnlyEnumerable("Properties", new ODataProperty()); enumerable.Count().Should().Be(1); }
public void GetOrCreateReadOnlyEnumerableShouldGetForReadOnlyEnumerableSource() { var enumerable = new ReadOnlyEnumerable<int>(); var enumerable2 = enumerable.GetOrCreateReadOnlyEnumerable("Integers"); enumerable2.As<object>().Should().NotBeSameAs(ReadOnlyEnumerable<int>.Empty()); enumerable2.As<object>().Should().BeSameAs(enumerable); }
/// <summary> /// true if <paramref name="source"/> is the same instance as ReadOnlyEnumerableOfT.Empty(). false otherwise. /// </summary> /// <typeparam name="T">The element type of the enumerable.</typeparam> /// <param name="source">The enumerable in question.</param> /// <returns>Returns true if <paramref name="source"/> is the empty ReadOnlyEnumerableOfT. false otherwise.</returns> internal static bool IsEmptyReadOnlyEnumerable <T>(this IEnumerable <T> source) { return(ReferenceEquals(source, ReadOnlyEnumerable <T> .Empty())); }