Only allocate lists when we need to (#120)

Turnerj · web-flow · commit e41be227874e · 2019-12-31T12:20:15.000+10:30
diff --git a/Source/Schema.NET/Values{T1,T2,T3,T4}.cs b/Source/Schema.NET/Values{T1,T2,T3,T4}.cs
@@ -101,40 +101,60 @@ public Values(IEnumerable<object> items)
                 throw new ArgumentNullException(nameof(items));
             }
 
-            var items1 = new List<T1>();
-            var items2 = new List<T2>();
-            var items3 = new List<T3>();
-            var items4 = new List<T4>();
+            List<T1> items1 = null;
+            List<T2> items2 = null;
+            List<T3> items3 = null;
+            List<T4> items4 = null;
 
             foreach (var item in items)
             {
                 if (item is T4 itemT4)
                 {
+                    if (items4 == null)
+                    {
+                        items4 = new List<T4>();
+                    }
+
                     items4.Add(itemT4);
                 }
                 else if (item is T3 itemT3)
                 {
+                    if (items3 == null)
+                    {
+                        items3 = new List<T3>();
+                    }
+
                     items3.Add(itemT3);
                 }
                 else if (item is T2 itemT2)
                 {
+                    if (items2 == null)
+                    {
+                        items2 = new List<T2>();
+                    }
+
                     items2.Add(itemT2);
                 }
                 else if (item is T1 itemT1)
                 {
+                    if (items1 == null)
+                    {
+                        items1 = new List<T1>();
+                    }
+
                     items1.Add(itemT1);
                 }
             }
 
-            this.HasValue1 = items1.Count > 0;
-            this.HasValue2 = items2.Count > 0;
-            this.HasValue3 = items3.Count > 0;
-            this.HasValue4 = items4.Count > 0;
+            this.HasValue1 = items1?.Count > 0;
+            this.HasValue2 = items2?.Count > 0;
+            this.HasValue3 = items3?.Count > 0;
+            this.HasValue4 = items4?.Count > 0;
 
-            this.Value1 = items1;
-            this.Value2 = items2;
-            this.Value3 = items3;
-            this.Value4 = items4;
+            this.Value1 = items1 == null ? default : (OneOrMany<T1>)items1;
+            this.Value2 = items2 == null ? default : (OneOrMany<T2>)items2;
+            this.Value3 = items3 == null ? default : (OneOrMany<T3>)items3;
+            this.Value4 = items4 == null ? default : (OneOrMany<T4>)items4;
         }
 
         /// <summary>
diff --git a/Source/Schema.NET/Values{T1,T2,T3}.cs b/Source/Schema.NET/Values{T1,T2,T3}.cs
@@ -78,33 +78,48 @@ public Values(IEnumerable<object> items)
                 throw new ArgumentNullException(nameof(items));
             }
 
-            var items1 = new List<T1>();
-            var items2 = new List<T2>();
-            var items3 = new List<T3>();
+            List<T1> items1 = null;
+            List<T2> items2 = null;
+            List<T3> items3 = null;
 
             foreach (var item in items)
             {
                 if (item is T3 itemT3)
                 {
+                    if (items3 == null)
+                    {
+                        items3 = new List<T3>();
+                    }
+
                     items3.Add(itemT3);
                 }
                 else if (item is T2 itemT2)
                 {
+                    if (items2 == null)
+                    {
+                        items2 = new List<T2>();
+                    }
+
                     items2.Add(itemT2);
                 }
                 else if (item is T1 itemT1)
                 {
+                    if (items1 == null)
+                    {
+                        items1 = new List<T1>();
+                    }
+
                     items1.Add(itemT1);
                 }
             }
 
-            this.HasValue1 = items1.Count > 0;
-            this.HasValue2 = items2.Count > 0;
-            this.HasValue3 = items3.Count > 0;
+            this.HasValue1 = items1?.Count > 0;
+            this.HasValue2 = items2?.Count > 0;
+            this.HasValue3 = items3?.Count > 0;
 
-            this.Value1 = items1;
-            this.Value2 = items2;
-            this.Value3 = items3;
+            this.Value1 = items1 == null ? default : (OneOrMany<T1>)items1;
+            this.Value2 = items2 == null ? default : (OneOrMany<T2>)items2;
+            this.Value3 = items3 == null ? default : (OneOrMany<T3>)items3;
         }
 
         /// <summary>
diff --git a/Source/Schema.NET/Values{T1,T2}.cs b/Source/Schema.NET/Values{T1,T2}.cs
@@ -59,26 +59,36 @@ public Values(IEnumerable<object> items)
                 throw new ArgumentNullException(nameof(items));
             }
 
-            var items1 = new List<T1>();
-            var items2 = new List<T2>();
+            List<T1> items1 = null;
+            List<T2> items2 = null;
 
             foreach (var item in items)
             {
                 if (item is T2 itemT2)
                 {
+                    if (items2 == null)
+                    {
+                        items2 = new List<T2>();
+                    }
+
                     items2.Add(itemT2);
                 }
                 else if (item is T1 itemT1)
                 {
+                    if (items1 == null)
+                    {
+                        items1 = new List<T1>();
+                    }
+
                     items1.Add(itemT1);
                 }
             }
 
