diff --git a/net/FlatBuffers/ByteBuffer.cs b/net/FlatBuffers/ByteBuffer.cs
index 5e212dd..6e0fe35 100644
--- a/net/FlatBuffers/ByteBuffer.cs
+++ b/net/FlatBuffers/ByteBuffer.cs
@@ -14,24 +14,25 @@
  * limitations under the License.
  */
 
-// There are 3 #defines that have an impact on performance / features of this ByteBuffer implementation
+// There are three conditional compilation symbols that have an impact on performance/features of this ByteBuffer implementation.
 //
-//      UNSAFE_BYTEBUFFER 
+//      UNSAFE_BYTEBUFFER
 //          This will use unsafe code to manipulate the underlying byte array. This
 //          can yield a reasonable performance increase.
 //
 //      BYTEBUFFER_NO_BOUNDS_CHECK
 //          This will disable the bounds check asserts to the byte array. This can
-//          yield a small performance gain in normal code..
+//          yield a small performance gain in normal code.
 //
 //      ENABLE_SPAN_T
-//          This will enable reading and writing blocks of memory with a Span<T> instead if just
+//          This will enable reading and writing blocks of memory with a Span<T> instead of just
 //          T[].  You can also enable writing directly to shared memory or other types of memory
 //          by providing a custom implementation of ByteBufferAllocator.
-//          ENABLE_SPAN_T also requires UNSAFE_BYTEBUFFER to be defined
+//          ENABLE_SPAN_T also requires UNSAFE_BYTEBUFFER to be defined, or .NET
+//          Standard 2.1.
 //
 // Using UNSAFE_BYTEBUFFER and BYTEBUFFER_NO_BOUNDS_CHECK together can yield a
-// performance gain of ~15% for some operations, however doing so is potentially 
+// performance gain of ~15% for some operations, however doing so is potentially
 // dangerous. Do so at your own risk!
 //
 
@@ -42,19 +43,19 @@
 using System.Runtime.InteropServices;
 using System.Text;
 
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
 using System.Buffers.Binary;
 #endif
 
-#if ENABLE_SPAN_T && !UNSAFE_BYTEBUFFER
-#error ENABLE_SPAN_T requires UNSAFE_BYTEBUFFER to also be defined
+#if ENABLE_SPAN_T && !UNSAFE_BYTEBUFFER && !NETSTANDARD2_1
+#warning ENABLE_SPAN_T requires UNSAFE_BYTEBUFFER to also be defined
 #endif
 
 namespace FlatBuffers
 {
     public abstract class ByteBufferAllocator
     {
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
         public abstract Span<byte> Span { get; }
         public abstract ReadOnlySpan<byte> ReadOnlySpan { get; }
         public abstract Memory<byte> Memory { get; }
@@ -102,7 +103,7 @@
             InitBuffer();
         }
 
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
         public override Span<byte> Span => _buffer;
         public override ReadOnlySpan<byte> ReadOnlySpan => _buffer;
         public override Memory<byte> Memory => _buffer;
@@ -224,7 +225,7 @@
             return SizeOf<T>() * x.Length;
         }
 
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
         public static int ArraySize<T>(Span<T> x)
         {
             return SizeOf<T>() * x.Length;
@@ -233,7 +234,7 @@
 
         // Get a portion of the buffer casted into an array of type T, given
         // the buffer position and length.
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
         public T[] ToArray<T>(int pos, int len)
             where T : struct
         {
@@ -261,7 +262,7 @@
             return ToArray<byte>(0, Length);
         }
 
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
         public ReadOnlyMemory<byte> ToReadOnlyMemory(int pos, int len)
         {
             return _buffer.ReadOnlyMemory.Slice(pos, len);
@@ -289,11 +290,14 @@
 #endif
 
 #if !UNSAFE_BYTEBUFFER
-        // Pre-allocated helper arrays for convertion.
-        private float[] floathelper = new[] { 0.0f };
-        private int[] inthelper = new[] { 0 };
-        private double[] doublehelper = new[] { 0.0 };
-        private ulong[] ulonghelper = new[] { 0UL };
+        // A conversion union where all the members are overlapping. This allows to reinterpret the bytes of one type
+        // as another, without additional copies.
+        [StructLayout(LayoutKind.Explicit)]
+        struct ConversionUnion
+        {
+          [FieldOffset(0)] public int intValue;
+          [FieldOffset(0)] public float floatValue;
+        }
 #endif // !UNSAFE_BYTEBUFFER
 
         // Helper functions for the unsafe version.
@@ -321,7 +325,7 @@
                     ((input & 0xFF00000000000000UL) >> 56));
         }
 
