[C#] support Object API (#5710)

* [C#] support Object API * fix sign-compare * fix indent * add new line before for loop. * using auto whenever possible * reduce the amout of blank lines. * wip: support vectors of union * done: support unions of vectors * set C# version to 4.0 * remove null propagation operator * remove auto property initializer * remove expression-bodied method * remove pattern matching * add Example2 to NetTest.sh * separate JavaUsage.md and CsharpUsage.md from JavaCsharpUsage.md * add C# Object based API notes. * support vs2010. * remove range based for loop. * remove System.Linq * fix indent * CreateSharedString to CreateString * check shared attribute * snake case
2026-06-12 07:50:59 +00:00 · 2020-01-31 03:18:28 +09:00
parent c580fa284c
commit 7418d85872
36 changed files with 2548 additions and 107 deletions
--- a/tests/MyGame/Example/Ability.cs
+++ b/tests/MyGame/Example/Ability.cs
@@ -6,6 +6,7 @@ namespace MyGame.Example
 {

 using global::System;
+using global::System.Collections.Generic;
 using global::FlatBuffers;

 public struct Ability : IFlatbufferObject
@@ -26,7 +27,34 @@ public struct Ability : IFlatbufferObject
    builder.PutUint(Id);
    return new Offset<MyGame.Example.Ability>(builder.Offset);
  }
+  public AbilityT UnPack() {
+    var _o = new AbilityT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AbilityT _o) {
+    _o.Id = this.Id;
+    _o.Distance = this.Distance;
+  }
+  public static Offset<MyGame.Example.Ability> Pack(FlatBufferBuilder builder, AbilityT _o) {
+    if (_o == null) return default(Offset<MyGame.Example.Ability>);
+    return CreateAbility(
+      builder,
+      _o.Id,
+      _o.Distance);
+  }
 };

+public class AbilityT
+{
+  public uint Id { get; set; }
+  public uint Distance { get; set; }
+
+  public AbilityT() {
+    this.Id = 0;
+    this.Distance = 0;
+  }
+}
+

 }
--- a/tests/MyGame/Example/Any.cs
+++ b/tests/MyGame/Example/Any.cs
@@ -13,5 +13,29 @@ public enum Any : byte
  MyGame_Example2_Monster = 3,
 };

+public class AnyUnion {
+  public Any Type { get; set; }
+  public object Value { get; set; }
+
+  public AnyUnion() {
+    this.Type = Any.NONE;
+    this.Value = null;
+  }
+
+  public T As<T>() where T : class { return this.Value as T; }
+  public MyGame.Example.MonsterT AsMonster() { return this.As<MyGame.Example.MonsterT>(); }
+  internal MyGame.Example.TestSimpleTableWithEnumT AsTestSimpleTableWithEnum() { return this.As<MyGame.Example.TestSimpleTableWithEnumT>(); }
+  public MyGame.Example2.MonsterT AsMyGame_Example2_Monster() { return this.As<MyGame.Example2.MonsterT>(); }
+
+  public static int Pack(FlatBuffers.FlatBufferBuilder builder, AnyUnion _o) {
+    switch (_o.Type) {
+      default: return 0;
+      case Any.Monster: return MyGame.Example.Monster.Pack(builder, _o.AsMonster()).Value;
+      case Any.TestSimpleTableWithEnum: return MyGame.Example.TestSimpleTableWithEnum.Pack(builder, _o.AsTestSimpleTableWithEnum()).Value;
+      case Any.MyGame_Example2_Monster: return MyGame.Example2.Monster.Pack(builder, _o.AsMyGame_Example2_Monster()).Value;
+    }
+  }
+}
+

 }
--- a/tests/MyGame/Example/AnyAmbiguousAliases.cs
+++ b/tests/MyGame/Example/AnyAmbiguousAliases.cs
@@ -13,5 +13,29 @@ public enum AnyAmbiguousAliases : byte
  M3 = 3,
 };

+public class AnyAmbiguousAliasesUnion {
+  public AnyAmbiguousAliases Type { get; set; }
+  public object Value { get; set; }
+
+  public AnyAmbiguousAliasesUnion() {
+    this.Type = AnyAmbiguousAliases.NONE;
+    this.Value = null;
+  }
+
+  public T As<T>() where T : class { return this.Value as T; }
+  public MyGame.Example.MonsterT AsM1() { return this.As<MyGame.Example.MonsterT>(); }
+  public MyGame.Example.MonsterT AsM2() { return this.As<MyGame.Example.MonsterT>(); }
+  public MyGame.Example.MonsterT AsM3() { return this.As<MyGame.Example.MonsterT>(); }
+
+  public static int Pack(FlatBuffers.FlatBufferBuilder builder, AnyAmbiguousAliasesUnion _o) {
+    switch (_o.Type) {
+      default: return 0;
+      case AnyAmbiguousAliases.M1: return MyGame.Example.Monster.Pack(builder, _o.AsM1()).Value;
+      case AnyAmbiguousAliases.M2: return MyGame.Example.Monster.Pack(builder, _o.AsM2()).Value;
+      case AnyAmbiguousAliases.M3: return MyGame.Example.Monster.Pack(builder, _o.AsM3()).Value;
+    }
+  }
+}
+

 }
--- a/tests/MyGame/Example/AnyUniqueAliases.cs
+++ b/tests/MyGame/Example/AnyUniqueAliases.cs
@@ -13,5 +13,29 @@ public enum AnyUniqueAliases : byte
  M2 = 3,
 };

+public class AnyUniqueAliasesUnion {
+  public AnyUniqueAliases Type { get; set; }
+  public object Value { get; set; }
+
+  public AnyUniqueAliasesUnion() {
+    this.Type = AnyUniqueAliases.NONE;
+    this.Value = null;
+  }
+
+  public T As<T>() where T : class { return this.Value as T; }
+  public MyGame.Example.MonsterT AsM() { return this.As<MyGame.Example.MonsterT>(); }
+  internal MyGame.Example.TestSimpleTableWithEnumT AsTS() { return this.As<MyGame.Example.TestSimpleTableWithEnumT>(); }
+  public MyGame.Example2.MonsterT AsM2() { return this.As<MyGame.Example2.MonsterT>(); }
+
+  public static int Pack(FlatBuffers.FlatBufferBuilder builder, AnyUniqueAliasesUnion _o) {
+    switch (_o.Type) {
+      default: return 0;
+      case AnyUniqueAliases.M: return MyGame.Example.Monster.Pack(builder, _o.AsM()).Value;
+      case AnyUniqueAliases.TS: return MyGame.Example.TestSimpleTableWithEnum.Pack(builder, _o.AsTS()).Value;
+      case AnyUniqueAliases.M2: return MyGame.Example2.Monster.Pack(builder, _o.AsM2()).Value;
+    }
+  }
+}
+

 }
