From 0e677d27ae8ed489f2fa6f5e95b0e498319a887e Mon Sep 17 00:00:00 2001
From: Curt Hagenlocher <curt@hagenlocher.org>
Date: Wed, 16 Aug 2023 11:26:00 -0700
Subject: [PATCH] GH-35698: [C#] Update FlatBuffers (#35699)

### Rationale for this change

The FlatBuffers definitions in the C# code don't seem to have been updated for a while. Adding the latest FlatBuffers code ensures that we're up to date with both the Arrow definitions and the FlatBuffers compiler.

### What changes are included in this PR?

The latest version of the C# FlatBuffers runtime files were copied into the project (with visibility changed from public to internal).
The latest version of the FlatBuffers compiler was used against the latest version of the Arrow .fbs source. The output of the compiler was edited to more closely match the existing code by moving it into the directory structure and namespaces of the existing classes and by changing class visibility from public to internal.
A few small changes were made to the existing source to accommodate changes in the FlatBuffers runtime, most specifically that the files have moved from the namespace "FlatBuffers" to the namespace "Google.FlatBuffers".

### Are these changes tested?

No substantive product changes were made. All tests still pass.

### Are there any user-facing changes?

No.

Resolves #35698
* Closes: #35698

Authored-by: Curt Hagenlocher <curt@hagenlocher.org>
Signed-off-by: Weston Pace <weston.pace@gmail.com>
---
 .../Internal/FlightDataStream.cs              |   2 +-
 .../Internal/FlightMessageSerializer.cs       |   2 +-
 csharp/src/Apache.Arrow/Flatbuf/Block.cs      |   9 +-
 .../Apache.Arrow/Flatbuf/BodyCompression.cs   |  28 +-
 csharp/src/Apache.Arrow/Flatbuf/Buffer.cs     |  12 +-
 .../Apache.Arrow/Flatbuf/DictionaryBatch.cs   |  29 +-
 .../Flatbuf/DictionaryEncoding.cs             |  42 +-
 .../Flatbuf/Enums/BodyCompressionMethod.cs    |   2 +-
 .../Flatbuf/Enums/DictionaryKind.cs           |  19 +
 .../Flatbuf/Enums/IntervalUnit.cs             |   5 +-
 .../Flatbuf/Enums/MessageHeader.cs            |  42 +-
 csharp/src/Apache.Arrow/Flatbuf/Enums/Type.cs | 127 ++-
 csharp/src/Apache.Arrow/Flatbuf/Field.cs      |  75 +-
 csharp/src/Apache.Arrow/Flatbuf/FieldNode.cs  |   9 +-
 .../Apache.Arrow/Flatbuf/FixedSizeBinary.cs   |  24 +-
 .../src/Apache.Arrow/Flatbuf/FixedSizeList.cs |  24 +-
 .../Flatbuf/FlatBuffers/ByteBuffer.cs         | 270 ++++--
 .../Flatbuf/FlatBuffers/ByteBufferUtil.cs     |   2 +-
 .../Flatbuf/FlatBuffers/FlatBufferBuilder.cs  | 243 +++++-
 .../FlatBuffers/FlatBufferConstants.cs        |  10 +-
 .../Flatbuf/FlatBuffers/FlatBufferVerify.cs   | 822 ++++++++++++++++++
 .../Flatbuf/FlatBuffers/IFlatbufferObject.cs  |   2 +-
 .../Flatbuf/FlatBuffers/Offset.cs             |   2 +-
 .../Flatbuf/FlatBuffers/Struct.cs             |  13 +-
 .../Apache.Arrow/Flatbuf/FlatBuffers/Table.cs |  37 +-
 csharp/src/Apache.Arrow/Flatbuf/Footer.cs     |  31 +-
 csharp/src/Apache.Arrow/Flatbuf/KeyValue.cs   |  29 +-
 csharp/src/Apache.Arrow/Flatbuf/Map.cs        |  41 +-
 csharp/src/Apache.Arrow/Flatbuf/Message.cs    |  38 +-
 .../src/Apache.Arrow/Flatbuf/RecordBatch.cs   |  27 +-
 .../src/Apache.Arrow/Flatbuf/RunEndEncoded.cs |  45 +
 csharp/src/Apache.Arrow/Flatbuf/Schema.cs     |  38 +-
 .../Flatbuf/SparseMatrixCompressedAxis.cs     |  15 +
 .../Flatbuf/SparseMatrixIndexCSX.cs           |  95 ++
 .../src/Apache.Arrow/Flatbuf/SparseTensor.cs  | 106 +++
 .../Apache.Arrow/Flatbuf/SparseTensorIndex.cs |  42 +
 .../Flatbuf/SparseTensorIndexCOO.cs           | 107 +++
 .../Flatbuf/SparseTensorIndexCSF.cs           | 155 ++++
 csharp/src/Apache.Arrow/Flatbuf/Tensor.cs     |  63 +-
 csharp/src/Apache.Arrow/Flatbuf/TensorDim.cs  |  27 +-
 .../src/Apache.Arrow/Flatbuf/Types/Binary.cs  |  22 +-
 csharp/src/Apache.Arrow/Flatbuf/Types/Bool.cs |  21 +-
 csharp/src/Apache.Arrow/Flatbuf/Types/Date.cs |  28 +-
 .../src/Apache.Arrow/Flatbuf/Types/Decimal.cs |  28 +-
 .../Apache.Arrow/Flatbuf/Types/Duration.cs    |  24 +-
 .../Flatbuf/Types/FloatingPoint.cs            |  24 +-
 csharp/src/Apache.Arrow/Flatbuf/Types/Int.cs  |  25 +-
 .../Apache.Arrow/Flatbuf/Types/Interval.cs    |  24 +-
 .../Apache.Arrow/Flatbuf/Types/LargeBinary.cs |  21 +-
 .../Apache.Arrow/Flatbuf/Types/LargeList.cs   |  21 +-
 .../Apache.Arrow/Flatbuf/Types/LargeUtf8.cs   |  21 +-
 csharp/src/Apache.Arrow/Flatbuf/Types/List.cs |  21 +-
 csharp/src/Apache.Arrow/Flatbuf/Types/Null.cs |  21 +-
 .../src/Apache.Arrow/Flatbuf/Types/Struct_.cs |  21 +-
 csharp/src/Apache.Arrow/Flatbuf/Types/Time.cs |  42 +-
 .../Apache.Arrow/Flatbuf/Types/Timestamp.cs   | 160 +++-
 .../src/Apache.Arrow/Flatbuf/Types/Union.cs   |  31 +-
 csharp/src/Apache.Arrow/Flatbuf/Types/Utf8.cs |  21 +-
 .../src/Apache.Arrow/Ipc/ArrowFileWriter.cs   |  16 +-
 .../Ipc/ArrowMemoryReaderImplementation.cs    |   2 +-
 .../Ipc/ArrowReaderImplementation.cs          |   2 +-
 .../Ipc/ArrowStreamReaderImplementation.cs    |   8 +-
 .../src/Apache.Arrow/Ipc/ArrowStreamWriter.cs |   2 +-
 .../Ipc/ArrowTypeFlatbufferBuilder.cs         |   2 +-
 .../Ipc/ReadOnlyMemoryBufferAllocator.cs      |   2 +-
 65 files changed, 2922 insertions(+), 399 deletions(-)
 create mode 100644 csharp/src/Apache.Arrow/Flatbuf/Enums/DictionaryKind.cs
 create mode 100644 csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/FlatBufferVerify.cs
 create mode 100644 csharp/src/Apache.Arrow/Flatbuf/RunEndEncoded.cs
 create mode 100644 csharp/src/Apache.Arrow/Flatbuf/SparseMatrixCompressedAxis.cs
 create mode 100644 csharp/src/Apache.Arrow/Flatbuf/SparseMatrixIndexCSX.cs
 create mode 100644 csharp/src/Apache.Arrow/Flatbuf/SparseTensor.cs
 create mode 100644 csharp/src/Apache.Arrow/Flatbuf/SparseTensorIndex.cs
 create mode 100644 csharp/src/Apache.Arrow/Flatbuf/SparseTensorIndexCOO.cs
 create mode 100644 csharp/src/Apache.Arrow/Flatbuf/SparseTensorIndexCSF.cs

diff --git a/csharp/src/Apache.Arrow.Flight/Internal/FlightDataStream.cs b/csharp/src/Apache.Arrow.Flight/Internal/FlightDataStream.cs
index 8658845723222..3211212c99cb9 100644
--- a/csharp/src/Apache.Arrow.Flight/Internal/FlightDataStream.cs
+++ b/csharp/src/Apache.Arrow.Flight/Internal/FlightDataStream.cs
@@ -22,7 +22,7 @@
 using Apache.Arrow.Flatbuf;
 using Apache.Arrow.Flight.Protocol;
 using Apache.Arrow.Ipc;
-using FlatBuffers;
+using Google.FlatBuffers;
 using Google.Protobuf;
 using Grpc.Core;
 
diff --git a/csharp/src/Apache.Arrow.Flight/Internal/FlightMessageSerializer.cs b/csharp/src/Apache.Arrow.Flight/Internal/FlightMessageSerializer.cs
index 36b13a63d3c0f..9df28b5033c06 100644
--- a/csharp/src/Apache.Arrow.Flight/Internal/FlightMessageSerializer.cs
+++ b/csharp/src/Apache.Arrow.Flight/Internal/FlightMessageSerializer.cs
@@ -19,7 +19,7 @@
 using System.IO;
 using System.Text;
 using Apache.Arrow.Ipc;
-using FlatBuffers;
+using Google.FlatBuffers;
 
 namespace Apache.Arrow.Flight
 {
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Block.cs b/csharp/src/Apache.Arrow/Flatbuf/Block.cs
index 89c065b202c3a..8df0159cd6921 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Block.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Block.cs
@@ -6,13 +6,14 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 internal struct Block : IFlatbufferObject
 {
   private Struct __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Struct(_i, _bb); }
   public Block __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   /// Index to the start of the RecordBlock (note this is past the Message header)
@@ -20,7 +21,7 @@ internal struct Block : IFlatbufferObject
   /// Length of the metadata
   public int MetaDataLength { get { return __p.bb.GetInt(__p.bb_pos + 8); } }
   /// Length of the data (this is aligned so there can be a gap between this and
-  /// the metatdata).
+  /// the metadata).
   public long BodyLength { get { return __p.bb.GetLong(__p.bb_pos + 16); } }
 
   public static Offset<Block> CreateBlock(FlatBufferBuilder builder, long Offset, int MetaDataLength, long BodyLength) {
@@ -31,7 +32,7 @@ public static Offset<Block> CreateBlock(FlatBufferBuilder builder, long Offset,
     builder.PutLong(Offset);
     return new Offset<Block>(builder.Offset);
   }
-};
+}
 
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/BodyCompression.cs b/csharp/src/Apache.Arrow/Flatbuf/BodyCompression.cs
index dda0dd403518f..bbc0e1e46fd7c 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/BodyCompression.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/BodyCompression.cs
@@ -6,7 +6,8 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// Optional compression for the memory buffers constituting IPC message
 /// bodies. Intended for use with RecordBatch but could be used for other
@@ -15,12 +16,14 @@ internal struct BodyCompression : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static BodyCompression GetRootAsBodyCompression(ByteBuffer _bb) { return GetRootAsBodyCompression(_bb, new BodyCompression()); }
   public static BodyCompression GetRootAsBodyCompression(ByteBuffer _bb, BodyCompression obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public BodyCompression __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
-  /// Compressor library
+  /// Compressor library.
+  /// For LZ4_FRAME, each compressed buffer must consist of a single frame.
   public CompressionType Codec { get { int o = __p.__offset(4); return o != 0 ? (CompressionType)__p.bb.GetSbyte(o + __p.bb_pos) : CompressionType.LZ4_FRAME; } }
   /// Indicates the way the record batch body was compressed
   public BodyCompressionMethod Method { get { int o = __p.__offset(6); return o != 0 ? (BodyCompressionMethod)__p.bb.GetSbyte(o + __p.bb_pos) : BodyCompressionMethod.BUFFER; } }
@@ -28,20 +31,31 @@ internal struct BodyCompression : IFlatbufferObject
   public static Offset<BodyCompression> CreateBodyCompression(FlatBufferBuilder builder,
       CompressionType codec = CompressionType.LZ4_FRAME,
       BodyCompressionMethod method = BodyCompressionMethod.BUFFER) {
-    builder.StartObject(2);
+    builder.StartTable(2);
     BodyCompression.AddMethod(builder, method);
     BodyCompression.AddCodec(builder, codec);
     return BodyCompression.EndBodyCompression(builder);
   }
 
-  public static void StartBodyCompression(FlatBufferBuilder builder) { builder.StartObject(2); }
+  public static void StartBodyCompression(FlatBufferBuilder builder) { builder.StartTable(2); }
   public static void AddCodec(FlatBufferBuilder builder, CompressionType codec) { builder.AddSbyte(0, (sbyte)codec, 0); }
   public static void AddMethod(FlatBufferBuilder builder, BodyCompressionMethod method) { builder.AddSbyte(1, (sbyte)method, 0); }
   public static Offset<BodyCompression> EndBodyCompression(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<BodyCompression>(o);
   }
-};
+}
+
 
+static internal class BodyCompressionVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Codec*/, 1 /*CompressionType*/, 1, false)
+      && verifier.VerifyField(tablePos, 6 /*Method*/, 1 /*BodyCompressionMethod*/, 1, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Buffer.cs b/csharp/src/Apache.Arrow/Flatbuf/Buffer.cs
index 7b2315cab4b29..419800d1338e4 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Buffer.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Buffer.cs
@@ -6,7 +6,8 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// ----------------------------------------------------------------------
 /// A Buffer represents a single contiguous memory segment
@@ -14,14 +15,17 @@ internal struct Buffer : IFlatbufferObject
 {
   private Struct __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Struct(_i, _bb); }
   public Buffer __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   /// The relative offset into the shared memory page where the bytes for this
   /// buffer starts
   public long Offset { get { return __p.bb.GetLong(__p.bb_pos + 0); } }
   /// The absolute length (in bytes) of the memory buffer. The memory is found
-  /// from offset (inclusive) to offset + length (non-inclusive).
+  /// from offset (inclusive) to offset + length (non-inclusive). When building
+  /// messages using the encapsulated IPC message, padding bytes may be written
+  /// after a buffer, but such padding bytes do not need to be accounted for in
+  /// the size here.
   public long Length { get { return __p.bb.GetLong(__p.bb_pos + 8); } }
 
   public static Offset<Buffer> CreateBuffer(FlatBufferBuilder builder, long Offset, long Length) {
@@ -30,7 +34,7 @@ public static Offset<Buffer> CreateBuffer(FlatBufferBuilder builder, long Offset
     builder.PutLong(Offset);
     return new Offset<Buffer>(builder.Offset);
   }
-};
+}
 
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/DictionaryBatch.cs b/csharp/src/Apache.Arrow/Flatbuf/DictionaryBatch.cs
index e3afafdd5cb16..180e94108d1a7 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/DictionaryBatch.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/DictionaryBatch.cs
@@ -6,7 +6,8 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// For sending dictionary encoding information. Any Field can be
 /// dictionary-encoded, but in this case none of its children may be
@@ -18,37 +19,51 @@ internal struct DictionaryBatch : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static DictionaryBatch GetRootAsDictionaryBatch(ByteBuffer _bb) { return GetRootAsDictionaryBatch(_bb, new DictionaryBatch()); }
   public static DictionaryBatch GetRootAsDictionaryBatch(ByteBuffer _bb, DictionaryBatch obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public DictionaryBatch __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   public long Id { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
   public RecordBatch? Data { get { int o = __p.__offset(6); return o != 0 ? (RecordBatch?)(new RecordBatch()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
   /// If isDelta is true the values in the dictionary are to be appended to a
-  /// dictionary with the indicated id
+  /// dictionary with the indicated id. If isDelta is false this dictionary
+  /// should replace the existing dictionary.
   public bool IsDelta { get { int o = __p.__offset(8); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
 
   public static Offset<DictionaryBatch> CreateDictionaryBatch(FlatBufferBuilder builder,
       long id = 0,
       Offset<RecordBatch> dataOffset = default(Offset<RecordBatch>),
       bool isDelta = false) {
-    builder.StartObject(3);
+    builder.StartTable(3);
     DictionaryBatch.AddId(builder, id);
     DictionaryBatch.AddData(builder, dataOffset);
     DictionaryBatch.AddIsDelta(builder, isDelta);
     return DictionaryBatch.EndDictionaryBatch(builder);
   }
 
-  public static void StartDictionaryBatch(FlatBufferBuilder builder) { builder.StartObject(3); }
+  public static void StartDictionaryBatch(FlatBufferBuilder builder) { builder.StartTable(3); }
   public static void AddId(FlatBufferBuilder builder, long id) { builder.AddLong(0, id, 0); }
   public static void AddData(FlatBufferBuilder builder, Offset<RecordBatch> dataOffset) { builder.AddOffset(1, dataOffset.Value, 0); }
   public static void AddIsDelta(FlatBufferBuilder builder, bool isDelta) { builder.AddBool(2, isDelta, false); }
   public static Offset<DictionaryBatch> EndDictionaryBatch(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<DictionaryBatch>(o);
   }
-};
+}
+
 
+static internal class DictionaryBatchVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Id*/, 8 /*long*/, 8, false)
+      && verifier.VerifyTable(tablePos, 6 /*Data*/, RecordBatchVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 8 /*IsDelta*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/DictionaryEncoding.cs b/csharp/src/Apache.Arrow/Flatbuf/DictionaryEncoding.cs
index 02a35fdd41b1e..ecf1dd788f468 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/DictionaryEncoding.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/DictionaryEncoding.cs
@@ -6,52 +6,72 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
-/// ----------------------------------------------------------------------
-/// Dictionary encoding metadata
 internal struct DictionaryEncoding : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static DictionaryEncoding GetRootAsDictionaryEncoding(ByteBuffer _bb) { return GetRootAsDictionaryEncoding(_bb, new DictionaryEncoding()); }
   public static DictionaryEncoding GetRootAsDictionaryEncoding(ByteBuffer _bb, DictionaryEncoding obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public DictionaryEncoding __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   /// The known dictionary id in the application where this data is used. In
   /// the file or streaming formats, the dictionary ids are found in the
   /// DictionaryBatch messages
   public long Id { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
-  /// The dictionary indices are constrained to be positive integers. If this
-  /// field is null, the indices must be signed int32
+  /// The dictionary indices are constrained to be non-negative integers. If
+  /// this field is null, the indices must be signed int32. To maximize
+  /// cross-language compatibility and performance, implementations are
+  /// recommended to prefer signed integer types over unsigned integer types
+  /// and to avoid uint64 indices unless they are required by an application.
   public Int? IndexType { get { int o = __p.__offset(6); return o != 0 ? (Int?)(new Int()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
   /// By default, dictionaries are not ordered, or the order does not have
   /// semantic meaning. In some statistical, applications, dictionary-encoding
   /// is used to represent ordered categorical data, and we provide a way to
   /// preserve that metadata here
   public bool IsOrdered { get { int o = __p.__offset(8); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
+  public DictionaryKind DictionaryKind { get { int o = __p.__offset(10); return o != 0 ? (DictionaryKind)__p.bb.GetShort(o + __p.bb_pos) : DictionaryKind.DenseArray; } }
 
   public static Offset<DictionaryEncoding> CreateDictionaryEncoding(FlatBufferBuilder builder,
       long id = 0,
       Offset<Int> indexTypeOffset = default(Offset<Int>),
-      bool isOrdered = false) {
-    builder.StartObject(3);
+      bool isOrdered = false,
+      DictionaryKind dictionaryKind = DictionaryKind.DenseArray) {
+    builder.StartTable(4);
     DictionaryEncoding.AddId(builder, id);
     DictionaryEncoding.AddIndexType(builder, indexTypeOffset);
+    DictionaryEncoding.AddDictionaryKind(builder, dictionaryKind);
     DictionaryEncoding.AddIsOrdered(builder, isOrdered);
     return DictionaryEncoding.EndDictionaryEncoding(builder);
   }
 
-  public static void StartDictionaryEncoding(FlatBufferBuilder builder) { builder.StartObject(3); }
+  public static void StartDictionaryEncoding(FlatBufferBuilder builder) { builder.StartTable(4); }
   public static void AddId(FlatBufferBuilder builder, long id) { builder.AddLong(0, id, 0); }
   public static void AddIndexType(FlatBufferBuilder builder, Offset<Int> indexTypeOffset) { builder.AddOffset(1, indexTypeOffset.Value, 0); }
   public static void AddIsOrdered(FlatBufferBuilder builder, bool isOrdered) { builder.AddBool(2, isOrdered, false); }
+  public static void AddDictionaryKind(FlatBufferBuilder builder, DictionaryKind dictionaryKind) { builder.AddShort(3, (short)dictionaryKind, 0); }
   public static Offset<DictionaryEncoding> EndDictionaryEncoding(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<DictionaryEncoding>(o);
   }
-};
+}
+
 
+static internal class DictionaryEncodingVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Id*/, 8 /*long*/, 8, false)
+      && verifier.VerifyTable(tablePos, 6 /*IndexType*/, IntVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 8 /*IsOrdered*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyField(tablePos, 10 /*DictionaryKind*/, 2 /*DictionaryKind*/, 2, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Enums/BodyCompressionMethod.cs b/csharp/src/Apache.Arrow/Flatbuf/Enums/BodyCompressionMethod.cs
index e9f6b6e831e54..e1f0c8f79ddf4 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Enums/BodyCompressionMethod.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Enums/BodyCompressionMethod.cs
@@ -17,7 +17,7 @@ internal enum BodyCompressionMethod : sbyte
   /// uncompressed length may be set to -1 to indicate that the data that
   /// follows is not compressed, which can be useful for cases where
   /// compression does not yield appreciable savings.
- BUFFER = 0,
+  BUFFER = 0,
 };
 
 
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Enums/DictionaryKind.cs b/csharp/src/Apache.Arrow/Flatbuf/Enums/DictionaryKind.cs
new file mode 100644
index 0000000000000..9a67bc7c5c86f
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Flatbuf/Enums/DictionaryKind.cs
@@ -0,0 +1,19 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Apache.Arrow.Flatbuf
+{
+
+/// ----------------------------------------------------------------------
+/// Dictionary encoding metadata
+/// Maintained for forwards compatibility, in the future
+/// Dictionaries might be explicit maps between integers and values
+/// allowing for non-contiguous index values
+internal enum DictionaryKind : short
+{
+  DenseArray = 0,
+};
+
+
+}
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Enums/IntervalUnit.cs b/csharp/src/Apache.Arrow/Flatbuf/Enums/IntervalUnit.cs
index d1363968df064..ac82c72e24e8b 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Enums/IntervalUnit.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Enums/IntervalUnit.cs
@@ -7,8 +7,9 @@ namespace Apache.Arrow.Flatbuf
 
 internal enum IntervalUnit : short
 {
- YEAR_MONTH = 0,
- DAY_TIME = 1,
+  YEAR_MONTH = 0,
+  DAY_TIME = 1,
+  MONTH_DAY_NANO = 2,
 };
 
 
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Enums/MessageHeader.cs b/csharp/src/Apache.Arrow/Flatbuf/Enums/MessageHeader.cs
index 94d239bfa9345..1204b1e276e6e 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Enums/MessageHeader.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Enums/MessageHeader.cs
@@ -15,12 +15,44 @@ namespace Apache.Arrow.Flatbuf
 /// it is best to send data using RecordBatch
 internal enum MessageHeader : byte
 {
- NONE = 0,
- Schema = 1,
- DictionaryBatch = 2,
- RecordBatch = 3,
- Tensor = 4,
+  NONE = 0,
+  Schema = 1,
+  DictionaryBatch = 2,
+  RecordBatch = 3,
+  Tensor = 4,
+  SparseTensor = 5,
 };
 
 
+
+static internal class MessageHeaderVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos)
+  {
+    bool result = true;
+    switch((MessageHeader)typeId)
+    {
+      case MessageHeader.Schema:
+        result = SchemaVerify.Verify(verifier, tablePos);
+        break;
+      case MessageHeader.DictionaryBatch:
+        result = DictionaryBatchVerify.Verify(verifier, tablePos);
+        break;
+      case MessageHeader.RecordBatch:
+        result = RecordBatchVerify.Verify(verifier, tablePos);
+        break;
+      case MessageHeader.Tensor:
+        result = TensorVerify.Verify(verifier, tablePos);
+        break;
+      case MessageHeader.SparseTensor:
+        result = SparseTensorVerify.Verify(verifier, tablePos);
+        break;
+      default: result = true;
+        break;
+    }
+    return result;
+  }
+}
+
+
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Enums/Type.cs b/csharp/src/Apache.Arrow/Flatbuf/Enums/Type.cs
index e8a7932a70369..10f852efb9b96 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Enums/Type.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Enums/Type.cs
@@ -10,29 +10,112 @@ namespace Apache.Arrow.Flatbuf
 /// add new logical types to Type without breaking backwards compatibility
 internal enum Type : byte
 {
- NONE = 0,
- Null = 1,
- Int = 2,
- FloatingPoint = 3,
- Binary = 4,
- Utf8 = 5,
- Bool = 6,
- Decimal = 7,
- Date = 8,
- Time = 9,
- Timestamp = 10,
- Interval = 11,
- List = 12,
- Struct_ = 13,
- Union = 14,
- FixedSizeBinary = 15,
- FixedSizeList = 16,
- Map = 17,
- Duration = 18,
- LargeBinary = 19,
- LargeUtf8 = 20,
- LargeList = 21,
+  NONE = 0,
+  Null = 1,
+  Int = 2,
+  FloatingPoint = 3,
+  Binary = 4,
+  Utf8 = 5,
+  Bool = 6,
+  Decimal = 7,
+  Date = 8,
+  Time = 9,
+  Timestamp = 10,
+  Interval = 11,
+  List = 12,
+  Struct_ = 13,
+  Union = 14,
+  FixedSizeBinary = 15,
+  FixedSizeList = 16,
+  Map = 17,
+  Duration = 18,
+  LargeBinary = 19,
+  LargeUtf8 = 20,
+  LargeList = 21,
+  RunEndEncoded = 22,
 };
 
 
+
+static internal class TypeVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos)
+  {
+    bool result = true;
+    switch((Type)typeId)
+    {
+      case Type.Null:
+        result = NullVerify.Verify(verifier, tablePos);
+        break;
+      case Type.Int:
+        result = IntVerify.Verify(verifier, tablePos);
+        break;
+      case Type.FloatingPoint:
+        result = FloatingPointVerify.Verify(verifier, tablePos);
+        break;
+      case Type.Binary:
+        result = BinaryVerify.Verify(verifier, tablePos);
+        break;
+      case Type.Utf8:
+        result = Utf8Verify.Verify(verifier, tablePos);
+        break;
+      case Type.Bool:
+        result = BoolVerify.Verify(verifier, tablePos);
+        break;
+      case Type.Decimal:
+        result = DecimalVerify.Verify(verifier, tablePos);
+        break;
+      case Type.Date:
+        result = DateVerify.Verify(verifier, tablePos);
+        break;
+      case Type.Time:
+        result = TimeVerify.Verify(verifier, tablePos);
+        break;
+      case Type.Timestamp:
+        result = TimestampVerify.Verify(verifier, tablePos);
+        break;
+      case Type.Interval:
+        result = IntervalVerify.Verify(verifier, tablePos);
+        break;
+      case Type.List:
+        result = ListVerify.Verify(verifier, tablePos);
+        break;
+      case Type.Struct_:
+        result = Struct_Verify.Verify(verifier, tablePos);
+        break;
+      case Type.Union:
+        result = UnionVerify.Verify(verifier, tablePos);
+        break;
+      case Type.FixedSizeBinary:
+        result = FixedSizeBinaryVerify.Verify(verifier, tablePos);
+        break;
+      case Type.FixedSizeList:
+        result = FixedSizeListVerify.Verify(verifier, tablePos);
+        break;
+      case Type.Map:
+        result = MapVerify.Verify(verifier, tablePos);
+        break;
+      case Type.Duration:
+        result = DurationVerify.Verify(verifier, tablePos);
+        break;
+      case Type.LargeBinary:
+        result = LargeBinaryVerify.Verify(verifier, tablePos);
+        break;
+      case Type.LargeUtf8:
+        result = LargeUtf8Verify.Verify(verifier, tablePos);
+        break;
+      case Type.LargeList:
+        result = LargeListVerify.Verify(verifier, tablePos);
+        break;
+      case Type.RunEndEncoded:
+        result = RunEndEncodedVerify.Verify(verifier, tablePos);
+        break;
+      default: result = true;
+        break;
+    }
+    return result;
+  }
+}
+
+
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Field.cs b/csharp/src/Apache.Arrow/Flatbuf/Field.cs
index a4f9e3057343e..c5c6c0a165598 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Field.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Field.cs
@@ -6,49 +6,76 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// ----------------------------------------------------------------------
 /// A field represents a named column in a record / row batch or child of a
 /// nested type.