-#if !UNSAFE_BYTEBUFFER
+#if !UNSAFE_BYTEBUFFER && (!ENABLE_SPAN_T || !NETSTANDARD2_1)
         // Helper functions for the safe (but slower) version.
         protected void WriteLittleEndian(int offset, int count, ulong data)
         {
@@ -361,7 +365,46 @@
             }
             return r;
         }
-#endif // !UNSAFE_BYTEBUFFER
+#elif ENABLE_SPAN_T && NETSTANDARD2_1
+        protected void WriteLittleEndian(int offset, int count, ulong data)
+        {
+            if (BitConverter.IsLittleEndian)
+            {
+                for (int i = 0; i < count; i++)
+                {
+                    _buffer.Span[offset + i] = (byte)(data >> i * 8);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < count; i++)
+                {
+                    _buffer.Span[offset + count - 1 - i] = (byte)(data >> i * 8);
+                }
+            }
+        }
+
+        protected ulong ReadLittleEndian(int offset, int count)
+        {
+            AssertOffsetAndLength(offset, count);
+            ulong r = 0;
+            if (BitConverter.IsLittleEndian)
+            {
+                for (int i = 0; i < count; i++)
+                {
+                    r |= (ulong)_buffer.Span[offset + i] << i * 8;
+                }
+            }
+            else
+            {
+                for (int i = 0; i < count; i++)
+                {
+                    r |= (ulong)_buffer.Span[offset + count - 1 - i] << i * 8;
+                }
+            }
+            return r;
+        }
+#endif
 
         private void AssertOffsetAndLength(int offset, int length)
         {
@@ -372,7 +415,7 @@
 #endif
         }
 
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
 
         public void PutSbyte(int offset, sbyte value)
         {
@@ -420,7 +463,7 @@
             PutByte(offset, value);
         }
 
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && UNSAFE_BYTEBUFFER
         public unsafe void PutStringUTF8(int offset, string value)
         {
             AssertOffsetAndLength(offset, value.Length);
@@ -432,6 +475,13 @@
                 }
             }
         }