--- a/tests/MyGame/Example/ArrayStruct.cs
+++ b/tests/MyGame/Example/ArrayStruct.cs
@@ -6,6 +6,7 @@ namespace MyGame.Example
 {

 using global::System;
+using global::System.Collections.Generic;
 using global::FlatBuffers;

 public struct ArrayStruct : IFlatbufferObject
@@ -56,7 +57,66 @@ public struct ArrayStruct : IFlatbufferObject
    builder.PutFloat(A);
    return new Offset<MyGame.Example.ArrayStruct>(builder.Offset);
  }
+  public ArrayStructT UnPack() {
+    var _o = new ArrayStructT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(ArrayStructT _o) {
+    _o.A = this.A;
+    _o.B = new int[15];
+    for (var _j = 0; _j < 15; ++_j) { _o.B[_j] = this.B(_j); }
+    _o.C = this.C;
+    _o.D = new MyGame.Example.NestedStructT[2];
+    for (var _j = 0; _j < 2; ++_j) { _o.D[_j] = this.D(_j).UnPack(); }
+    _o.E = this.E;
+    _o.F = new long[2];
+    for (var _j = 0; _j < 2; ++_j) { _o.F[_j] = this.F(_j); }
+  }
+  public static Offset<MyGame.Example.ArrayStruct> Pack(FlatBufferBuilder builder, ArrayStructT _o) {
+    if (_o == null) return default(Offset<MyGame.Example.ArrayStruct>);
+    var _b = _o.B;
+    var _d_a = new int[2,2];
+    for (var idx0 = 0; idx0 < 2; ++idx0) {for (var idx1 = 0; idx1 < 2; ++idx1) {_d_a[idx0,idx1] = _o.D[idx0].A[idx1];}}
+    var _d_b = new MyGame.Example.TestEnum[2];
+    for (var idx0 = 0; idx0 < 2; ++idx0) {_d_b[idx0] = _o.D[idx0].B;}
+    var _d_c = new MyGame.Example.TestEnum[2,2];
+    for (var idx0 = 0; idx0 < 2; ++idx0) {for (var idx1 = 0; idx1 < 2; ++idx1) {_d_c[idx0,idx1] = _o.D[idx0].C[idx1];}}
+    var _d_d = new long[2,2];
+    for (var idx0 = 0; idx0 < 2; ++idx0) {for (var idx1 = 0; idx1 < 2; ++idx1) {_d_d[idx0,idx1] = _o.D[idx0].D[idx1];}}
+    var _f = _o.F;
+    return CreateArrayStruct(
+      builder,
+      _o.A,
+      _b,
+      _o.C,
+      _d_a,
+      _d_b,
+      _d_c,
+      _d_d,
+      _o.E,
+      _f);
+  }
 };

+public class ArrayStructT
+{
+  public float A { get; set; }
+  public int[] B { get; set; }
+  public sbyte C { get; set; }
+  public MyGame.Example.NestedStructT[] D { get; set; }
+  public int E { get; set; }
+  public long[] F { get; set; }
+
+  public ArrayStructT() {
+    this.A = 0.0f;
+    this.B = new int[15];
+    this.C = 0;
+    this.D = new MyGame.Example.NestedStructT[2];
+    this.E = 0;
+    this.F = new long[2];
+  }
+}
+

 }
--- a/tests/MyGame/Example/ArrayTable.cs
+++ b/tests/MyGame/Example/ArrayTable.cs
@@ -6,6 +6,7 @@ namespace MyGame.Example
 {

 using global::System;
+using global::System.Collections.Generic;
 using global::FlatBuffers;

 public struct ArrayTable : IFlatbufferObject
@@ -29,7 +30,30 @@ public struct ArrayTable : IFlatbufferObject
  }
  public static void FinishArrayTableBuffer(FlatBufferBuilder builder, Offset<MyGame.Example.ArrayTable> offset) { builder.Finish(offset.Value, "ARRT"); }
  public static void FinishSizePrefixedArrayTableBuffer(FlatBufferBuilder builder, Offset<MyGame.Example.ArrayTable> offset) { builder.FinishSizePrefixed(offset.Value, "ARRT"); }
+  public ArrayTableT UnPack() {
+    var _o = new ArrayTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(ArrayTableT _o) {
+    _o.A = this.A.HasValue ? this.A.Value.UnPack() : null;
+  }
+  public static Offset<MyGame.Example.ArrayTable> Pack(FlatBufferBuilder builder, ArrayTableT _o) {
+    if (_o == null) return default(Offset<MyGame.Example.ArrayTable>);
+    StartArrayTable(builder);
+    AddA(builder, MyGame.Example.ArrayStruct.Pack(builder, _o.A));
+    return EndArrayTable(builder);
+  }
 };

+public class ArrayTableT
+{
+  public MyGame.Example.ArrayStructT A { get; set; }
+
+  public ArrayTableT() {
+    this.A = new MyGame.Example.ArrayStructT();
+  }
+}
+

 }
--- a/tests/MyGame/Example/Monster.cs
+++ b/tests/MyGame/Example/Monster.cs
@@ -6,6 +6,7 @@ namespace MyGame.Example
 {

 using global::System;
+using global::System.Collections.Generic;
 using global::FlatBuffers;

 /// an example documentation comment: monster object
@@ -318,7 +319,374 @@ public struct Monster : IFlatbufferObject
    }
    return null;
  }
