Add overloads for C# ByteBuffer/FlatBufferBuilder to allow adding vector blocks from ArraySegments or IntPtr (#7193)

* Add overloads to Add/Put for ArraySegment and IntPtr

In order to allow using code to reduce memory allocations, add overloads to ByteBuffer's and FlatBuffersBuilder's Put/Add methods that take ArraySegment<T> or IntPtr respectively.
Also, adaptions to the c# code generator in flatc to emit corresponding CreateVectorBlock() overloads

* Add missing files generated with generate_code.py

The previous commit changed the C# code generate, but didn't contain the updated generated test files.

* Incorporate review findings

(1) Adhere to 80 characters limit.
(2) In FlatBufferBuilder.Add(IntPtr,int), move zero length check topmost and add sanity check against negative input

tests/FlatBuffers.Test/FlatBufferBuilderTests.cs

@@ -553,6 +553,18 @@ namespace FlatBuffers.Test
 
             Assert.Throws<ArgumentNullException>(() => fbb.Add(data));
         }
+        
+        [FlatBuffersTestMethod]
+        public unsafe void FlatBufferBuilder_Add_Array_UnsupportedType_Throws()
+        {
+            var fbb = CreateBuffer(false);
+                  
+            var storedOffset = fbb.Offset;
+
+            // Construct the data array
+            var data = new DummyStruct[10];
+            Assert.Throws<ArgumentException>(() => fbb.Add(data));
+        }
 
         [FlatBuffersTestMethod]
         public void FlatBufferBuilder_Add_Array_Empty_Noop()
@@ -570,6 +582,159 @@ namespace FlatBuffers.Test
             var endOffset = fbb.Offset;
             Assert.AreEqual(endOffset, storedOffset);
         }
+    
+        [FlatBuffersTestMethod]
+        public void FlatBufferBuilder_Add_ArraySegment_Default_Throws()
+        {
+            var fbb = CreateBuffer(false);
+
+            // Construct the data array
+            ArraySegment<float> data = default;
+
+            Assert.Throws<ArgumentNullException>(() => fbb.Add(data));
+        }
+            
+        [FlatBuffersTestMethod]
+        public unsafe void FlatBufferBuilder_Add_ArraySegment_UnsupportedType_Throws()
+        {
+            var fbb = CreateBuffer(false);
+                  
+            var storedOffset = fbb.Offset;
+
+            // Construct the data array
+            var array = new DummyStruct[10];
+            var data = new ArraySegment<DummyStruct>(array);
+            Assert.Throws<ArgumentException>(() => fbb.Add(data));
+        }
+
+        [FlatBuffersTestMethod]
+        public void FlatBufferBuilder_Add_ArraySegment_Empty_Noop()
+        {
+            var fbb = CreateBuffer(false);
+                  
+            var storedOffset = fbb.Offset;
+
+            // Construct the data array
+            var array = new float[10];
+            var data = new ArraySegment<float>(array, 5, 0);
+            fbb.Add(data);
+
+            // Make sure the offset didn't change since nothing
+            // was really added
+            var endOffset = fbb.Offset;
+            Assert.AreEqual(endOffset, storedOffset);
+        }
+    
+        [FlatBuffersTestMethod]
+        public void FlatBufferBuilder_Add_IntPtr_Zero_Throws()
+        {
+            var fbb = CreateBuffer(false);
+
+            // Construct the data array
+            var data = IntPtr.Zero;
+            var length = 100;
+
+            Assert.Throws<ArgumentNullException>(() => fbb.Add<float>(data, length));
+        }
+            
+        [FlatBuffersTestMethod]
+        public unsafe void FlatBufferBuilder_Add_IntPtr_SizeNegative_Throws()
+        {
+            var fbb = CreateBuffer(false);
+
+            // Construct the data array
+            var array = new float[10];
+            fixed(float* ptr = array)
+            {
+                var data = (IntPtr)ptr;
+                var length = -1;
+                Assert.Throws<ArgumentOutOfRangeException>(() => fbb.Add<float>(data, length));
+            }
+        }
+
+        [FlatBuffersTestMethod]
+        public void FlatBufferBuilder_Add_IntPtr_Zero_Empty_Noop()
+        {
+            var fbb = CreateBuffer(false);
+
+            var storedOffset = fbb.Offset;
+
+            // Construct the data array
+            var data = IntPtr.Zero;
+            var length = 0;
+
+            fbb.Add<float>(data, length);
+
+            // make sure that a length of 0 doesn't throw also if ptr is Zero as well
+            // and that nothing was really added
+            var endOffset = fbb.Offset;
+            Assert.AreEqual(endOffset, storedOffset);
+        }
+
+        [FlatBuffersTestMethod]
+        public unsafe void FlatBufferBuilder_Add_IntPtr_Empty_Noop()
+        {
+            var fbb = CreateBuffer(false);
+                  
+            var storedOffset = fbb.Offset;
+
+            // Construct the data array
+            var array = new float[10];
+            fixed(float* ptr = array)
+            {
+                var data = (IntPtr)ptr;
+                var length = 0;
+                fbb.Add<float>(data, length);
+            }
+
+            // Make sure the offset didn't change since nothing
+            // was really added
+            var endOffset = fbb.Offset;
+            Assert.AreEqual(endOffset, storedOffset);
+        }
+    
+        [FlatBuffersTestMethod]
+        public unsafe void FlatBufferBuilder_Add_IntPtr_SizeInBytesNotMatchingDataType_Throws()
+        {
+            var fbb = CreateBuffer(false);
+                  
+            var storedOffset = fbb.Offset;
+
+            // Construct the data array
+            var array = new float[10];
+            fixed(float* ptr = array)
+            {
+                const int invalidBytes = 1;
+                var data = (IntPtr)ptr;
+                // add some invalid bytes to the length
+                var length = 2 * sizeof(float) + invalidBytes;
+            
+                Assert.Throws<ArgumentException>(() => fbb.Add<float>(data, length));
+            }
+        }
+    
+        [FlatBuffersTestMethod]
+        public unsafe void FlatBufferBuilder_Add_IntPtr_UnsupportedType_Throws()
+        {
+            var fbb = CreateBuffer(false);
+                  
+            var storedOffset = fbb.Offset;
+
+            // Construct the data array
+            var array = new DummyStruct[10];
+            fixed(DummyStruct* ptr = array)
+            {
+                var data = (IntPtr)ptr;
+                var length = 10 * sizeof(DummyStruct);
+            
+                Assert.Throws<ArgumentException>(() => fbb.Add<DummyStruct>(data, length));
+            }
+        }
+
+        private struct DummyStruct
+        {
+            int value;
+        }
 
         [FlatBuffersTestMethod]
         public void FlatBufferBuilder_Add_null_String()