+#elif ENABLE_SPAN_T && NETSTANDARD2_1
+        public void PutStringUTF8(int offset, string value)
+        {
+            AssertOffsetAndLength(offset, value.Length);
+            Encoding.UTF8.GetBytes(value.AsSpan().Slice(0, value.Length),
+                _buffer.Span.Slice(offset));
+        }
 #else
         public void PutStringUTF8(int offset, string value)
         {
@@ -451,7 +501,7 @@
         public unsafe void PutUshort(int offset, ushort value)
         {
             AssertOffsetAndLength(offset, sizeof(ushort));
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T // && UNSAFE_BYTEBUFFER
             Span<byte> span = _buffer.Span.Slice(offset);
             BinaryPrimitives.WriteUInt16LittleEndian(span, value);
 #else
@@ -472,7 +522,7 @@
         public unsafe void PutUint(int offset, uint value)
         {
             AssertOffsetAndLength(offset, sizeof(uint));
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T // && UNSAFE_BYTEBUFFER
             Span<byte> span = _buffer.Span.Slice(offset);
             BinaryPrimitives.WriteUInt32LittleEndian(span, value);
 #else
@@ -493,7 +543,7 @@
         public unsafe void PutUlong(int offset, ulong value)
         {
             AssertOffsetAndLength(offset, sizeof(ulong));
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T // && UNSAFE_BYTEBUFFER
             Span<byte> span = _buffer.Span.Slice(offset);
             BinaryPrimitives.WriteUInt64LittleEndian(span, value);
 #else
@@ -509,7 +559,7 @@
         public unsafe void PutFloat(int offset, float value)
         {
             AssertOffsetAndLength(offset, sizeof(float));
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T // && UNSAFE_BYTEBUFFER
             fixed (byte* ptr = &MemoryMarshal.GetReference(_buffer.Span))
 #else
             fixed (byte* ptr = _buffer.Buffer)
@@ -529,7 +579,7 @@
         public unsafe void PutDouble(int offset, double value)
         {
             AssertOffsetAndLength(offset, sizeof(double));
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T // && UNSAFE_BYTEBUFFER
             fixed (byte* ptr = &MemoryMarshal.GetReference(_buffer.Span))
 #else
             fixed (byte* ptr = _buffer.Buffer)
@@ -586,22 +636,23 @@
         public void PutFloat(int offset, float value)
         {
             AssertOffsetAndLength(offset, sizeof(float));
-            floathelper[0] = value;
-            Buffer.BlockCopy(floathelper, 0, inthelper, 0, sizeof(float));
-            WriteLittleEndian(offset, sizeof(float), (ulong)inthelper[0]);
+            // TODO(derekbailey): use BitConvert.SingleToInt32Bits() whenever flatbuffers upgrades to a .NET version
+            // that contains it.
+            ConversionUnion union;
+            union.intValue = 0;
+            union.floatValue = value;    
+            WriteLittleEndian(offset, sizeof(float), (ulong)union.intValue);
         }
 
         public void PutDouble(int offset, double value)
         {
             AssertOffsetAndLength(offset, sizeof(double));
-            doublehelper[0] = value;
-            Buffer.BlockCopy(doublehelper, 0, ulonghelper, 0, sizeof(double));
-            WriteLittleEndian(offset, sizeof(double), ulonghelper[0]);
+            WriteLittleEndian(offset, sizeof(double), (ulong)BitConverter.DoubleToInt64Bits(value));
         }
 
 #endif // UNSAFE_BYTEBUFFER
 
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
         public sbyte GetSbyte(int index)
         {
             AssertOffsetAndLength(index, sizeof(sbyte));
@@ -627,7 +678,7 @@
         }
 #endif
 
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && UNSAFE_BYTEBUFFER
         public unsafe string GetStringUTF8(int startPos, int len)
         {
             fixed (byte* buffer = &MemoryMarshal.GetReference(_buffer.ReadOnlySpan.Slice(startPos)))
@@ -635,6 +686,11 @@
                 return Encoding.UTF8.GetString(buffer, len);
             }
         }
+#elif ENABLE_SPAN_T && NETSTANDARD2_1
+        public string GetStringUTF8(int startPos, int len)
+        {
+            return Encoding.UTF8.GetString(_buffer.Span.Slice(startPos, len));
+        }
 #else
         public string GetStringUTF8(int startPos, int len)
         {
@@ -652,7 +708,7 @@
         public unsafe ushort GetUshort(int offset)
         {
             AssertOffsetAndLength(offset, sizeof(ushort));
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T // && UNSAFE_BYTEBUFFER
             ReadOnlySpan<byte> span = _buffer.ReadOnlySpan.Slice(offset);
             return BinaryPrimitives.ReadUInt16LittleEndian(span);
 #else
@@ -673,7 +729,7 @@
         public unsafe uint GetUint(int offset)
         {
             AssertOffsetAndLength(offset, sizeof(uint));
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T // && UNSAFE_BYTEBUFFER
             ReadOnlySpan<byte> span = _buffer.ReadOnlySpan.Slice(offset);
             return BinaryPrimitives.ReadUInt32LittleEndian(span);
 #else
@@ -694,7 +750,7 @@
         public unsafe ulong GetUlong(int offset)
         {
             AssertOffsetAndLength(offset, sizeof(ulong));
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T // && UNSAFE_BYTEBUFFER
             ReadOnlySpan<byte> span = _buffer.ReadOnlySpan.Slice(offset);
             return BinaryPrimitives.ReadUInt64LittleEndian(span);
 #else            
@@ -710,7 +766,7 @@
         public unsafe float GetFloat(int offset)
         {
             AssertOffsetAndLength(offset, sizeof(float));
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T // && UNSAFE_BYTEBUFFER
             fixed (byte* ptr = &MemoryMarshal.GetReference(_buffer.ReadOnlySpan))
 #else
             fixed (byte* ptr = _buffer.Buffer)
@@ -731,7 +787,7 @@
         public unsafe double GetDouble(int offset)
         {
             AssertOffsetAndLength(offset, sizeof(double));
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T // && UNSAFE_BYTEBUFFER
             fixed (byte* ptr = &MemoryMarshal.GetReference(_buffer.ReadOnlySpan))
 #else
             fixed (byte* ptr = _buffer.Buffer)
@@ -782,19 +838,17 @@
 
         public float GetFloat(int index)
         {
-            int i = (int)ReadLittleEndian(index, sizeof(float));
-            inthelper[0] = i;
-            Buffer.BlockCopy(inthelper, 0, floathelper, 0, sizeof(float));
-            return floathelper[0];
+            // TODO(derekbailey): use BitConvert.Int32BitsToSingle() whenever flatbuffers upgrades to a .NET version
+            // that contains it.
+            ConversionUnion union;
+            union.floatValue = 0;
+            union.intValue = (int)ReadLittleEndian(index, sizeof(float));
+            return union.floatValue;
         }
 
         public double GetDouble(int index)
         {
-            ulong i = ReadLittleEndian(index, sizeof(double));
-            // There's Int64BitsToDouble but it uses unsafe code internally.
-            ulonghelper[0] = i;
-            Buffer.BlockCopy(ulonghelper, 0, doublehelper, 0, sizeof(double));
-            return doublehelper[0];
+            return BitConverter.Int64BitsToDouble((long)ReadLittleEndian(index, sizeof(double)));
         }
 #endif // UNSAFE_BYTEBUFFER
 
@@ -832,7 +886,7 @@
                 offset -= numBytes;
                 AssertOffsetAndLength(offset, numBytes);
                 // if we are LE, just do a block copy
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
                 MemoryMarshal.Cast<T, byte>(x).CopyTo(_buffer.Span.Slice(offset, numBytes));
 #else
                 Buffer.BlockCopy(x, 0, _buffer.Buffer, offset, numBytes);
@@ -851,7 +905,7 @@
             return offset;
         }
 
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
         public int Put<T>(int offset, Span<T> x)
             where T : struct
         {
diff --git a/net/FlatBuffers/FlatBufferBuilder.cs b/net/FlatBuffers/FlatBufferBuilder.cs
index 27c16b3..c72b624 100644
--- a/net/FlatBuffers/FlatBufferBuilder.cs
+++ b/net/FlatBuffers/FlatBufferBuilder.cs
@@ -90,6 +90,10 @@
             _objectStart = 0;
             _numVtables = 0;
             _vectorNumElems = 0;
+            if (_sharedStringMap != null)
+            {
+                _sharedStringMap.Clear();
+            }
         }
 
         /// <summary>
@@ -206,7 +210,7 @@
             _space = _bb.Put(_space, x);
         }
 
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
         /// <summary>
         /// Puts a span of type T into this builder at the
         /// current offset
@@ -317,7 +321,7 @@
             Put(x);
         }
 
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
         /// <summary>
         /// Add a span of type T to the buffer (aligns the data and grows if necessary).
         /// </summary>
@@ -446,6 +450,15 @@
         public void AddBool(int o, bool x, bool d) { if (ForceDefaults || x != d) { AddBool(x); Slot(o); } }
 
         /// <summary>
+        /// Adds a Boolean to the Table at index `o` in its vtable using the nullable value `x`
+        /// </summary>
+        /// <param name="o">The index into the vtable</param>
+        /// <param name="x">The nullable boolean value to put into the buffer. If it doesn't have a value
+        /// it will skip writing to the buffer.</param>       
+        public void AddBool(int o, bool? x) { if (x.HasValue) { AddBool(x.Value); Slot(o); } }
+
+        
+        /// <summary>
         /// Adds a SByte to the Table at index `o` in its vtable using the value `x` and default `d`
         /// </summary>
         /// <param name="o">The index into the vtable</param>
@@ -455,6 +468,14 @@
         public void AddSbyte(int o, sbyte x, sbyte d) { if (ForceDefaults || x != d) { AddSbyte(x); Slot(o); } }
 
         /// <summary>
+        /// Adds a SByte to the Table at index `o` in its vtable using the nullable value `x`
+        /// </summary>
+        /// <param name="o">The index into the vtable</param>
+        /// <param name="x">The nullable sbyte value to put into the buffer. If it doesn't have a value
+        /// it will skip writing to the buffer.</param>  
+        public void AddSbyte(int o, sbyte? x) { if (x.HasValue) { AddSbyte(x.Value); Slot(o); } }
+
+        /// <summary>
         /// Adds a Byte to the Table at index `o` in its vtable using the value `x` and default `d`
         /// </summary>
         /// <param name="o">The index into the vtable</param>
@@ -464,6 +485,14 @@
         public void AddByte(int o, byte x, byte d) { if (ForceDefaults || x != d) { AddByte(x); Slot(o); } }
 
         /// <summary>
+        /// Adds a Byte to the Table at index `o` in its vtable using the nullable value `x`
+        /// </summary>
+        /// <param name="o">The index into the vtable</param>
+        /// <param name="x">The nullable byte value to put into the buffer. If it doesn't have a value
+        /// it will skip writing to the buffer.</param>  
+        public void AddByte(int o, byte? x) { if (x.HasValue) { AddByte(x.Value); Slot(o); } }
+
+        /// <summary>
         /// Adds a Int16 to the Table at index `o` in its vtable using the value `x` and default `d`
         /// </summary>
         /// <param name="o">The index into the vtable</param>
@@ -473,6 +502,14 @@
         public void AddShort(int o, short x, int d) { if (ForceDefaults || x != d) { AddShort(x); Slot(o); } }
 
         /// <summary>
+        /// Adds a Int16 to the Table at index `o` in its vtable using the nullable value `x`
+        /// </summary>
+        /// <param name="o">The index into the vtable</param>
+        /// <param name="x">The nullable int16 value to put into the buffer. If it doesn't have a value
+        /// it will skip writing to the buffer.</param>  
+        public void AddShort(int o, short? x) { if (x.HasValue) { AddShort(x.Value); Slot(o); } }
+
+        /// <summary>
         /// Adds a UInt16 to the Table at index `o` in its vtable using the value `x` and default `d`
         /// </summary>
         /// <param name="o">The index into the vtable</param>
@@ -482,6 +519,14 @@
         public void AddUshort(int o, ushort x, ushort d) { if (ForceDefaults || x != d) { AddUshort(x); Slot(o); } }
 
         /// <summary>
+        /// Adds a Uint16 to the Table at index `o` in its vtable using the nullable value `x`
+        /// </summary>
+        /// <param name="o">The index into the vtable</param>
+        /// <param name="x">The nullable uint16 value to put into the buffer. If it doesn't have a value
+        /// it will skip writing to the buffer.</param>  
+        public void AddUshort(int o, ushort? x) { if (x.HasValue) { AddUshort(x.Value); Slot(o); } }
+
+        /// <summary>
         /// Adds an Int32 to the Table at index `o` in its vtable using the value `x` and default `d`
         /// </summary>
         /// <param name="o">The index into the vtable</param>
@@ -491,6 +536,14 @@
         public void AddInt(int o, int x, int d) { if (ForceDefaults || x != d) { AddInt(x); Slot(o); } }
 
         /// <summary>
+        /// Adds a Int32 to the Table at index `o` in its vtable using the nullable value `x`
+        /// </summary>
+        /// <param name="o">The index into the vtable</param>
+        /// <param name="x">The nullable int32 value to put into the buffer. If it doesn't have a value
+        /// it will skip writing to the buffer.</param>  
+        public void AddInt(int o, int? x) { if (x.HasValue) { AddInt(x.Value); Slot(o); } }
+
+        /// <summary>
         /// Adds a UInt32 to the Table at index `o` in its vtable using the value `x` and default `d`
         /// </summary>
         /// <param name="o">The index into the vtable</param>
@@ -500,6 +553,14 @@
         public void AddUint(int o, uint x, uint d) { if (ForceDefaults || x != d) { AddUint(x); Slot(o); } }
 
         /// <summary>
+        /// Adds a UInt32 to the Table at index `o` in its vtable using the nullable value `x`
+        /// </summary>
+        /// <param name="o">The index into the vtable</param>
+        /// <param name="x">The nullable uint32 value to put into the buffer. If it doesn't have a value
+        /// it will skip writing to the buffer.</param>  
+        public void AddUint(int o, uint? x) { if (x.HasValue) { AddUint(x.Value); Slot(o); } }
+
+        /// <summary>
         /// Adds an Int64 to the Table at index `o` in its vtable using the value `x` and default `d`
         /// </summary>
         /// <param name="o">The index into the vtable</param>
@@ -509,6 +570,14 @@
         public void AddLong(int o, long x, long d) { if (ForceDefaults || x != d) { AddLong(x); Slot(o); } }
 
         /// <summary>
+        /// Adds a Int64 to the Table at index `o` in its vtable using the nullable value `x`
+        /// </summary>
+        /// <param name="o">The index into the vtable</param>
+        /// <param name="x">The nullable int64 value to put into the buffer. If it doesn't have a value
+        /// it will skip writing to the buffer.</param>  
+        public void AddLong(int o, long? x) { if (x.HasValue) { AddLong(x.Value); Slot(o); } }
+
+        /// <summary>
         /// Adds a UInt64 to the Table at index `o` in its vtable using the value `x` and default `d`
         /// </summary>
         /// <param name="o">The index into the vtable</param>
@@ -518,6 +587,14 @@
         public void AddUlong(int o, ulong x, ulong d) { if (ForceDefaults || x != d) { AddUlong(x); Slot(o); } }
 
         /// <summary>
+        /// Adds a UInt64 to the Table at index `o` in its vtable using the nullable value `x`
+        /// </summary>
+        /// <param name="o">The index into the vtable</param>
+        /// <param name="x">The nullable int64 value to put into the buffer. If it doesn't have a value
+        /// it will skip writing to the buffer.</param>  
+        public void AddUlong(int o, ulong? x) { if (x.HasValue) { AddUlong(x.Value); Slot(o); } }
+
+        /// <summary>
         /// Adds a Single to the Table at index `o` in its vtable using the value `x` and default `d`
         /// </summary>
         /// <param name="o">The index into the vtable</param>
@@ -527,6 +604,14 @@
         public void AddFloat(int o, float x, double d) { if (ForceDefaults || x != d) { AddFloat(x); Slot(o); } }
 
         /// <summary>
+        /// Adds a Single to the Table at index `o` in its vtable using the nullable value `x`
+        /// </summary>
+        /// <param name="o">The index into the vtable</param>
+        /// <param name="x">The nullable single value to put into the buffer. If it doesn't have a value
+        /// it will skip writing to the buffer.</param>  
+        public void AddFloat(int o, float? x) { if (x.HasValue) { AddFloat(x.Value); Slot(o); } }
+
+        /// <summary>
         /// Adds a Double to the Table at index `o` in its vtable using the value `x` and default `d`
         /// </summary>
         /// <param name="o">The index into the vtable</param>
@@ -536,6 +621,14 @@
         public void AddDouble(int o, double x, double d) { if (ForceDefaults || x != d) { AddDouble(x); Slot(o); } }
 
         /// <summary>
+        /// Adds a Double to the Table at index `o` in its vtable using the nullable value `x`
+        /// </summary>
+        /// <param name="o">The index into the vtable</param>
+        /// <param name="x">The nullable double value to put into the buffer. If it doesn't have a value
+        /// it will skip writing to the buffer.</param>  
+        public void AddDouble(int o, double? x) { if (x.HasValue) { AddDouble(x.Value); Slot(o); } }
+
+        /// <summary>
         /// Adds a buffer offset to the Table at index `o` in its vtable using the value `x` and default `d`
         /// </summary>
         /// <param name="o">The index into the vtable</param>
@@ -554,6 +647,10 @@
         /// </returns>
         public StringOffset CreateString(string s)
         {
+            if (s == null)
+            {
+                return new StringOffset(0);
+            }
             NotNested();
             AddByte(0);
             var utf8StringLen = Encoding.UTF8.GetByteCount(s);
@@ -563,7 +660,7 @@
         }
 
 
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
         /// <summary>
         /// Creates a string in the buffer from a Span containing
         /// a UTF8 string.
@@ -594,6 +691,11 @@
         /// </returns>
         public StringOffset CreateSharedString(string s)
         {
+            if (s == null)
+            {
+              return new StringOffset(0);
+            }
+
             if (_sharedStringMap == null)
             {
                 _sharedStringMap = new Dictionary<string, StringOffset>();
diff --git a/net/FlatBuffers/FlatBufferConstants.cs b/net/FlatBuffers/FlatBufferConstants.cs
index 730d7ef..1d4c5dc 100644
--- a/net/FlatBuffers/FlatBufferConstants.cs
+++ b/net/FlatBuffers/FlatBufferConstants.cs
@@ -32,6 +32,6 @@
         Changes to the C# implementation need to be sure to change
         the version here and in the code generator on every possible
         incompatible change */
-        public static void FLATBUFFERS_1_11_1() {}
+        public static void FLATBUFFERS_1_12_0() {}
     }
 }
diff --git a/net/FlatBuffers/FlatBuffers.Core.csproj b/net/FlatBuffers/FlatBuffers.Core.csproj
deleted file mode 100644
index 4285dd7..0000000
--- a/net/FlatBuffers/FlatBuffers.Core.csproj
+++ /dev/null
@@ -1,19 +0,0 @@
-﻿<Project Sdk="Microsoft.NET.Sdk">
-
-    <PropertyGroup>
-        <TargetFramework>netstandard2.0</TargetFramework>
-    </PropertyGroup>
-
-    <ItemGroup>
-      <Compile Remove="Properties\**" />
-    </ItemGroup>
-
-    <ItemGroup>
-      <EmbeddedResource Remove="Properties\**" />
-    </ItemGroup>
-
-    <ItemGroup>
-      <None Remove="Properties\**" />
-    </ItemGroup>
-
-</Project>
diff --git a/net/FlatBuffers/FlatBuffers.csproj b/net/FlatBuffers/FlatBuffers.csproj
index a029094..54cba5a 100644
--- a/net/FlatBuffers/FlatBuffers.csproj
+++ b/net/FlatBuffers/FlatBuffers.csproj
@@ -1,54 +1,23 @@
-﻿<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+﻿<Project Sdk="Microsoft.NET.Sdk">
+
   <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectGuid>{28C00774-1E73-4A75-AD8F-844CD21A064D}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>FlatBuffers</RootNamespace>
-    <AssemblyName>FlatBuffers</AssemblyName>
-    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
+    <TargetFrameworks>netstandard2.1;netstandard2.0;net46</TargetFrameworks>
+    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
   </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
+
+  <PropertyGroup Condition="'$(UNSAFE_BYTEBUFFER)' == 'true'">
+    <DefineConstants>$(DefineConstants);UNSAFE_BYTEBUFFER</DefineConstants>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
+  <PropertyGroup Condition="'$(BYTEBUFFER_NO_BOUNDS_CHECK)' == 'true'">
+    <DefineConstants>$(DefineConstants);BYTEBUFFER_NO_BOUNDS_CHECK</DefineConstants>
   </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="System" />
-    <Reference Include="System.Core" />
+  <PropertyGroup Condition="'$(ENABLE_SPAN_T)' == 'true'">
+    <DefineConstants>$(DefineConstants);ENABLE_SPAN_T</DefineConstants>
+  </PropertyGroup>
+
+  <ItemGroup Condition="('$(ENABLE_SPAN_T)' == 'true') And (('$(TargetFramework)' == 'netstandard2.0') Or ('$(TargetFramework)' == 'net46'))">
+    <PackageReference Include="System.Memory" Version="4.5.4" />
   </ItemGroup>
-  <ItemGroup>
-    <Compile Include="ByteBuffer.cs" />
-    <Compile Include="FlatBufferBuilder.cs" />
-    <Compile Include="FlatBufferConstants.cs" />
-    <Compile Include="IFlatbufferObject.cs" />
-    <Compile Include="Offset.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="Struct.cs" />
-    <Compile Include="Table.cs" />
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
-  -->
-</Project>
\ No newline at end of file
+
+</Project>
diff --git a/net/FlatBuffers/FlatBuffers.net35.csproj b/net/FlatBuffers/FlatBuffers.net35.csproj
new file mode 100644
index 0000000..574580e
--- /dev/null
+++ b/net/FlatBuffers/FlatBuffers.net35.csproj
@@ -0,0 +1,57 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{28C00774-1E73-4A75-AD8F-844CD21A064D}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>FlatBuffers</RootNamespace>
+    <AssemblyName>FlatBuffers</AssemblyName>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\net35</OutputPath>
+    <IntermediateOutputPath>obj\Debug\net35</IntermediateOutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\net35</OutputPath>
+    <IntermediateOutputPath>obj\Release\net35</IntermediateOutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="ByteBuffer.cs" />
+    <Compile Include="ByteBufferUtil.cs" />
+    <Compile Include="FlatBufferBuilder.cs" />
+    <Compile Include="FlatBufferConstants.cs" />
+    <Compile Include="IFlatbufferObject.cs" />
+    <Compile Include="Offset.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Struct.cs" />
+    <Compile Include="Table.cs" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
\ No newline at end of file
diff --git a/net/FlatBuffers/Struct.cs b/net/FlatBuffers/Struct.cs
index 4f7fac9..4832cda 100644
--- a/net/FlatBuffers/Struct.cs
+++ b/net/FlatBuffers/Struct.cs
@@ -25,7 +25,7 @@
         public ByteBuffer bb { get; private set; }
 
         // Re-init the internal state with an external buffer {@code ByteBuffer} and an offset within.
-        public Struct(int _i, ByteBuffer _bb)
+        public Struct(int _i, ByteBuffer _bb) : this()
         {
             bb = _bb;
             bb_pos = _i;
diff --git a/net/FlatBuffers/Table.cs b/net/FlatBuffers/Table.cs
index e10ba95..d888de5 100644
--- a/net/FlatBuffers/Table.cs
+++ b/net/FlatBuffers/Table.cs
@@ -16,6 +16,7 @@
 
 using System;
 using System.Text;
+using System.Runtime.InteropServices;
 
 namespace FlatBuffers
 {
@@ -30,7 +31,7 @@
         public ByteBuffer ByteBuffer { get { return bb; } }
 
         // Re-init the internal state with an external buffer {@code ByteBuffer} and an offset within.
-        public Table(int _i, ByteBuffer _bb)
+        public Table(int _i, ByteBuffer _bb) : this()
         {
             bb = _bb;
             bb_pos = _i;
@@ -85,21 +86,27 @@
             return offset + bb.GetInt(offset) + sizeof(int);  // data starts after the length
         }
 
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
         // Get the data of a vector whoses offset is stored at "offset" in this object as an
         // Spant&lt;byte&gt;. If the vector is not present in the ByteBuffer,
         // then an empty span will be returned.
-        public Span<byte> __vector_as_span(int offset)
+        public Span<T> __vector_as_span<T>(int offset, int elementSize) where T : struct
         {
+            if (!BitConverter.IsLittleEndian)
+            {
+               throw new NotSupportedException("Getting typed span on a Big Endian " +
+                                               "system is not support");
+            }
+
             var o = this.__offset(offset);
             if (0 == o)
             {
-                return new Span<byte>();
+                return new Span<T>();
             }
 
             var pos = this.__vector(o);
             var len = this.__vector_len(o);
-            return bb.ToSpan(pos, len);
+            return MemoryMarshal.Cast<byte, T>(bb.ToSpan(pos, len * elementSize));
         }
 #else
         // Get the data of a vector whoses offset is stored at "offset" in this object as an
@@ -145,9 +152,8 @@
         // Initialize any Table-derived type to point to the union at the given offset.
         public T __union<T>(int offset) where T : struct, IFlatbufferObject
         {
-            offset += bb_pos;
             T t = new T();
-            t.__init(offset + bb.GetInt(offset), bb);
+            t.__init(__indirect(offset), bb);
             return t;
         }