+  public MonsterT UnPack() {
+    var _o = new MonsterT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(MonsterT _o) {
+    _o.Pos = this.Pos.HasValue ? this.Pos.Value.UnPack() : null;
+    _o.Mana = this.Mana;
+    _o.Hp = this.Hp;
+    _o.Name = this.Name;
+    _o.Inventory = new List<byte>();
+    for (var _j = 0; _j < this.InventoryLength; ++_j) {_o.Inventory.Add(this.Inventory(_j));}
+    _o.Color = this.Color;
+    _o.Test = new MyGame.Example.AnyUnion();
+    _o.Test.Type = this.TestType;
+    switch (this.TestType) {
+      default: break;
+      case MyGame.Example.Any.Monster:
+        _o.Test.Value = this.Test<MyGame.Example.Monster>().HasValue ? this.Test<MyGame.Example.Monster>().Value.UnPack() : null;
+        break;
+      case MyGame.Example.Any.TestSimpleTableWithEnum:
+        _o.Test.Value = this.Test<MyGame.Example.TestSimpleTableWithEnum>().HasValue ? this.Test<MyGame.Example.TestSimpleTableWithEnum>().Value.UnPack() : null;
+        break;
+      case MyGame.Example.Any.MyGame_Example2_Monster:
+        _o.Test.Value = this.Test<MyGame.Example2.Monster>().HasValue ? this.Test<MyGame.Example2.Monster>().Value.UnPack() : null;
+        break;
+    }
+    _o.Test4 = new List<MyGame.Example.TestT>();
+    for (var _j = 0; _j < this.Test4Length; ++_j) {_o.Test4.Add(this.Test4(_j).HasValue ? this.Test4(_j).Value.UnPack() : null);}
+    _o.Testarrayofstring = new List<string>();
+    for (var _j = 0; _j < this.TestarrayofstringLength; ++_j) {_o.Testarrayofstring.Add(this.Testarrayofstring(_j));}
+    _o.Testarrayoftables = new List<MyGame.Example.MonsterT>();
+    for (var _j = 0; _j < this.TestarrayoftablesLength; ++_j) {_o.Testarrayoftables.Add(this.Testarrayoftables(_j).HasValue ? this.Testarrayoftables(_j).Value.UnPack() : null);}
+    _o.Enemy = this.Enemy.HasValue ? this.Enemy.Value.UnPack() : null;
+    _o.Testnestedflatbuffer = new List<byte>();
+    for (var _j = 0; _j < this.TestnestedflatbufferLength; ++_j) {_o.Testnestedflatbuffer.Add(this.Testnestedflatbuffer(_j));}
+    _o.Testempty = this.Testempty.HasValue ? this.Testempty.Value.UnPack() : null;
+    _o.Testbool = this.Testbool;
+    _o.Testhashs32Fnv1 = this.Testhashs32Fnv1;
+    _o.Testhashu32Fnv1 = this.Testhashu32Fnv1;
+    _o.Testhashs64Fnv1 = this.Testhashs64Fnv1;
+    _o.Testhashu64Fnv1 = this.Testhashu64Fnv1;
+    _o.Testhashs32Fnv1a = this.Testhashs32Fnv1a;
+    _o.Testhashu32Fnv1a = this.Testhashu32Fnv1a;
+    _o.Testhashs64Fnv1a = this.Testhashs64Fnv1a;
+    _o.Testhashu64Fnv1a = this.Testhashu64Fnv1a;
+    _o.Testarrayofbools = new List<bool>();
+    for (var _j = 0; _j < this.TestarrayofboolsLength; ++_j) {_o.Testarrayofbools.Add(this.Testarrayofbools(_j));}
+    _o.Testf = this.Testf;
+    _o.Testf2 = this.Testf2;
+    _o.Testf3 = this.Testf3;
+    _o.Testarrayofstring2 = new List<string>();
+    for (var _j = 0; _j < this.Testarrayofstring2Length; ++_j) {_o.Testarrayofstring2.Add(this.Testarrayofstring2(_j));}
+    _o.Testarrayofsortedstruct = new List<MyGame.Example.AbilityT>();
+    for (var _j = 0; _j < this.TestarrayofsortedstructLength; ++_j) {_o.Testarrayofsortedstruct.Add(this.Testarrayofsortedstruct(_j).HasValue ? this.Testarrayofsortedstruct(_j).Value.UnPack() : null);}
+    _o.Flex = new List<byte>();
+    for (var _j = 0; _j < this.FlexLength; ++_j) {_o.Flex.Add(this.Flex(_j));}
+    _o.Test5 = new List<MyGame.Example.TestT>();
+    for (var _j = 0; _j < this.Test5Length; ++_j) {_o.Test5.Add(this.Test5(_j).HasValue ? this.Test5(_j).Value.UnPack() : null);}
+    _o.VectorOfLongs = new List<long>();
+    for (var _j = 0; _j < this.VectorOfLongsLength; ++_j) {_o.VectorOfLongs.Add(this.VectorOfLongs(_j));}
+    _o.VectorOfDoubles = new List<double>();
+    for (var _j = 0; _j < this.VectorOfDoublesLength; ++_j) {_o.VectorOfDoubles.Add(this.VectorOfDoubles(_j));}
+    _o.ParentNamespaceTest = this.ParentNamespaceTest.HasValue ? this.ParentNamespaceTest.Value.UnPack() : null;
+    _o.VectorOfReferrables = new List<MyGame.Example.ReferrableT>();
+    for (var _j = 0; _j < this.VectorOfReferrablesLength; ++_j) {_o.VectorOfReferrables.Add(this.VectorOfReferrables(_j).HasValue ? this.VectorOfReferrables(_j).Value.UnPack() : null);}
+    _o.SingleWeakReference = this.SingleWeakReference;
+    _o.VectorOfWeakReferences = new List<ulong>();
+    for (var _j = 0; _j < this.VectorOfWeakReferencesLength; ++_j) {_o.VectorOfWeakReferences.Add(this.VectorOfWeakReferences(_j));}
+    _o.VectorOfStrongReferrables = new List<MyGame.Example.ReferrableT>();
+    for (var _j = 0; _j < this.VectorOfStrongReferrablesLength; ++_j) {_o.VectorOfStrongReferrables.Add(this.VectorOfStrongReferrables(_j).HasValue ? this.VectorOfStrongReferrables(_j).Value.UnPack() : null);}
+    _o.CoOwningReference = this.CoOwningReference;
+    _o.VectorOfCoOwningReferences = new List<ulong>();
+    for (var _j = 0; _j < this.VectorOfCoOwningReferencesLength; ++_j) {_o.VectorOfCoOwningReferences.Add(this.VectorOfCoOwningReferences(_j));}
+    _o.NonOwningReference = this.NonOwningReference;
+    _o.VectorOfNonOwningReferences = new List<ulong>();
+    for (var _j = 0; _j < this.VectorOfNonOwningReferencesLength; ++_j) {_o.VectorOfNonOwningReferences.Add(this.VectorOfNonOwningReferences(_j));}
+    _o.AnyUnique = new MyGame.Example.AnyUniqueAliasesUnion();
+    _o.AnyUnique.Type = this.AnyUniqueType;
+    switch (this.AnyUniqueType) {
+      default: break;
+      case MyGame.Example.AnyUniqueAliases.M:
+        _o.AnyUnique.Value = this.AnyUnique<MyGame.Example.Monster>().HasValue ? this.AnyUnique<MyGame.Example.Monster>().Value.UnPack() : null;
+        break;
+      case MyGame.Example.AnyUniqueAliases.TS:
+        _o.AnyUnique.Value = this.AnyUnique<MyGame.Example.TestSimpleTableWithEnum>().HasValue ? this.AnyUnique<MyGame.Example.TestSimpleTableWithEnum>().Value.UnPack() : null;
+        break;
+      case MyGame.Example.AnyUniqueAliases.M2:
+        _o.AnyUnique.Value = this.AnyUnique<MyGame.Example2.Monster>().HasValue ? this.AnyUnique<MyGame.Example2.Monster>().Value.UnPack() : null;
+        break;
+    }
+    _o.AnyAmbiguous = new MyGame.Example.AnyAmbiguousAliasesUnion();
+    _o.AnyAmbiguous.Type = this.AnyAmbiguousType;
+    switch (this.AnyAmbiguousType) {
+      default: break;
+      case MyGame.Example.AnyAmbiguousAliases.M1:
+        _o.AnyAmbiguous.Value = this.AnyAmbiguous<MyGame.Example.Monster>().HasValue ? this.AnyAmbiguous<MyGame.Example.Monster>().Value.UnPack() : null;
+        break;
+      case MyGame.Example.AnyAmbiguousAliases.M2:
+        _o.AnyAmbiguous.Value = this.AnyAmbiguous<MyGame.Example.Monster>().HasValue ? this.AnyAmbiguous<MyGame.Example.Monster>().Value.UnPack() : null;
+        break;
+      case MyGame.Example.AnyAmbiguousAliases.M3:
+        _o.AnyAmbiguous.Value = this.AnyAmbiguous<MyGame.Example.Monster>().HasValue ? this.AnyAmbiguous<MyGame.Example.Monster>().Value.UnPack() : null;
+        break;
+    }
+    _o.VectorOfEnums = new List<MyGame.Example.Color>();
+    for (var _j = 0; _j < this.VectorOfEnumsLength; ++_j) {_o.VectorOfEnums.Add(this.VectorOfEnums(_j));}
+    _o.SignedEnum = this.SignedEnum;
+  }
+  public static Offset<MyGame.Example.Monster> Pack(FlatBufferBuilder builder, MonsterT _o) {
+    if (_o == null) return default(Offset<MyGame.Example.Monster>);
+    var _name = _o.Name == null ? default(StringOffset) : builder.CreateString(_o.Name);
+    var _inventory = default(VectorOffset);
+    if (_o.Inventory != null) {
+      var __inventory = _o.Inventory.ToArray();
+      _inventory = CreateInventoryVector(builder, __inventory);
+    }
+    var _test_type = _o.Test == null ? MyGame.Example.Any.NONE : _o.Test.Type;
+    var _test = _o.Test == null ? 0 : MyGame.Example.AnyUnion.Pack(builder, _o.Test);
+    var _test4 = default(VectorOffset);
+    if (_o.Test4 != null) {
+      StartTest4Vector(builder, _o.Test4.Count);
+      for (var _j = _o.Test4.Count - 1; _j >= 0; --_j) { MyGame.Example.Test.Pack(builder, _o.Test4[_j]); }
+      _test4 = builder.EndVector();
+    }
+    var _testarrayofstring = default(VectorOffset);
+    if (_o.Testarrayofstring != null) {
+      var __testarrayofstring = new StringOffset[_o.Testarrayofstring.Count];
+      for (var _j = 0; _j < __testarrayofstring.Length; ++_j) { __testarrayofstring[_j] = builder.CreateString(_o.Testarrayofstring[_j]); }
+      _testarrayofstring = CreateTestarrayofstringVector(builder, __testarrayofstring);
+    }
+    var _testarrayoftables = default(VectorOffset);
+    if (_o.Testarrayoftables != null) {
+      var __testarrayoftables = new Offset<MyGame.Example.Monster>[_o.Testarrayoftables.Count];
+      for (var _j = 0; _j < __testarrayoftables.Length; ++_j) { __testarrayoftables[_j] = MyGame.Example.Monster.Pack(builder, _o.Testarrayoftables[_j]); }
+      _testarrayoftables = CreateTestarrayoftablesVector(builder, __testarrayoftables);
+    }
+    var _enemy = _o.Enemy == null ? default(Offset<MyGame.Example.Monster>) : MyGame.Example.Monster.Pack(builder, _o.Enemy);
+    var _testnestedflatbuffer = default(VectorOffset);
+    if (_o.Testnestedflatbuffer != null) {
+      var __testnestedflatbuffer = _o.Testnestedflatbuffer.ToArray();
+      _testnestedflatbuffer = CreateTestnestedflatbufferVector(builder, __testnestedflatbuffer);
+    }
+    var _testempty = _o.Testempty == null ? default(Offset<MyGame.Example.Stat>) : MyGame.Example.Stat.Pack(builder, _o.Testempty);
+    var _testarrayofbools = default(VectorOffset);
+    if (_o.Testarrayofbools != null) {
+      var __testarrayofbools = _o.Testarrayofbools.ToArray();
+      _testarrayofbools = CreateTestarrayofboolsVector(builder, __testarrayofbools);
+    }
+    var _testarrayofstring2 = default(VectorOffset);
+    if (_o.Testarrayofstring2 != null) {
+      var __testarrayofstring2 = new StringOffset[_o.Testarrayofstring2.Count];
+      for (var _j = 0; _j < __testarrayofstring2.Length; ++_j) { __testarrayofstring2[_j] = builder.CreateString(_o.Testarrayofstring2[_j]); }
+      _testarrayofstring2 = CreateTestarrayofstring2Vector(builder, __testarrayofstring2);
+    }
+    var _testarrayofsortedstruct = default(VectorOffset);
+    if (_o.Testarrayofsortedstruct != null) {
+      StartTestarrayofsortedstructVector(builder, _o.Testarrayofsortedstruct.Count);
+      for (var _j = _o.Testarrayofsortedstruct.Count - 1; _j >= 0; --_j) { MyGame.Example.Ability.Pack(builder, _o.Testarrayofsortedstruct[_j]); }
+      _testarrayofsortedstruct = builder.EndVector();
+    }
+    var _flex = default(VectorOffset);
+    if (_o.Flex != null) {
+      var __flex = _o.Flex.ToArray();
+      _flex = CreateFlexVector(builder, __flex);
+    }
+    var _test5 = default(VectorOffset);
+    if (_o.Test5 != null) {
+      StartTest5Vector(builder, _o.Test5.Count);
+      for (var _j = _o.Test5.Count - 1; _j >= 0; --_j) { MyGame.Example.Test.Pack(builder, _o.Test5[_j]); }
+      _test5 = builder.EndVector();
+    }
+    var _vector_of_longs = default(VectorOffset);
+    if (_o.VectorOfLongs != null) {
+      var __vector_of_longs = _o.VectorOfLongs.ToArray();
+      _vector_of_longs = CreateVectorOfLongsVector(builder, __vector_of_longs);
+    }
+    var _vector_of_doubles = default(VectorOffset);
+    if (_o.VectorOfDoubles != null) {
+      var __vector_of_doubles = _o.VectorOfDoubles.ToArray();
+      _vector_of_doubles = CreateVectorOfDoublesVector(builder, __vector_of_doubles);
+    }
+    var _parent_namespace_test = _o.ParentNamespaceTest == null ? default(Offset<MyGame.InParentNamespace>) : MyGame.InParentNamespace.Pack(builder, _o.ParentNamespaceTest);
+    var _vector_of_referrables = default(VectorOffset);
+    if (_o.VectorOfReferrables != null) {
+      var __vector_of_referrables = new Offset<MyGame.Example.Referrable>[_o.VectorOfReferrables.Count];
+      for (var _j = 0; _j < __vector_of_referrables.Length; ++_j) { __vector_of_referrables[_j] = MyGame.Example.Referrable.Pack(builder, _o.VectorOfReferrables[_j]); }
+      _vector_of_referrables = CreateVectorOfReferrablesVector(builder, __vector_of_referrables);
+    }
+    var _vector_of_weak_references = default(VectorOffset);
+    if (_o.VectorOfWeakReferences != null) {
+      var __vector_of_weak_references = _o.VectorOfWeakReferences.ToArray();
+      _vector_of_weak_references = CreateVectorOfWeakReferencesVector(builder, __vector_of_weak_references);
+    }
+    var _vector_of_strong_referrables = default(VectorOffset);
+    if (_o.VectorOfStrongReferrables != null) {
+      var __vector_of_strong_referrables = new Offset<MyGame.Example.Referrable>[_o.VectorOfStrongReferrables.Count];
+      for (var _j = 0; _j < __vector_of_strong_referrables.Length; ++_j) { __vector_of_strong_referrables[_j] = MyGame.Example.Referrable.Pack(builder, _o.VectorOfStrongReferrables[_j]); }
+      _vector_of_strong_referrables = CreateVectorOfStrongReferrablesVector(builder, __vector_of_strong_referrables);
+    }
+    var _vector_of_co_owning_references = default(VectorOffset);
+    if (_o.VectorOfCoOwningReferences != null) {
+      var __vector_of_co_owning_references = _o.VectorOfCoOwningReferences.ToArray();
+      _vector_of_co_owning_references = CreateVectorOfCoOwningReferencesVector(builder, __vector_of_co_owning_references);
+    }
+    var _vector_of_non_owning_references = default(VectorOffset);
+    if (_o.VectorOfNonOwningReferences != null) {
+      var __vector_of_non_owning_references = _o.VectorOfNonOwningReferences.ToArray();
+      _vector_of_non_owning_references = CreateVectorOfNonOwningReferencesVector(builder, __vector_of_non_owning_references);
+    }
+    var _any_unique_type = _o.AnyUnique == null ? MyGame.Example.AnyUniqueAliases.NONE : _o.AnyUnique.Type;
+    var _any_unique = _o.AnyUnique == null ? 0 : MyGame.Example.AnyUniqueAliasesUnion.Pack(builder, _o.AnyUnique);
+    var _any_ambiguous_type = _o.AnyAmbiguous == null ? MyGame.Example.AnyAmbiguousAliases.NONE : _o.AnyAmbiguous.Type;
+    var _any_ambiguous = _o.AnyAmbiguous == null ? 0 : MyGame.Example.AnyAmbiguousAliasesUnion.Pack(builder, _o.AnyAmbiguous);
+    var _vector_of_enums = default(VectorOffset);
+    if (_o.VectorOfEnums != null) {
+      var __vector_of_enums = _o.VectorOfEnums.ToArray();
+      _vector_of_enums = CreateVectorOfEnumsVector(builder, __vector_of_enums);
+    }
+    StartMonster(builder);
+    AddPos(builder, MyGame.Example.Vec3.Pack(builder, _o.Pos));
+    AddMana(builder, _o.Mana);
+    AddHp(builder, _o.Hp);
+    AddName(builder, _name);
+    AddInventory(builder, _inventory);
+    AddColor(builder, _o.Color);
+    AddTestType(builder, _test_type);
+    AddTest(builder, _test);
+    AddTest4(builder, _test4);
+    AddTestarrayofstring(builder, _testarrayofstring);
+    AddTestarrayoftables(builder, _testarrayoftables);
+    AddEnemy(builder, _enemy);
+    AddTestnestedflatbuffer(builder, _testnestedflatbuffer);
+    AddTestempty(builder, _testempty);
+    AddTestbool(builder, _o.Testbool);
+    AddTesthashs32Fnv1(builder, _o.Testhashs32Fnv1);
+    AddTesthashu32Fnv1(builder, _o.Testhashu32Fnv1);
+    AddTesthashs64Fnv1(builder, _o.Testhashs64Fnv1);
+    AddTesthashu64Fnv1(builder, _o.Testhashu64Fnv1);
+    AddTesthashs32Fnv1a(builder, _o.Testhashs32Fnv1a);
+    AddTesthashu32Fnv1a(builder, _o.Testhashu32Fnv1a);
+    AddTesthashs64Fnv1a(builder, _o.Testhashs64Fnv1a);
+    AddTesthashu64Fnv1a(builder, _o.Testhashu64Fnv1a);
+    AddTestarrayofbools(builder, _testarrayofbools);
+    AddTestf(builder, _o.Testf);
+    AddTestf2(builder, _o.Testf2);
+    AddTestf3(builder, _o.Testf3);
+    AddTestarrayofstring2(builder, _testarrayofstring2);
+    AddTestarrayofsortedstruct(builder, _testarrayofsortedstruct);
+    AddFlex(builder, _flex);
+    AddTest5(builder, _test5);
+    AddVectorOfLongs(builder, _vector_of_longs);
+    AddVectorOfDoubles(builder, _vector_of_doubles);
+    AddParentNamespaceTest(builder, _parent_namespace_test);
+    AddVectorOfReferrables(builder, _vector_of_referrables);
+    AddSingleWeakReference(builder, _o.SingleWeakReference);
+    AddVectorOfWeakReferences(builder, _vector_of_weak_references);
+    AddVectorOfStrongReferrables(builder, _vector_of_strong_referrables);
+    AddCoOwningReference(builder, _o.CoOwningReference);
+    AddVectorOfCoOwningReferences(builder, _vector_of_co_owning_references);
+    AddNonOwningReference(builder, _o.NonOwningReference);
+    AddVectorOfNonOwningReferences(builder, _vector_of_non_owning_references);
+    AddAnyUniqueType(builder, _any_unique_type);
+    AddAnyUnique(builder, _any_unique);
+    AddAnyAmbiguousType(builder, _any_ambiguous_type);
+    AddAnyAmbiguous(builder, _any_ambiguous);
+    AddVectorOfEnums(builder, _vector_of_enums);
+    AddSignedEnum(builder, _o.SignedEnum);
+    return EndMonster(builder);
+  }
 };

