Refactoring OneOrMany (#118)

* Overhaul of OneOrMany

- Only uses an array internally
- Hot path for strings
- Addresses inconsistency null rules for items

* Updating tests to match new logic

The change relates to value types now having no items actually acting that they have no items, not returning an item because the default value isn't equal to null.

* Simplify HashCode generation

* Add Span support

* Added custom methods for `ToArray` and `FirstOrDefault`

* Optimise zero-length array allocation

* Removed custom FirstOrDefault

Author: Turnerj

Source/Schema.NET/OneOrMany{T}.cs

@@ -4,6 +4,7 @@ namespace Schema.NET
     using System.Collections;
     using System.Collections.Generic;
     using System.Linq;
+    using System.Runtime.CompilerServices;
 
     /// <summary>
     /// A single or list of values.
@@ -15,131 +16,134 @@ public readonly struct OneOrMany<T>
         : IReadOnlyCollection<T>, IEnumerable<T>, IValues, IEquatable<OneOrMany<T>>
 #pragma warning restore CA1710 // Identifiers should have correct suffix
     {
-        private readonly List<T> collection;
-        private readonly T item;
+        private readonly T[] collection;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="OneOrMany{T}"/> struct.
         /// </summary>
         /// <param name="item">The single item value.</param>
         public OneOrMany(T item)
         {
-            this.collection = null;
-            this.item = item;
+            if (item is null || (item is string itemAsString && string.IsNullOrWhiteSpace(itemAsString)))
+            {
+                this.collection = null;
+                this.HasOne = false;
+            }
+            else
+            {
+                this.collection = new[] { item };
+                this.HasOne = true;
+            }
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="OneOrMany{T}"/> struct.
         /// </summary>
-        /// <param name="array">The array of values.</param>
-        public OneOrMany(params T[] array)
-            : this(array is null ? null : new List<T>(array))
+        /// <param name="span">The span of values.</param>
+        public OneOrMany(ReadOnlySpan<T> span)
         {
+            if (!span.IsEmpty)
+            {
+                var items = new T[span.Length];
+                var index = 0;
+
+                if (typeof(T) == typeof(string))
+                {
+                    for (var i = 0; i < span.Length; i++)
+                    {
+                        var item = span[i];
+                        if (!string.IsNullOrWhiteSpace(item as string))
+                        {
+                            items[index] = item;
+                            index++;
+                        }
+                    }
+                }
+                else
+                {
+                    for (var i = 0; i < span.Length; i++)
+                    {
+                        var item = span[i];
+                        if (item != null)
+                        {
+                            items[index] = item;
+                            index++;
+                        }
+                    }
+                }
+
+                if (index > 0)
+                {
+                    if (index == span.Length)
+                    {
+                        this.collection = items;
+                    }
+                    else
+                    {
+                        this.collection = new T[index];
+                        Array.Copy(items, 0, this.collection, 0, index);
+                    }
+
+                    this.HasOne = index == 1;
+                    return;
+                }
+            }
+
+            this.collection = null;
+            this.HasOne = false;
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="OneOrMany{T}"/> struct.
         /// </summary>
-        /// <param name="collection">The collection of values.</param>
-        public OneOrMany(IEnumerable<T> collection)
-            : this(collection is null ? null : new List<T>(collection))
+        /// <param name="array">The array of values.</param>
+        public OneOrMany(params T[] array)
+            : this(array.AsSpan())
         {
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="OneOrMany{T}"/> struct.
         /// </summary>
-        /// <param name="list">The list of values.</param>
-        public OneOrMany(List<T> list)
+        /// <param name="collection">The collection of values.</param>
+        public OneOrMany(IEnumerable<T> collection)
+            : this(collection.ToArray().AsSpan())
         {
-            if (list is null)
-            {
-                throw new ArgumentNullException(nameof(list));
-            }
-
-            if (list.Count == 1)
-            {
-                this.collection = null;
-                this.item = list[0];
-            }
-            else
-            {
-                this.collection = list;
-                this.item = default;
-            }
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="OneOrMany{T}"/> struct.
         /// </summary>
-        /// <param name="list">The list of values.</param>
-        public OneOrMany(IEnumerable<object> list)
+        /// <param name="collection">The list of values.</param>
+        public OneOrMany(IEnumerable<object> collection)
+            : this(collection.Cast<T>().ToArray().AsSpan())
         {
-            if (list is null)
-            {
-                throw new ArgumentNullException(nameof(list));
-            }
-
-            var items = new List<T>();
-            foreach (var item in list)
-            {
-                if (item is T itemT)
-                {
-                    items.Add(itemT);
-                }
-            }
-
-            if (items.Count == 1)
-            {
-                this.collection = null;
-                this.item = items[0];
-            }
-            else
-            {
-                this.collection = items;
-                this.item = default;
-            }
         }
 
         /// <summary>
         /// Gets the number of elements contained in the <see cref="OneOrMany{T}"/>.
         /// </summary>
-        public int Count
-        {
-            get
-            {
-                if (this.HasOne)
-                {
-                    return 1;
-                }
-                else if (this.HasMany)
-                {
-                    return this.collection.Count;
-                }
-
-                return 0;
-            }
-        }
+        public int Count => this.collection?.Length ?? 0;
 
         /// <summary>
         /// Gets a value indicating whether this instance has a single item value.
         /// </summary>
         /// <value><c>true</c> if this instance has a single item value; otherwise, <c>false</c>.</value>
-        public bool HasOne => this.collection is null && this.item != null;
+        public bool HasOne { get; }
 
         /// <summary>
         /// Gets a value indicating whether this instance has more than one value.
         /// </summary>
         /// <value><c>true</c> if this instance has more than one value; otherwise, <c>false</c>.</value>
-        public bool HasMany => this.collection != null;
+        public bool HasMany => this.collection?.Length > 1;
 
         /// <summary>
         /// Performs an implicit conversion from <typeparamref name="T"/> to <see cref="OneOrMany{T}"/>.
         /// </summary>
         /// <param name="item">The single item value.</param>
         /// <returns>The result of the conversion.</returns>
 #pragma warning disable CA2225 // Operator overloads have named alternates
-        public static implicit operator OneOrMany<T>(T item) => item != null && IsStringNullOrWhiteSpace(item) ? default : new OneOrMany<T>(item);
+        public static implicit operator OneOrMany<T>(T item) => new OneOrMany<T>(item);
 #pragma warning restore CA2225 // Operator overloads have named alternates
 
         /// <summary>
@@ -148,7 +152,7 @@ public int Count
         /// <param name="array">The array of values.</param>
         /// <returns>The result of the conversion.</returns>
 #pragma warning disable CA2225 // Operator overloads have named alternates
-        public static implicit operator OneOrMany<T>(T[] array) => new OneOrMany<T>(array?.Where(x => x != null && !IsStringNullOrWhiteSpace(x)));
+        public static implicit operator OneOrMany<T>(T[] array) => new OneOrMany<T>(array);
 #pragma warning restore CA2225 // Operator overloads have named alternates
 
         /// <summary>
@@ -157,7 +161,7 @@ public int Count
         /// <param name="list">The list of values.</param>
         /// <returns>The result of the conversion.</returns>
 #pragma warning disable CA2225 // Operator overloads have named alternates
-        public static implicit operator OneOrMany<T>(List<T> list) => new OneOrMany<T>(list?.Where(x => x != null && !IsStringNullOrWhiteSpace(x)));
+        public static implicit operator OneOrMany<T>(List<T> list) => new OneOrMany<T>(list);
 #pragma warning restore CA2225 // Operator overloads have named alternates
 
         /// <summary>
@@ -219,17 +223,13 @@ public int Count
         /// <returns>An enumerator for the <see cref="OneOrMany{T}"/>.</returns>
         public IEnumerator<T> GetEnumerator()
         {
-            if (this.HasMany)
+            if (this.collection != null)
             {
-                foreach (var item in this.collection)
+                for (var i = 0; i < this.collection.Length; i++)
                 {
-                    yield return item;
+                    yield return this.collection[i];
                 }
             }
-            else if (this.HasOne)
-            {
-                yield return this.item;
-            }
         }
 
         /// <summary>
@@ -238,6 +238,32 @@ public IEnumerator<T> GetEnumerator()
         /// <returns>An enumerator for the <see cref="OneOrMany{T}"/>.</returns>
         IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator();
 
+        /// <summary>
+        /// Creates an array from <see cref="OneOrMany{T}" />.
+        /// </summary>
+        /// <returns>An array containing all the elements.</returns>
+        public T[] ToArray()
+        {
+            if (this.HasOne)
+            {
+                return new[] { this.collection[0] };
+            }
+            else if (this.HasMany)
+            {
+                var result = new T[this.collection.Length];
+                Array.Copy(this.collection, 0, result, 0, this.collection.Length);
+                return result;
+            }
+            else
+            {
+#if NETSTANDARD1_1
+                return new T[0];
+#else
+                return Array.Empty<T>();
+#endif
+            }
+        }
+
         /// <summary>
         /// Indicates whether the current object is equal to another object of the same type.
         /// </summary>
@@ -253,16 +279,16 @@ public bool Equals(OneOrMany<T> other)
             }
             else if (this.HasOne && other.HasOne)
             {
-                return this.item.Equals(other.item);
+                return this.collection[0].Equals(other.collection[0]);
             }
             else if (this.HasMany && other.HasMany)
             {
-                if (this.collection.Count != other.collection.Count)
+                if (this.collection.Length != other.collection.Length)
                 {
                     return false;
                 }
 
-                for (var i = 0; i < this.collection.Count; i++)
+                for (var i = 0; i < this.collection.Length; i++)
                 {
                     if (!EqualityComparer<T>.Default.Equals(this.collection[i], other.collection[i]))
                     {
@@ -291,26 +317,6 @@ public bool Equals(OneOrMany<T> other)
         /// <returns>
         /// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table.
         /// </returns>
-        public override int GetHashCode()
-        {
-            if (this.HasOne)
-            {
-                return HashCode.Of(this.item);
-            }
-            else if (this.HasMany)
-            {
-                return HashCode.OfEach(this.collection);
-            }
-
-            return 0;
-        }
-
-        /// <summary>
-        /// Checks whether the generic T item is a string that is either null or contains whitespace.
-        /// </summary>
-        /// <returns>
-        /// Returns true if the supplied item is a string that is null or contains whitespace.
-        /// </returns>
-        private static bool IsStringNullOrWhiteSpace(T item) => item.GetType() == typeof(string) && string.IsNullOrWhiteSpace(item as string);
+        public override int GetHashCode() => HashCode.OfEach(this.collection);
     }
 }

Source/Schema.NET/Schema.NET.csproj

@@ -44,6 +44,7 @@
     <PackageReference Include="Microsoft.SourceLink.GitHub" PrivateAssets="All" Version="1.0.0" />
     <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="16.4.43" />
     <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
+    <PackageReference Include="System.Memory" Version="4.5.3" />
   </ItemGroup>
 
   <ItemGroup Label="Analyzer Package References">

Tests/Schema.NET.Test/OneOrManyTest.cs

@@ -57,7 +57,7 @@ public void Constructor_NullList_ThrowsArgumentNullException() =>
             Assert.Throws<ArgumentNullException>(() => new OneOrMany<int>((List<int>)null));
 
         [Fact]
-        public void Count_DefaultStructConstructor_ReturnsOne() => Assert.Single(default(OneOrMany<int>));
+        public void Count_DefaultStructConstructor_ReturnsZero() => Assert.Empty(default(OneOrMany<int>));
 
         [Fact]
         public void Count_DefaultClassConstructor_ReturnsZero() => Assert.Empty(default(OneOrMany<string>));
@@ -76,7 +76,7 @@ public void Count_Enumerable_ReturnsTwo() =>
             Assert.Equal(2, new OneOrMany<int>(new List<int>() { 1, 2 }).Count);
 
         [Fact]
-        public void HasOne_DefaultStructConstructor_ReturnsTrue() => Assert.True(default(OneOrMany<int>).HasOne);
+        public void HasOne_DefaultStructConstructor_ReturnsFalse() => Assert.False(default(OneOrMany<int>).HasOne);
 
         [Fact]
         public void HasOne_DefaultClassConstructor_ReturnsFalse() => Assert.False(default(OneOrMany<string>).HasOne);
@@ -169,11 +169,8 @@ public void NotEqualsOperator_IsNotEqual_ReturnsTrue() =>
             Assert.True(new OneOrMany<int>(1) != new OneOrMany<int>(2));
 
         [Fact]
-        public void GetEnumerator_DefaultStructConstructor_ReturnsZero()
-        {
-            var item = Assert.Single(((IEnumerable)default(OneOrMany<int>)).Cast<object>());
-            Assert.Equal(0, item);
-        }
+        public void GetEnumerator_DefaultStructConstructor_ReturnsNull() =>
+            Assert.Empty(((IEnumerable)default(OneOrMany<int>)).Cast<object>());
 
         [Fact]
         public void GetEnumerator_DefaultClassConstructor_ReturnsNull() =>