-///
-/// - children is only for nested Arrow arrays
-/// - For primitive types, children will have length 0
-/// - nullable should default to true in general
 internal struct Field : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Field GetRootAsField(ByteBuffer _bb) { return GetRootAsField(_bb, new Field()); }
   public static Field GetRootAsField(ByteBuffer _bb, Field obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Field __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
+  /// Name is not required, in i.e. a List
   public string Name { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetNameBytes() { return __p.__vector_as_span(4); }
+  public Span<byte> GetNameBytes() { return __p.__vector_as_span<byte>(4, 1); }
 #else
   public ArraySegment<byte>? GetNameBytes() { return __p.__vector_as_arraysegment(4); }
 #endif
   public byte[] GetNameArray() { return __p.__vector_as_array<byte>(4); }
+  /// Whether or not this field can contain nulls. Should be true in general.
   public bool Nullable { get { int o = __p.__offset(6); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
-  public Type TypeType { get { int o = __p.__offset(8); return o != 0 ? (Type)__p.bb.Get(o + __p.bb_pos) : Flatbuf.Type.NONE; } }
-  public TTable? Type<TTable>() where TTable : struct, IFlatbufferObject { int o = __p.__offset(10); return o != 0 ? (TTable?)__p.__union<TTable>(o) : null; }
+  public Type TypeType { get { int o = __p.__offset(8); return o != 0 ? (Type)__p.bb.Get(o + __p.bb_pos) : Apache.Arrow.Flatbuf.Type.NONE; } }
+  /// This is the type of the decoded value if the field is dictionary encoded.
+  public TTable? Type<TTable>() where TTable : struct, IFlatbufferObject { int o = __p.__offset(10); return o != 0 ? (TTable?)__p.__union<TTable>(o + __p.bb_pos) : null; }
+  public Null TypeAsNull() { return Type<Null>().Value; }
+  public Int TypeAsInt() { return Type<Int>().Value; }
+  public FloatingPoint TypeAsFloatingPoint() { return Type<FloatingPoint>().Value; }
+  public Binary TypeAsBinary() { return Type<Binary>().Value; }
+  public Utf8 TypeAsUtf8() { return Type<Utf8>().Value; }
+  public Bool TypeAsBool() { return Type<Bool>().Value; }
+  public Decimal TypeAsDecimal() { return Type<Decimal>().Value; }
+  public Date TypeAsDate() { return Type<Date>().Value; }
+  public Time TypeAsTime() { return Type<Time>().Value; }
+  public Timestamp TypeAsTimestamp() { return Type<Timestamp>().Value; }
+  public Interval TypeAsInterval() { return Type<Interval>().Value; }
+  public List TypeAsList() { return Type<List>().Value; }
+  public Struct_ TypeAsStruct_() { return Type<Struct_>().Value; }
+  public Union TypeAsUnion() { return Type<Union>().Value; }
+  public FixedSizeBinary TypeAsFixedSizeBinary() { return Type<FixedSizeBinary>().Value; }
+  public FixedSizeList TypeAsFixedSizeList() { return Type<FixedSizeList>().Value; }
+  public Map TypeAsMap() { return Type<Map>().Value; }
+  public Duration TypeAsDuration() { return Type<Duration>().Value; }
+  public LargeBinary TypeAsLargeBinary() { return Type<LargeBinary>().Value; }
+  public LargeUtf8 TypeAsLargeUtf8() { return Type<LargeUtf8>().Value; }
+  public LargeList TypeAsLargeList() { return Type<LargeList>().Value; }
+  public RunEndEncoded TypeAsRunEndEncoded() { return Type<RunEndEncoded>().Value; }
+  /// Present only if the field is dictionary encoded.
   public DictionaryEncoding? Dictionary { get { int o = __p.__offset(12); return o != 0 ? (DictionaryEncoding?)(new DictionaryEncoding()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
+  /// children apply only to nested data types like Struct, List and Union. For
+  /// primitive types children will have length 0.
   public Field? Children(int j) { int o = __p.__offset(14); return o != 0 ? (Field?)(new Field()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
   public int ChildrenLength { get { int o = __p.__offset(14); return o != 0 ? __p.__vector_len(o) : 0; } }
+  /// User-defined metadata
   public KeyValue? CustomMetadata(int j) { int o = __p.__offset(16); return o != 0 ? (KeyValue?)(new KeyValue()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
   public int CustomMetadataLength { get { int o = __p.__offset(16); return o != 0 ? __p.__vector_len(o) : 0; } }
 
   public static Offset<Field> CreateField(FlatBufferBuilder builder,
       StringOffset nameOffset = default(StringOffset),
       bool nullable = false,
-      Type type_type = Flatbuf.Type.NONE,
+      Type type_type = Apache.Arrow.Flatbuf.Type.NONE,
       int typeOffset = 0,
       Offset<DictionaryEncoding> dictionaryOffset = default(Offset<DictionaryEncoding>),
       VectorOffset childrenOffset = default(VectorOffset),
       VectorOffset custom_metadataOffset = default(VectorOffset)) {
-    builder.StartObject(7);
+    builder.StartTable(7);
     Field.AddCustomMetadata(builder, custom_metadataOffset);
     Field.AddChildren(builder, childrenOffset);
     Field.AddDictionary(builder, dictionaryOffset);
@@ -59,7 +86,7 @@ public static Offset<Field> CreateField(FlatBufferBuilder builder,
     return Field.EndField(builder);
   }
 
-  public static void StartField(FlatBufferBuilder builder) { builder.StartObject(7); }
+  public static void StartField(FlatBufferBuilder builder) { builder.StartTable(7); }
   public static void AddName(FlatBufferBuilder builder, StringOffset nameOffset) { builder.AddOffset(0, nameOffset.Value, 0); }
   public static void AddNullable(FlatBufferBuilder builder, bool nullable) { builder.AddBool(1, nullable, false); }
   public static void AddTypeType(FlatBufferBuilder builder, Type typeType) { builder.AddByte(2, (byte)typeType, 0); }
@@ -68,16 +95,36 @@ public static Offset<Field> CreateField(FlatBufferBuilder builder,
   public static void AddChildren(FlatBufferBuilder builder, VectorOffset childrenOffset) { builder.AddOffset(5, childrenOffset.Value, 0); }
   public static VectorOffset CreateChildrenVector(FlatBufferBuilder builder, Offset<Field>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
   public static VectorOffset CreateChildrenVectorBlock(FlatBufferBuilder builder, Offset<Field>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateChildrenVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<Field>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateChildrenVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<Field>>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartChildrenVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
   public static void AddCustomMetadata(FlatBufferBuilder builder, VectorOffset customMetadataOffset) { builder.AddOffset(6, customMetadataOffset.Value, 0); }
   public static VectorOffset CreateCustomMetadataVector(FlatBufferBuilder builder, Offset<KeyValue>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
   public static VectorOffset CreateCustomMetadataVectorBlock(FlatBufferBuilder builder, Offset<KeyValue>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateCustomMetadataVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<KeyValue>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateCustomMetadataVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<KeyValue>>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartCustomMetadataVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
   public static Offset<Field> EndField(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Field>(o);
   }
-};
+}
+
 
+static internal class FieldVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyString(tablePos, 4 /*Name*/, false)
+      && verifier.VerifyField(tablePos, 6 /*Nullable*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyField(tablePos, 8 /*TypeType*/, 1 /*Type*/, 1, false)
+      && verifier.VerifyUnion(tablePos, 8, 10 /*Type*/, TypeVerify.Verify, false)
+      && verifier.VerifyTable(tablePos, 12 /*Dictionary*/, DictionaryEncodingVerify.Verify, false)
+      && verifier.VerifyVectorOfTables(tablePos, 14 /*Children*/, FieldVerify.Verify, false)
+      && verifier.VerifyVectorOfTables(tablePos, 16 /*CustomMetadata*/, KeyValueVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/FieldNode.cs b/csharp/src/Apache.Arrow/Flatbuf/FieldNode.cs
index 811e10ea46bdf..960970d73e0a2 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/FieldNode.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/FieldNode.cs
@@ -6,7 +6,8 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// ----------------------------------------------------------------------
 /// Data structures for describing a table row batch (a collection of
@@ -14,14 +15,14 @@ namespace Apache.Arrow.Flatbuf
 /// Metadata about a field at some level of a nested type tree (but not
 /// its children).
 ///
-/// For example, a List<Int16> with values [[1, 2, 3], null, [4], [5, 6], null]
+/// For example, a List<Int16> with values `[[1, 2, 3], null, [4], [5, 6], null]`
 /// would have {length: 5, null_count: 2} for its List node, and {length: 6,
 /// null_count: 0} for its Int16 node, as separate FieldNode structs
 internal struct FieldNode : IFlatbufferObject
 {
   private Struct __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Struct(_i, _bb); }
   public FieldNode __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   /// The number of value slots in the Arrow array at this level of a nested
@@ -38,7 +39,7 @@ public static Offset<FieldNode> CreateFieldNode(FlatBufferBuilder builder, long
     builder.PutLong(Length);
     return new Offset<FieldNode>(builder.Offset);
   }
-};
+}
 
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/FixedSizeBinary.cs b/csharp/src/Apache.Arrow/Flatbuf/FixedSizeBinary.cs
index b6414a23b5c2e..babe81f7f1fb5 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/FixedSizeBinary.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/FixedSizeBinary.cs
@@ -6,15 +6,17 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 internal struct FixedSizeBinary : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static FixedSizeBinary GetRootAsFixedSizeBinary(ByteBuffer _bb) { return GetRootAsFixedSizeBinary(_bb, new FixedSizeBinary()); }
   public static FixedSizeBinary GetRootAsFixedSizeBinary(ByteBuffer _bb, FixedSizeBinary obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public FixedSizeBinary __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   /// Number of bytes per value
@@ -22,18 +24,28 @@ internal struct FixedSizeBinary : IFlatbufferObject
 
   public static Offset<FixedSizeBinary> CreateFixedSizeBinary(FlatBufferBuilder builder,
       int byteWidth = 0) {
-    builder.StartObject(1);
+    builder.StartTable(1);
     FixedSizeBinary.AddByteWidth(builder, byteWidth);
     return FixedSizeBinary.EndFixedSizeBinary(builder);
   }
 
-  public static void StartFixedSizeBinary(FlatBufferBuilder builder) { builder.StartObject(1); }
+  public static void StartFixedSizeBinary(FlatBufferBuilder builder) { builder.StartTable(1); }
   public static void AddByteWidth(FlatBufferBuilder builder, int byteWidth) { builder.AddInt(0, byteWidth, 0); }
   public static Offset<FixedSizeBinary> EndFixedSizeBinary(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<FixedSizeBinary>(o);
   }
-};
+}
+
 
+static internal class FixedSizeBinaryVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*ByteWidth*/, 4 /*int*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/FixedSizeList.cs b/csharp/src/Apache.Arrow/Flatbuf/FixedSizeList.cs
index 0ca69b7a1960f..6293a7fdd896c 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/FixedSizeList.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/FixedSizeList.cs
@@ -6,15 +6,17 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 internal struct FixedSizeList : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static FixedSizeList GetRootAsFixedSizeList(ByteBuffer _bb) { return GetRootAsFixedSizeList(_bb, new FixedSizeList()); }
   public static FixedSizeList GetRootAsFixedSizeList(ByteBuffer _bb, FixedSizeList obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public FixedSizeList __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   /// Number of list items per value
@@ -22,18 +24,28 @@ internal struct FixedSizeList : IFlatbufferObject
 
   public static Offset<FixedSizeList> CreateFixedSizeList(FlatBufferBuilder builder,
       int listSize = 0) {
-    builder.StartObject(1);
+    builder.StartTable(1);
     FixedSizeList.AddListSize(builder, listSize);
     return FixedSizeList.EndFixedSizeList(builder);
   }
 
-  public static void StartFixedSizeList(FlatBufferBuilder builder) { builder.StartObject(1); }
+  public static void StartFixedSizeList(FlatBufferBuilder builder) { builder.StartTable(1); }
   public static void AddListSize(FlatBufferBuilder builder, int listSize) { builder.AddInt(0, listSize, 0); }
   public static Offset<FixedSizeList> EndFixedSizeList(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<FixedSizeList>(o);
   }
-};
+}
+
 
+static internal class FixedSizeListVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*ListSize*/, 4 /*int*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/ByteBuffer.cs b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/ByteBuffer.cs
index 91cd5cccb647f..e65735c347a6d 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/ByteBuffer.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/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
+namespace Google.FlatBuffers
 {
     internal 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 @@ public override void GrowFront(int newSize)
             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;
@@ -214,7 +215,7 @@ public static bool IsSupportedType<T>()
         }
 
         /// <summary>
-        /// Get the wire-size (in bytes) of a typed array
+        /// Get the wire-size (in bytes) of an typed array
         /// </summary>
         /// <typeparam name="T">The type of the array</typeparam>
         /// <param name="x">The array to get the size of</param>
@@ -224,7 +225,19 @@ public static int ArraySize<T>(T[] x)
             return SizeOf<T>() * x.Length;
         }
 
-#if ENABLE_SPAN_T
+        /// <summary>
+        /// Get the wire-size (in bytes) of an typed array segment, taking only the
+        /// range specified by <paramref name="x"/> into account.
+        /// </summary>
+        /// <typeparam name="T">The type of the array</typeparam>
+        /// <param name="x">The array segment to get the size of</param>
+        /// <returns>The number of bytes the array segment takes on wire</returns>
+        public static int ArraySize<T>(ArraySegment<T> x)
+        {
+            return SizeOf<T>() * x.Count;
+        }
+
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
         public static int ArraySize<T>(Span<T> x)
         {
             return SizeOf<T>() * x.Length;
@@ -233,7 +246,7 @@ public static int ArraySize<T>(Span<T> x)
 
         // 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 +274,7 @@ public byte[] ToFullArray()
             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 +302,14 @@ public MemoryStream ToMemoryStream(int pos, int len)
 #endif
 
 #if !UNSAFE_BYTEBUFFER
-        // Pre-allocated helper arrays for conversion.
-        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.
@@ -305,8 +321,8 @@ static public ushort ReverseBytes(ushort input)
         static public uint ReverseBytes(uint input)
         {
             return ((input & 0x000000FFU) << 24) |
-                   ((input & 0x0000FF00U) << 8) |
-                   ((input & 0x00FF0000U) >> 8) |
+                   ((input & 0x0000FF00U) <<  8) |
+                   ((input & 0x00FF0000U) >>  8) |
                    ((input & 0xFF000000U) >> 24);
         }
         static public ulong ReverseBytes(ulong input)
@@ -314,14 +330,14 @@ static public ulong ReverseBytes(ulong input)
             return (((input & 0x00000000000000FFUL) << 56) |
                     ((input & 0x000000000000FF00UL) << 40) |
                     ((input & 0x0000000000FF0000UL) << 24) |
-                    ((input & 0x00000000FF000000UL) << 8) |
-                    ((input & 0x000000FF00000000UL) >> 8) |
+                    ((input & 0x00000000FF000000UL) <<  8) |
+                    ((input & 0x000000FF00000000UL) >>  8) |
                     ((input & 0x0000FF0000000000UL) >> 24) |
                     ((input & 0x00FF000000000000UL) >> 40) |
                     ((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 +377,46 @@ protected ulong ReadLittleEndian(int offset, int count)
             }
             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 +427,7 @@ private void AssertOffsetAndLength(int offset, int length)
 #endif
         }
 
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
 
         public void PutSbyte(int offset, sbyte value)
         {
@@ -420,7 +475,7 @@ public void Put(int offset, byte value)
             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 +487,13 @@ public unsafe void PutStringUTF8(int offset, string value)
                 }
             }
         }
+#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 +513,7 @@ public void PutShort(int offset, short value)
         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 +534,7 @@ public void PutInt(int offset, int value)
         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 +555,7 @@ public unsafe void PutLong(int offset, long value)
         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 +571,7 @@ public unsafe void PutUlong(int offset, ulong value)
         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 +591,7 @@ public unsafe void PutFloat(int offset, float value)
         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 +648,23 @@ public void PutUlong(int offset, ulong value)
         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 +690,7 @@ public byte Get(int index)
         }
 #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 +698,11 @@ public unsafe string GetStringUTF8(int startPos, int len)
                 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 +720,7 @@ public short GetShort(int offset)
         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 +741,7 @@ public int GetInt(int offset)
         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 +762,7 @@ public long GetLong(int offset)
         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 +778,7 @@ public unsafe ulong GetUlong(int offset)
         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 +799,7 @@ public unsafe float GetFloat(int offset)
         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 +850,17 @@ public ulong GetUlong(int index)
 
         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
 
@@ -815,7 +881,30 @@ public int Put<T>(int offset, T[] x)
                 throw new ArgumentNullException("Cannot put a null array");
             }
 
-            if (x.Length == 0)
+            return Put(offset, new ArraySegment<T>(x));
+        }
+
+        /// <summary>
+        /// Copies an array segment of type T into this buffer, ending at the 
+        /// given offset into this buffer. The starting offset is calculated 
+        /// based on the count of the array segment and is the value returned.
+        /// </summary>
+        /// <typeparam name="T">The type of the input data (must be a struct)
+        /// </typeparam>
+        /// <param name="offset">The offset into this buffer where the copy 
+        /// will end</param>
+        /// <param name="x">The array segment to copy data from</param>
+        /// <returns>The 'start' location of this buffer now, after the copy 
+        /// completed</returns>
+        public int Put<T>(int offset, ArraySegment<T> x)
+            where T : struct
+        {
+            if (x.Equals(default(ArraySegment<T>)))
+            {
+                throw new ArgumentNullException("Cannot put a uninitialized array segment");
+            }
+
+            if (x.Count == 0)
             {
                 throw new ArgumentException("Cannot put an empty array");
             }
@@ -832,10 +921,71 @@ public int Put<T>(int offset, T[] x)
                 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);
+                var srcOffset = ByteBuffer.SizeOf<T>() * x.Offset;
+                Buffer.BlockCopy(x.Array, srcOffset, _buffer.Buffer, offset, numBytes);
+#endif
+            }
+            else
+            {
+                throw new NotImplementedException("Big Endian Support not implemented yet " +
+                    "for putting typed arrays");
+                // if we are BE, we have to swap each element by itself
+                //for(int i = x.Length - 1; i >= 0; i--)
+                //{
+                //  todo: low priority, but need to genericize the Put<T>() functions
+                //}
+            }
+            return offset;
+        }
+
+        /// <summary>
+        /// Copies an array segment of type T into this buffer, ending at the 
+        /// given offset into this buffer. The starting offset is calculated 
+        /// based on the count of the array segment and is the value returned.
+        /// </summary>
+        /// <typeparam name="T">The type of the input data (must be a struct)
+        /// </typeparam>
+        /// <param name="offset">The offset into this buffer where the copy 
+        /// will end</param>
+        /// <param name="ptr">The pointer to copy data from</param>
+        /// <param name="sizeInBytes">The number of bytes to copy</param>
+        /// <returns>The 'start' location of this buffer now, after the copy 
+        /// completed</returns>
+        public int Put<T>(int offset, IntPtr ptr, int sizeInBytes)
+            where T : struct
+        {
+            if (ptr == IntPtr.Zero)
+            {
+                throw new ArgumentNullException("Cannot add a null pointer");
+            }
+
+            if(sizeInBytes <= 0)
+            {
+                throw new ArgumentException("Cannot put an empty array");
+            }
+
+            if (!IsSupportedType<T>())
+            {
+                throw new ArgumentException("Cannot put an array of type "
+                    + typeof(T) + " into this buffer");
+            }
+
+            if (BitConverter.IsLittleEndian)
+            {
+                offset -= sizeInBytes;
+                AssertOffsetAndLength(offset, sizeInBytes);
+                // if we are LE, just do a block copy
+#if ENABLE_SPAN_T && UNSAFE_BYTEBUFFER
+                unsafe
+                { 
+                    var span = new Span<byte>(ptr.ToPointer(), sizeInBytes);
+                    span.CopyTo(_buffer.Span.Slice(offset, sizeInBytes));
+                }
+#else
+                Marshal.Copy(ptr, _buffer.Buffer, offset, sizeInBytes);
 #endif
             }
             else
@@ -851,7 +1001,7 @@ public int Put<T>(int offset, T[] x)
             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/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/ByteBufferUtil.cs b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/ByteBufferUtil.cs
index cfba4305e17ad..37c13d6986b42 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/ByteBufferUtil.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/ByteBufferUtil.cs
@@ -16,7 +16,7 @@
 
 using System;
 
-namespace FlatBuffers
+namespace Google.FlatBuffers
 {
 	/// <summary>
 	/// Class that collects utility functions around `ByteBuffer`.
diff --git a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/FlatBufferBuilder.cs b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/FlatBufferBuilder.cs
index 65873a6345813..aa17d23867f99 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/FlatBufferBuilder.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/FlatBufferBuilder.cs
@@ -16,13 +16,14 @@
 
 
 using System;
+using System.Collections.Generic;
 using System.Text;
 
 /// @file
 /// @addtogroup flatbuffers_csharp_api
 /// @{
 
-namespace FlatBuffers
+namespace Google.FlatBuffers
 {
     /// <summary>
     /// Responsible for building up and accessing a FlatBuffer formatted byte
@@ -47,6 +48,9 @@ internal class FlatBufferBuilder
         // For the current vector being built.
         private int _vectorNumElems = 0;
 
+        // For CreateSharedString
+        private Dictionary<string, StringOffset> _sharedStringMap = null;
+
         /// <summary>
         /// Create a FlatBufferBuilder with a given initial size.
         /// </summary>
@@ -63,7 +67,7 @@ public FlatBufferBuilder(int initialSize)
         }
 
         /// <summary>
-        /// Create a FlatBufferBuilder backed by the passed in ByteBuffer
+        /// Create a FlatBufferBuilder backed by the pased in ByteBuffer
         /// </summary>
         /// <param name="buffer">The ByteBuffer to write to</param>
         public FlatBufferBuilder(ByteBuffer buffer)
@@ -86,6 +90,10 @@ public void Clear()
             _objectStart = 0;
             _numVtables = 0;
             _vectorNumElems = 0;
+            if (_sharedStringMap != null)
+            {
+                _sharedStringMap.Clear();
+            }
         }
 
         /// <summary>
@@ -191,7 +199,7 @@ public void PutFloat(float x)
         }
 
         /// <summary>
-        /// Puts an array of type T into this builder at the 
+        /// Puts an array of type T into this builder at the
         /// current offset
         /// </summary>
         /// <typeparam name="T">The type of the input data </typeparam>
@@ -202,9 +210,34 @@ public void Put<T>(T[] x)
             _space = _bb.Put(_space, x);
         }
 
-#if ENABLE_SPAN_T
         /// <summary>
-        /// Puts a span of type T into this builder at the 
+        /// Puts an array of type T into this builder at the
+        /// current offset
+        /// </summary>
+        /// <typeparam name="T">The type of the input data </typeparam>
+        /// <param name="x">The array segment to copy data from</param>
+        public void Put<T>(ArraySegment<T> x)
+            where T : struct
+        {
+            _space = _bb.Put(_space, x);
+        }
+
+        /// <summary>
+        /// Puts data of type T into this builder at the
+        /// current offset
+        /// </summary>
+        /// <typeparam name="T">The type of the input data </typeparam>
+        /// <param name="ptr">The pointer to copy data from</param>
+        /// <param name="sizeInBytes">The length of the data in bytes</param>
+        public void Put<T>(IntPtr ptr, int sizeInBytes)
+            where T : struct
+        {
+            _space = _bb.Put<T>(_space, ptr, sizeInBytes);
+        }
+
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
+        /// <summary>
+        /// Puts a span of type T into this builder at the
         /// current offset
         /// </summary>
         /// <typeparam name="T">The type of the input data </typeparam>
@@ -289,13 +322,24 @@ public void PutDouble(double x)
         /// <param name="x">The array to copy data from</param>
         public void Add<T>(T[] x)
             where T : struct
+        {
+            Add(new ArraySegment<T>(x));
+        }
+
+        /// <summary>
+        /// Add an array of type T to the buffer (aligns the data and grows if necessary).
+        /// </summary>
+        /// <typeparam name="T">The type of the input data</typeparam>
+        /// <param name="x">The array segment to copy data from</param>
+        public void Add<T>(ArraySegment<T> x)
+            where T : struct
         {
             if (x == null)
             {
                 throw new ArgumentNullException("Cannot add a null array");
             }
 
-            if( x.Length == 0)
+            if( x.Count == 0)
             {
                 // don't do anything if the array is empty
                 return;
@@ -309,11 +353,53 @@ public void Add<T>(T[] x)
             int size = ByteBuffer.SizeOf<T>();
             // Need to prep on size (for data alignment) and then we pass the
             // rest of the length (minus 1) as additional bytes
-            Prep(size, size * (x.Length - 1));
+            Prep(size, size * (x.Count - 1));
             Put(x);
         }
 
-#if ENABLE_SPAN_T
+        /// <summary>
+        /// Adds the data of type T pointed to by the given pointer to the buffer (aligns the data and grows if necessary).
+        /// </summary>
+        /// <typeparam name="T">The type of the input data</typeparam>
+        /// <param name="ptr">The pointer to copy data from</param>
+        /// <param name="sizeInBytes">The data size in bytes</param>
+        public void Add<T>(IntPtr ptr, int sizeInBytes)
+            where T : struct
+        {
+            if(sizeInBytes == 0)
+            {
+                // don't do anything if the array is empty
+                return;
+            }
+
+            if (ptr == IntPtr.Zero)
+            {
+                throw new ArgumentNullException("Cannot add a null pointer");
+            }
+
+            if(sizeInBytes < 0)
+            {
+                throw new ArgumentOutOfRangeException("sizeInBytes", "sizeInBytes cannot be negative");
+            }
+
+            if(!ByteBuffer.IsSupportedType<T>())
+            {
+                throw new ArgumentException("Cannot add this Type array to the builder");
+            }
+
+            int size = ByteBuffer.SizeOf<T>();
+            if((sizeInBytes % size) != 0)
+            {
+                throw new ArgumentException("The given size in bytes " + sizeInBytes + " doesn't match the element size of T ( " + size + ")", "sizeInBytes");
+            }
+
+            // Need to prep on size (for data alignment) and then we pass the
+            // rest of the length (minus 1) as additional bytes
+            Prep(size, sizeInBytes - size);
+            Put<T>(ptr, sizeInBytes);
+        }
+
+#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>
@@ -352,7 +438,8 @@ public void AddOffset(int off)
             if (off > Offset)
                 throw new ArgumentException();
 
-            off = Offset - off + sizeof(int);
+            if (off != 0)
+                off = Offset - off + sizeof(int);
             PutInt(off);
         }
 
@@ -387,7 +474,7 @@ public VectorOffset CreateVectorOfTables<T>(Offset<T>[] offsets) where T : struc
             return EndVector();
         }
 
-        /// @cond FLATBUFFERS_INTERNAL
+        /// @cond FLATBUFFERS_INTENRAL
         public void Nested(int obj)
         {
             // Structs are always stored inline, so need to be created right
@@ -407,7 +494,7 @@ public void NotNested()
                     "FlatBuffers: object serialization must not be nested.");
         }
 
-        public void StartObject(int numfields)
+        public void StartTable(int numfields)
         {
             if (numfields < 0)
                 throw new ArgumentOutOfRangeException("Flatbuffers: invalid numfields");
@@ -441,6 +528,15 @@ public void Slot(int voffset)
         /// <param name="d">The default value to compare the value against</param>
         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>
@@ -450,6 +546,14 @@ public void Slot(int voffset)
         /// <param name="d">The default value to compare the value against</param>
         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>
@@ -459,6 +563,14 @@ public void Slot(int voffset)
         /// <param name="d">The default value to compare the value against</param>
         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>
@@ -468,6 +580,14 @@ public void Slot(int voffset)
         /// <param name="d">The default value to compare the value against</param>
         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>
@@ -477,6 +597,14 @@ public void Slot(int voffset)
         /// <param name="d">The default value to compare the value against</param>
         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>
@@ -486,6 +614,14 @@ public void Slot(int voffset)
         /// <param name="d">The default value to compare the value against</param>
         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>
@@ -495,6 +631,14 @@ public void Slot(int voffset)
         /// <param name="d">The default value to compare the value against</param>
         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>
@@ -504,6 +648,14 @@ public void Slot(int voffset)
         /// <param name="d">The default value to compare the value against</param>
         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>
@@ -513,6 +665,14 @@ public void Slot(int voffset)
         /// <param name="d">The default value to compare the value against</param>
         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>
@@ -522,6 +682,14 @@ public void Slot(int voffset)
         /// <param name="d">The default value to compare the value against</param>
         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>
@@ -531,14 +699,22 @@ public void Slot(int voffset)
         /// <param name="d">The default value to compare the value against</param>
         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>
         /// <param name="x">The value to put into the buffer. If the value is equal to the default
-        /// and <see cref="ForceDefaults"/> is false, the value will be skipped.</param>
+        /// the value will be skipped.</param>
         /// <param name="d">The default value to compare the value against</param>
-        public void AddOffset(int o, int x, int d) { if (ForceDefaults || x != d) { AddOffset(x); Slot(o); } }
+        public void AddOffset(int o, int x, int d) { if (x != d) { AddOffset(x); Slot(o); } }
         /// @endcond
 
         /// <summary>
@@ -550,6 +726,10 @@ public void Slot(int voffset)
         /// </returns>
         public StringOffset CreateString(string s)
         {
+            if (s == null)
+            {
+                return new StringOffset(0);
+            }
             NotNested();
             AddByte(0);
             var utf8StringLen = Encoding.UTF8.GetByteCount(s);
@@ -559,7 +739,7 @@ public StringOffset CreateString(string s)
         }
 
 
-#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.
@@ -579,6 +759,37 @@ public StringOffset CreateUTF8String(Span<byte> chars)
         }
 #endif
 
+        /// <summary>
+        /// Store a string in the buffer, which can contain any binary data.
+        /// If a string with this exact contents has already been serialized before,
+        /// instead simply returns the offset of the existing string.
+        /// </summary>
+        /// <param name="s">The string to encode.</param>
+        /// <returns>
+        /// The offset in the buffer where the encoded string starts.
+        /// </returns>
+        public StringOffset CreateSharedString(string s)
+        {
+            if (s == null)
+            {
+              return new StringOffset(0);
+            }
+
+            if (_sharedStringMap == null)
+            {
+                _sharedStringMap = new Dictionary<string, StringOffset>();
+            }
+
+            if (_sharedStringMap.ContainsKey(s))
+            {
+                return _sharedStringMap[s];
+            }
+
+            var stringOffset = CreateString(s);
+            _sharedStringMap.Add(s, stringOffset);
+            return stringOffset;
+        }
+
         /// @cond FLATBUFFERS_INTERNAL
         // Structs are stored inline, so nothing additional is being added.
         // `d` is always 0.
@@ -591,11 +802,11 @@ public void AddStruct(int voffset, int x, int d)
             }
         }
 
-        public int EndObject()
+        public int EndTable()
         {
             if (_vtableSize < 0)
                 throw new InvalidOperationException(
-                  "Flatbuffers: calling endObject without a startObject");
+                  "Flatbuffers: calling EndTable without a StartTable");
 
             AddInt((int)0);
             var vtableloc = Offset;
diff --git a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/FlatBufferConstants.cs b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/FlatBufferConstants.cs
index 68a4e9cad0950..c26f1b66d1023 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/FlatBufferConstants.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/FlatBufferConstants.cs
@@ -19,11 +19,19 @@
 using System.Linq;
 using System.Text;
 
-namespace FlatBuffers
+namespace Google.FlatBuffers
 {
     internal static class FlatBufferConstants
     {
         public const int FileIdentifierLength = 4;
         public const int SizePrefixLength = 4;
+        /** A version identifier to force a compile error if someone
+        accidentally tries to build generated code with a runtime of
+        two mismatched version. Versions need to always match, as
+        the runtime and generated code are modified in sync.
+        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_23_5_9() {}
     }
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/FlatBufferVerify.cs b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/FlatBufferVerify.cs
new file mode 100644
index 0000000000000..b108aa3e28ec3
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/FlatBufferVerify.cs
@@ -0,0 +1,822 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+using System;
+using System.Reflection;using System.Collections.Generic;
+using System.IO;
+
+namespace Google.FlatBuffers
+{
+
+  /// <summary>
+  /// The Class of the Verifier Options
+  /// </summary>
+  internal class Options
+  {
+    public const int DEFAULT_MAX_DEPTH = 64;
+    public const int DEFAULT_MAX_TABLES = 1000000;
+
+    private int max_depth = 0;
+    private int max_tables = 0;
+    private bool string_end_check = false;
+    private bool alignment_check = false;
+
+    public Options()
+    {
+      max_depth = DEFAULT_MAX_DEPTH;
+      max_tables = DEFAULT_MAX_TABLES;
+      string_end_check = true;
+      alignment_check = true;
+    }
+
+    public Options(int maxDepth, int maxTables, bool stringEndCheck, bool alignmentCheck)
+    {
+      max_depth = maxDepth;
+      max_tables = maxTables;
+      string_end_check = stringEndCheck;
+      alignment_check = alignmentCheck;
+    }
+    /// <summary> Maximum depth of nested tables allowed in a valid flatbuffer. </summary>
+    public int maxDepth
+    {
+      get { return max_depth; }
+      set { max_depth = value; }
+    }
+    /// <summary> Maximum number of tables allowed in a valid flatbuffer. </summary>
+    public int maxTables
+    {
+      get { return max_tables; }
+      set { max_tables = value; }
+    }
+    /// <summary> Check that string contains its null terminator </summary>
+    public bool stringEndCheck
+    {
+      get { return string_end_check; }
+      set { string_end_check = value; }
+    }
+    /// <summary> Check alignment of elements </summary>
+    public bool alignmentCheck
+    {
+      get { return alignment_check; }
+      set { alignment_check = value; }
+    }
+  }
+
+  internal struct checkElementStruct
+  {
+    public bool elementValid;
+    public uint elementOffset;
+  }
+
+  internal delegate bool VerifyTableAction(Verifier verifier, uint tablePos);
+  internal delegate bool VerifyUnionAction(Verifier verifier, byte typeId, uint tablePos);
+
+  /// <summary>
+  /// The Main Class of the FlatBuffer Verifier
+  /// </summary>
+  internal class Verifier
+  {
+    private ByteBuffer verifier_buffer = null;
+    private Options verifier_options = null;
+    private int depth_cnt = 0;
+    private int num_tables_cnt = 0;
+
+    public const int SIZE_BYTE = 1;
+    public const int SIZE_INT = 4;
+    public const int SIZE_U_OFFSET = 4;
+    public const int SIZE_S_OFFSET = 4;
+    public const int SIZE_V_OFFSET = 2;
+    public const int SIZE_PREFIX_LENGTH = FlatBufferConstants.SizePrefixLength;         // default size = 4
+    public const int FLATBUFFERS_MAX_BUFFER_SIZE = System.Int32.MaxValue;               // default size = 2147483647
+    public const int FILE_IDENTIFIER_LENGTH = FlatBufferConstants.FileIdentifierLength; // default size = 4
+
+    /// <summary> The Base Constructor of the Verifier object </summary>
+    public Verifier()
+    {
+      // Verifier buffer
+      verifier_buffer = null;
+      // Verifier settings 
+      verifier_options = null;
+      // Depth counter
+      depth_cnt = 0;
+      // Tables counter
+      num_tables_cnt = 0;
+    }
+
+    /// <summary> The Constructor of the Verifier object with input parameters: ByteBuffer and/or Options </summary>
+    /// <param name="buf"> Input flat byte buffer defined as ByteBuffer type</param>
+    /// <param name="options"> Options object with settings for the coniguration the Verifier </param>
+    public Verifier(ByteBuffer buf, Options options = null)
+    {
+      verifier_buffer = buf;
+      verifier_options = options ?? new Options();
+      depth_cnt = 0;
+      num_tables_cnt = 0;
+    }
+
+    /// <summary> Bytes Buffer for Verify</summary>
+    public ByteBuffer Buf
+    {
+      get { return verifier_buffer; }
+      set { verifier_buffer = value; }
+    }
+    /// <summary> Options of the Verifier </summary>
+    public Options options
+    {
+      get { return verifier_options; }
+      set { verifier_options = value; }
+    }
+    /// <summary> Counter of tables depth in a tested flatbuffer  </summary>
+    public int depth
+    {
+      get { return depth_cnt; }
+      set { depth_cnt = value; }
+    }
+    /// <summary> Counter of tables in a tested flatbuffer </summary>
+    public int numTables
+    {
+      get { return num_tables_cnt; }
+      set { num_tables_cnt = value; }
+    }
+
+
+    /// <summary> Method set maximum tables depth of valid structure</summary>
+    /// <param name="value"> Specify Value of the maximum depth of the structure</param>
+    public Verifier SetMaxDepth(int value)
+    {
+      verifier_options.maxDepth = value;
+      return this;
+    }
+    /// <summary> Specify maximum number of tables in structure </summary>
+    /// <param name="value"> Specify Value of the maximum number of the tables in the structure</param>
+    public Verifier SetMaxTables(int value)
+    {
+      verifier_options.maxTables = value;
+      return this;
+    }
+    /// <summary> Enable/disable buffer content alignment check </summary>
+    /// <param name="value"> Value of the State for buffer content alignment check (Enable = true) </param>
+    public Verifier SetAlignmentCheck(bool value)
+    {
+      verifier_options.alignmentCheck = value;
+      return this;
+    }
+    /// <summary> Enable/disable checking of string termination '0' character </summary>
+    /// <param name="value"> Value of the option for string termination '0' character check (Enable = true)</param>
+    public Verifier SetStringCheck(bool value)
+    {
+      verifier_options.stringEndCheck = value;
+      return this;
+    }
+
+    /// <summary> Check if there is identifier in buffer </summary>
+    /// <param name="buf"> Input flat byte buffer defined as ByteBuffer type </param>
+    /// <param name="startPos">Start position of data in the Byte Buffer</param>
+    /// <param name="identifier"> Identifier for the Byte Buffer</param>
+    /// <returns> Return True when the Byte Buffer Identifier is present</returns>
+    private bool BufferHasIdentifier(ByteBuffer buf, uint startPos, string identifier)
+    {
+      if (identifier.Length != FILE_IDENTIFIER_LENGTH)
+      {
+        throw new ArgumentException("FlatBuffers: file identifier must be length" + Convert.ToString(FILE_IDENTIFIER_LENGTH));
+      }
+      for (int i = 0; i < FILE_IDENTIFIER_LENGTH; i++)
+      {
+        if ((sbyte)identifier[i] != verifier_buffer.GetSbyte(Convert.ToInt32(SIZE_S_OFFSET + i + startPos)))
+        {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    /// <summary> Get UOffsetT from buffer at given position - it must be verified before read </summary>
+    /// <param name="buf"> Input flat byte buffer defined as ByteBuffer type </param>
+    /// <param name="pos"> Position of data in the Byte Buffer</param>
+    /// <returns> Return the UOffset Value (Unsigned Integer type - 4 bytes) in pos </returns>
+    private uint ReadUOffsetT(ByteBuffer buf, uint pos)
+    {
+      return buf.GetUint(Convert.ToInt32(pos));
+    }
+    /// <summary> Get SOffsetT from buffer at given position - it must be verified before read </summary>
+    /// <param name="buf"> Input flat byte buffer defined as ByteBuffer type </param>
+    /// <param name="pos"> Position of data in the Byte Buffer</param>
+    /// <returns> Return the SOffset Value (Signed Integer type - 4 bytes) in pos </returns>
+    private int ReadSOffsetT(ByteBuffer buf, int pos)
+    {
+      return buf.GetInt(pos);
+    }
+    /// <summary> Get VOffsetT from buffer at given position - it must be verified before read </summary>
+    /// <param name="buf"> Input flat byte buffer defined as ByteBuffer type </param>
+    /// <param name="pos"> Position of data in the Byte Buffer</param>
+    /// <returns> Return the VOffset Value (Short type - 2 bytes) in pos </returns>
+    private short ReadVOffsetT(ByteBuffer buf, int pos)
+    {
+      return buf.GetShort(pos);
+    }
+
+    /// <summary> Get table data area relative offset from vtable. Result is relative to table start
+    ///           Fields which are deprecated are ignored by checking against the vtable's length. </summary>
+    /// <param name="pos"> Position of data in the Byte Buffer </param>
+    /// <param name="vtableOffset"> offset of value in the Table</param>
+    /// <returns> Return the relative VOffset Value (Short type - 2 bytes) in calculated offset </returns>
+    private short GetVRelOffset(int pos, short vtableOffset)
+    {
+      short VOffset = 0;
+      // Used try/catch because pos typa as int 32bit
+      try
+      {
+        // First, get vtable offset
+        short vtable = Convert.ToInt16(pos - ReadSOffsetT(verifier_buffer, pos));
+        // Check that offset points to vtable area (is smaller than vtable size)
+        if (vtableOffset < ReadVOffsetT(verifier_buffer, vtable))
+        {
+          // Now, we can read offset value - TODO check this value against size of table data
+          VOffset = ReadVOffsetT(verifier_buffer, vtable + vtableOffset);
+        }
+        else
+        {
+          VOffset = 0;
+        }
+      }
+      catch (Exception e)
+      {
+        Console.WriteLine("Exception: {0}", e);
+        return VOffset;
+      }
+      return VOffset;
+
+    }
+    /// <summary> Get table data area absolute offset from vtable. Result is the absolute buffer offset.
+    /// The result value offset cannot be '0' (pointing to itself) so after validation this method returnes '0'
+    /// value as a marker for missing optional entry </summary>
+    /// <param name="tablePos"> Table Position value in the Byte Buffer </param>
+    /// <param name="vtableOffset"> offset value in the Table</param>
+    /// <returns> Return the absolute UOffset Value </returns>
+    private uint GetVOffset(uint tablePos, short vtableOffset)
+    {
+      uint UOffset = 0;
+      // First, get vtable relative offset
+      short relPos = GetVRelOffset(Convert.ToInt32(tablePos), vtableOffset);
+      if (relPos != 0)
+      {
+        // Calculate offset based on table postion
+        UOffset = Convert.ToUInt32(tablePos + relPos);
+      }
+      else
+      {
+        UOffset = 0;
+      }
+      return UOffset;
+    }
+
+    /// <summary> Check flatbuffer complexity (tables depth, elements counter and so on) </summary>
+    /// <returns> If complexity is too high function returns false as verification error </returns>
+    private bool CheckComplexity()
+    {
+      return ((depth <= options.maxDepth) && (numTables <= options.maxTables));
+    }
+
+    /// <summary> Check alignment of element. </summary>
+    /// <returns> Return True when alignment of the element is correct</returns>
+    private bool CheckAlignment(uint element, ulong align)
+    {
+      return (((element & (align - 1)) == 0) || (!options.alignmentCheck));
+    }
+
+    /// <summary> Check if element is valid in buffer area. </summary> 
+    /// <param name="pos"> Value defines the offset/position to element</param>
+    /// <param name="elementSize"> Size of element</param>
+    /// <returns> Return True when Element is correct </returns>
+    private bool CheckElement(uint pos, ulong elementSize)
+    {
+      return ((elementSize < Convert.ToUInt64(verifier_buffer.Length)) && (pos <= (Convert.ToUInt32(verifier_buffer.Length) - elementSize)));
+    }
+    /// <summary> Check if element is a valid scalar. </summary>
+    /// <param name="pos"> Value defines the offset to scalar</param>
+    /// <param name="elementSize"> Size of element</param>
+    /// <returns> Return True when Scalar Element is correct </returns>
+    private bool CheckScalar(uint pos, ulong elementSize)
+    {
+      return ((CheckAlignment(pos, elementSize)) && (CheckElement(pos, elementSize)));
+    }
+    /// <summary> Check offset. It is a scalar with size of UOffsetT. </summary>
+    private bool CheckOffset(uint offset)
+    {
+      return (CheckScalar(offset, SIZE_U_OFFSET));
+    }
+
+    private checkElementStruct CheckVectorOrString(uint pos, ulong elementSize)
+    {
+      var result = new checkElementStruct
+      {
+        elementValid = false,
+        elementOffset = 0
+      };
+
+      uint vectorPos = pos;
+      // Check we can read the vector/string size field (it is of uoffset size)
+      if (!CheckScalar(vectorPos, SIZE_U_OFFSET))
+      {
+        // result.elementValid = false; result.elementOffset = 0;
+        return result;
+      }
+      // Check the whole array. If this is a string, the byte past the array
+      // must be 0.
+      uint size = ReadUOffsetT(verifier_buffer, vectorPos);
+      ulong max_elements = (FLATBUFFERS_MAX_BUFFER_SIZE / elementSize);
+      if (size >= max_elements)
+      {
+        // Protect against byte_size overflowing. 
+        // result.elementValid = false; result.elementOffset = 0;
+        return result;
+      }
+
+      uint bytes_size = SIZE_U_OFFSET + (Convert.ToUInt32(elementSize) * size);
+      uint buffer_end_pos = vectorPos + bytes_size;
+      result.elementValid = CheckElement(vectorPos, bytes_size);
+      result.elementOffset = buffer_end_pos;
+      return (result);
+    }
+
+    /// <summary>Verify a string at given position.</summary>
+    private bool CheckString(uint pos)
+    {
+      var result = CheckVectorOrString(pos, SIZE_BYTE);
+      if (options.stringEndCheck)
+      {
+        result.elementValid = result.elementValid && CheckScalar(result.elementOffset, 1); // Must have terminator
+        result.elementValid = result.elementValid && (verifier_buffer.GetSbyte(Convert.ToInt32(result.elementOffset)) == 0); // Terminating byte must be 0.
+      }
+      return result.elementValid;
+    }
+
+    /// <summary> Verify the vector of elements of given size </summary>
+    private bool CheckVector(uint pos, ulong elementSize)
+    {
+      var result = CheckVectorOrString(pos, elementSize);
+      return result.elementValid;
+    }
+    /// <summary> Verify table content using structure dependent generated function </summary>
+    private bool CheckTable(uint tablePos, VerifyTableAction verifyAction)
+    {
+      return verifyAction(this, tablePos);
+    }
+
+    /// <summary> String check wrapper function to be used in vector of strings check </summary>
+    private bool CheckStringFunc(Verifier verifier, uint pos)
+    {
+      return verifier.CheckString(pos);
+    }
+
+    /// <summary> Check vector of objects. Use generated object verification function </summary>
+    private bool CheckVectorOfObjects(uint pos, VerifyTableAction verifyAction)
+    {
+      if (!CheckVector(pos, SIZE_U_OFFSET))
+      {
+        return false;
+      }
+      uint size = ReadUOffsetT(verifier_buffer, pos);
+      // Vector data starts just after vector size/length
+      uint vecStart = pos + SIZE_U_OFFSET;
+      uint vecOff = 0;
+      // Iterate offsets and verify referenced objects
+      for (uint i = 0; i < size; i++)
+      {
+        vecOff = vecStart + (i * SIZE_U_OFFSET);
+        if (!CheckIndirectOffset(vecOff))
+        {
+          return false;
+        }
+        uint objOffset = GetIndirectOffset(vecOff);
+        if (!verifyAction(this, objOffset))
+        {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    /// <summary> Check if the offset referenced by offsetPos is the valid offset pointing to buffer</summary>
+    //  offsetPos - offset to offset data
+    private bool CheckIndirectOffset(uint pos)
+    {
+      // Check the input offset is valid
+      if(!CheckScalar(pos, SIZE_U_OFFSET))
+      {
+        return false;
+      }
+      // Get indirect offset
+      uint offset = ReadUOffsetT(verifier_buffer, pos);
+      // May not point to itself neither wrap around  (buffers are max 2GB)
+      if ((offset == 0) || (offset >= FLATBUFFERS_MAX_BUFFER_SIZE))
+      {
+        return false;
+      }
+      // Must be inside the buffer
+      return CheckElement(pos + offset, 1);
+    }
+
+    /// <summary> Check flatbuffer content using generated object verification function </summary>
+    private bool CheckBufferFromStart(string identifier, uint startPos, VerifyTableAction verifyAction)
+    {
+      if ((identifier != null) &&
+          (identifier.Length == 0) &&
+          ((verifier_buffer.Length < (SIZE_U_OFFSET + FILE_IDENTIFIER_LENGTH)) || (!BufferHasIdentifier(verifier_buffer, startPos, identifier))))
+      {
+        return false;
+      }
+      if(!CheckIndirectOffset(startPos))
+      {
+        return false;
+      }
+      uint offset = GetIndirectOffset(startPos);
+      return CheckTable(offset, verifyAction); //  && GetComputedSize()
+    }
+
+    /// <summary> Get indirect offset. It is an offset referenced by offset Pos </summary>
+    private uint GetIndirectOffset(uint pos)
+    {
+      // Get indirect offset referenced by offsetPos
+      uint offset = pos + ReadUOffsetT(verifier_buffer, pos);
+      return offset;
+    }
+
+    /// <summary> Verify beginning of table </summary>
+    /// <param name="tablePos"> Position in the Table </param>
+    /// <returns> Return True when the verification of the beginning of the table is passed</returns> 
+    // (this method is used internally by generated verification functions)
+    public bool VerifyTableStart(uint tablePos)
+    {
+      // Starting new table verification increases complexity of structure
+      depth_cnt++;
+      num_tables_cnt++;
+
+      if (!CheckScalar(tablePos, SIZE_S_OFFSET))
+      {
+        return false;
+      }
+      uint vtable = (uint)(tablePos - ReadSOffsetT(verifier_buffer, Convert.ToInt32(tablePos)));
+      return ((CheckComplexity()) && (CheckScalar(vtable, SIZE_V_OFFSET)) && (CheckAlignment(Convert.ToUInt32(ReadVOffsetT(verifier_buffer, Convert.ToInt32(vtable))), SIZE_V_OFFSET)) && (CheckElement(vtable, Convert.ToUInt64(ReadVOffsetT(verifier_buffer, Convert.ToInt32(vtable))))));
+    }
+
+    /// <summary> Verify end of table. In practice, this function does not check buffer but handles
+    /// verification statistics update </summary>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyTableEnd(uint tablePos)
+    {
+      depth--;
+      return true;
+    }
+
+    /// <summary> Verifiy static/inlined data area field </summary>
+    /// <param name="tablePos"> Position in the Table</param>
+    /// <param name="offsetId"> Offset to the static/inlined data element </param>
+    /// <param name="elementSize"> Size of the element </param>
+    /// <param name="align"> Alignment bool value </param>
+    /// <param name="required"> Required Value when the offset == 0 </param>
+    /// <returns>Return True when the verification of the static/inlined data element is passed</returns>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyField(uint tablePos, short offsetId, ulong elementSize, ulong align, bool required)
+    {
+      uint offset = GetVOffset(tablePos, offsetId);
+      if (offset != 0)
+      {
+        return ((CheckAlignment(offset, align)) && (CheckElement(offset, elementSize)));
+      }
+      return !required; // it is OK if field is not required
+    }
+
+    /// <summary> Verify string </summary> 
+    /// <param name="tablePos"> Position in the Table</param>
+    /// <param name="vOffset"> Offset to the String element </param>
+    /// <param name="required"> Required Value when the offset == 0 </param>
+    /// <returns>Return True when the verification of the String is passed</returns>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyString(uint tablePos, short vOffset, bool required)
+    {
+      var offset = GetVOffset(tablePos, vOffset);
+      if (offset == 0)
+      {
+        return !required;
+      }
+      if (!CheckIndirectOffset(offset))
+      {
+        return false;
+      }
+      var strOffset = GetIndirectOffset(offset);
+      return CheckString(strOffset);
+    }
+
+    /// <summary> Verify vector of fixed size structures and scalars </summary>
+    /// <param name="tablePos"> Position in the Table</param>
+    /// <param name="vOffset"> Offset to the Vector of Data </param>
+    /// <param name="elementSize"> Size of the element</param>
+    /// <param name="required"> Required Value when the offset == 0 </param>
+    /// <returns>Return True when the verification of the Vector of Data passed</returns>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyVectorOfData(uint tablePos, short vOffset, ulong elementSize, bool required)
+    {
+      var offset = GetVOffset(tablePos, vOffset);
+      if (offset == 0)
+      {
+        return !required;
+      }
+      if (!CheckIndirectOffset(offset))
+      {
+        return false;
+      }
+      var vecOffset = GetIndirectOffset(offset);
+      return  CheckVector(vecOffset, elementSize);
+    }
+
+    /// <summary> Verify array of strings </summary>
+    /// <param name="tablePos"> Position in the Table</param>
+    /// <param name="offsetId"> Offset to the Vector of String </param>
+    /// <param name="required"> Required Value when the offset == 0 </param>
+    /// <returns>Return True when the verification of the Vector of String passed</returns>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyVectorOfStrings(uint tablePos, short offsetId, bool required)
+    {
+      var offset = GetVOffset(tablePos, offsetId);
+      if (offset == 0)
+      {
+        return !required;
+      }
+      if (!CheckIndirectOffset(offset))
+      {
+        return false;
+      }
+      var vecOffset = GetIndirectOffset(offset);
+      return CheckVectorOfObjects(vecOffset, CheckStringFunc); 
+    }
+
+    /// <summary> Verify vector of tables (objects). Tables are verified using generated verifyObjFunc </summary>
+    /// <param name="tablePos"> Position in the Table</param>
+    /// <param name="offsetId"> Offset to the Vector of Table </param>
+    /// <param name="verifyAction"> Method used to the verification Table </param>
+    /// <param name="required"> Required Value when the offset == 0 </param>
+    /// <returns>Return True when the verification of the Vector of Table passed</returns>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyVectorOfTables(uint tablePos, short offsetId, VerifyTableAction verifyAction, bool required)
+    {
+      var offset = GetVOffset(tablePos, offsetId);
+      if (offset == 0)
+      {
+        return !required;
+      }
+      if (!CheckIndirectOffset(offset))
+      {
+        return false;
+      }
+      var vecOffset = GetIndirectOffset(offset);
+      return CheckVectorOfObjects(vecOffset, verifyAction);
+    }
+
+    /// <summary> Verify table object using generated verification function. </summary>
+    /// <param name="tablePos"> Position in the Table</param>
+    /// <param name="offsetId"> Offset to the Table </param>
+    /// <param name="verifyAction"> Method used to the verification Table </param>
+    /// <param name="required"> Required Value when the offset == 0 </param>
+    /// <returns>Return True when the verification of the Table passed</returns>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyTable(uint tablePos, short offsetId, VerifyTableAction verifyAction, bool required)
+    {
+      var offset = GetVOffset(tablePos, offsetId);
+      if (offset == 0)
+      {
+        return !required;
+      }
+      if (!CheckIndirectOffset(offset))
+      {
+        return false;
+      }
+      var tabOffset = GetIndirectOffset(offset);
+      return CheckTable(tabOffset, verifyAction);
+    }
+
+    /// <summary> Verify nested buffer object. When verifyObjFunc is provided, it is used to verify object structure. </summary>
+    /// <param name="tablePos"> Position in the Table </param>
+    /// <param name="offsetId"> Offset to the Table </param>
+    /// <param name="verifyAction">  Method used to the verification Table </param>
+    /// <param name="required"> Required Value when the offset == 0  </param>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyNestedBuffer(uint tablePos, short offsetId, VerifyTableAction verifyAction, bool required)
+    {
+      var offset = GetVOffset(tablePos, offsetId);
+      if (offset == 0)
+      {
+        return !required;
+      }
+      uint vecOffset = GetIndirectOffset(offset);
+      if (!CheckVector(vecOffset, SIZE_BYTE))
+      {
+        return false;
+      }
+      if (verifyAction != null)
+      {
+        var vecLength = ReadUOffsetT(verifier_buffer, vecOffset);
+        // Buffer begins after vector length
+        var vecStart = vecOffset + SIZE_U_OFFSET;
+        // Create and Copy nested buffer bytes from part of Verify Buffer
+        var nestedByteBuffer = new ByteBuffer(verifier_buffer.ToArray(Convert.ToInt32(vecStart), Convert.ToInt32(vecLength)));
+        var nestedVerifyier = new Verifier(nestedByteBuffer, options);
+        // There is no internal identifier - use empty one
+        if (!nestedVerifyier.CheckBufferFromStart("", 0, verifyAction))
+        {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    /// <summary> Verifiy static/inlined data area at absolute offset </summary>
+    /// <param name="pos"> Position of static/inlined data area in the Byte Buffer</param>
+    /// <param name="elementSize"> Size of the union data</param>
+    /// <param name="align"> Alignment bool value </param>
+    /// <returns>Return True when the verification of the Union Data is passed</returns>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyUnionData(uint pos, ulong elementSize, ulong align)
+    {
+      bool result = ((CheckAlignment(pos, align)) && (CheckElement(pos, elementSize)));
+      return result;
+    }
+
+    /// <summary> Verify string referenced by absolute offset value </summary>
+    /// <param name="pos"> Position of Union String in the Byte Buffer</param>
+    /// <returns>Return True when the verification of the Union String is passed</returns> 
+    // (this method is used internally by generated verification functions)
+    public bool VerifyUnionString(uint pos)
+    {
+      bool result = CheckString(pos);
+      return result;
+    }
+
+    /// <summary> Method verifies union object using generated verification function </summary>
+    /// <param name="tablePos"> Position in the Table</param>
+    /// <param name="typeIdVOffset"> Offset in the Table</param>
+    /// <param name="valueVOffset"> Offset to Element</param>
+    /// <param name="verifyAction"> Verification Method used for Union</param>
+    /// <param name="required"> Required Value when the offset == 0 </param>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyUnion(uint tablePos, short typeIdVOffset, short valueVOffset, VerifyUnionAction verifyAction, bool required)
+    {
+      // Check the union type index
+      var offset = GetVOffset(tablePos, typeIdVOffset);
+      if (offset == 0)
+      {
+        return !required;
+      }
+      if (!((CheckAlignment(offset, SIZE_BYTE)) && (CheckElement(offset, SIZE_BYTE))))
+      {
+        return false;
+      }
+      // Check union data
+      offset = GetVOffset(tablePos, valueVOffset);
+      // Take type id
+      var typeId = verifier_buffer.Get(Convert.ToInt32(offset));
+      if (offset == 0)
+      {
+        // When value data is not present, allow union verification function to deal with illegal offset
+        return verifyAction(this, typeId, Convert.ToUInt32(verifier_buffer.Length));
+      }
+      if (!CheckIndirectOffset(offset))
+      {
+        return false;
+      }
+      // Take value offset and validate union structure
+      uint unionOffset = GetIndirectOffset(offset);
+      return verifyAction(this, typeId, unionOffset);
+    }
+
+    /// <summary> Verify vector of unions (objects). Unions are verified using generated verifyObjFunc </summary>
+    /// <param name="tablePos"> Position of the Table</param>
+    /// <param name="typeOffsetId"> Offset in the Table (Union type id)</param>
+    /// <param name="offsetId"> Offset to vector of Data Stucture offset</param>
+    /// <param name="verifyAction"> Verification Method used for Union</param>
+    /// <param name="required"> Required Value when the offset == 0 </param>
+    /// <returns>Return True when the verification of the Vector of Unions passed</returns>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyVectorOfUnion(uint tablePos, short typeOffsetId, short offsetId, VerifyUnionAction verifyAction, bool required)
+    {
+      // type id offset must be valid
+      var offset = GetVOffset(tablePos, typeOffsetId);
+      if (offset == 0)
+      {
+        return !required;
+      }
+      if (!CheckIndirectOffset(offset))
+      {
+        return false;
+      }
+      // Get type id table absolute offset
+      var typeIdVectorOffset = GetIndirectOffset(offset);
+      // values offset must be valid
+      offset = GetVOffset(tablePos, offsetId);
+      if (!CheckIndirectOffset(offset))
+      {
+        return false;
+      }
+      var valueVectorOffset = GetIndirectOffset(offset);
+      // validate referenced vectors
+      if(!CheckVector(typeIdVectorOffset, SIZE_BYTE) ||
+         !CheckVector(valueVectorOffset, SIZE_U_OFFSET))
+      {
+        return false;
+      }
+      // Both vectors should have the same length
+      var typeIdVectorLength = ReadUOffsetT(verifier_buffer, typeIdVectorOffset);
+      var valueVectorLength = ReadUOffsetT(verifier_buffer, valueVectorOffset);
+      if (typeIdVectorLength != valueVectorLength)
+      {
+        return false;
+      }
+      // Verify each union from vectors
+      var typeIdStart = typeIdVectorOffset + SIZE_U_OFFSET;
+      var valueStart = valueVectorOffset + SIZE_U_OFFSET;
+      for (uint i = 0; i < typeIdVectorLength; i++)
+      {
+        // Get type id
+        byte typeId = verifier_buffer.Get(Convert.ToInt32(typeIdStart + i * SIZE_U_OFFSET));
+        // get offset to vector item
+        uint off = valueStart + i * SIZE_U_OFFSET;
+        // Check the vector item has a proper offset
+        if (!CheckIndirectOffset(off))
+        {
+          return false;
+        }
+        uint valueOffset = GetIndirectOffset(off);
+        // Verify object
+        if (!verifyAction(this, typeId, valueOffset))
+        {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    // Method verifies flatbuffer data using generated Table verification function.
+    // The data buffer is already provided when creating [Verifier] object (see [NewVerifier])
+    //
+    //   - identifier - the expected identifier of buffer data.
+    //     When empty identifier is provided the identifier validation is skipped.
+    //   - sizePrefixed - this flag should be true when buffer is prefixed with content size
+    //   - verifyObjFunc - function to be used for verification. This function is generated by compiler and included in each table definition file with name "<Tablename>Verify"
+    //
+    // Example:
+    //
+    //  /* Verify Monster table. Ignore buffer name and assume buffer does not contain data length prefix */
+    //  isValid = verifier.verifyBuffer(bb, false, MonsterVerify)
+    //
+    //  /* Verify Monster table. Buffer name is 'MONS' and contains data length prefix */
+    //  isValid = verifier.verifyBuffer("MONS", true, MonsterVerify)
+    /// <summary> Method verifies flatbuffer data using generated Table verification function </summary>
+    /// 
+    /// <param name="identifier"> The expected identifier of buffer data</param>
+    /// <param name="sizePrefixed"> Flag should be true when buffer is prefixed with content size</param>
+    /// <param name="verifyAction"> Function to be used for verification. This function is generated by compiler and included in each table definition file</param>
+    /// <returns> Return True when verification of FlatBuffer passed</returns>
+    /// <example>
+    /// Example 1. Verify Monster table. Ignore buffer name and assume buffer does not contain data length prefix 
+    /// <code>  isValid = verifier.VerifyBuffer(bb, false, MonsterVerify)</code>
+    /// Example 2. Verify Monster table. Buffer name is 'MONS' and contains data length prefix 
+    /// <code>  isValid = verifier.VerifyBuffer("MONS", true, MonsterVerify)</code>
+    /// </example>
+    public bool VerifyBuffer(string identifier, bool sizePrefixed, VerifyTableAction verifyAction)
+    {
+      // Reset counters - starting verification from beginning
+      depth = 0;
+      numTables = 0;
+
+      var start = (uint)(verifier_buffer.Position);
+      if (sizePrefixed) 
+      {
+        start = (uint)(verifier_buffer.Position) + SIZE_PREFIX_LENGTH;
+        if(!CheckScalar((uint)(verifier_buffer.Position), SIZE_PREFIX_LENGTH))
+        {
+          return false;
+        }
+        uint size = ReadUOffsetT(verifier_buffer, (uint)(verifier_buffer.Position));
+        if (size != ((uint)(verifier_buffer.Length) - start))
+        {
+          return false;
+        }
+      } 
+      return CheckBufferFromStart(identifier, start, verifyAction);
+    }
+  }
+
+}
diff --git a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/IFlatbufferObject.cs b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/IFlatbufferObject.cs
index 1be932c9867e9..72073b0e17218 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/IFlatbufferObject.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/IFlatbufferObject.cs
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-namespace FlatBuffers
+namespace Google.FlatBuffers
 {
     /// <summary>
     /// This is the base for both structs and tables.
diff --git a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/Offset.cs b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/Offset.cs
index 70b75b6de7e51..582bb3b9d5f5f 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/Offset.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/Offset.cs
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-namespace FlatBuffers
+namespace Google.FlatBuffers
 {
     /// <summary>
     /// Offset class for typesafe assignments.
diff --git a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/Struct.cs b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/Struct.cs
index ca44ff920447a..313aadec5d21d 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/Struct.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/Struct.cs
@@ -14,14 +14,21 @@
  * limitations under the License.
  */
 
-namespace FlatBuffers
+namespace Google.FlatBuffers
 {
     /// <summary>
     /// All structs in the generated code derive from this class, and add their own accessors.
     /// </summary>
     internal struct Struct
     {
-        public int bb_pos;
-        public ByteBuffer bb;
+        public int bb_pos { get; private set; }
+        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) : this()
+        {
+            bb = _bb;
+            bb_pos = _i;
+        }
     }
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/Table.cs b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/Table.cs
index f809072ba83a0..e2452e40eb8e9 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/Table.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/Table.cs
@@ -16,19 +16,27 @@
 
 using System;
 using System.Text;
+using System.Runtime.InteropServices;
 
-namespace FlatBuffers
+namespace Google.FlatBuffers
 {
     /// <summary>
     /// All tables in the generated code derive from this struct, and add their own accessors.
     /// </summary>
     internal struct Table
     {
-        public int bb_pos;
-        public ByteBuffer bb;
+        public int bb_pos { get; private set; }
+        public ByteBuffer bb { get; private set; }
 
         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) : this()
+        {
+            bb = _bb;
+            bb_pos = _i;
+        }
+
         // Look up a field in the vtable, return an offset into the object, or 0 if the field is not
         // present.
         public int __offset(int vtableOffset)
@@ -57,7 +65,11 @@ public static int __indirect(int offset, ByteBuffer bb)
         // Create a .NET String from UTF-8 data stored inside the flatbuffer.
         public string __string(int offset)
         {
-            offset += bb.GetInt(offset);
+            int stringOffset = bb.GetInt(offset);
+            if (stringOffset == 0)
+                return null;
+
+            offset += stringOffset;
             var len = bb.GetInt(offset);
             var startPos = offset + sizeof(int);
             return bb.GetStringUTF8(startPos, len);
@@ -78,21 +90,27 @@ public int __vector(int offset)
             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
@@ -138,9 +156,8 @@ public T[] __vector_as_array<T>(int offset)
         // 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;
         }
 
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Footer.cs b/csharp/src/Apache.Arrow/Flatbuf/Footer.cs
index 37dbfef94093a..6c1530d3de8cf 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Footer.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Footer.cs
@@ -6,7 +6,8 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// ----------------------------------------------------------------------
 /// Arrow File metadata
@@ -15,9 +16,11 @@ internal struct Footer : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Footer GetRootAsFooter(ByteBuffer _bb) { return GetRootAsFooter(_bb, new Footer()); }
   public static Footer GetRootAsFooter(ByteBuffer _bb, Footer obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public static bool VerifyFooter(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("", false, FooterVerify.Verify); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Footer __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   public MetadataVersion Version { get { int o = __p.__offset(4); return o != 0 ? (MetadataVersion)__p.bb.GetShort(o + __p.bb_pos) : MetadataVersion.V1; } }
@@ -36,7 +39,7 @@ public static Offset<Footer> CreateFooter(FlatBufferBuilder builder,
       VectorOffset dictionariesOffset = default(VectorOffset),
       VectorOffset recordBatchesOffset = default(VectorOffset),
       VectorOffset custom_metadataOffset = default(VectorOffset)) {
-    builder.StartObject(5);
+    builder.StartTable(5);
     Footer.AddCustomMetadata(builder, custom_metadataOffset);
     Footer.AddRecordBatches(builder, recordBatchesOffset);
     Footer.AddDictionaries(builder, dictionariesOffset);
@@ -45,7 +48,7 @@ public static Offset<Footer> CreateFooter(FlatBufferBuilder builder,
     return Footer.EndFooter(builder);
   }
 
-  public static void StartFooter(FlatBufferBuilder builder) { builder.StartObject(5); }
+  public static void StartFooter(FlatBufferBuilder builder) { builder.StartTable(5); }
   public static void AddVersion(FlatBufferBuilder builder, MetadataVersion version) { builder.AddShort(0, (short)version, 0); }
   public static void AddSchema(FlatBufferBuilder builder, Offset<Schema> schemaOffset) { builder.AddOffset(1, schemaOffset.Value, 0); }
   public static void AddDictionaries(FlatBufferBuilder builder, VectorOffset dictionariesOffset) { builder.AddOffset(2, dictionariesOffset.Value, 0); }
@@ -55,14 +58,30 @@ public static Offset<Footer> CreateFooter(FlatBufferBuilder builder,
   public static void AddCustomMetadata(FlatBufferBuilder builder, VectorOffset customMetadataOffset) { builder.AddOffset(4, customMetadataOffset.Value, 0); }
   public static VectorOffset CreateCustomMetadataVector(FlatBufferBuilder builder, Offset<KeyValue>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
   public static VectorOffset CreateCustomMetadataVectorBlock(FlatBufferBuilder builder, Offset<KeyValue>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateCustomMetadataVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<KeyValue>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateCustomMetadataVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<KeyValue>>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartCustomMetadataVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
   public static Offset<Footer> EndFooter(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Footer>(o);
   }
   public static void FinishFooterBuffer(FlatBufferBuilder builder, Offset<Footer> offset) { builder.Finish(offset.Value); }
   public static void FinishSizePrefixedFooterBuffer(FlatBufferBuilder builder, Offset<Footer> offset) { builder.FinishSizePrefixed(offset.Value); }
-};
+}
+
 
+static internal class FooterVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Version*/, 2 /*MetadataVersion*/, 2, false)
+      && verifier.VerifyTable(tablePos, 6 /*Schema*/, SchemaVerify.Verify, false)
+      && verifier.VerifyVectorOfData(tablePos, 8 /*Dictionaries*/, 24 /*Block*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 10 /*RecordBatches*/, 24 /*Block*/, false)
+      && verifier.VerifyVectorOfTables(tablePos, 12 /*CustomMetadata*/, KeyValueVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/KeyValue.cs b/csharp/src/Apache.Arrow/Flatbuf/KeyValue.cs
index 5b8c2efcaac14..3dffb618604fc 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/KeyValue.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/KeyValue.cs
@@ -6,7 +6,8 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// ----------------------------------------------------------------------
 /// user defined key value pairs to add custom metadata to arrow
@@ -15,21 +16,22 @@ internal struct KeyValue : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static KeyValue GetRootAsKeyValue(ByteBuffer _bb) { return GetRootAsKeyValue(_bb, new KeyValue()); }
   public static KeyValue GetRootAsKeyValue(ByteBuffer _bb, KeyValue obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public KeyValue __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   public string Key { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetKeyBytes() { return __p.__vector_as_span(4); }
+  public Span<byte> GetKeyBytes() { return __p.__vector_as_span<byte>(4, 1); }
 #else
   public ArraySegment<byte>? GetKeyBytes() { return __p.__vector_as_arraysegment(4); }
 #endif
   public byte[] GetKeyArray() { return __p.__vector_as_array<byte>(4); }
   public string Value { get { int o = __p.__offset(6); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetValueBytes() { return __p.__vector_as_span(6); }
+  public Span<byte> GetValueBytes() { return __p.__vector_as_span<byte>(6, 1); }
 #else
   public ArraySegment<byte>? GetValueBytes() { return __p.__vector_as_arraysegment(6); }
 #endif
@@ -38,20 +40,31 @@ internal struct KeyValue : IFlatbufferObject
   public static Offset<KeyValue> CreateKeyValue(FlatBufferBuilder builder,
       StringOffset keyOffset = default(StringOffset),
       StringOffset valueOffset = default(StringOffset)) {
-    builder.StartObject(2);
+    builder.StartTable(2);
     KeyValue.AddValue(builder, valueOffset);
     KeyValue.AddKey(builder, keyOffset);
     return KeyValue.EndKeyValue(builder);
   }
 
-  public static void StartKeyValue(FlatBufferBuilder builder) { builder.StartObject(2); }
+  public static void StartKeyValue(FlatBufferBuilder builder) { builder.StartTable(2); }
   public static void AddKey(FlatBufferBuilder builder, StringOffset keyOffset) { builder.AddOffset(0, keyOffset.Value, 0); }
   public static void AddValue(FlatBufferBuilder builder, StringOffset valueOffset) { builder.AddOffset(1, valueOffset.Value, 0); }
   public static Offset<KeyValue> EndKeyValue(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<KeyValue>(o);
   }
-};
+}
+
 
+static internal class KeyValueVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyString(tablePos, 4 /*Key*/, false)
+      && verifier.VerifyString(tablePos, 6 /*Value*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Map.cs b/csharp/src/Apache.Arrow/Flatbuf/Map.cs
index 9141f4c932d03..4b4c292482d29 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Map.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Map.cs
@@ -6,28 +6,30 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// A Map is a logical nested type that is represented as
 ///
-/// List<entry: Struct<key: K, value: V>>
+/// List<entries: Struct<key: K, value: V>>
 ///
 /// In this layout, the keys and values are each respectively contiguous. We do
 /// not constrain the key and value types, so the application is responsible
 /// for ensuring that the keys are hashable and unique. Whether the keys are sorted
-/// may be set in the metadata for this field
+/// may be set in the metadata for this field.
 ///
-/// In a Field with Map type, the Field has a child Struct field, which then
+/// In a field with Map type, the field has a child Struct field, which then
 /// has two children: key type and the second the value type. The names of the
-/// child fields may be respectively "entry", "key", and "value", but this is
-/// not enforced
+/// child fields may be respectively "entries", "key", and "value", but this is
+/// not enforced.
 ///
 /// Map
-///   - child[0] entry: Struct
+/// ```text
+///   - child[0] entries: Struct
 ///     - child[0] key: K
 ///     - child[1] value: V
-///
-/// Neither the "entry" field nor the "key" field may be nullable.
+/// ```
+/// Neither the "entries" field nor the "key" field may be nullable.
 ///
 /// The metadata is structured so that Arrow systems without special handling
 /// for Map can make Map an alias for List. The "layout" attribute for the Map
@@ -36,9 +38,10 @@ internal struct Map : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Map GetRootAsMap(ByteBuffer _bb) { return GetRootAsMap(_bb, new Map()); }
   public static Map GetRootAsMap(ByteBuffer _bb, Map obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Map __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   /// Set to true if the keys within each value are sorted
@@ -46,18 +49,28 @@ internal struct Map : IFlatbufferObject
 
   public static Offset<Map> CreateMap(FlatBufferBuilder builder,
       bool keysSorted = false) {
-    builder.StartObject(1);
+    builder.StartTable(1);
     Map.AddKeysSorted(builder, keysSorted);
     return Map.EndMap(builder);
   }
 
-  public static void StartMap(FlatBufferBuilder builder) { builder.StartObject(1); }
+  public static void StartMap(FlatBufferBuilder builder) { builder.StartTable(1); }
   public static void AddKeysSorted(FlatBufferBuilder builder, bool keysSorted) { builder.AddBool(0, keysSorted, false); }
   public static Offset<Map> EndMap(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Map>(o);
   }
-};
+}
+
 
+static internal class MapVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*KeysSorted*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Message.cs b/csharp/src/Apache.Arrow/Flatbuf/Message.cs
index db54e6ab32c79..5cd469d7e94f3 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Message.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Message.cs
@@ -6,20 +6,28 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 internal struct Message : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Message GetRootAsMessage(ByteBuffer _bb) { return GetRootAsMessage(_bb, new Message()); }
   public static Message GetRootAsMessage(ByteBuffer _bb, Message obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public static bool VerifyMessage(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("", false, MessageVerify.Verify); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Message __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   public MetadataVersion Version { get { int o = __p.__offset(4); return o != 0 ? (MetadataVersion)__p.bb.GetShort(o + __p.bb_pos) : MetadataVersion.V1; } }
   public MessageHeader HeaderType { get { int o = __p.__offset(6); return o != 0 ? (MessageHeader)__p.bb.Get(o + __p.bb_pos) : MessageHeader.NONE; } }
-  public TTable? Header<TTable>() where TTable : struct, IFlatbufferObject { int o = __p.__offset(8); return o != 0 ? (TTable?)__p.__union<TTable>(o) : null; }
+  public TTable? Header<TTable>() where TTable : struct, IFlatbufferObject { int o = __p.__offset(8); return o != 0 ? (TTable?)__p.__union<TTable>(o + __p.bb_pos) : null; }
+  public Schema HeaderAsSchema() { return Header<Schema>().Value; }
+  public DictionaryBatch HeaderAsDictionaryBatch() { return Header<DictionaryBatch>().Value; }
+  public RecordBatch HeaderAsRecordBatch() { return Header<RecordBatch>().Value; }
+  public Tensor HeaderAsTensor() { return Header<Tensor>().Value; }
+  public SparseTensor HeaderAsSparseTensor() { return Header<SparseTensor>().Value; }
   public long BodyLength { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
   public KeyValue? CustomMetadata(int j) { int o = __p.__offset(12); return o != 0 ? (KeyValue?)(new KeyValue()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
   public int CustomMetadataLength { get { int o = __p.__offset(12); return o != 0 ? __p.__vector_len(o) : 0; } }
@@ -30,7 +38,7 @@ public static Offset<Message> CreateMessage(FlatBufferBuilder builder,
       int headerOffset = 0,
       long bodyLength = 0,
       VectorOffset custom_metadataOffset = default(VectorOffset)) {
-    builder.StartObject(5);
+    builder.StartTable(5);
     Message.AddBodyLength(builder, bodyLength);
     Message.AddCustomMetadata(builder, custom_metadataOffset);
     Message.AddHeader(builder, headerOffset);
@@ -39,7 +47,7 @@ public static Offset<Message> CreateMessage(FlatBufferBuilder builder,
     return Message.EndMessage(builder);
   }
 
-  public static void StartMessage(FlatBufferBuilder builder) { builder.StartObject(5); }
+  public static void StartMessage(FlatBufferBuilder builder) { builder.StartTable(5); }
   public static void AddVersion(FlatBufferBuilder builder, MetadataVersion version) { builder.AddShort(0, (short)version, 0); }
   public static void AddHeaderType(FlatBufferBuilder builder, MessageHeader headerType) { builder.AddByte(1, (byte)headerType, 0); }
   public static void AddHeader(FlatBufferBuilder builder, int headerOffset) { builder.AddOffset(2, headerOffset, 0); }
@@ -47,14 +55,30 @@ public static Offset<Message> CreateMessage(FlatBufferBuilder builder,
   public static void AddCustomMetadata(FlatBufferBuilder builder, VectorOffset customMetadataOffset) { builder.AddOffset(4, customMetadataOffset.Value, 0); }
   public static VectorOffset CreateCustomMetadataVector(FlatBufferBuilder builder, Offset<KeyValue>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
   public static VectorOffset CreateCustomMetadataVectorBlock(FlatBufferBuilder builder, Offset<KeyValue>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateCustomMetadataVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<KeyValue>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateCustomMetadataVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<KeyValue>>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartCustomMetadataVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
   public static Offset<Message> EndMessage(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Message>(o);
   }
   public static void FinishMessageBuffer(FlatBufferBuilder builder, Offset<Message> offset) { builder.Finish(offset.Value); }
   public static void FinishSizePrefixedMessageBuffer(FlatBufferBuilder builder, Offset<Message> offset) { builder.FinishSizePrefixed(offset.Value); }
-};
+}
+
 
+static internal class MessageVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Version*/, 2 /*MetadataVersion*/, 2, false)
+      && verifier.VerifyField(tablePos, 6 /*HeaderType*/, 1 /*MessageHeader*/, 1, false)
+      && verifier.VerifyUnion(tablePos, 6, 8 /*Header*/, MessageHeaderVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 10 /*BodyLength*/, 8 /*long*/, 8, false)
+      && verifier.VerifyVectorOfTables(tablePos, 12 /*CustomMetadata*/, KeyValueVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/RecordBatch.cs b/csharp/src/Apache.Arrow/Flatbuf/RecordBatch.cs
index 4c95acde9d85d..9ab9715165ddc 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/RecordBatch.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/RecordBatch.cs
@@ -6,7 +6,8 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// A data header describing the shared memory layout of a "record" or "row"
 /// batch. Some systems call this a "row batch" internally and others a "record
@@ -15,9 +16,10 @@ internal struct RecordBatch : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static RecordBatch GetRootAsRecordBatch(ByteBuffer _bb) { return GetRootAsRecordBatch(_bb, new RecordBatch()); }
   public static RecordBatch GetRootAsRecordBatch(ByteBuffer _bb, RecordBatch obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public RecordBatch __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   /// number of records / rows. The arrays in the batch should all have this
@@ -42,7 +44,7 @@ public static Offset<RecordBatch> CreateRecordBatch(FlatBufferBuilder builder,
       VectorOffset nodesOffset = default(VectorOffset),
       VectorOffset buffersOffset = default(VectorOffset),
       Offset<BodyCompression> compressionOffset = default(Offset<BodyCompression>)) {
-    builder.StartObject(4);
+    builder.StartTable(4);
     RecordBatch.AddLength(builder, length);
     RecordBatch.AddCompression(builder, compressionOffset);
     RecordBatch.AddBuffers(builder, buffersOffset);
@@ -50,7 +52,7 @@ public static Offset<RecordBatch> CreateRecordBatch(FlatBufferBuilder builder,
     return RecordBatch.EndRecordBatch(builder);
   }
 
-  public static void StartRecordBatch(FlatBufferBuilder builder) { builder.StartObject(4); }
+  public static void StartRecordBatch(FlatBufferBuilder builder) { builder.StartTable(4); }
   public static void AddLength(FlatBufferBuilder builder, long length) { builder.AddLong(0, length, 0); }
   public static void AddNodes(FlatBufferBuilder builder, VectorOffset nodesOffset) { builder.AddOffset(1, nodesOffset.Value, 0); }
   public static void StartNodesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(16, numElems, 8); }
@@ -58,10 +60,23 @@ public static Offset<RecordBatch> CreateRecordBatch(FlatBufferBuilder builder,
   public static void StartBuffersVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(16, numElems, 8); }
   public static void AddCompression(FlatBufferBuilder builder, Offset<BodyCompression> compressionOffset) { builder.AddOffset(3, compressionOffset.Value, 0); }
   public static Offset<RecordBatch> EndRecordBatch(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<RecordBatch>(o);
   }
-};
+}
+
 
+static internal class RecordBatchVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Length*/, 8 /*long*/, 8, false)
+      && verifier.VerifyVectorOfData(tablePos, 6 /*Nodes*/, 16 /*FieldNode*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 8 /*Buffers*/, 16 /*Buffer*/, false)
+      && verifier.VerifyTable(tablePos, 10 /*Compression*/, BodyCompressionVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/RunEndEncoded.cs b/csharp/src/Apache.Arrow/Flatbuf/RunEndEncoded.cs
new file mode 100644
index 0000000000000..78c602c425bb2
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Flatbuf/RunEndEncoded.cs
@@ -0,0 +1,45 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Apache.Arrow.Flatbuf
+{
+
+using global::System;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
+
+/// Contains two child arrays, run_ends and values.
+/// The run_ends child array must be a 16/32/64-bit integer array
+/// which encodes the indices at which the run with the value in 
+/// each corresponding index in the values child array ends.
+/// Like list/struct types, the value array can be of any type.
+internal struct RunEndEncoded : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
+  public static RunEndEncoded GetRootAsRunEndEncoded(ByteBuffer _bb) { return GetRootAsRunEndEncoded(_bb, new RunEndEncoded()); }
+  public static RunEndEncoded GetRootAsRunEndEncoded(ByteBuffer _bb, RunEndEncoded obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public RunEndEncoded __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+
+  public static void StartRunEndEncoded(FlatBufferBuilder builder) { builder.StartTable(0); }
+  public static Offset<RunEndEncoded> EndRunEndEncoded(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<RunEndEncoded>(o);
+  }
+}
+
+
+static internal class RunEndEncodedVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Schema.cs b/csharp/src/Apache.Arrow/Flatbuf/Schema.cs
index 3764e7ba3a1fa..1d7b3f4f343fe 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Schema.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Schema.cs
@@ -6,7 +6,8 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// ----------------------------------------------------------------------
 /// A Schema describes the columns in a row batch
@@ -14,9 +15,11 @@ internal struct Schema : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Schema GetRootAsSchema(ByteBuffer _bb) { return GetRootAsSchema(_bb, new Schema()); }
   public static Schema GetRootAsSchema(ByteBuffer _bb, Schema obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public static bool VerifySchema(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("", false, SchemaVerify.Verify); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Schema __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   /// endianness of the buffer
@@ -31,18 +34,18 @@ internal struct Schema : IFlatbufferObject
   public Feature Features(int j) { int o = __p.__offset(10); return o != 0 ? (Feature)__p.bb.GetLong(__p.__vector(o) + j * 8) : (Feature)0; }
   public int FeaturesLength { get { int o = __p.__offset(10); return o != 0 ? __p.__vector_len(o) : 0; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetFeaturesBytes() { return __p.__vector_as_span(10); }
+  public Span<Feature> GetFeaturesBytes() { return __p.__vector_as_span<Feature>(10, 8); }
 #else
   public ArraySegment<byte>? GetFeaturesBytes() { return __p.__vector_as_arraysegment(10); }
 #endif
-  public Feature[] GetFeaturesArray() { return __p.__vector_as_array<Feature>(10); }
+  public Feature[] GetFeaturesArray() { int o = __p.__offset(10); if (o == 0) return null; int p = __p.__vector(o); int l = __p.__vector_len(o); Feature[] a = new Feature[l]; for (int i = 0; i < l; i++) { a[i] = (Feature)__p.bb.GetLong(p + i * 8); } return a; }
 
   public static Offset<Schema> CreateSchema(FlatBufferBuilder builder,
       Endianness endianness = Endianness.Little,
       VectorOffset fieldsOffset = default(VectorOffset),
       VectorOffset custom_metadataOffset = default(VectorOffset),
       VectorOffset featuresOffset = default(VectorOffset)) {
-    builder.StartObject(4);
+    builder.StartTable(4);
     Schema.AddFeatures(builder, featuresOffset);
     Schema.AddCustomMetadata(builder, custom_metadataOffset);
     Schema.AddFields(builder, fieldsOffset);
@@ -50,27 +53,46 @@ public static Offset<Schema> CreateSchema(FlatBufferBuilder builder,
     return Schema.EndSchema(builder);
   }
 
-  public static void StartSchema(FlatBufferBuilder builder) { builder.StartObject(4); }
+  public static void StartSchema(FlatBufferBuilder builder) { builder.StartTable(4); }
   public static void AddEndianness(FlatBufferBuilder builder, Endianness endianness) { builder.AddShort(0, (short)endianness, 0); }
   public static void AddFields(FlatBufferBuilder builder, VectorOffset fieldsOffset) { builder.AddOffset(1, fieldsOffset.Value, 0); }
   public static VectorOffset CreateFieldsVector(FlatBufferBuilder builder, Offset<Field>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
   public static VectorOffset CreateFieldsVectorBlock(FlatBufferBuilder builder, Offset<Field>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateFieldsVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<Field>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateFieldsVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<Field>>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartFieldsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
   public static void AddCustomMetadata(FlatBufferBuilder builder, VectorOffset customMetadataOffset) { builder.AddOffset(2, customMetadataOffset.Value, 0); }
   public static VectorOffset CreateCustomMetadataVector(FlatBufferBuilder builder, Offset<KeyValue>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
   public static VectorOffset CreateCustomMetadataVectorBlock(FlatBufferBuilder builder, Offset<KeyValue>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateCustomMetadataVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<KeyValue>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateCustomMetadataVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<KeyValue>>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartCustomMetadataVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
   public static void AddFeatures(FlatBufferBuilder builder, VectorOffset featuresOffset) { builder.AddOffset(3, featuresOffset.Value, 0); }
   public static VectorOffset CreateFeaturesVector(FlatBufferBuilder builder, Feature[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong((long)data[i]); return builder.EndVector(); }
   public static VectorOffset CreateFeaturesVectorBlock(FlatBufferBuilder builder, Feature[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateFeaturesVectorBlock(FlatBufferBuilder builder, ArraySegment<Feature> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateFeaturesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Feature>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartFeaturesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
   public static Offset<Schema> EndSchema(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Schema>(o);
   }
   public static void FinishSchemaBuffer(FlatBufferBuilder builder, Offset<Schema> offset) { builder.Finish(offset.Value); }
   public static void FinishSizePrefixedSchemaBuffer(FlatBufferBuilder builder, Offset<Schema> offset) { builder.FinishSizePrefixed(offset.Value); }
-};
+}
+
 
+static internal class SchemaVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Endianness*/, 2 /*Endianness*/, 2, false)
+      && verifier.VerifyVectorOfTables(tablePos, 6 /*Fields*/, FieldVerify.Verify, false)
+      && verifier.VerifyVectorOfTables(tablePos, 8 /*CustomMetadata*/, KeyValueVerify.Verify, false)
+      && verifier.VerifyVectorOfData(tablePos, 10 /*Features*/, 8 /*Feature*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/SparseMatrixCompressedAxis.cs b/csharp/src/Apache.Arrow/Flatbuf/SparseMatrixCompressedAxis.cs
new file mode 100644
index 0000000000000..67bf99271127c
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Flatbuf/SparseMatrixCompressedAxis.cs
@@ -0,0 +1,15 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Apache.Arrow.Flatbuf
+{
+
+internal enum SparseMatrixCompressedAxis : short
+{
+  Row = 0,
+  Column = 1,
+};
+
+
+}
diff --git a/csharp/src/Apache.Arrow/Flatbuf/SparseMatrixIndexCSX.cs b/csharp/src/Apache.Arrow/Flatbuf/SparseMatrixIndexCSX.cs
new file mode 100644
index 0000000000000..feea620e7c6b6
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Flatbuf/SparseMatrixIndexCSX.cs
@@ -0,0 +1,95 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Apache.Arrow.Flatbuf
+{
+
+using global::System;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
+
+/// Compressed Sparse format, that is matrix-specific.
+internal struct SparseMatrixIndexCSX : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
+  public static SparseMatrixIndexCSX GetRootAsSparseMatrixIndexCSX(ByteBuffer _bb) { return GetRootAsSparseMatrixIndexCSX(_bb, new SparseMatrixIndexCSX()); }
+  public static SparseMatrixIndexCSX GetRootAsSparseMatrixIndexCSX(ByteBuffer _bb, SparseMatrixIndexCSX obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public SparseMatrixIndexCSX __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  /// Which axis, row or column, is compressed
+  public SparseMatrixCompressedAxis CompressedAxis { get { int o = __p.__offset(4); return o != 0 ? (SparseMatrixCompressedAxis)__p.bb.GetShort(o + __p.bb_pos) : SparseMatrixCompressedAxis.Row; } }
+  /// The type of values in indptrBuffer
+  public Int? IndptrType { get { int o = __p.__offset(6); return o != 0 ? (Int?)(new Int()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
+  /// indptrBuffer stores the location and size of indptr array that
+  /// represents the range of the rows.
+  /// The i-th row spans from `indptr[i]` to `indptr[i+1]` in the data.
+  /// The length of this array is 1 + (the number of rows), and the type
+  /// of index value is long.
+  ///
+  /// For example, let X be the following 6x4 matrix:
+  /// ```text
+  ///   X := [[0, 1, 2, 0],
+  ///         [0, 0, 3, 0],
+  ///         [0, 4, 0, 5],
+  ///         [0, 0, 0, 0],
+  ///         [6, 0, 7, 8],
+  ///         [0, 9, 0, 0]].
+  /// ```
+  /// The array of non-zero values in X is:
+  /// ```text
+  ///   values(X) = [1, 2, 3, 4, 5, 6, 7, 8, 9].
+  /// ```
+  /// And the indptr of X is:
+  /// ```text
+  ///   indptr(X) = [0, 2, 3, 5, 5, 8, 10].
+  /// ```
+  public Buffer? IndptrBuffer { get { int o = __p.__offset(8); return o != 0 ? (Buffer?)(new Buffer()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  /// The type of values in indicesBuffer
+  public Int? IndicesType { get { int o = __p.__offset(10); return o != 0 ? (Int?)(new Int()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
+  /// indicesBuffer stores the location and size of the array that
+  /// contains the column indices of the corresponding non-zero values.
+  /// The type of index value is long.
+  ///
+  /// For example, the indices of the above X is:
+  /// ```text
+  ///   indices(X) = [1, 2, 2, 1, 3, 0, 2, 3, 1].
+  /// ```
+  /// Note that the indices are sorted in lexicographical order for each row.
+  public Buffer? IndicesBuffer { get { int o = __p.__offset(12); return o != 0 ? (Buffer?)(new Buffer()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+
+  public static void StartSparseMatrixIndexCSX(FlatBufferBuilder builder) { builder.StartTable(5); }
+  public static void AddCompressedAxis(FlatBufferBuilder builder, SparseMatrixCompressedAxis compressedAxis) { builder.AddShort(0, (short)compressedAxis, 0); }
+  public static void AddIndptrType(FlatBufferBuilder builder, Offset<Int> indptrTypeOffset) { builder.AddOffset(1, indptrTypeOffset.Value, 0); }
+  public static void AddIndptrBuffer(FlatBufferBuilder builder, Offset<Buffer> indptrBufferOffset) { builder.AddStruct(2, indptrBufferOffset.Value, 0); }
+  public static void AddIndicesType(FlatBufferBuilder builder, Offset<Int> indicesTypeOffset) { builder.AddOffset(3, indicesTypeOffset.Value, 0); }
+  public static void AddIndicesBuffer(FlatBufferBuilder builder, Offset<Buffer> indicesBufferOffset) { builder.AddStruct(4, indicesBufferOffset.Value, 0); }
+  public static Offset<SparseMatrixIndexCSX> EndSparseMatrixIndexCSX(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    builder.Required(o, 6);  // indptrType
+    builder.Required(o, 8);  // indptrBuffer
+    builder.Required(o, 10);  // indicesType
+    builder.Required(o, 12);  // indicesBuffer
+    return new Offset<SparseMatrixIndexCSX>(o);
+  }
+}
+
+
+static internal class SparseMatrixIndexCSXVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*CompressedAxis*/, 2 /*SparseMatrixCompressedAxis*/, 2, false)
+      && verifier.VerifyTable(tablePos, 6 /*IndptrType*/, IntVerify.Verify, true)
+      && verifier.VerifyField(tablePos, 8 /*IndptrBuffer*/, 16 /*Buffer*/, 8, true)
+      && verifier.VerifyTable(tablePos, 10 /*IndicesType*/, IntVerify.Verify, true)
+      && verifier.VerifyField(tablePos, 12 /*IndicesBuffer*/, 16 /*Buffer*/, 8, true)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}
diff --git a/csharp/src/Apache.Arrow/Flatbuf/SparseTensor.cs b/csharp/src/Apache.Arrow/Flatbuf/SparseTensor.cs
new file mode 100644
index 0000000000000..3f9e1de7c00a9
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Flatbuf/SparseTensor.cs
@@ -0,0 +1,106 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Apache.Arrow.Flatbuf
+{
+
+using global::System;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
+
+internal struct SparseTensor : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
+  public static SparseTensor GetRootAsSparseTensor(ByteBuffer _bb) { return GetRootAsSparseTensor(_bb, new SparseTensor()); }
+  public static SparseTensor GetRootAsSparseTensor(ByteBuffer _bb, SparseTensor obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public static bool VerifySparseTensor(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("", false, SparseTensorVerify.Verify); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public SparseTensor __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public Type TypeType { get { int o = __p.__offset(4); return o != 0 ? (Type)__p.bb.Get(o + __p.bb_pos) : Apache.Arrow.Flatbuf.Type.NONE; } }
+  /// The type of data contained in a value cell.
+  /// Currently only fixed-width value types are supported,
+  /// no strings or nested types.
+  public TTable? Type<TTable>() where TTable : struct, IFlatbufferObject { int o = __p.__offset(6); return o != 0 ? (TTable?)__p.__union<TTable>(o + __p.bb_pos) : null; }
+  public Null TypeAsNull() { return Type<Null>().Value; }
+  public Int TypeAsInt() { return Type<Int>().Value; }
+  public FloatingPoint TypeAsFloatingPoint() { return Type<FloatingPoint>().Value; }
+  public Binary TypeAsBinary() { return Type<Binary>().Value; }
+  public Utf8 TypeAsUtf8() { return Type<Utf8>().Value; }
+  public Bool TypeAsBool() { return Type<Bool>().Value; }
+  public Decimal TypeAsDecimal() { return Type<Decimal>().Value; }
+  public Date TypeAsDate() { return Type<Date>().Value; }
+  public Time TypeAsTime() { return Type<Time>().Value; }
+  public Timestamp TypeAsTimestamp() { return Type<Timestamp>().Value; }
+  public Interval TypeAsInterval() { return Type<Interval>().Value; }
+  public List TypeAsList() { return Type<List>().Value; }
+  public Struct_ TypeAsStruct_() { return Type<Struct_>().Value; }
+  public Union TypeAsUnion() { return Type<Union>().Value; }
+  public FixedSizeBinary TypeAsFixedSizeBinary() { return Type<FixedSizeBinary>().Value; }
+  public FixedSizeList TypeAsFixedSizeList() { return Type<FixedSizeList>().Value; }
+  public Map TypeAsMap() { return Type<Map>().Value; }
+  public Duration TypeAsDuration() { return Type<Duration>().Value; }
+  public LargeBinary TypeAsLargeBinary() { return Type<LargeBinary>().Value; }
+  public LargeUtf8 TypeAsLargeUtf8() { return Type<LargeUtf8>().Value; }
+  public LargeList TypeAsLargeList() { return Type<LargeList>().Value; }
+  public RunEndEncoded TypeAsRunEndEncoded() { return Type<RunEndEncoded>().Value; }
+  /// The dimensions of the tensor, optionally named.
+  public TensorDim? Shape(int j) { int o = __p.__offset(8); return o != 0 ? (TensorDim?)(new TensorDim()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int ShapeLength { get { int o = __p.__offset(8); return o != 0 ? __p.__vector_len(o) : 0; } }
+  /// The number of non-zero values in a sparse tensor.
+  public long NonZeroLength { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SparseTensorIndex SparseIndexType { get { int o = __p.__offset(12); return o != 0 ? (SparseTensorIndex)__p.bb.Get(o + __p.bb_pos) : SparseTensorIndex.NONE; } }
+  /// Sparse tensor index
+  public TTable? SparseIndex<TTable>() where TTable : struct, IFlatbufferObject { int o = __p.__offset(14); return o != 0 ? (TTable?)__p.__union<TTable>(o + __p.bb_pos) : null; }
+  public SparseTensorIndexCOO SparseIndexAsSparseTensorIndexCOO() { return SparseIndex<SparseTensorIndexCOO>().Value; }
+  public SparseMatrixIndexCSX SparseIndexAsSparseMatrixIndexCSX() { return SparseIndex<SparseMatrixIndexCSX>().Value; }
+  public SparseTensorIndexCSF SparseIndexAsSparseTensorIndexCSF() { return SparseIndex<SparseTensorIndexCSF>().Value; }
+  /// The location and size of the tensor's data
+  public Buffer? Data { get { int o = __p.__offset(16); return o != 0 ? (Buffer?)(new Buffer()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+
+  public static void StartSparseTensor(FlatBufferBuilder builder) { builder.StartTable(7); }
+  public static void AddTypeType(FlatBufferBuilder builder, Type typeType) { builder.AddByte(0, (byte)typeType, 0); }
+  public static void AddType(FlatBufferBuilder builder, int typeOffset) { builder.AddOffset(1, typeOffset, 0); }
+  public static void AddShape(FlatBufferBuilder builder, VectorOffset shapeOffset) { builder.AddOffset(2, shapeOffset.Value, 0); }
+  public static VectorOffset CreateShapeVector(FlatBufferBuilder builder, Offset<TensorDim>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+  public static VectorOffset CreateShapeVectorBlock(FlatBufferBuilder builder, Offset<TensorDim>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateShapeVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<TensorDim>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateShapeVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<TensorDim>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartShapeVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddNonZeroLength(FlatBufferBuilder builder, long nonZeroLength) { builder.AddLong(3, nonZeroLength, 0); }
+  public static void AddSparseIndexType(FlatBufferBuilder builder, SparseTensorIndex sparseIndexType) { builder.AddByte(4, (byte)sparseIndexType, 0); }
+  public static void AddSparseIndex(FlatBufferBuilder builder, int sparseIndexOffset) { builder.AddOffset(5, sparseIndexOffset, 0); }
+  public static void AddData(FlatBufferBuilder builder, Offset<Buffer> dataOffset) { builder.AddStruct(6, dataOffset.Value, 0); }
+  public static Offset<SparseTensor> EndSparseTensor(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    builder.Required(o, 6);  // type
+    builder.Required(o, 8);  // shape
+    builder.Required(o, 14);  // sparseIndex
+    builder.Required(o, 16);  // data
+    return new Offset<SparseTensor>(o);
+  }
+  public static void FinishSparseTensorBuffer(FlatBufferBuilder builder, Offset<SparseTensor> offset) { builder.Finish(offset.Value); }
+  public static void FinishSizePrefixedSparseTensorBuffer(FlatBufferBuilder builder, Offset<SparseTensor> offset) { builder.FinishSizePrefixed(offset.Value); }
+}
+
+
+static internal class SparseTensorVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*TypeType*/, 1 /*Type*/, 1, false)
+      && verifier.VerifyUnion(tablePos, 4, 6 /*Type*/, TypeVerify.Verify, true)
+      && verifier.VerifyVectorOfTables(tablePos, 8 /*Shape*/, TensorDimVerify.Verify, true)
+      && verifier.VerifyField(tablePos, 10 /*NonZeroLength*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 12 /*SparseIndexType*/, 1 /*SparseTensorIndex*/, 1, false)
+      && verifier.VerifyUnion(tablePos, 12, 14 /*SparseIndex*/, SparseTensorIndexVerify.Verify, true)
+      && verifier.VerifyField(tablePos, 16 /*Data*/, 16 /*Buffer*/, 8, true)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}
diff --git a/csharp/src/Apache.Arrow/Flatbuf/SparseTensorIndex.cs b/csharp/src/Apache.Arrow/Flatbuf/SparseTensorIndex.cs
new file mode 100644
index 0000000000000..16bfb2dd173f7
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Flatbuf/SparseTensorIndex.cs
@@ -0,0 +1,42 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Apache.Arrow.Flatbuf
+{
+
+internal enum SparseTensorIndex : byte
+{
+  NONE = 0,
+  SparseTensorIndexCOO = 1,
+  SparseMatrixIndexCSX = 2,
+  SparseTensorIndexCSF = 3,
+};
+
+
+
+static internal class SparseTensorIndexVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos)
+  {
+    bool result = true;
+    switch((SparseTensorIndex)typeId)
+    {
+      case SparseTensorIndex.SparseTensorIndexCOO:
+        result = SparseTensorIndexCOOVerify.Verify(verifier, tablePos);
+        break;
+      case SparseTensorIndex.SparseMatrixIndexCSX:
+        result = SparseMatrixIndexCSXVerify.Verify(verifier, tablePos);
+        break;
+      case SparseTensorIndex.SparseTensorIndexCSF:
+        result = SparseTensorIndexCSFVerify.Verify(verifier, tablePos);
+        break;
+      default: result = true;
+        break;
+    }
+    return result;
+  }
+}
+
+
+}
diff --git a/csharp/src/Apache.Arrow/Flatbuf/SparseTensorIndexCOO.cs b/csharp/src/Apache.Arrow/Flatbuf/SparseTensorIndexCOO.cs
new file mode 100644
index 0000000000000..f0cdae226603a
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Flatbuf/SparseTensorIndexCOO.cs
@@ -0,0 +1,107 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Apache.Arrow.Flatbuf
+{
+
+using global::System;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
+
+/// ----------------------------------------------------------------------
+/// EXPERIMENTAL: Data structures for sparse tensors
+/// Coordinate (COO) format of sparse tensor index.
+///
+/// COO's index list are represented as a NxM matrix,
+/// where N is the number of non-zero values,
+/// and M is the number of dimensions of a sparse tensor.
+///
+/// indicesBuffer stores the location and size of the data of this indices
+/// matrix.  The value type and the stride of the indices matrix is
+/// specified in indicesType and indicesStrides fields.
+///
+/// For example, let X be a 2x3x4x5 tensor, and it has the following
+/// 6 non-zero values:
+/// ```text
+///   X[0, 1, 2, 0] := 1
+///   X[1, 1, 2, 3] := 2
+///   X[0, 2, 1, 0] := 3
+///   X[0, 1, 3, 0] := 4
+///   X[0, 1, 2, 1] := 5
+///   X[1, 2, 0, 4] := 6
+/// ```
+/// In COO format, the index matrix of X is the following 4x6 matrix:
+/// ```text
+///   [[0, 0, 0, 0, 1, 1],
+///    [1, 1, 1, 2, 1, 2],
+///    [2, 2, 3, 1, 2, 0],
+///    [0, 1, 0, 0, 3, 4]]
+/// ```
+/// When isCanonical is true, the indices is sorted in lexicographical order
+/// (row-major order), and it does not have duplicated entries.  Otherwise,
+/// the indices may not be sorted, or may have duplicated entries.
+internal struct SparseTensorIndexCOO : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
+  public static SparseTensorIndexCOO GetRootAsSparseTensorIndexCOO(ByteBuffer _bb) { return GetRootAsSparseTensorIndexCOO(_bb, new SparseTensorIndexCOO()); }
+  public static SparseTensorIndexCOO GetRootAsSparseTensorIndexCOO(ByteBuffer _bb, SparseTensorIndexCOO obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public SparseTensorIndexCOO __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  /// The type of values in indicesBuffer
+  public Int? IndicesType { get { int o = __p.__offset(4); return o != 0 ? (Int?)(new Int()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
+  /// Non-negative byte offsets to advance one value cell along each dimension
+  /// If omitted, default to row-major order (C-like).
+  public long IndicesStrides(int j) { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int IndicesStridesLength { get { int o = __p.__offset(6); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetIndicesStridesBytes() { return __p.__vector_as_span<long>(6, 8); }
+#else
+  public ArraySegment<byte>? GetIndicesStridesBytes() { return __p.__vector_as_arraysegment(6); }
+#endif
+  public long[] GetIndicesStridesArray() { return __p.__vector_as_array<long>(6); }
+  /// The location and size of the indices matrix's data
+  public Buffer? IndicesBuffer { get { int o = __p.__offset(8); return o != 0 ? (Buffer?)(new Buffer()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  /// This flag is true if and only if the indices matrix is sorted in
+  /// row-major order, and does not have duplicated entries.
+  /// This sort order is the same as of Tensorflow's SparseTensor,
+  /// but it is inverse order of SciPy's canonical coo_matrix
+  /// (SciPy employs column-major order for its coo_matrix).
+  public bool IsCanonical { get { int o = __p.__offset(10); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
+
+  public static void StartSparseTensorIndexCOO(FlatBufferBuilder builder) { builder.StartTable(4); }
+  public static void AddIndicesType(FlatBufferBuilder builder, Offset<Int> indicesTypeOffset) { builder.AddOffset(0, indicesTypeOffset.Value, 0); }
+  public static void AddIndicesStrides(FlatBufferBuilder builder, VectorOffset indicesStridesOffset) { builder.AddOffset(1, indicesStridesOffset.Value, 0); }
+  public static VectorOffset CreateIndicesStridesVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateIndicesStridesVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateIndicesStridesVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateIndicesStridesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartIndicesStridesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static void AddIndicesBuffer(FlatBufferBuilder builder, Offset<Buffer> indicesBufferOffset) { builder.AddStruct(2, indicesBufferOffset.Value, 0); }
+  public static void AddIsCanonical(FlatBufferBuilder builder, bool isCanonical) { builder.AddBool(3, isCanonical, false); }
+  public static Offset<SparseTensorIndexCOO> EndSparseTensorIndexCOO(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    builder.Required(o, 4);  // indicesType
+    builder.Required(o, 8);  // indicesBuffer
+    return new Offset<SparseTensorIndexCOO>(o);
+  }
+}
+
+
+static internal class SparseTensorIndexCOOVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTable(tablePos, 4 /*IndicesType*/, IntVerify.Verify, true)
+      && verifier.VerifyVectorOfData(tablePos, 6 /*IndicesStrides*/, 8 /*long*/, false)
+      && verifier.VerifyField(tablePos, 8 /*IndicesBuffer*/, 16 /*Buffer*/, 8, true)
+      && verifier.VerifyField(tablePos, 10 /*IsCanonical*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}
diff --git a/csharp/src/Apache.Arrow/Flatbuf/SparseTensorIndexCSF.cs b/csharp/src/Apache.Arrow/Flatbuf/SparseTensorIndexCSF.cs
new file mode 100644
index 0000000000000..1ca54ed83fd5d
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Flatbuf/SparseTensorIndexCSF.cs
@@ -0,0 +1,155 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Apache.Arrow.Flatbuf
+{
+
+using global::System;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
+
+/// Compressed Sparse Fiber (CSF) sparse tensor index.
+internal struct SparseTensorIndexCSF : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
+  public static SparseTensorIndexCSF GetRootAsSparseTensorIndexCSF(ByteBuffer _bb) { return GetRootAsSparseTensorIndexCSF(_bb, new SparseTensorIndexCSF()); }
+  public static SparseTensorIndexCSF GetRootAsSparseTensorIndexCSF(ByteBuffer _bb, SparseTensorIndexCSF obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public SparseTensorIndexCSF __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  /// CSF is a generalization of compressed sparse row (CSR) index.
+  /// See [smith2017knl](http://shaden.io/pub-files/smith2017knl.pdf)
+  ///
+  /// CSF index recursively compresses each dimension of a tensor into a set
+  /// of prefix trees. Each path from a root to leaf forms one tensor
+  /// non-zero index. CSF is implemented with two arrays of buffers and one
+  /// arrays of integers.
+  ///
+  /// For example, let X be a 2x3x4x5 tensor and let it have the following
+  /// 8 non-zero values:
+  /// ```text
+  ///   X[0, 0, 0, 1] := 1
+  ///   X[0, 0, 0, 2] := 2
+  ///   X[0, 1, 0, 0] := 3
+  ///   X[0, 1, 0, 2] := 4
+  ///   X[0, 1, 1, 0] := 5
+  ///   X[1, 1, 1, 0] := 6
+  ///   X[1, 1, 1, 1] := 7
+  ///   X[1, 1, 1, 2] := 8
+  /// ```
+  /// As a prefix tree this would be represented as:
+  /// ```text
+  ///         0          1
+  ///        / \         |
+  ///       0   1        1
+  ///      /   / \       |
+  ///     0   0   1      1
+  ///    /|  /|   |    /| |
+  ///   1 2 0 2   0   0 1 2
+  /// ```
+  /// The type of values in indptrBuffers
+  public Int? IndptrType { get { int o = __p.__offset(4); return o != 0 ? (Int?)(new Int()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
+  /// indptrBuffers stores the sparsity structure.
+  /// Each two consecutive dimensions in a tensor correspond to a buffer in
+  /// indptrBuffers. A pair of consecutive values at `indptrBuffers[dim][i]`
+  /// and `indptrBuffers[dim][i + 1]` signify a range of nodes in
+  /// `indicesBuffers[dim + 1]` who are children of `indicesBuffers[dim][i]` node.
+  ///
+  /// For example, the indptrBuffers for the above X is:
+  /// ```text
+  ///   indptrBuffer(X) = [
+  ///                       [0, 2, 3],
+  ///                       [0, 1, 3, 4],
+  ///                       [0, 2, 4, 5, 8]
+  ///                     ].
+  /// ```
+  public Buffer? IndptrBuffers(int j) { int o = __p.__offset(6); return o != 0 ? (Buffer?)(new Buffer()).__assign(__p.__vector(o) + j * 16, __p.bb) : null; }
+  public int IndptrBuffersLength { get { int o = __p.__offset(6); return o != 0 ? __p.__vector_len(o) : 0; } }
+  /// The type of values in indicesBuffers
+  public Int? IndicesType { get { int o = __p.__offset(8); return o != 0 ? (Int?)(new Int()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
+  /// indicesBuffers stores values of nodes.
+  /// Each tensor dimension corresponds to a buffer in indicesBuffers.
+  /// For example, the indicesBuffers for the above X is:
+  /// ```text
+  ///   indicesBuffer(X) = [
+  ///                        [0, 1],
+  ///                        [0, 1, 1],
+  ///                        [0, 0, 1, 1],
+  ///                        [1, 2, 0, 2, 0, 0, 1, 2]
+  ///                      ].
+  /// ```
+  public Buffer? IndicesBuffers(int j) { int o = __p.__offset(10); return o != 0 ? (Buffer?)(new Buffer()).__assign(__p.__vector(o) + j * 16, __p.bb) : null; }
+  public int IndicesBuffersLength { get { int o = __p.__offset(10); return o != 0 ? __p.__vector_len(o) : 0; } }
+  /// axisOrder stores the sequence in which dimensions were traversed to
+  /// produce the prefix tree.
+  /// For example, the axisOrder for the above X is:
+  /// ```text
+  ///   axisOrder(X) = [0, 1, 2, 3].
+  /// ```
+  public int AxisOrder(int j) { int o = __p.__offset(12); return o != 0 ? __p.bb.GetInt(__p.__vector(o) + j * 4) : (int)0; }
+  public int AxisOrderLength { get { int o = __p.__offset(12); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<int> GetAxisOrderBytes() { return __p.__vector_as_span<int>(12, 4); }
+#else
+  public ArraySegment<byte>? GetAxisOrderBytes() { return __p.__vector_as_arraysegment(12); }
+#endif
+  public int[] GetAxisOrderArray() { return __p.__vector_as_array<int>(12); }
+
+  public static Offset<SparseTensorIndexCSF> CreateSparseTensorIndexCSF(FlatBufferBuilder builder,
+      Offset<Int> indptrTypeOffset = default(Offset<Int>),
+      VectorOffset indptrBuffersOffset = default(VectorOffset),
+      Offset<Int> indicesTypeOffset = default(Offset<Int>),
+      VectorOffset indicesBuffersOffset = default(VectorOffset),
+      VectorOffset axisOrderOffset = default(VectorOffset)) {
+    builder.StartTable(5);
+    SparseTensorIndexCSF.AddAxisOrder(builder, axisOrderOffset);
+    SparseTensorIndexCSF.AddIndicesBuffers(builder, indicesBuffersOffset);
+    SparseTensorIndexCSF.AddIndicesType(builder, indicesTypeOffset);
+    SparseTensorIndexCSF.AddIndptrBuffers(builder, indptrBuffersOffset);
+    SparseTensorIndexCSF.AddIndptrType(builder, indptrTypeOffset);
+    return SparseTensorIndexCSF.EndSparseTensorIndexCSF(builder);
+  }
+
+  public static void StartSparseTensorIndexCSF(FlatBufferBuilder builder) { builder.StartTable(5); }
+  public static void AddIndptrType(FlatBufferBuilder builder, Offset<Int> indptrTypeOffset) { builder.AddOffset(0, indptrTypeOffset.Value, 0); }
+  public static void AddIndptrBuffers(FlatBufferBuilder builder, VectorOffset indptrBuffersOffset) { builder.AddOffset(1, indptrBuffersOffset.Value, 0); }
+  public static void StartIndptrBuffersVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(16, numElems, 8); }
+  public static void AddIndicesType(FlatBufferBuilder builder, Offset<Int> indicesTypeOffset) { builder.AddOffset(2, indicesTypeOffset.Value, 0); }
+  public static void AddIndicesBuffers(FlatBufferBuilder builder, VectorOffset indicesBuffersOffset) { builder.AddOffset(3, indicesBuffersOffset.Value, 0); }
+  public static void StartIndicesBuffersVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(16, numElems, 8); }
+  public static void AddAxisOrder(FlatBufferBuilder builder, VectorOffset axisOrderOffset) { builder.AddOffset(4, axisOrderOffset.Value, 0); }
+  public static VectorOffset CreateAxisOrderVector(FlatBufferBuilder builder, int[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddInt(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateAxisOrderVectorBlock(FlatBufferBuilder builder, int[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateAxisOrderVectorBlock(FlatBufferBuilder builder, ArraySegment<int> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateAxisOrderVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<int>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartAxisOrderVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SparseTensorIndexCSF> EndSparseTensorIndexCSF(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    builder.Required(o, 4);  // indptrType
+    builder.Required(o, 6);  // indptrBuffers
+    builder.Required(o, 8);  // indicesType
+    builder.Required(o, 10);  // indicesBuffers
+    builder.Required(o, 12);  // axisOrder
+    return new Offset<SparseTensorIndexCSF>(o);
+  }
+}
+
+
+static internal class SparseTensorIndexCSFVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTable(tablePos, 4 /*IndptrType*/, IntVerify.Verify, true)
+      && verifier.VerifyVectorOfData(tablePos, 6 /*IndptrBuffers*/, 16 /*Buffer*/, true)
+      && verifier.VerifyTable(tablePos, 8 /*IndicesType*/, IntVerify.Verify, true)
+      && verifier.VerifyVectorOfData(tablePos, 10 /*IndicesBuffers*/, 16 /*Buffer*/, true)
+      && verifier.VerifyVectorOfData(tablePos, 12 /*AxisOrder*/, 4 /*int*/, true)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Tensor.cs b/csharp/src/Apache.Arrow/Flatbuf/Tensor.cs
index 918d7d6ea73f6..f8c213768a3fc 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Tensor.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Tensor.cs
@@ -6,29 +6,55 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 internal struct Tensor : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Tensor GetRootAsTensor(ByteBuffer _bb) { return GetRootAsTensor(_bb, new Tensor()); }
   public static Tensor GetRootAsTensor(ByteBuffer _bb, Tensor obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public static bool VerifyTensor(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("", false, TensorVerify.Verify); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Tensor __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
-  public Type TypeType { get { int o = __p.__offset(4); return o != 0 ? (Type)__p.bb.Get(o + __p.bb_pos) : Flatbuf.Type.NONE; } }
+  public Type TypeType { get { int o = __p.__offset(4); return o != 0 ? (Type)__p.bb.Get(o + __p.bb_pos) : Apache.Arrow.Flatbuf.Type.NONE; } }
   /// The type of data contained in a value cell. Currently only fixed-width
   /// value types are supported, no strings or nested types
-  public TTable? Type<TTable>() where TTable : struct, IFlatbufferObject { int o = __p.__offset(6); return o != 0 ? (TTable?)__p.__union<TTable>(o) : null; }
+  public TTable? Type<TTable>() where TTable : struct, IFlatbufferObject { int o = __p.__offset(6); return o != 0 ? (TTable?)__p.__union<TTable>(o + __p.bb_pos) : null; }
+  public Null TypeAsNull() { return Type<Null>().Value; }
+  public Int TypeAsInt() { return Type<Int>().Value; }
+  public FloatingPoint TypeAsFloatingPoint() { return Type<FloatingPoint>().Value; }
+  public Binary TypeAsBinary() { return Type<Binary>().Value; }
+  public Utf8 TypeAsUtf8() { return Type<Utf8>().Value; }
+  public Bool TypeAsBool() { return Type<Bool>().Value; }
+  public Decimal TypeAsDecimal() { return Type<Decimal>().Value; }
+  public Date TypeAsDate() { return Type<Date>().Value; }
+  public Time TypeAsTime() { return Type<Time>().Value; }
+  public Timestamp TypeAsTimestamp() { return Type<Timestamp>().Value; }
+  public Interval TypeAsInterval() { return Type<Interval>().Value; }
+  public List TypeAsList() { return Type<List>().Value; }
+  public Struct_ TypeAsStruct_() { return Type<Struct_>().Value; }
+  public Union TypeAsUnion() { return Type<Union>().Value; }
+  public FixedSizeBinary TypeAsFixedSizeBinary() { return Type<FixedSizeBinary>().Value; }
+  public FixedSizeList TypeAsFixedSizeList() { return Type<FixedSizeList>().Value; }
+  public Map TypeAsMap() { return Type<Map>().Value; }
+  public Duration TypeAsDuration() { return Type<Duration>().Value; }
+  public LargeBinary TypeAsLargeBinary() { return Type<LargeBinary>().Value; }
+  public LargeUtf8 TypeAsLargeUtf8() { return Type<LargeUtf8>().Value; }
+  public LargeList TypeAsLargeList() { return Type<LargeList>().Value; }
+  public RunEndEncoded TypeAsRunEndEncoded() { return Type<RunEndEncoded>().Value; }
   /// The dimensions of the tensor, optionally named
   public TensorDim? Shape(int j) { int o = __p.__offset(8); return o != 0 ? (TensorDim?)(new TensorDim()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
   public int ShapeLength { get { int o = __p.__offset(8); return o != 0 ? __p.__vector_len(o) : 0; } }
   /// Non-negative byte offsets to advance one value cell along each dimension
+  /// If omitted, default to row-major order (C-like).
   public long Strides(int j) { int o = __p.__offset(10); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
   public int StridesLength { get { int o = __p.__offset(10); return o != 0 ? __p.__vector_len(o) : 0; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetStridesBytes() { return __p.__vector_as_span(10); }
+  public Span<long> GetStridesBytes() { return __p.__vector_as_span<long>(10, 8); }
 #else
   public ArraySegment<byte>? GetStridesBytes() { return __p.__vector_as_arraysegment(10); }
 #endif
@@ -36,25 +62,46 @@ internal struct Tensor : IFlatbufferObject
   /// The location and size of the tensor's data
   public Buffer? Data { get { int o = __p.__offset(12); return o != 0 ? (Buffer?)(new Buffer()).__assign(o + __p.bb_pos, __p.bb) : null; } }
 
-  public static void StartTensor(FlatBufferBuilder builder) { builder.StartObject(5); }
+  public static void StartTensor(FlatBufferBuilder builder) { builder.StartTable(5); }
   public static void AddTypeType(FlatBufferBuilder builder, Type typeType) { builder.AddByte(0, (byte)typeType, 0); }
   public static void AddType(FlatBufferBuilder builder, int typeOffset) { builder.AddOffset(1, typeOffset, 0); }
   public static void AddShape(FlatBufferBuilder builder, VectorOffset shapeOffset) { builder.AddOffset(2, shapeOffset.Value, 0); }
   public static VectorOffset CreateShapeVector(FlatBufferBuilder builder, Offset<TensorDim>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
   public static VectorOffset CreateShapeVectorBlock(FlatBufferBuilder builder, Offset<TensorDim>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateShapeVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<TensorDim>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateShapeVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<TensorDim>>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartShapeVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
   public static void AddStrides(FlatBufferBuilder builder, VectorOffset stridesOffset) { builder.AddOffset(3, stridesOffset.Value, 0); }
   public static VectorOffset CreateStridesVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
   public static VectorOffset CreateStridesVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateStridesVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateStridesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartStridesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
   public static void AddData(FlatBufferBuilder builder, Offset<Buffer> dataOffset) { builder.AddStruct(4, dataOffset.Value, 0); }
   public static Offset<Tensor> EndTensor(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
+    builder.Required(o, 6);  // type
+    builder.Required(o, 8);  // shape
+    builder.Required(o, 12);  // data
     return new Offset<Tensor>(o);
   }
   public static void FinishTensorBuffer(FlatBufferBuilder builder, Offset<Tensor> offset) { builder.Finish(offset.Value); }
   public static void FinishSizePrefixedTensorBuffer(FlatBufferBuilder builder, Offset<Tensor> offset) { builder.FinishSizePrefixed(offset.Value); }
-};
+}
+
 
+static internal class TensorVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*TypeType*/, 1 /*Type*/, 1, false)
+      && verifier.VerifyUnion(tablePos, 4, 6 /*Type*/, TypeVerify.Verify, true)
+      && verifier.VerifyVectorOfTables(tablePos, 8 /*Shape*/, TensorDimVerify.Verify, true)
+      && verifier.VerifyVectorOfData(tablePos, 10 /*Strides*/, 8 /*long*/, false)
+      && verifier.VerifyField(tablePos, 12 /*Data*/, 16 /*Buffer*/, 8, true)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/TensorDim.cs b/csharp/src/Apache.Arrow/Flatbuf/TensorDim.cs
index a4c51824b8e51..43d2ef5736224 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/TensorDim.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/TensorDim.cs
@@ -6,7 +6,8 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// ----------------------------------------------------------------------
 /// Data structures for dense tensors
@@ -15,9 +16,10 @@ internal struct TensorDim : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static TensorDim GetRootAsTensorDim(ByteBuffer _bb) { return GetRootAsTensorDim(_bb, new TensorDim()); }
   public static TensorDim GetRootAsTensorDim(ByteBuffer _bb, TensorDim obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public TensorDim __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   /// Length of dimension
@@ -25,7 +27,7 @@ internal struct TensorDim : IFlatbufferObject
   /// Name of the dimension, optional
   public string Name { get { int o = __p.__offset(6); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetNameBytes() { return __p.__vector_as_span(6); }
+  public Span<byte> GetNameBytes() { return __p.__vector_as_span<byte>(6, 1); }
 #else
   public ArraySegment<byte>? GetNameBytes() { return __p.__vector_as_arraysegment(6); }
 #endif
@@ -34,20 +36,31 @@ internal struct TensorDim : IFlatbufferObject
   public static Offset<TensorDim> CreateTensorDim(FlatBufferBuilder builder,
       long size = 0,
       StringOffset nameOffset = default(StringOffset)) {
-    builder.StartObject(2);
+    builder.StartTable(2);
     TensorDim.AddSize(builder, size);
     TensorDim.AddName(builder, nameOffset);
     return TensorDim.EndTensorDim(builder);
   }
 
-  public static void StartTensorDim(FlatBufferBuilder builder) { builder.StartObject(2); }
+  public static void StartTensorDim(FlatBufferBuilder builder) { builder.StartTable(2); }
   public static void AddSize(FlatBufferBuilder builder, long size) { builder.AddLong(0, size, 0); }
   public static void AddName(FlatBufferBuilder builder, StringOffset nameOffset) { builder.AddOffset(1, nameOffset.Value, 0); }
   public static Offset<TensorDim> EndTensorDim(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<TensorDim>(o);
   }
-};
+}
+
 
+static internal class TensorDimVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Size*/, 8 /*long*/, 8, false)
+      && verifier.VerifyString(tablePos, 6 /*Name*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/Binary.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/Binary.cs
index 0738d11e903a7..1c7b334388b5e 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/Binary.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/Binary.cs
@@ -6,24 +6,36 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
+/// Opaque binary data
 internal struct Binary : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Binary GetRootAsBinary(ByteBuffer _bb) { return GetRootAsBinary(_bb, new Binary()); }
   public static Binary GetRootAsBinary(ByteBuffer _bb, Binary obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Binary __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
 
-  public static void StartBinary(FlatBufferBuilder builder) { builder.StartObject(0); }
+  public static void StartBinary(FlatBufferBuilder builder) { builder.StartTable(0); }
   public static Offset<Binary> EndBinary(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Binary>(o);
   }
-};
+}
+
 
+static internal class BinaryVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/Bool.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/Bool.cs
index da488abfe01e4..529ce7dcae8e2 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/Bool.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/Bool.cs
@@ -6,24 +6,35 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 internal struct Bool : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Bool GetRootAsBool(ByteBuffer _bb) { return GetRootAsBool(_bb, new Bool()); }
   public static Bool GetRootAsBool(ByteBuffer _bb, Bool obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Bool __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
 
-  public static void StartBool(FlatBufferBuilder builder) { builder.StartObject(0); }
+  public static void StartBool(FlatBufferBuilder builder) { builder.StartTable(0); }
   public static Offset<Bool> EndBool(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Bool>(o);
   }
-};
+}
+
 
+static internal class BoolVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/Date.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/Date.cs
index e9b7fb3ccaea0..aef1db96db0f3 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/Date.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/Date.cs
@@ -6,10 +6,11 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
-/// Date is either a 32-bit or 64-bit type representing elapsed time since UNIX
-/// epoch (1970-01-01), stored in either of two units:
+/// Date is either a 32-bit or 64-bit signed integer type representing an
+/// elapsed time since UNIX epoch (1970-01-01), stored in either of two units:
 ///
 /// * Milliseconds (64 bits) indicating UNIX time elapsed since the epoch (no
 ///   leap seconds), where the values are evenly divisible by 86400000
@@ -18,27 +19,38 @@ internal struct Date : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Date GetRootAsDate(ByteBuffer _bb) { return GetRootAsDate(_bb, new Date()); }
   public static Date GetRootAsDate(ByteBuffer _bb, Date obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Date __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   public DateUnit Unit { get { int o = __p.__offset(4); return o != 0 ? (DateUnit)__p.bb.GetShort(o + __p.bb_pos) : DateUnit.MILLISECOND; } }
 
   public static Offset<Date> CreateDate(FlatBufferBuilder builder,
       DateUnit unit = DateUnit.MILLISECOND) {
-    builder.StartObject(1);
+    builder.StartTable(1);
     Date.AddUnit(builder, unit);
     return Date.EndDate(builder);
   }
 
-  public static void StartDate(FlatBufferBuilder builder) { builder.StartObject(1); }
+  public static void StartDate(FlatBufferBuilder builder) { builder.StartTable(1); }
   public static void AddUnit(FlatBufferBuilder builder, DateUnit unit) { builder.AddShort(0, (short)unit, 1); }
   public static Offset<Date> EndDate(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Date>(o);
   }
-};
+}
+
 
+static internal class DateVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Unit*/, 2 /*DateUnit*/, 2, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/Decimal.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/Decimal.cs
index 97f62b6761b24..fd303786b1d55 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/Decimal.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/Decimal.cs
@@ -6,19 +6,21 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// Exact decimal value represented as an integer value in two's
 /// complement. Currently only 128-bit (16-byte) and 256-bit (32-byte) integers
 /// are used. The representation uses the endianness indicated
 /// in the Schema.
-internal struct Decimal: IFlatbufferObject
+internal struct Decimal : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Decimal GetRootAsDecimal(ByteBuffer _bb) { return GetRootAsDecimal(_bb, new Decimal()); }
   public static Decimal GetRootAsDecimal(ByteBuffer _bb, Decimal obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Decimal __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   /// Total number of decimal digits
@@ -33,22 +35,34 @@ public static Offset<Decimal> CreateDecimal(FlatBufferBuilder builder,
       int precision = 0,
       int scale = 0,
       int bitWidth = 128) {
-    builder.StartObject(3);
+    builder.StartTable(3);
     Decimal.AddBitWidth(builder, bitWidth);
     Decimal.AddScale(builder, scale);
     Decimal.AddPrecision(builder, precision);
     return Decimal.EndDecimal(builder);
   }
 
-  public static void StartDecimal(FlatBufferBuilder builder) { builder.StartObject(3); }
+  public static void StartDecimal(FlatBufferBuilder builder) { builder.StartTable(3); }
   public static void AddPrecision(FlatBufferBuilder builder, int precision) { builder.AddInt(0, precision, 0); }
   public static void AddScale(FlatBufferBuilder builder, int scale) { builder.AddInt(1, scale, 0); }
   public static void AddBitWidth(FlatBufferBuilder builder, int bitWidth) { builder.AddInt(2, bitWidth, 128); }
   public static Offset<Decimal> EndDecimal(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Decimal>(o);
   }
-};
+}
+
 
+static internal class DecimalVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Precision*/, 4 /*int*/, 4, false)
+      && verifier.VerifyField(tablePos, 6 /*Scale*/, 4 /*int*/, 4, false)
+      && verifier.VerifyField(tablePos, 8 /*BitWidth*/, 4 /*int*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/Duration.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/Duration.cs
index 1f3a9e4109586..28c2a510e5c1a 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/Duration.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/Duration.cs
@@ -6,33 +6,45 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 internal struct Duration : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Duration GetRootAsDuration(ByteBuffer _bb) { return GetRootAsDuration(_bb, new Duration()); }
   public static Duration GetRootAsDuration(ByteBuffer _bb, Duration obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Duration __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   public TimeUnit Unit { get { int o = __p.__offset(4); return o != 0 ? (TimeUnit)__p.bb.GetShort(o + __p.bb_pos) : TimeUnit.MILLISECOND; } }
 
   public static Offset<Duration> CreateDuration(FlatBufferBuilder builder,
       TimeUnit unit = TimeUnit.MILLISECOND) {
-    builder.StartObject(1);
+    builder.StartTable(1);
     Duration.AddUnit(builder, unit);
     return Duration.EndDuration(builder);
   }
 
-  public static void StartDuration(FlatBufferBuilder builder) { builder.StartObject(1); }
+  public static void StartDuration(FlatBufferBuilder builder) { builder.StartTable(1); }
   public static void AddUnit(FlatBufferBuilder builder, TimeUnit unit) { builder.AddShort(0, (short)unit, 1); }
   public static Offset<Duration> EndDuration(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Duration>(o);
   }
-};
+}
+
 
+static internal class DurationVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Unit*/, 2 /*TimeUnit*/, 2, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/FloatingPoint.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/FloatingPoint.cs
index 0cb58ecf4efe6..611c130b2ebfb 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/FloatingPoint.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/FloatingPoint.cs
@@ -6,33 +6,45 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 internal struct FloatingPoint : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static FloatingPoint GetRootAsFloatingPoint(ByteBuffer _bb) { return GetRootAsFloatingPoint(_bb, new FloatingPoint()); }
   public static FloatingPoint GetRootAsFloatingPoint(ByteBuffer _bb, FloatingPoint obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public FloatingPoint __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   public Precision Precision { get { int o = __p.__offset(4); return o != 0 ? (Precision)__p.bb.GetShort(o + __p.bb_pos) : Precision.HALF; } }
 
   public static Offset<FloatingPoint> CreateFloatingPoint(FlatBufferBuilder builder,
       Precision precision = Precision.HALF) {
-    builder.StartObject(1);
+    builder.StartTable(1);
     FloatingPoint.AddPrecision(builder, precision);
     return FloatingPoint.EndFloatingPoint(builder);
   }
 
-  public static void StartFloatingPoint(FlatBufferBuilder builder) { builder.StartObject(1); }
+  public static void StartFloatingPoint(FlatBufferBuilder builder) { builder.StartTable(1); }
   public static void AddPrecision(FlatBufferBuilder builder, Precision precision) { builder.AddShort(0, (short)precision, 0); }
   public static Offset<FloatingPoint> EndFloatingPoint(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<FloatingPoint>(o);
   }
-};
+}
+
 
+static internal class FloatingPointVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Precision*/, 2 /*Precision*/, 2, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/Int.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/Int.cs
index 754080279f584..d0cec48f44fe7 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/Int.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/Int.cs
@@ -6,15 +6,17 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 internal struct Int : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Int GetRootAsInt(ByteBuffer _bb) { return GetRootAsInt(_bb, new Int()); }
   public static Int GetRootAsInt(ByteBuffer _bb, Int obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Int __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   public int BitWidth { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
@@ -23,20 +25,31 @@ internal struct Int : IFlatbufferObject
   public static Offset<Int> CreateInt(FlatBufferBuilder builder,
       int bitWidth = 0,
       bool is_signed = false) {
-    builder.StartObject(2);
+    builder.StartTable(2);
     Int.AddBitWidth(builder, bitWidth);
     Int.AddIsSigned(builder, is_signed);
     return Int.EndInt(builder);
   }
 
-  public static void StartInt(FlatBufferBuilder builder) { builder.StartObject(2); }
+  public static void StartInt(FlatBufferBuilder builder) { builder.StartTable(2); }
   public static void AddBitWidth(FlatBufferBuilder builder, int bitWidth) { builder.AddInt(0, bitWidth, 0); }
   public static void AddIsSigned(FlatBufferBuilder builder, bool isSigned) { builder.AddBool(1, isSigned, false); }
   public static Offset<Int> EndInt(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Int>(o);
   }
-};
+}
+
 
+static internal class IntVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*BitWidth*/, 4 /*int*/, 4, false)
+      && verifier.VerifyField(tablePos, 6 /*IsSigned*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/Interval.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/Interval.cs
index bb92448ac4383..7d31603e29166 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/Interval.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/Interval.cs
@@ -6,33 +6,45 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 internal struct Interval : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Interval GetRootAsInterval(ByteBuffer _bb) { return GetRootAsInterval(_bb, new Interval()); }
   public static Interval GetRootAsInterval(ByteBuffer _bb, Interval obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Interval __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   public IntervalUnit Unit { get { int o = __p.__offset(4); return o != 0 ? (IntervalUnit)__p.bb.GetShort(o + __p.bb_pos) : IntervalUnit.YEAR_MONTH; } }
 
   public static Offset<Interval> CreateInterval(FlatBufferBuilder builder,
       IntervalUnit unit = IntervalUnit.YEAR_MONTH) {
-    builder.StartObject(1);
+    builder.StartTable(1);
     Interval.AddUnit(builder, unit);
     return Interval.EndInterval(builder);
   }
 
-  public static void StartInterval(FlatBufferBuilder builder) { builder.StartObject(1); }
+  public static void StartInterval(FlatBufferBuilder builder) { builder.StartTable(1); }
   public static void AddUnit(FlatBufferBuilder builder, IntervalUnit unit) { builder.AddShort(0, (short)unit, 0); }
   public static Offset<Interval> EndInterval(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Interval>(o);
   }
-};
+}
+
 
+static internal class IntervalVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Unit*/, 2 /*IntervalUnit*/, 2, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/LargeBinary.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/LargeBinary.cs
index 8ac6aa2cd0328..bcc33842323fe 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/LargeBinary.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/LargeBinary.cs
@@ -6,7 +6,8 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// Same as Binary, but with 64-bit offsets, allowing to represent
 /// extremely large data values.
@@ -14,18 +15,28 @@ internal struct LargeBinary : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static LargeBinary GetRootAsLargeBinary(ByteBuffer _bb) { return GetRootAsLargeBinary(_bb, new LargeBinary()); }
   public static LargeBinary GetRootAsLargeBinary(ByteBuffer _bb, LargeBinary obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public LargeBinary __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
 
-  public static void StartLargeBinary(FlatBufferBuilder builder) { builder.StartObject(0); }
+  public static void StartLargeBinary(FlatBufferBuilder builder) { builder.StartTable(0); }
   public static Offset<LargeBinary> EndLargeBinary(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<LargeBinary>(o);
   }
-};
+}
+
 
+static internal class LargeBinaryVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/LargeList.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/LargeList.cs
index 49e69a87f9adb..4bd09610ad1ef 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/LargeList.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/LargeList.cs
@@ -6,7 +6,8 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// Same as List, but with 64-bit offsets, allowing to represent
 /// extremely large data values.
@@ -14,18 +15,28 @@ internal struct LargeList : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static LargeList GetRootAsLargeList(ByteBuffer _bb) { return GetRootAsLargeList(_bb, new LargeList()); }
   public static LargeList GetRootAsLargeList(ByteBuffer _bb, LargeList obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public LargeList __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
 
-  public static void StartLargeList(FlatBufferBuilder builder) { builder.StartObject(0); }
+  public static void StartLargeList(FlatBufferBuilder builder) { builder.StartTable(0); }
   public static Offset<LargeList> EndLargeList(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<LargeList>(o);
   }
-};
+}
+
 
+static internal class LargeListVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/LargeUtf8.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/LargeUtf8.cs
index ebb64390ff49c..21c8c9dd2b313 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/LargeUtf8.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/LargeUtf8.cs
@@ -6,7 +6,8 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// Same as Utf8, but with 64-bit offsets, allowing to represent
 /// extremely large data values.
@@ -14,18 +15,28 @@ internal struct LargeUtf8 : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static LargeUtf8 GetRootAsLargeUtf8(ByteBuffer _bb) { return GetRootAsLargeUtf8(_bb, new LargeUtf8()); }
   public static LargeUtf8 GetRootAsLargeUtf8(ByteBuffer _bb, LargeUtf8 obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public LargeUtf8 __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
 
-  public static void StartLargeUtf8(FlatBufferBuilder builder) { builder.StartObject(0); }
+  public static void StartLargeUtf8(FlatBufferBuilder builder) { builder.StartTable(0); }
   public static Offset<LargeUtf8> EndLargeUtf8(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<LargeUtf8>(o);
   }
-};
+}
+
 
+static internal class LargeUtf8Verify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/List.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/List.cs
index 8f4985bb53801..37ffee6d88da9 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/List.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/List.cs
@@ -6,24 +6,35 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 internal struct List : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static List GetRootAsList(ByteBuffer _bb) { return GetRootAsList(_bb, new List()); }
   public static List GetRootAsList(ByteBuffer _bb, List obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public List __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
 
-  public static void StartList(FlatBufferBuilder builder) { builder.StartObject(0); }
+  public static void StartList(FlatBufferBuilder builder) { builder.StartTable(0); }
   public static Offset<List> EndList(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<List>(o);
   }
-};
+}
+
 
+static internal class ListVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/Null.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/Null.cs
index 85fa5bb99199f..82902f35aef25 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/Null.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/Null.cs
@@ -6,25 +6,36 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// These are stored in the flatbuffer in the Type union below
 internal struct Null : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Null GetRootAsNull(ByteBuffer _bb) { return GetRootAsNull(_bb, new Null()); }
   public static Null GetRootAsNull(ByteBuffer _bb, Null obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Null __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
 
-  public static void StartNull(FlatBufferBuilder builder) { builder.StartObject(0); }
+  public static void StartNull(FlatBufferBuilder builder) { builder.StartTable(0); }
   public static Offset<Null> EndNull(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Null>(o);
   }
-};
+}
+
 
+static internal class NullVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/Struct_.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/Struct_.cs
index 8f3d708cd9a05..a8f29e35b3898 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/Struct_.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/Struct_.cs
@@ -6,7 +6,8 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// A Struct_ in the flatbuffer metadata is the same as an Arrow Struct
 /// (according to the physical memory layout). We used Struct_ here as
@@ -15,18 +16,28 @@ internal struct Struct_ : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Struct_ GetRootAsStruct_(ByteBuffer _bb) { return GetRootAsStruct_(_bb, new Struct_()); }
   public static Struct_ GetRootAsStruct_(ByteBuffer _bb, Struct_ obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Struct_ __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
 
-  public static void StartStruct_(FlatBufferBuilder builder) { builder.StartObject(0); }
+  public static void StartStruct_(FlatBufferBuilder builder) { builder.StartTable(0); }
   public static Offset<Struct_> EndStruct_(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Struct_>(o);
   }
-};
+}
+
 
+static internal class Struct_Verify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/Time.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/Time.cs
index 1d7c0881cca42..4cb330238f4c5 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/Time.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/Time.cs
@@ -6,18 +6,31 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
-/// Time type. The physical storage type depends on the unit
-/// - SECOND and MILLISECOND: 32 bits
-/// - MICROSECOND and NANOSECOND: 64 bits
+/// Time is either a 32-bit or 64-bit signed integer type representing an
+/// elapsed time since midnight, stored in either of four units: seconds,
+/// milliseconds, microseconds or nanoseconds.
+///
+/// The integer `bitWidth` depends on the `unit` and must be one of the following:
+/// * SECOND and MILLISECOND: 32 bits
+/// * MICROSECOND and NANOSECOND: 64 bits
+///
+/// The allowed values are between 0 (inclusive) and 86400 (=24*60*60) seconds
+/// (exclusive), adjusted for the time unit (for example, up to 86400000
+/// exclusive for the MILLISECOND unit).
+/// This definition doesn't allow for leap seconds. Time values from
+/// measurements with leap seconds will need to be corrected when ingesting
+/// into Arrow (for example by replacing the value 86400 with 86399).
 internal struct Time : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Time GetRootAsTime(ByteBuffer _bb) { return GetRootAsTime(_bb, new Time()); }
   public static Time GetRootAsTime(ByteBuffer _bb, Time obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Time __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   public TimeUnit Unit { get { int o = __p.__offset(4); return o != 0 ? (TimeUnit)__p.bb.GetShort(o + __p.bb_pos) : TimeUnit.MILLISECOND; } }
@@ -26,20 +39,31 @@ internal struct Time : IFlatbufferObject
   public static Offset<Time> CreateTime(FlatBufferBuilder builder,
       TimeUnit unit = TimeUnit.MILLISECOND,
       int bitWidth = 32) {
-    builder.StartObject(2);
+    builder.StartTable(2);
     Time.AddBitWidth(builder, bitWidth);
     Time.AddUnit(builder, unit);
     return Time.EndTime(builder);
   }
 
-  public static void StartTime(FlatBufferBuilder builder) { builder.StartObject(2); }
+  public static void StartTime(FlatBufferBuilder builder) { builder.StartTable(2); }
   public static void AddUnit(FlatBufferBuilder builder, TimeUnit unit) { builder.AddShort(0, (short)unit, 1); }
   public static void AddBitWidth(FlatBufferBuilder builder, int bitWidth) { builder.AddInt(1, bitWidth, 32); }
   public static Offset<Time> EndTime(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Time>(o);
   }
-};
+}
+
 
+static internal class TimeVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Unit*/, 2 /*TimeUnit*/, 2, false)
+      && verifier.VerifyField(tablePos, 6 /*BitWidth*/, 4 /*int*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/Timestamp.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/Timestamp.cs
index c0168b4cbf84f..93620ea577899 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/Timestamp.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/Timestamp.cs
@@ -6,47 +6,138 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
-/// Time elapsed from the Unix epoch, 00:00:00.000 on 1 January 1970, excluding
-/// leap seconds, as a 64-bit integer. Note that UNIX time does not include
-/// leap seconds.
+/// Timestamp is a 64-bit signed integer representing an elapsed time since a
+/// fixed epoch, stored in either of four units: seconds, milliseconds,
+/// microseconds or nanoseconds, and is optionally annotated with a timezone.
 ///
-/// The Timestamp metadata supports both "time zone naive" and "time zone
-/// aware" timestamps. Read about the timezone attribute for more detail
+/// Timestamp values do not include any leap seconds (in other words, all
+/// days are considered 86400 seconds long).
+///
+/// Timestamps with a non-empty timezone
+/// ------------------------------------
+///
+/// If a Timestamp column has a non-empty timezone value, its epoch is
+/// 1970-01-01 00:00:00 (January 1st 1970, midnight) in the *UTC* timezone
+/// (the Unix epoch), regardless of the Timestamp's own timezone.
+///
+/// Therefore, timestamp values with a non-empty timezone correspond to
+/// physical points in time together with some additional information about
+/// how the data was obtained and/or how to display it (the timezone).
+///
+///   For example, the timestamp value 0 with the timezone string "Europe/Paris"
+///   corresponds to "January 1st 1970, 00h00" in the UTC timezone, but the
+///   application may prefer to display it as "January 1st 1970, 01h00" in
+///   the Europe/Paris timezone (which is the same physical point in time).
+///
+/// One consequence is that timestamp values with a non-empty timezone
+/// can be compared and ordered directly, since they all share the same
+/// well-known point of reference (the Unix epoch).
+///
+/// Timestamps with an unset / empty timezone
+/// -----------------------------------------
+///
+/// If a Timestamp column has no timezone value, its epoch is
+/// 1970-01-01 00:00:00 (January 1st 1970, midnight) in an *unknown* timezone.
+///
+/// Therefore, timestamp values without a timezone cannot be meaningfully
+/// interpreted as physical points in time, but only as calendar / clock
+/// indications ("wall clock time") in an unspecified timezone.
+///
+///   For example, the timestamp value 0 with an empty timezone string
+///   corresponds to "January 1st 1970, 00h00" in an unknown timezone: there
+///   is not enough information to interpret it as a well-defined physical
+///   point in time.
+///
+/// One consequence is that timestamp values without a timezone cannot
+/// be reliably compared or ordered, since they may have different points of
+/// reference.  In particular, it is *not* possible to interpret an unset
+/// or empty timezone as the same as "UTC".
+///
+/// Conversion between timezones
+/// ----------------------------
+///
+/// If a Timestamp column has a non-empty timezone, changing the timezone
+/// to a different non-empty value is a metadata-only operation:
+/// the timestamp values need not change as their point of reference remains
+/// the same (the Unix epoch).
+///
+/// However, if a Timestamp column has no timezone value, changing it to a
+/// non-empty value requires to think about the desired semantics.
+/// One possibility is to assume that the original timestamp values are
+/// relative to the epoch of the timezone being set; timestamp values should
+/// then adjusted to the Unix epoch (for example, changing the timezone from
+/// empty to "Europe/Paris" would require converting the timestamp values
+/// from "Europe/Paris" to "UTC", which seems counter-intuitive but is
+/// nevertheless correct).
+///
+/// Guidelines for encoding data from external libraries
+/// ----------------------------------------------------
+///
+/// Date & time libraries often have multiple different data types for temporal
+/// data. In order to ease interoperability between different implementations the
+/// Arrow project has some recommendations for encoding these types into a Timestamp
+/// column.
+///
+/// An "instant" represents a physical point in time that has no relevant timezone
+/// (for example, astronomical data). To encode an instant, use a Timestamp with
+/// the timezone string set to "UTC", and make sure the Timestamp values
+/// are relative to the UTC epoch (January 1st 1970, midnight).
+///
+/// A "zoned date-time" represents a physical point in time annotated with an
+/// informative timezone (for example, the timezone in which the data was
+/// recorded).  To encode a zoned date-time, use a Timestamp with the timezone
+/// string set to the name of the timezone, and make sure the Timestamp values
+/// are relative to the UTC epoch (January 1st 1970, midnight).
+///
+///  (There is some ambiguity between an instant and a zoned date-time with the
+///   UTC timezone.  Both of these are stored the same in Arrow.  Typically,
+///   this distinction does not matter.  If it does, then an application should
+///   use custom metadata or an extension type to distinguish between the two cases.)
+///
+/// An "offset date-time" represents a physical point in time combined with an
+/// explicit offset from UTC.  To encode an offset date-time, use a Timestamp
+/// with the timezone string set to the numeric timezone offset string
+/// (e.g. "+03:00"), and make sure the Timestamp values are relative to
+/// the UTC epoch (January 1st 1970, midnight).
+///
+/// A "naive date-time" (also called "local date-time" in some libraries)
+/// represents a wall clock time combined with a calendar date, but with
+/// no indication of how to map this information to a physical point in time.
+/// Naive date-times must be handled with care because of this missing
+/// information, and also because daylight saving time (DST) may make
+/// some values ambiguous or non-existent. A naive date-time may be
+/// stored as a struct with Date and Time fields. However, it may also be
+/// encoded into a Timestamp column with an empty timezone. The timestamp
+/// values should be computed "as if" the timezone of the date-time values
+/// was UTC; for example, the naive date-time "January 1st 1970, 00h00" would
+/// be encoded as timestamp value 0.
 internal struct Timestamp : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Timestamp GetRootAsTimestamp(ByteBuffer _bb) { return GetRootAsTimestamp(_bb, new Timestamp()); }
   public static Timestamp GetRootAsTimestamp(ByteBuffer _bb, Timestamp obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Timestamp __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   public TimeUnit Unit { get { int o = __p.__offset(4); return o != 0 ? (TimeUnit)__p.bb.GetShort(o + __p.bb_pos) : TimeUnit.SECOND; } }
-  /// The time zone is a string indicating the name of a time zone, one of:
+  /// The timezone is an optional string indicating the name of a timezone,
+  /// one of:
   ///
-  /// * As used in the Olson time zone database (the "tz database" or
-  ///   "tzdata"), such as "America/New_York"
-  /// * An absolute time zone offset of the form +XX:XX or -XX:XX, such as +07:30
+  /// * As used in the Olson timezone database (the "tz database" or
+  ///   "tzdata"), such as "America/New_York".
+  /// * An absolute timezone offset of the form "+XX:XX" or "-XX:XX",
+  ///   such as "+07:30".
   ///
   /// Whether a timezone string is present indicates different semantics about
-  /// the data:
-  ///
-  /// * If the time zone is null or equal to an empty string, the data is "time
-  ///   zone naive" and shall be displayed *as is* to the user, not localized
-  ///   to the locale of the user. This data can be though of as UTC but
-  ///   without having "UTC" as the time zone, it is not considered to be
-  ///   localized to any time zone
-  ///
-  /// * If the time zone is set to a valid value, values can be displayed as
-  ///   "localized" to that time zone, even though the underlying 64-bit
-  ///   integers are identical to the same data stored in UTC. Converting
-  ///   between time zones is a metadata-only operation and does not change the
-  ///   underlying values
+  /// the data (see above).
   public string Timezone { get { int o = __p.__offset(6); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetTimezoneBytes() { return __p.__vector_as_span(6); }
+  public Span<byte> GetTimezoneBytes() { return __p.__vector_as_span<byte>(6, 1); }
 #else
   public ArraySegment<byte>? GetTimezoneBytes() { return __p.__vector_as_arraysegment(6); }
 #endif
@@ -55,20 +146,31 @@ internal struct Timestamp : IFlatbufferObject
   public static Offset<Timestamp> CreateTimestamp(FlatBufferBuilder builder,
       TimeUnit unit = TimeUnit.SECOND,
       StringOffset timezoneOffset = default(StringOffset)) {
-    builder.StartObject(2);
+    builder.StartTable(2);
     Timestamp.AddTimezone(builder, timezoneOffset);
     Timestamp.AddUnit(builder, unit);
     return Timestamp.EndTimestamp(builder);
   }
 
-  public static void StartTimestamp(FlatBufferBuilder builder) { builder.StartObject(2); }
+  public static void StartTimestamp(FlatBufferBuilder builder) { builder.StartTable(2); }
   public static void AddUnit(FlatBufferBuilder builder, TimeUnit unit) { builder.AddShort(0, (short)unit, 0); }
   public static void AddTimezone(FlatBufferBuilder builder, StringOffset timezoneOffset) { builder.AddOffset(1, timezoneOffset.Value, 0); }
   public static Offset<Timestamp> EndTimestamp(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Timestamp>(o);
   }
-};
+}
+
 
+static internal class TimestampVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Unit*/, 2 /*TimeUnit*/, 2, false)
+      && verifier.VerifyString(tablePos, 6 /*Timezone*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/Union.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/Union.cs
index de2a85a17de0a..9657071efa686 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/Union.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/Union.cs
@@ -6,26 +6,28 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// A union is a complex type with children in Field
 /// By default ids in the type vector refer to the offsets in the children
 /// optionally typeIds provides an indirection between the child offset and the type id
-/// for each child typeIds[offset] is the id used in the type vector
+/// for each child `typeIds[offset]` is the id used in the type vector
 internal struct Union : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Union GetRootAsUnion(ByteBuffer _bb) { return GetRootAsUnion(_bb, new Union()); }
   public static Union GetRootAsUnion(ByteBuffer _bb, Union obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Union __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   public UnionMode Mode { get { int o = __p.__offset(4); return o != 0 ? (UnionMode)__p.bb.GetShort(o + __p.bb_pos) : UnionMode.Sparse; } }
   public int TypeIds(int j) { int o = __p.__offset(6); return o != 0 ? __p.bb.GetInt(__p.__vector(o) + j * 4) : (int)0; }
   public int TypeIdsLength { get { int o = __p.__offset(6); return o != 0 ? __p.__vector_len(o) : 0; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetTypeIdsBytes() { return __p.__vector_as_span(6); }
+  public Span<int> GetTypeIdsBytes() { return __p.__vector_as_span<int>(6, 4); }
 #else
   public ArraySegment<byte>? GetTypeIdsBytes() { return __p.__vector_as_arraysegment(6); }
 #endif
@@ -34,23 +36,36 @@ internal struct Union : IFlatbufferObject
   public static Offset<Union> CreateUnion(FlatBufferBuilder builder,
       UnionMode mode = UnionMode.Sparse,
       VectorOffset typeIdsOffset = default(VectorOffset)) {
-    builder.StartObject(2);
+    builder.StartTable(2);
     Union.AddTypeIds(builder, typeIdsOffset);
     Union.AddMode(builder, mode);
     return Union.EndUnion(builder);
   }
 
-  public static void StartUnion(FlatBufferBuilder builder) { builder.StartObject(2); }
+  public static void StartUnion(FlatBufferBuilder builder) { builder.StartTable(2); }
   public static void AddMode(FlatBufferBuilder builder, UnionMode mode) { builder.AddShort(0, (short)mode, 0); }
   public static void AddTypeIds(FlatBufferBuilder builder, VectorOffset typeIdsOffset) { builder.AddOffset(1, typeIdsOffset.Value, 0); }
   public static VectorOffset CreateTypeIdsVector(FlatBufferBuilder builder, int[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddInt(data[i]); return builder.EndVector(); }
   public static VectorOffset CreateTypeIdsVectorBlock(FlatBufferBuilder builder, int[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateTypeIdsVectorBlock(FlatBufferBuilder builder, ArraySegment<int> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateTypeIdsVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<int>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartTypeIdsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
   public static Offset<Union> EndUnion(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Union>(o);
   }
-};
+}
+
 
+static internal class UnionVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Mode*/, 2 /*UnionMode*/, 2, false)
+      && verifier.VerifyVectorOfData(tablePos, 6 /*TypeIds*/, 4 /*int*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/Utf8.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/Utf8.cs
index e2b80f4070c93..23c0fb4aa8669 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/Utf8.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/Utf8.cs
@@ -6,25 +6,36 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// Unicode with UTF-8 encoding
 internal struct Utf8 : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Utf8 GetRootAsUtf8(ByteBuffer _bb) { return GetRootAsUtf8(_bb, new Utf8()); }
   public static Utf8 GetRootAsUtf8(ByteBuffer _bb, Utf8 obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Utf8 __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
 
-  public static void StartUtf8(FlatBufferBuilder builder) { builder.StartObject(0); }
+  public static void StartUtf8(FlatBufferBuilder builder) { builder.StartTable(0); }
   public static Offset<Utf8> EndUtf8(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Utf8>(o);
   }
-};
+}
+
 
+static internal class Utf8Verify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Ipc/ArrowFileWriter.cs b/csharp/src/Apache.Arrow/Ipc/ArrowFileWriter.cs
index 3d81715036e40..4fefb121cb669 100644
--- a/csharp/src/Apache.Arrow/Ipc/ArrowFileWriter.cs
+++ b/csharp/src/Apache.Arrow/Ipc/ArrowFileWriter.cs
@@ -144,7 +144,7 @@ private void WriteFooter(Schema schema)
 
             // Serialize the schema
 
-            FlatBuffers.Offset<Flatbuf.Schema> schemaOffset = SerializeSchema(schema);
+            Google.FlatBuffers.Offset<Flatbuf.Schema> schemaOffset = SerializeSchema(schema);
 
             // Serialize all record batches
 
@@ -158,18 +158,18 @@ private void WriteFooter(Schema schema)
                     Builder, recordBatch.Offset, recordBatch.MetadataLength, recordBatch.BodyLength);
             }
 
-            FlatBuffers.VectorOffset recordBatchesVectorOffset = Builder.EndVector();
+            Google.FlatBuffers.VectorOffset recordBatchesVectorOffset = Builder.EndVector();
 
             // Serialize all dictionaries
             // NOTE: Currently unsupported.
 
             Flatbuf.Footer.StartDictionariesVector(Builder, 0);
 
-            FlatBuffers.VectorOffset dictionaryBatchesOffset = Builder.EndVector();
+            Google.FlatBuffers.VectorOffset dictionaryBatchesOffset = Builder.EndVector();
 
             // Serialize and write the footer flatbuffer
 
-            FlatBuffers.Offset<Flatbuf.Footer> footerOffset = Flatbuf.Footer.CreateFooter(Builder, CurrentMetadataVersion,
+            Google.FlatBuffers.Offset<Flatbuf.Footer> footerOffset = Flatbuf.Footer.CreateFooter(Builder, CurrentMetadataVersion,
                 schemaOffset, dictionaryBatchesOffset, recordBatchesVectorOffset);
 
             Builder.Finish(footerOffset.Value);
@@ -204,7 +204,7 @@ private async Task WriteFooterAsync(Schema schema, CancellationToken cancellatio
 
             // Serialize the schema
 
-            FlatBuffers.Offset<Flatbuf.Schema> schemaOffset = SerializeSchema(schema);
+            Google.FlatBuffers.Offset<Flatbuf.Schema> schemaOffset = SerializeSchema(schema);
 
             // Serialize all record batches
 
@@ -218,18 +218,18 @@ private async Task WriteFooterAsync(Schema schema, CancellationToken cancellatio
                     Builder, recordBatch.Offset, recordBatch.MetadataLength, recordBatch.BodyLength);
             }
 
-            FlatBuffers.VectorOffset recordBatchesVectorOffset = Builder.EndVector();
+            Google.FlatBuffers.VectorOffset recordBatchesVectorOffset = Builder.EndVector();
 
             // Serialize all dictionaries
             // NOTE: Currently unsupported.
 
             Flatbuf.Footer.StartDictionariesVector(Builder, 0);
 
-            FlatBuffers.VectorOffset dictionaryBatchesOffset = Builder.EndVector();
+            Google.FlatBuffers.VectorOffset dictionaryBatchesOffset = Builder.EndVector();
 
             // Serialize and write the footer flatbuffer
 
-            FlatBuffers.Offset<Flatbuf.Footer> footerOffset = Flatbuf.Footer.CreateFooter(Builder, CurrentMetadataVersion,
+            Google.FlatBuffers.Offset<Flatbuf.Footer> footerOffset = Flatbuf.Footer.CreateFooter(Builder, CurrentMetadataVersion,
                 schemaOffset, dictionaryBatchesOffset, recordBatchesVectorOffset);
 
             Builder.Finish(footerOffset.Value);
diff --git a/csharp/src/Apache.Arrow/Ipc/ArrowMemoryReaderImplementation.cs b/csharp/src/Apache.Arrow/Ipc/ArrowMemoryReaderImplementation.cs
index ce546d422e9b2..af4f963ee520f 100644
--- a/csharp/src/Apache.Arrow/Ipc/ArrowMemoryReaderImplementation.cs
+++ b/csharp/src/Apache.Arrow/Ipc/ArrowMemoryReaderImplementation.cs
@@ -14,7 +14,7 @@
 // limitations under the License.
 
 using Apache.Arrow.Flatbuf;
-using FlatBuffers;
+using Google.FlatBuffers;
 using System;
 using System.Buffers.Binary;
 using System.IO;
diff --git a/csharp/src/Apache.Arrow/Ipc/ArrowReaderImplementation.cs b/csharp/src/Apache.Arrow/Ipc/ArrowReaderImplementation.cs
index ed93000736e0b..62616962077b6 100644
--- a/csharp/src/Apache.Arrow/Ipc/ArrowReaderImplementation.cs
+++ b/csharp/src/Apache.Arrow/Ipc/ArrowReaderImplementation.cs
@@ -13,7 +13,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-using FlatBuffers;
 using System;
 using System.Buffers;
 using System.Collections.Generic;
@@ -24,6 +23,7 @@
 using Apache.Arrow.Flatbuf;
 using Apache.Arrow.Types;
 using Apache.Arrow.Memory;
+using Google.FlatBuffers;
 using Type = System.Type;
 
 namespace Apache.Arrow.Ipc
diff --git a/csharp/src/Apache.Arrow/Ipc/ArrowStreamReaderImplementation.cs b/csharp/src/Apache.Arrow/Ipc/ArrowStreamReaderImplementation.cs
index 8ae8fc49ca5ee..df80ffe1e0fa5 100644
--- a/csharp/src/Apache.Arrow/Ipc/ArrowStreamReaderImplementation.cs
+++ b/csharp/src/Apache.Arrow/Ipc/ArrowStreamReaderImplementation.cs
@@ -86,7 +86,7 @@ await ArrayPool<byte>.Shared.RentReturnAsync(messageLength, async (messageBuff)
                         .ConfigureAwait(false);
                     EnsureFullRead(bodyBuff, bytesRead);
 
-                    FlatBuffers.ByteBuffer bodybb = CreateByteBuffer(bodyBuff);
+                    Google.FlatBuffers.ByteBuffer bodybb = CreateByteBuffer(bodyBuff);
                     result = CreateArrowObjectFromMessage(message, bodybb, bodyBuffOwner);
                 }).ConfigureAwait(false);
             }
@@ -124,7 +124,7 @@ protected RecordBatch ReadRecordBatch()
                     bytesRead = BaseStream.ReadFullBuffer(bodyBuff);
                     EnsureFullRead(bodyBuff, bytesRead);
 
-                    FlatBuffers.ByteBuffer bodybb = CreateByteBuffer(bodyBuff);
+                    Google.FlatBuffers.ByteBuffer bodybb = CreateByteBuffer(bodyBuff);
                     result = CreateArrowObjectFromMessage(message, bodybb, bodyBuffOwner);
                 });
             }
@@ -149,7 +149,7 @@ await ArrayPool<byte>.Shared.RentReturnAsync(schemaMessageLength, async (buff) =
                 int bytesRead = await BaseStream.ReadFullBufferAsync(buff).ConfigureAwait(false);
                 EnsureFullRead(buff, bytesRead);
 
-                FlatBuffers.ByteBuffer schemabb = CreateByteBuffer(buff);
+                Google.FlatBuffers.ByteBuffer schemabb = CreateByteBuffer(buff);
                 Schema = MessageSerializer.GetSchema(ReadMessage<Flatbuf.Schema>(schemabb), ref _dictionaryMemo);
             }).ConfigureAwait(false);
         }
@@ -169,7 +169,7 @@ protected virtual void ReadSchema()
                 int bytesRead = BaseStream.ReadFullBuffer(buff);
                 EnsureFullRead(buff, bytesRead);
 
-                FlatBuffers.ByteBuffer schemabb = CreateByteBuffer(buff);
+                Google.FlatBuffers.ByteBuffer schemabb = CreateByteBuffer(buff);
                 Schema = MessageSerializer.GetSchema(ReadMessage<Flatbuf.Schema>(schemabb), ref _dictionaryMemo);
             });
         }
diff --git a/csharp/src/Apache.Arrow/Ipc/ArrowStreamWriter.cs b/csharp/src/Apache.Arrow/Ipc/ArrowStreamWriter.cs
index 5ffda3dfba6f5..ca567b67e95d1 100644
--- a/csharp/src/Apache.Arrow/Ipc/ArrowStreamWriter.cs
+++ b/csharp/src/Apache.Arrow/Ipc/ArrowStreamWriter.cs
@@ -23,7 +23,7 @@
 using System.Threading.Tasks;
 using Apache.Arrow.Arrays;
 using Apache.Arrow.Types;
-using FlatBuffers;
+using Google.FlatBuffers;
 
 namespace Apache.Arrow.Ipc
 {
diff --git a/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs b/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs
index 400937669e309..befd87c2e0ae0 100644
--- a/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs
+++ b/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs
@@ -16,7 +16,7 @@
 using System;
 using Apache.Arrow.Flatbuf;
 using Apache.Arrow.Types;
-using FlatBuffers;
+using Google.FlatBuffers;
 using DateUnit = Apache.Arrow.Flatbuf.DateUnit;
 using TimeUnit = Apache.Arrow.Types.TimeUnit;
 
diff --git a/csharp/src/Apache.Arrow/Ipc/ReadOnlyMemoryBufferAllocator.cs b/csharp/src/Apache.Arrow/Ipc/ReadOnlyMemoryBufferAllocator.cs
index 7e78fcf9ec994..0f968739c56e6 100644
--- a/csharp/src/Apache.Arrow/Ipc/ReadOnlyMemoryBufferAllocator.cs
+++ b/csharp/src/Apache.Arrow/Ipc/ReadOnlyMemoryBufferAllocator.cs
@@ -13,7 +13,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-using FlatBuffers;
+using Google.FlatBuffers;
 using System;
 
 namespace Apache.Arrow.Ipc