+public class MonsterT
+{
+  public MyGame.Example.Vec3T Pos { get; set; }
+  public short Mana { get; set; }
+  public short Hp { get; set; }
+  public string Name { get; set; }
+  public List<byte> Inventory { get; set; }
+  public MyGame.Example.Color Color { get; set; }
+  public MyGame.Example.AnyUnion Test { get; set; }
+  public List<MyGame.Example.TestT> Test4 { get; set; }
+  public List<string> Testarrayofstring { get; set; }
+  public List<MyGame.Example.MonsterT> Testarrayoftables { get; set; }
+  public MyGame.Example.MonsterT Enemy { get; set; }
+  public List<byte> Testnestedflatbuffer { get; set; }
+  public MyGame.Example.StatT Testempty { get; set; }
+  public bool Testbool { get; set; }
+  public int Testhashs32Fnv1 { get; set; }
+  public uint Testhashu32Fnv1 { get; set; }
+  public long Testhashs64Fnv1 { get; set; }
+  public ulong Testhashu64Fnv1 { get; set; }
+  public int Testhashs32Fnv1a { get; set; }
+  public uint Testhashu32Fnv1a { get; set; }
+  public long Testhashs64Fnv1a { get; set; }
+  public ulong Testhashu64Fnv1a { get; set; }
+  public List<bool> Testarrayofbools { get; set; }
+  public float Testf { get; set; }
+  public float Testf2 { get; set; }
+  public float Testf3 { get; set; }
+  public List<string> Testarrayofstring2 { get; set; }
+  public List<MyGame.Example.AbilityT> Testarrayofsortedstruct { get; set; }
+  public List<byte> Flex { get; set; }
+  public List<MyGame.Example.TestT> Test5 { get; set; }
+  public List<long> VectorOfLongs { get; set; }
+  public List<double> VectorOfDoubles { get; set; }
+  public MyGame.InParentNamespaceT ParentNamespaceTest { get; set; }
+  public List<MyGame.Example.ReferrableT> VectorOfReferrables { get; set; }
+  public ulong SingleWeakReference { get; set; }
+  public List<ulong> VectorOfWeakReferences { get; set; }
+  public List<MyGame.Example.ReferrableT> VectorOfStrongReferrables { get; set; }
+  public ulong CoOwningReference { get; set; }
+  public List<ulong> VectorOfCoOwningReferences { get; set; }
+  public ulong NonOwningReference { get; set; }
+  public List<ulong> VectorOfNonOwningReferences { get; set; }
+  public MyGame.Example.AnyUniqueAliasesUnion AnyUnique { get; set; }
+  public MyGame.Example.AnyAmbiguousAliasesUnion AnyAmbiguous { get; set; }
+  public List<MyGame.Example.Color> VectorOfEnums { get; set; }
+  public MyGame.Example.Race SignedEnum { get; set; }
+
+  public MonsterT() {
+    this.Pos = new MyGame.Example.Vec3T();
+    this.Mana = 150;
+    this.Hp = 100;
+    this.Name = null;
+    this.Inventory = null;
+    this.Color = MyGame.Example.Color.Blue;
+    this.Test = null;
+    this.Test4 = null;
+    this.Testarrayofstring = null;
+    this.Testarrayoftables = null;
+    this.Enemy = null;
+    this.Testnestedflatbuffer = null;
+    this.Testempty = null;
+    this.Testbool = false;
+    this.Testhashs32Fnv1 = 0;
+    this.Testhashu32Fnv1 = 0;
+    this.Testhashs64Fnv1 = 0;
+    this.Testhashu64Fnv1 = 0;
+    this.Testhashs32Fnv1a = 0;
+    this.Testhashu32Fnv1a = 0;
+    this.Testhashs64Fnv1a = 0;
+    this.Testhashu64Fnv1a = 0;
+    this.Testarrayofbools = null;
+    this.Testf = 3.14159f;
+    this.Testf2 = 3.0f;
+    this.Testf3 = 0.0f;
+    this.Testarrayofstring2 = null;
+    this.Testarrayofsortedstruct = null;
+    this.Flex = null;
+    this.Test5 = null;
+    this.VectorOfLongs = null;
+    this.VectorOfDoubles = null;
+    this.ParentNamespaceTest = null;
+    this.VectorOfReferrables = null;
+    this.SingleWeakReference = 0;
+    this.VectorOfWeakReferences = null;
+    this.VectorOfStrongReferrables = null;
+    this.CoOwningReference = 0;
+    this.VectorOfCoOwningReferences = null;
+    this.NonOwningReference = 0;
+    this.VectorOfNonOwningReferences = null;
+    this.AnyUnique = null;
+    this.AnyAmbiguous = null;
+    this.VectorOfEnums = null;
+    this.SignedEnum = MyGame.Example.Race.None;
+  }
+}
+

 }