-            this.HasValue1 = items1.Count > 0;
-            this.HasValue2 = items2.Count > 0;
+            this.HasValue1 = items1?.Count > 0;
+            this.HasValue2 = items2?.Count > 0;
 
-            this.Value1 = items1;
-            this.Value2 = items2;
+            this.Value1 = items1 == null ? default : (OneOrMany<T1>)items1;
+            this.Value2 = items2 == null ? default : (OneOrMany<T2>)items2;
         }
 
         /// <summary>

Original file line number	Diff line number	Diff line change
`@@ -78,33 +78,48 @@ public Values(IEnumerable<object> items)`
`78`	`78`	`throw new ArgumentNullException(nameof(items));`
`79`	`79`	`}`
`80`	`80`
`81`		`- var items1 = new List<T1>();`
`82`		`- var items2 = new List<T2>();`
`83`		`- var items3 = new List<T3>();`
	`81`	`+ List<T1> items1 = null;`
	`82`	`+ List<T2> items2 = null;`
	`83`	`+ List<T3> items3 = null;`
`84`	`84`
`85`	`85`	`foreach (var item in items)`
`86`	`86`	`{`
`87`	`87`	`if (item is T3 itemT3)`
`88`	`88`	`{`
	`89`	`+ if (items3 == null)`
	`90`	`+ {`
	`91`	`+ items3 = new List<T3>();`
	`92`	`+ }`
	`93`	`+`
`89`	`94`	`items3.Add(itemT3);`
`90`	`95`	`}`
`91`	`96`	`else if (item is T2 itemT2)`
`92`	`97`	`{`
	`98`	`+ if (items2 == null)`
	`99`	`+ {`
	`100`	`+ items2 = new List<T2>();`
	`101`	`+ }`
	`102`	`+`
`93`	`103`	`items2.Add(itemT2);`
`94`	`104`	`}`
`95`	`105`	`else if (item is T1 itemT1)`
`96`	`106`	`{`
	`107`	`+ if (items1 == null)`
	`108`	`+ {`
	`109`	`+ items1 = new List<T1>();`
	`110`	`+ }`
	`111`	`+`
`97`	`112`	`items1.Add(itemT1);`
`98`	`113`	`}`
`99`	`114`	`}`
`100`	`115`
`101`		`- this.HasValue1 = items1.Count > 0;`
`102`		`- this.HasValue2 = items2.Count > 0;`
`103`		`- this.HasValue3 = items3.Count > 0;`
	`116`	`+ this.HasValue1 = items1?.Count > 0;`
	`117`	`+ this.HasValue2 = items2?.Count > 0;`
	`118`	`+ this.HasValue3 = items3?.Count > 0;`
`104`	`119`
`105`		`- this.Value1 = items1;`
`106`		`- this.Value2 = items2;`
`107`		`- this.Value3 = items3;`
	`120`	`+ this.Value1 = items1 == null ? default : (OneOrMany<T1>)items1;`
	`121`	`+ this.Value2 = items2 == null ? default : (OneOrMany<T2>)items2;`
	`122`	`+ this.Value3 = items3 == null ? default : (OneOrMany<T3>)items3;`
`108`	`123`	`}`
`109`	`124`
`110`	`125`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -59,26 +59,36 @@ public Values(IEnumerable<object> items)`
`59`	`59`	`throw new ArgumentNullException(nameof(items));`
`60`	`60`	`}`
`61`	`61`
`62`		`- var items1 = new List<T1>();`
`63`		`- var items2 = new List<T2>();`
	`62`	`+ List<T1> items1 = null;`
	`63`	`+ List<T2> items2 = null;`
`64`	`64`
`65`	`65`	`foreach (var item in items)`
`66`	`66`	`{`
`67`	`67`	`if (item is T2 itemT2)`
`68`	`68`	`{`
	`69`	`+ if (items2 == null)`
	`70`	`+ {`
	`71`	`+ items2 = new List<T2>();`
	`72`	`+ }`
	`73`	`+`
`69`	`74`	`items2.Add(itemT2);`
`70`	`75`	`}`
`71`	`76`	`else if (item is T1 itemT1)`
`72`	`77`	`{`
	`78`	`+ if (items1 == null)`
	`79`	`+ {`
	`80`	`+ items1 = new List<T1>();`
	`81`	`+ }`
	`82`	`+`
`73`	`83`	`items1.Add(itemT1);`
`74`	`84`	`}`
`75`	`85`	`}`
`76`	`86`
`77`		`- this.HasValue1 = items1.Count > 0;`
`78`		`- this.HasValue2 = items2.Count > 0;`
	`87`	`+ this.HasValue1 = items1?.Count > 0;`
	`88`	`+ this.HasValue2 = items2?.Count > 0;`
`79`	`89`
`80`		`- this.Value1 = items1;`
`81`		`- this.Value2 = items2;`
	`90`	`+ this.Value1 = items1 == null ? default : (OneOrMany<T1>)items1;`
	`91`	`+ this.Value2 = items2 == null ? default : (OneOrMany<T2>)items2;`
`82`	`92`	`}`
`83`	`93`
`84`	`94`	`/// <summary>`