--- a/tests/MyGame/Example/NestedStruct.cs
+++ b/tests/MyGame/Example/NestedStruct.cs
@@ -6,6 +6,7 @@ namespace MyGame.Example
 {

 using global::System;
+using global::System.Collections.Generic;
 using global::FlatBuffers;

 public struct NestedStruct : IFlatbufferObject
@@ -39,7 +40,48 @@ public struct NestedStruct : IFlatbufferObject
    }
    return new Offset<MyGame.Example.NestedStruct>(builder.Offset);
  }
+  public NestedStructT UnPack() {
+    var _o = new NestedStructT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(NestedStructT _o) {
+    _o.A = new int[2];
+    for (var _j = 0; _j < 2; ++_j) { _o.A[_j] = this.A(_j); }
+    _o.B = this.B;
+    _o.C = new MyGame.Example.TestEnum[2];
+    for (var _j = 0; _j < 2; ++_j) { _o.C[_j] = this.C(_j); }
+    _o.D = new long[2];
+    for (var _j = 0; _j < 2; ++_j) { _o.D[_j] = this.D(_j); }
+  }
+  public static Offset<MyGame.Example.NestedStruct> Pack(FlatBufferBuilder builder, NestedStructT _o) {
+    if (_o == null) return default(Offset<MyGame.Example.NestedStruct>);
+    var _a = _o.A;
+    var _c = _o.C;
+    var _d = _o.D;
+    return CreateNestedStruct(
+      builder,
+      _a,
+      _o.B,
+      _c,
+      _d);
+  }
 };

+public class NestedStructT
+{
+  public int[] A { get; set; }
+  public MyGame.Example.TestEnum B { get; set; }
+  public MyGame.Example.TestEnum[] C { get; set; }
+  public long[] D { get; set; }
+
+  public NestedStructT() {
+    this.A = new int[2];
+    this.B = MyGame.Example.TestEnum.A;
+    this.C = new MyGame.Example.TestEnum[2];
+    this.D = new long[2];
+  }
+}
+

 }
--- a/tests/MyGame/Example/Referrable.cs
+++ b/tests/MyGame/Example/Referrable.cs
@@ -6,6 +6,7 @@ namespace MyGame.Example
 {

 using global::System;
+using global::System.Collections.Generic;
 using global::FlatBuffers;

 public struct Referrable : IFlatbufferObject
@@ -59,7 +60,30 @@ public struct Referrable : IFlatbufferObject
    }
    return null;
  }
+  public ReferrableT UnPack() {
+    var _o = new ReferrableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(ReferrableT _o) {
+    _o.Id = this.Id;
+  }
+  public static Offset<MyGame.Example.Referrable> Pack(FlatBufferBuilder builder, ReferrableT _o) {
+    if (_o == null) return default(Offset<MyGame.Example.Referrable>);
+    return CreateReferrable(
+      builder,
+      _o.Id);
+  }
 };

+public class ReferrableT
+{
+  public ulong Id { get; set; }
+
+  public ReferrableT() {
+    this.Id = 0;
+  }
+}
+

 }
--- a/tests/MyGame/Example/Stat.cs
+++ b/tests/MyGame/Example/Stat.cs
@@ -6,6 +6,7 @@ namespace MyGame.Example
 {

 using global::System;
+using global::System.Collections.Generic;
 using global::FlatBuffers;

 public struct Stat : IFlatbufferObject
@@ -49,7 +50,39 @@ public struct Stat : IFlatbufferObject
    int o = builder.EndTable();
    return new Offset<MyGame.Example.Stat>(o);
  }
+  public StatT UnPack() {
+    var _o = new StatT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(StatT _o) {
+    _o.Id = this.Id;
+    _o.Val = this.Val;
+    _o.Count = this.Count;
+  }
+  public static Offset<MyGame.Example.Stat> Pack(FlatBufferBuilder builder, StatT _o) {
+    if (_o == null) return default(Offset<MyGame.Example.Stat>);
+    var _id = _o.Id == null ? default(StringOffset) : builder.CreateString(_o.Id);
+    return CreateStat(
+      builder,
+      _id,
+      _o.Val,
+      _o.Count);
+  }
 };

+public class StatT
+{
+  public string Id { get; set; }
+  public long Val { get; set; }
+  public ushort Count { get; set; }
+
+  public StatT() {
+    this.Id = null;
+    this.Val = 0;
+    this.Count = 0;
+  }
+}
+

 }
--- a/tests/MyGame/Example/Test.cs
+++ b/tests/MyGame/Example/Test.cs
@@ -6,6 +6,7 @@ namespace MyGame.Example
 {

 using global::System;
+using global::System.Collections.Generic;
 using global::FlatBuffers;

 public struct Test : IFlatbufferObject
@@ -27,7 +28,34 @@ public struct Test : IFlatbufferObject
    builder.PutShort(A);
    return new Offset<MyGame.Example.Test>(builder.Offset);
  }
+  public TestT UnPack() {
+    var _o = new TestT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(TestT _o) {
+    _o.A = this.A;
+    _o.B = this.B;
+  }
+  public static Offset<MyGame.Example.Test> Pack(FlatBufferBuilder builder, TestT _o) {
+    if (_o == null) return default(Offset<MyGame.Example.Test>);
+    return CreateTest(
+      builder,
+      _o.A,
+      _o.B);
+  }
 };

+public class TestT
+{
+  public short A { get; set; }
+  public sbyte B { get; set; }
+
+  public TestT() {
+    this.A = 0;
+    this.B = 0;
+  }
+}
+

 }
--- a/tests/MyGame/Example/TestSimpleTableWithEnum.cs
+++ b/tests/MyGame/Example/TestSimpleTableWithEnum.cs
@@ -6,6 +6,7 @@ namespace MyGame.Example
 {

 using global::System;
+using global::System.Collections.Generic;
 using global::FlatBuffers;

 internal partial struct TestSimpleTableWithEnum : IFlatbufferObject
@@ -34,7 +35,30 @@ internal partial struct TestSimpleTableWithEnum : IFlatbufferObject
    int o = builder.EndTable();
    return new Offset<MyGame.Example.TestSimpleTableWithEnum>(o);
  }
+  public TestSimpleTableWithEnumT UnPack() {
+    var _o = new TestSimpleTableWithEnumT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(TestSimpleTableWithEnumT _o) {
+    _o.Color = this.Color;
+  }
+  public static Offset<MyGame.Example.TestSimpleTableWithEnum> Pack(FlatBufferBuilder builder, TestSimpleTableWithEnumT _o) {
+    if (_o == null) return default(Offset<MyGame.Example.TestSimpleTableWithEnum>);
+    return CreateTestSimpleTableWithEnum(
+      builder,
+      _o.Color);
+  }
 };

+internal partial class TestSimpleTableWithEnumT
+{
+  public MyGame.Example.Color Color { get; set; }
+
+  public TestSimpleTableWithEnumT() {
+    this.Color = MyGame.Example.Color.Green;
+  }
+}
+

 }
--- a/tests/MyGame/Example/TypeAliases.cs
+++ b/tests/MyGame/Example/TypeAliases.cs
@@ -6,6 +6,7 @@ namespace MyGame.Example
 {

 using global::System;
+using global::System.Collections.Generic;
 using global::FlatBuffers;

 public struct TypeAliases : IFlatbufferObject
@@ -109,7 +110,86 @@ public struct TypeAliases : IFlatbufferObject
    int o = builder.EndTable();
    return new Offset<MyGame.Example.TypeAliases>(o);
  }
+  public TypeAliasesT UnPack() {
+    var _o = new TypeAliasesT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(TypeAliasesT _o) {
+    _o.I8 = this.I8;
+    _o.U8 = this.U8;
+    _o.I16 = this.I16;
+    _o.U16 = this.U16;
+    _o.I32 = this.I32;
+    _o.U32 = this.U32;
+    _o.I64 = this.I64;
+    _o.U64 = this.U64;
+    _o.F32 = this.F32;
+    _o.F64 = this.F64;
+    _o.V8 = new List<sbyte>();
+    for (var _j = 0; _j < this.V8Length; ++_j) {_o.V8.Add(this.V8(_j));}
+    _o.Vf64 = new List<double>();
+    for (var _j = 0; _j < this.Vf64Length; ++_j) {_o.Vf64.Add(this.Vf64(_j));}
+  }
+  public static Offset<MyGame.Example.TypeAliases> Pack(FlatBufferBuilder builder, TypeAliasesT _o) {
+    if (_o == null) return default(Offset<MyGame.Example.TypeAliases>);
+    var _v8 = default(VectorOffset);
+    if (_o.V8 != null) {
+      var __v8 = _o.V8.ToArray();
+      _v8 = CreateV8Vector(builder, __v8);
+    }
+    var _vf64 = default(VectorOffset);
+    if (_o.Vf64 != null) {
+      var __vf64 = _o.Vf64.ToArray();
+      _vf64 = CreateVf64Vector(builder, __vf64);
+    }
+    return CreateTypeAliases(
+      builder,
+      _o.I8,
+      _o.U8,
+      _o.I16,
+      _o.U16,
+      _o.I32,
+      _o.U32,
+      _o.I64,
+      _o.U64,
+      _o.F32,
+      _o.F64,
+      _v8,
+      _vf64);
+  }
 };

+public class TypeAliasesT
+{
+  public sbyte I8 { get; set; }
+  public byte U8 { get; set; }
+  public short I16 { get; set; }
+  public ushort U16 { get; set; }
+  public int I32 { get; set; }
+  public uint U32 { get; set; }
+  public long I64 { get; set; }
+  public ulong U64 { get; set; }
+  public float F32 { get; set; }
+  public double F64 { get; set; }
+  public List<sbyte> V8 { get; set; }
+  public List<double> Vf64 { get; set; }
+
+  public TypeAliasesT() {
+    this.I8 = 0;
+    this.U8 = 0;
+    this.I16 = 0;
+    this.U16 = 0;
+    this.I32 = 0;
+    this.U32 = 0;
+    this.I64 = 0;
+    this.U64 = 0;
+    this.F32 = 0.0f;
+    this.F64 = 0.0;
+    this.V8 = null;
+    this.Vf64 = null;
+  }
+}
+

 }
--- a/tests/MyGame/Example/Vec3.cs
+++ b/tests/MyGame/Example/Vec3.cs
@@ -6,6 +6,7 @@ namespace MyGame.Example
 {

 using global::System;
+using global::System.Collections.Generic;
 using global::FlatBuffers;

 public struct Vec3 : IFlatbufferObject
@@ -43,7 +44,51 @@ public struct Vec3 : IFlatbufferObject
    builder.PutFloat(X);
    return new Offset<MyGame.Example.Vec3>(builder.Offset);
  }
+  public Vec3T UnPack() {
+    var _o = new Vec3T();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(Vec3T _o) {
+    _o.X = this.X;
+    _o.Y = this.Y;
+    _o.Z = this.Z;
+    _o.Test1 = this.Test1;
+    _o.Test2 = this.Test2;
+    _o.Test3 = this.Test3.UnPack();
+  }
+  public static Offset<MyGame.Example.Vec3> Pack(FlatBufferBuilder builder, Vec3T _o) {
+    if (_o == null) return default(Offset<MyGame.Example.Vec3>);
+    return CreateVec3(
+      builder,
+      _o.X,
+      _o.Y,
+      _o.Z,
+      _o.Test1,
+      _o.Test2,
+      _o.Test3.A,
+      _o.Test3.B);
+  }
 };

+public class Vec3T
+{
+  public float X { get; set; }
+  public float Y { get; set; }
+  public float Z { get; set; }
+  public double Test1 { get; set; }
+  public MyGame.Example.Color Test2 { get; set; }
+  public MyGame.Example.TestT Test3 { get; set; }
+
+  public Vec3T() {
+    this.X = 0.0f;
+    this.Y = 0.0f;
+    this.Z = 0.0f;
+    this.Test1 = 0.0;
+    this.Test2 = 0;
+    this.Test3 = new MyGame.Example.TestT();
+  }
+}
+

 }