Merge branch 'master' of gitea.bywaystudios.com:wangshiyao/thrift-related

compiled_output/csharp/Byway/Thrift/Data/AdGiftData.cs

@@ -0,0 +1,214 @@
+/**
+ * <auto-generated>
+ * Autogenerated by Thrift Compiler (0.22.0)
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * </auto-generated>
+ */
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Thrift;
+using Thrift.Collections;
+using System.Runtime.Serialization;
+using Thrift.Protocol;
+using Thrift.Protocol.Entities;
+using Thrift.Protocol.Utilities;
+using Thrift.Transport;
+using Thrift.Transport.Client;
+
+
+#pragma warning disable IDE0079  // remove unnecessary pragmas
+#pragma warning disable IDE0017  // object init can be simplified
+#pragma warning disable IDE0028  // collection init can be simplified
+#pragma warning disable IDE0305  // collection init can be simplified
+#pragma warning disable IDE0034  // simplify default expression
+#pragma warning disable IDE0066  // use switch expression
+#pragma warning disable IDE0090  // simplify new expression
+#pragma warning disable IDE0290  // use primary CTOR
+#pragma warning disable IDE1006  // parts of the code use IDL spelling
+#pragma warning disable CA1822   // empty DeepCopy() methods still non-static
+#pragma warning disable IDE0083  // pattern matching "that is not SomeType" requires net5.0 but we still support earlier versions
+
+namespace Byway.Thrift.Data
+{
+
+  [DataContract(Namespace="")]
+  public partial class AdGiftData : TBase
+  {
+    private Dictionary<int, global::Byway.Thrift.Data.AdGiftDataItem> _adgiftdatas;
+
+    [DataMember(Order = 0)]
+    public Dictionary<int, global::Byway.Thrift.Data.AdGiftDataItem> Adgiftdatas
+    {
+      get
+      {
+        return _adgiftdatas;
+      }
+      set
+      {
+        __isset.@adgiftdatas = true;
+        this._adgiftdatas = value;
+      }
+    }
+
+
+    [DataMember(Order = 1)]
+    public Isset __isset;
+    [DataContract]
+    public struct Isset
+    {
+      [DataMember]
+      public bool @adgiftdatas;
+    }
+
+    #region XmlSerializer support
+
+    public bool ShouldSerializeAdgiftdatas()
+    {
+      return __isset.@adgiftdatas;
+    }
+
+    #endregion XmlSerializer support
+
+    public AdGiftData()
+    {
+    }
+
+    public AdGiftData DeepCopy()
+    {
+      var tmp5 = new AdGiftData();
+      if((Adgiftdatas != null) && __isset.@adgiftdatas)
+      {
+        tmp5.Adgiftdatas = this.Adgiftdatas.DeepCopy();
+      }
+      tmp5.__isset.@adgiftdatas = this.__isset.@adgiftdatas;
+      return tmp5;
+    }
+
+    public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
+    {
+      iprot.IncrementRecursionDepth();
+      try
+      {
+        TField field;
+        await iprot.ReadStructBeginAsync(cancellationToken);
+        while (true)
+        {
+          field = await iprot.ReadFieldBeginAsync(cancellationToken);
+          if (field.Type == TType.Stop)
+          {
+            break;
+          }
+
+          switch (field.ID)
+          {
+            case 1:
+              if (field.Type == TType.Map)
+              {
+                {
+                  var _map6 = await iprot.ReadMapBeginAsync(cancellationToken);
+                  Adgiftdatas = new Dictionary<int, global::Byway.Thrift.Data.AdGiftDataItem>(_map6.Count);
+                  for(int _i7 = 0; _i7 < _map6.Count; ++_i7)
+                  {
+                    int _key8;
+                    global::Byway.Thrift.Data.AdGiftDataItem _val9;
+                    _key8 = await iprot.ReadI32Async(cancellationToken);
+                    _val9 = new global::Byway.Thrift.Data.AdGiftDataItem();
+                    await _val9.ReadAsync(iprot, cancellationToken);
+                    Adgiftdatas[_key8] = _val9;
+                  }
+                  await iprot.ReadMapEndAsync(cancellationToken);
+                }
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            default: 
+              await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              break;
+          }
+
+          await iprot.ReadFieldEndAsync(cancellationToken);
+        }
+
+        await iprot.ReadStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        iprot.DecrementRecursionDepth();
+      }
+    }
+
+    public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
+    {
+      oprot.IncrementRecursionDepth();
+      try
+      {
+        var tmp10 = new TStruct("AdGiftData");
+        await oprot.WriteStructBeginAsync(tmp10, cancellationToken);
+        var tmp11 = new TField();
+        if((Adgiftdatas != null) && __isset.@adgiftdatas)
+        {
+          tmp11.Name = "adgiftdatas";
+          tmp11.Type = TType.Map;
+          tmp11.ID = 1;
+          await oprot.WriteFieldBeginAsync(tmp11, cancellationToken);
+          await oprot.WriteMapBeginAsync(new TMap(TType.I32, TType.Struct, Adgiftdatas.Count), cancellationToken);
+          foreach (int _iter12 in Adgiftdatas.Keys)
+          {
+            await oprot.WriteI32Async(_iter12, cancellationToken);
+            await Adgiftdatas[_iter12].WriteAsync(oprot, cancellationToken);
+          }
+          await oprot.WriteMapEndAsync(cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        await oprot.WriteFieldStopAsync(cancellationToken);
+        await oprot.WriteStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        oprot.DecrementRecursionDepth();
+      }
+    }
+
+    public override bool Equals(object that)
+    {
+      if (!(that is AdGiftData other)) return false;
+      if (ReferenceEquals(this, other)) return true;
+      return ((__isset.@adgiftdatas == other.__isset.@adgiftdatas) && ((!__isset.@adgiftdatas) || (TCollections.Equals(Adgiftdatas, other.Adgiftdatas))));
+    }
+
+    public override int GetHashCode() {
+      int hashcode = 157;
+      unchecked {
+        if((Adgiftdatas != null) && __isset.@adgiftdatas)
+        {
+          hashcode = (hashcode * 397) + TCollections.GetHashCode(Adgiftdatas);
+        }
+      }
+      return hashcode;
+    }
+
+    public override string ToString()
+    {
+      var tmp13 = new StringBuilder("AdGiftData(");
+      int tmp14 = 0;
+      if((Adgiftdatas != null) && __isset.@adgiftdatas)
+      {
+        if(0 < tmp14++) { tmp13.Append(", "); }
+        tmp13.Append("Adgiftdatas: ");
+        Adgiftdatas.ToString(tmp13);
+      }
+      tmp13.Append(')');
+      return tmp13.ToString();
+    }
+  }
+
+}

compiled_output/csharp/Byway/Thrift/Data/AdGiftDataItem.cs

@@ -0,0 +1,366 @@
+/**
+ * <auto-generated>
+ * Autogenerated by Thrift Compiler (0.22.0)
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * </auto-generated>
+ */
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Thrift;
+using Thrift.Collections;
+using System.Runtime.Serialization;
+using Thrift.Protocol;
+using Thrift.Protocol.Entities;
+using Thrift.Protocol.Utilities;
+using Thrift.Transport;
+using Thrift.Transport.Client;
+
+
+#pragma warning disable IDE0079  // remove unnecessary pragmas
+#pragma warning disable IDE0017  // object init can be simplified
+#pragma warning disable IDE0028  // collection init can be simplified
+#pragma warning disable IDE0305  // collection init can be simplified
+#pragma warning disable IDE0034  // simplify default expression
+#pragma warning disable IDE0066  // use switch expression
+#pragma warning disable IDE0090  // simplify new expression
+#pragma warning disable IDE0290  // use primary CTOR
+#pragma warning disable IDE1006  // parts of the code use IDL spelling
+#pragma warning disable CA1822   // empty DeepCopy() methods still non-static
+#pragma warning disable IDE0083  // pattern matching "that is not SomeType" requires net5.0 but we still support earlier versions
+
+namespace Byway.Thrift.Data
+{
+
+  [DataContract(Namespace="")]
+  public partial class AdGiftDataItem : TBase
+  {
+    private int _Id;
+    private int _SortId;
+    private int _NeedScore;
+    private string _ItemReward;
+
+    [DataMember(Order = 0)]
+    public int Id
+    {
+      get
+      {
+        return _Id;
+      }
+      set
+      {
+        __isset.Id = true;
+        this._Id = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public int SortId
+    {
+      get
+      {
+        return _SortId;
+      }
+      set
+      {
+        __isset.SortId = true;
+        this._SortId = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public int NeedScore
+    {
+      get
+      {
+        return _NeedScore;
+      }
+      set
+      {
+        __isset.NeedScore = true;
+        this._NeedScore = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public string ItemReward
+    {
+      get
+      {
+        return _ItemReward;
+      }
+      set
+      {
+        __isset.ItemReward = true;
+        this._ItemReward = value;
+      }
+    }
+
+
+    [DataMember(Order = 1)]
+    public Isset __isset;
+    [DataContract]
+    public struct Isset
+    {
+      [DataMember]
+      public bool Id;
+      [DataMember]
+      public bool SortId;
+      [DataMember]
+      public bool NeedScore;
+      [DataMember]
+      public bool ItemReward;
+    }
+
+    #region XmlSerializer support
+
+    public bool ShouldSerializeId()
+    {
+      return __isset.Id;
+    }
+
+    public bool ShouldSerializeSortId()
+    {
+      return __isset.SortId;
+    }
+
+    public bool ShouldSerializeNeedScore()
+    {
+      return __isset.NeedScore;
+    }
+
+    public bool ShouldSerializeItemReward()
+    {
+      return __isset.ItemReward;
+    }
+
+    #endregion XmlSerializer support
+
+    public AdGiftDataItem()
+    {
+    }
+
+    public AdGiftDataItem DeepCopy()
+    {
+      var tmp0 = new AdGiftDataItem();
+      if(__isset.Id)
+      {
+        tmp0.Id = this.Id;
+      }
+      tmp0.__isset.Id = this.__isset.Id;
+      if(__isset.SortId)
+      {
+        tmp0.SortId = this.SortId;
+      }
+      tmp0.__isset.SortId = this.__isset.SortId;
+      if(__isset.NeedScore)
+      {
+        tmp0.NeedScore = this.NeedScore;
+      }
+      tmp0.__isset.NeedScore = this.__isset.NeedScore;
+      if((ItemReward != null) && __isset.ItemReward)
+      {
+        tmp0.ItemReward = this.ItemReward;
+      }
+      tmp0.__isset.ItemReward = this.__isset.ItemReward;
+      return tmp0;
+    }
+
+    public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
+    {
+      iprot.IncrementRecursionDepth();
+      try
+      {
+        TField field;
+        await iprot.ReadStructBeginAsync(cancellationToken);
+        while (true)
+        {
+          field = await iprot.ReadFieldBeginAsync(cancellationToken);
+          if (field.Type == TType.Stop)
+          {
+            break;
+          }
+
+          switch (field.ID)
+          {
+            case 1:
+              if (field.Type == TType.I32)
+              {
+                Id = await iprot.ReadI32Async(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 2:
+              if (field.Type == TType.I32)
+              {
+                SortId = await iprot.ReadI32Async(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 3:
+              if (field.Type == TType.I32)
+              {
+                NeedScore = await iprot.ReadI32Async(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 4:
+              if (field.Type == TType.String)
+              {
+                ItemReward = await iprot.ReadStringAsync(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            default: 
+              await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              break;
+          }
+
+          await iprot.ReadFieldEndAsync(cancellationToken);
+        }
+
+        await iprot.ReadStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        iprot.DecrementRecursionDepth();
+      }
+    }
+
+    public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
+    {
+      oprot.IncrementRecursionDepth();
+      try
+      {
+        var tmp1 = new TStruct("AdGiftDataItem");
+        await oprot.WriteStructBeginAsync(tmp1, cancellationToken);
+        var tmp2 = new TField();
+        if(__isset.Id)
+        {
+          tmp2.Name = "Id";
+          tmp2.Type = TType.I32;
+          tmp2.ID = 1;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteI32Async(Id, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if(__isset.SortId)
+        {
+          tmp2.Name = "SortId";
+          tmp2.Type = TType.I32;
+          tmp2.ID = 2;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteI32Async(SortId, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if(__isset.NeedScore)
+        {
+          tmp2.Name = "NeedScore";
+          tmp2.Type = TType.I32;
+          tmp2.ID = 3;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteI32Async(NeedScore, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if((ItemReward != null) && __isset.ItemReward)
+        {
+          tmp2.Name = "ItemReward";
+          tmp2.Type = TType.String;
+          tmp2.ID = 4;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteStringAsync(ItemReward, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        await oprot.WriteFieldStopAsync(cancellationToken);
+        await oprot.WriteStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        oprot.DecrementRecursionDepth();
+      }
+    }
+
+    public override bool Equals(object that)
+    {
+      if (!(that is AdGiftDataItem other)) return false;
+      if (ReferenceEquals(this, other)) return true;
+      return ((__isset.Id == other.__isset.Id) && ((!__isset.Id) || (global::System.Object.Equals(Id, other.Id))))
+        && ((__isset.SortId == other.__isset.SortId) && ((!__isset.SortId) || (global::System.Object.Equals(SortId, other.SortId))))
+        && ((__isset.NeedScore == other.__isset.NeedScore) && ((!__isset.NeedScore) || (global::System.Object.Equals(NeedScore, other.NeedScore))))
+        && ((__isset.ItemReward == other.__isset.ItemReward) && ((!__isset.ItemReward) || (global::System.Object.Equals(ItemReward, other.ItemReward))));
+    }
+
+    public override int GetHashCode() {
+      int hashcode = 157;
+      unchecked {
+        if(__isset.Id)
+        {
+          hashcode = (hashcode * 397) + Id.GetHashCode();
+        }
+        if(__isset.SortId)
+        {
+          hashcode = (hashcode * 397) + SortId.GetHashCode();
+        }
+        if(__isset.NeedScore)
+        {
+          hashcode = (hashcode * 397) + NeedScore.GetHashCode();
+        }
+        if((ItemReward != null) && __isset.ItemReward)
+        {
+          hashcode = (hashcode * 397) + ItemReward.GetHashCode();
+        }
+      }
+      return hashcode;
+    }
+
+    public override string ToString()
+    {
+      var tmp3 = new StringBuilder("AdGiftDataItem(");
+      int tmp4 = 0;
+      if(__isset.Id)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("Id: ");
+        Id.ToString(tmp3);
+      }
+      if(__isset.SortId)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("SortId: ");
+        SortId.ToString(tmp3);
+      }
+      if(__isset.NeedScore)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("NeedScore: ");
+        NeedScore.ToString(tmp3);
+      }
+      if((ItemReward != null) && __isset.ItemReward)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("ItemReward: ");
+        ItemReward.ToString(tmp3);
+      }
+      tmp3.Append(')');
+      return tmp3.ToString();
+    }
+  }
+
+}

compiled_output/csharp/Byway/Thrift/Data/BagItemConfig.cs

@@ -0,0 +1,214 @@
+/**
+ * <auto-generated>
+ * Autogenerated by Thrift Compiler (0.22.0)
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * </auto-generated>
+ */
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Thrift;
+using Thrift.Collections;
+using System.Runtime.Serialization;
+using Thrift.Protocol;
+using Thrift.Protocol.Entities;
+using Thrift.Protocol.Utilities;
+using Thrift.Transport;
+using Thrift.Transport.Client;
+
+
+#pragma warning disable IDE0079  // remove unnecessary pragmas
+#pragma warning disable IDE0017  // object init can be simplified
+#pragma warning disable IDE0028  // collection init can be simplified
+#pragma warning disable IDE0305  // collection init can be simplified
+#pragma warning disable IDE0034  // simplify default expression
+#pragma warning disable IDE0066  // use switch expression
+#pragma warning disable IDE0090  // simplify new expression
+#pragma warning disable IDE0290  // use primary CTOR
+#pragma warning disable IDE1006  // parts of the code use IDL spelling
+#pragma warning disable CA1822   // empty DeepCopy() methods still non-static
+#pragma warning disable IDE0083  // pattern matching "that is not SomeType" requires net5.0 but we still support earlier versions
+
+namespace Byway.Thrift.Data
+{
+
+  [DataContract(Namespace="")]
+  public partial class BagItemConfig : TBase
+  {
+    private Dictionary<int, global::Byway.Thrift.Data.BagItemConfigItem> _bagitemconfigs;
+
+    [DataMember(Order = 0)]
+    public Dictionary<int, global::Byway.Thrift.Data.BagItemConfigItem> Bagitemconfigs
+    {
+      get
+      {
+        return _bagitemconfigs;
+      }
+      set
+      {
+        __isset.@bagitemconfigs = true;
+        this._bagitemconfigs = value;
+      }
+    }
+
+
+    [DataMember(Order = 1)]
+    public Isset __isset;
+    [DataContract]
+    public struct Isset
+    {
+      [DataMember]
+      public bool @bagitemconfigs;
+    }
+
+    #region XmlSerializer support
+
+    public bool ShouldSerializeBagitemconfigs()
+    {
+      return __isset.@bagitemconfigs;
+    }
+
+    #endregion XmlSerializer support
+
+    public BagItemConfig()
+    {
+    }
+
+    public BagItemConfig DeepCopy()
+    {
+      var tmp5 = new BagItemConfig();
+      if((Bagitemconfigs != null) && __isset.@bagitemconfigs)
+      {
+        tmp5.Bagitemconfigs = this.Bagitemconfigs.DeepCopy();
+      }
+      tmp5.__isset.@bagitemconfigs = this.__isset.@bagitemconfigs;
+      return tmp5;
+    }
+
+    public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
+    {
+      iprot.IncrementRecursionDepth();
+      try
+      {
+        TField field;
+        await iprot.ReadStructBeginAsync(cancellationToken);
+        while (true)
+        {
+          field = await iprot.ReadFieldBeginAsync(cancellationToken);
+          if (field.Type == TType.Stop)
+          {
+            break;
+          }
+
+          switch (field.ID)
+          {
+            case 1:
+              if (field.Type == TType.Map)
+              {
+                {
+                  var _map6 = await iprot.ReadMapBeginAsync(cancellationToken);
+                  Bagitemconfigs = new Dictionary<int, global::Byway.Thrift.Data.BagItemConfigItem>(_map6.Count);
+                  for(int _i7 = 0; _i7 < _map6.Count; ++_i7)
+                  {
+                    int _key8;
+                    global::Byway.Thrift.Data.BagItemConfigItem _val9;
+                    _key8 = await iprot.ReadI32Async(cancellationToken);
+                    _val9 = new global::Byway.Thrift.Data.BagItemConfigItem();
+                    await _val9.ReadAsync(iprot, cancellationToken);
+                    Bagitemconfigs[_key8] = _val9;
+                  }
+                  await iprot.ReadMapEndAsync(cancellationToken);
+                }
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            default: 
+              await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              break;
+          }
+
+          await iprot.ReadFieldEndAsync(cancellationToken);
+        }
+
+        await iprot.ReadStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        iprot.DecrementRecursionDepth();
+      }
+    }
+
+    public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
+    {
+      oprot.IncrementRecursionDepth();
+      try
+      {
+        var tmp10 = new TStruct("BagItemConfig");
+        await oprot.WriteStructBeginAsync(tmp10, cancellationToken);
+        var tmp11 = new TField();
+        if((Bagitemconfigs != null) && __isset.@bagitemconfigs)
+        {
+          tmp11.Name = "bagitemconfigs";
+          tmp11.Type = TType.Map;
+          tmp11.ID = 1;
+          await oprot.WriteFieldBeginAsync(tmp11, cancellationToken);
+          await oprot.WriteMapBeginAsync(new TMap(TType.I32, TType.Struct, Bagitemconfigs.Count), cancellationToken);
+          foreach (int _iter12 in Bagitemconfigs.Keys)
+          {
+            await oprot.WriteI32Async(_iter12, cancellationToken);
+            await Bagitemconfigs[_iter12].WriteAsync(oprot, cancellationToken);
+          }
+          await oprot.WriteMapEndAsync(cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        await oprot.WriteFieldStopAsync(cancellationToken);
+        await oprot.WriteStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        oprot.DecrementRecursionDepth();
+      }
+    }
+
+    public override bool Equals(object that)
+    {
+      if (!(that is BagItemConfig other)) return false;
+      if (ReferenceEquals(this, other)) return true;
+      return ((__isset.@bagitemconfigs == other.__isset.@bagitemconfigs) && ((!__isset.@bagitemconfigs) || (TCollections.Equals(Bagitemconfigs, other.Bagitemconfigs))));
+    }
+
+    public override int GetHashCode() {
+      int hashcode = 157;
+      unchecked {
+        if((Bagitemconfigs != null) && __isset.@bagitemconfigs)
+        {
+          hashcode = (hashcode * 397) + TCollections.GetHashCode(Bagitemconfigs);
+        }
+      }
+      return hashcode;
+    }
+
+    public override string ToString()
+    {
+      var tmp13 = new StringBuilder("BagItemConfig(");
+      int tmp14 = 0;
+      if((Bagitemconfigs != null) && __isset.@bagitemconfigs)
+      {
+        if(0 < tmp14++) { tmp13.Append(", "); }
+        tmp13.Append("Bagitemconfigs: ");
+        Bagitemconfigs.ToString(tmp13);
+      }
+      tmp13.Append(')');
+      return tmp13.ToString();
+    }
+  }
+
+}

compiled_output/csharp/Byway/Thrift/Data/BagItemConfigItem.cs

@@ -0,0 +1,366 @@
+/**
+ * <auto-generated>
+ * Autogenerated by Thrift Compiler (0.22.0)
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * </auto-generated>
+ */
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Thrift;
+using Thrift.Collections;
+using System.Runtime.Serialization;
+using Thrift.Protocol;
+using Thrift.Protocol.Entities;
+using Thrift.Protocol.Utilities;
+using Thrift.Transport;
+using Thrift.Transport.Client;
+
+
+#pragma warning disable IDE0079  // remove unnecessary pragmas
+#pragma warning disable IDE0017  // object init can be simplified
+#pragma warning disable IDE0028  // collection init can be simplified
+#pragma warning disable IDE0305  // collection init can be simplified
+#pragma warning disable IDE0034  // simplify default expression
+#pragma warning disable IDE0066  // use switch expression
+#pragma warning disable IDE0090  // simplify new expression
+#pragma warning disable IDE0290  // use primary CTOR
+#pragma warning disable IDE1006  // parts of the code use IDL spelling
+#pragma warning disable CA1822   // empty DeepCopy() methods still non-static
+#pragma warning disable IDE0083  // pattern matching "that is not SomeType" requires net5.0 but we still support earlier versions
+
+namespace Byway.Thrift.Data
+{
+
+  [DataContract(Namespace="")]
+  public partial class BagItemConfigItem : TBase
+  {
+    private int _Id;
+    private int _ItemId;
+    private string _Icon;
+    private int _TrueId;
+
+    [DataMember(Order = 0)]
+    public int Id
+    {
+      get
+      {
+        return _Id;
+      }
+      set
+      {
+        __isset.Id = true;
+        this._Id = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public int ItemId
+    {
+      get
+      {
+        return _ItemId;
+      }
+      set
+      {
+        __isset.ItemId = true;
+        this._ItemId = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public string Icon
+    {
+      get
+      {
+        return _Icon;
+      }
+      set
+      {
+        __isset.Icon = true;
+        this._Icon = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public int TrueId
+    {
+      get
+      {
+        return _TrueId;
+      }
+      set
+      {
+        __isset.TrueId = true;
+        this._TrueId = value;
+      }
+    }
+
+
+    [DataMember(Order = 1)]
+    public Isset __isset;
+    [DataContract]
+    public struct Isset
+    {
+      [DataMember]
+      public bool Id;
+      [DataMember]
+      public bool ItemId;
+      [DataMember]
+      public bool Icon;
+      [DataMember]
+      public bool TrueId;
+    }
+
+    #region XmlSerializer support
+
+    public bool ShouldSerializeId()
+    {
+      return __isset.Id;
+    }
+
+    public bool ShouldSerializeItemId()
+    {
+      return __isset.ItemId;
+    }
+
+    public bool ShouldSerializeIcon()
+    {
+      return __isset.Icon;
+    }
+
+    public bool ShouldSerializeTrueId()
+    {
+      return __isset.TrueId;
+    }
+
+    #endregion XmlSerializer support
+
+    public BagItemConfigItem()
+    {
+    }
+
+    public BagItemConfigItem DeepCopy()
+    {
+      var tmp0 = new BagItemConfigItem();
+      if(__isset.Id)
+      {
+        tmp0.Id = this.Id;
+      }
+      tmp0.__isset.Id = this.__isset.Id;
+      if(__isset.ItemId)
+      {
+        tmp0.ItemId = this.ItemId;
+      }
+      tmp0.__isset.ItemId = this.__isset.ItemId;
+      if((Icon != null) && __isset.Icon)
+      {
+        tmp0.Icon = this.Icon;
+      }
+      tmp0.__isset.Icon = this.__isset.Icon;
+      if(__isset.TrueId)
+      {
+        tmp0.TrueId = this.TrueId;
+      }
+      tmp0.__isset.TrueId = this.__isset.TrueId;
+      return tmp0;
+    }
+
+    public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
+    {
+      iprot.IncrementRecursionDepth();
+      try
+      {
+        TField field;
+        await iprot.ReadStructBeginAsync(cancellationToken);
+        while (true)
+        {
+          field = await iprot.ReadFieldBeginAsync(cancellationToken);
+          if (field.Type == TType.Stop)
+          {
+            break;
+          }
+
+          switch (field.ID)
+          {
+            case 1:
+              if (field.Type == TType.I32)
+              {
+                Id = await iprot.ReadI32Async(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 2:
+              if (field.Type == TType.I32)
+              {
+                ItemId = await iprot.ReadI32Async(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 3:
+              if (field.Type == TType.String)
+              {
+                Icon = await iprot.ReadStringAsync(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 4:
+              if (field.Type == TType.I32)
+              {
+                TrueId = await iprot.ReadI32Async(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            default: 
+              await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              break;
+          }
+
+          await iprot.ReadFieldEndAsync(cancellationToken);
+        }
+
+        await iprot.ReadStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        iprot.DecrementRecursionDepth();
+      }
+    }
+
+    public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
+    {
+      oprot.IncrementRecursionDepth();
+      try
+      {
+        var tmp1 = new TStruct("BagItemConfigItem");
+        await oprot.WriteStructBeginAsync(tmp1, cancellationToken);
+        var tmp2 = new TField();
+        if(__isset.Id)
+        {
+          tmp2.Name = "Id";
+          tmp2.Type = TType.I32;
+          tmp2.ID = 1;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteI32Async(Id, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if(__isset.ItemId)
+        {
+          tmp2.Name = "ItemId";
+          tmp2.Type = TType.I32;
+          tmp2.ID = 2;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteI32Async(ItemId, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if((Icon != null) && __isset.Icon)
+        {
+          tmp2.Name = "Icon";
+          tmp2.Type = TType.String;
+          tmp2.ID = 3;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteStringAsync(Icon, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if(__isset.TrueId)
+        {
+          tmp2.Name = "TrueId";
+          tmp2.Type = TType.I32;
+          tmp2.ID = 4;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteI32Async(TrueId, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        await oprot.WriteFieldStopAsync(cancellationToken);
+        await oprot.WriteStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        oprot.DecrementRecursionDepth();
+      }
+    }
+
+    public override bool Equals(object that)
+    {
+      if (!(that is BagItemConfigItem other)) return false;
+      if (ReferenceEquals(this, other)) return true;
+      return ((__isset.Id == other.__isset.Id) && ((!__isset.Id) || (global::System.Object.Equals(Id, other.Id))))
+        && ((__isset.ItemId == other.__isset.ItemId) && ((!__isset.ItemId) || (global::System.Object.Equals(ItemId, other.ItemId))))
+        && ((__isset.Icon == other.__isset.Icon) && ((!__isset.Icon) || (global::System.Object.Equals(Icon, other.Icon))))
+        && ((__isset.TrueId == other.__isset.TrueId) && ((!__isset.TrueId) || (global::System.Object.Equals(TrueId, other.TrueId))));
+    }
+
+    public override int GetHashCode() {
+      int hashcode = 157;
+      unchecked {
+        if(__isset.Id)
+        {
+          hashcode = (hashcode * 397) + Id.GetHashCode();
+        }
+        if(__isset.ItemId)
+        {
+          hashcode = (hashcode * 397) + ItemId.GetHashCode();
+        }
+        if((Icon != null) && __isset.Icon)
+        {
+          hashcode = (hashcode * 397) + Icon.GetHashCode();
+        }
+        if(__isset.TrueId)
+        {
+          hashcode = (hashcode * 397) + TrueId.GetHashCode();
+        }
+      }
+      return hashcode;
+    }
+
+    public override string ToString()
+    {
+      var tmp3 = new StringBuilder("BagItemConfigItem(");
+      int tmp4 = 0;
+      if(__isset.Id)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("Id: ");
+        Id.ToString(tmp3);
+      }
+      if(__isset.ItemId)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("ItemId: ");
+        ItemId.ToString(tmp3);
+      }
+      if((Icon != null) && __isset.Icon)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("Icon: ");
+        Icon.ToString(tmp3);
+      }
+      if(__isset.TrueId)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("TrueId: ");
+        TrueId.ToString(tmp3);
+      }
+      tmp3.Append(')');
+      return tmp3.ToString();
+    }
+  }
+
+}

compiled_output/csharp/Byway/Thrift/Data/BonusValue.cs

@@ -0,0 +1,214 @@
+/**
+ * <auto-generated>
+ * Autogenerated by Thrift Compiler (0.22.0)
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * </auto-generated>
+ */
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Thrift;
+using Thrift.Collections;
+using System.Runtime.Serialization;
+using Thrift.Protocol;
+using Thrift.Protocol.Entities;
+using Thrift.Protocol.Utilities;
+using Thrift.Transport;
+using Thrift.Transport.Client;
+
+
+#pragma warning disable IDE0079  // remove unnecessary pragmas
+#pragma warning disable IDE0017  // object init can be simplified
+#pragma warning disable IDE0028  // collection init can be simplified
+#pragma warning disable IDE0305  // collection init can be simplified
+#pragma warning disable IDE0034  // simplify default expression
+#pragma warning disable IDE0066  // use switch expression
+#pragma warning disable IDE0090  // simplify new expression
+#pragma warning disable IDE0290  // use primary CTOR
+#pragma warning disable IDE1006  // parts of the code use IDL spelling
+#pragma warning disable CA1822   // empty DeepCopy() methods still non-static
+#pragma warning disable IDE0083  // pattern matching "that is not SomeType" requires net5.0 but we still support earlier versions
+
+namespace Byway.Thrift.Data
+{
+
+  [DataContract(Namespace="")]
+  public partial class BonusValue : TBase
+  {
+    private Dictionary<int, global::Byway.Thrift.Data.BonusValueItem> _bonusvalues;
+
+    [DataMember(Order = 0)]
+    public Dictionary<int, global::Byway.Thrift.Data.BonusValueItem> Bonusvalues
+    {
+      get
+      {
+        return _bonusvalues;
+      }
+      set
+      {
+        __isset.@bonusvalues = true;
+        this._bonusvalues = value;
+      }
+    }
+
+
+    [DataMember(Order = 1)]
+    public Isset __isset;
+    [DataContract]
+    public struct Isset
+    {
+      [DataMember]
+      public bool @bonusvalues;
+    }
+
+    #region XmlSerializer support
+
+    public bool ShouldSerializeBonusvalues()
+    {
+      return __isset.@bonusvalues;
+    }
+
+    #endregion XmlSerializer support
+
+    public BonusValue()
+    {
+    }
+
+    public BonusValue DeepCopy()
+    {
+      var tmp5 = new BonusValue();
+      if((Bonusvalues != null) && __isset.@bonusvalues)
+      {
+        tmp5.Bonusvalues = this.Bonusvalues.DeepCopy();
+      }
+      tmp5.__isset.@bonusvalues = this.__isset.@bonusvalues;
+      return tmp5;
+    }
+
+    public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
+    {
+      iprot.IncrementRecursionDepth();
+      try
+      {
+        TField field;
+        await iprot.ReadStructBeginAsync(cancellationToken);
+        while (true)
+        {
+          field = await iprot.ReadFieldBeginAsync(cancellationToken);
+          if (field.Type == TType.Stop)
+          {
+            break;
+          }
+
+          switch (field.ID)
+          {
+            case 1:
+              if (field.Type == TType.Map)
+              {
+                {
+                  var _map6 = await iprot.ReadMapBeginAsync(cancellationToken);
+                  Bonusvalues = new Dictionary<int, global::Byway.Thrift.Data.BonusValueItem>(_map6.Count);
+                  for(int _i7 = 0; _i7 < _map6.Count; ++_i7)
+                  {
+                    int _key8;
+                    global::Byway.Thrift.Data.BonusValueItem _val9;
+                    _key8 = await iprot.ReadI32Async(cancellationToken);
+                    _val9 = new global::Byway.Thrift.Data.BonusValueItem();
+                    await _val9.ReadAsync(iprot, cancellationToken);
+                    Bonusvalues[_key8] = _val9;
+                  }
+                  await iprot.ReadMapEndAsync(cancellationToken);
+                }
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            default: 
+              await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              break;
+          }
+
+          await iprot.ReadFieldEndAsync(cancellationToken);
+        }
+
+        await iprot.ReadStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        iprot.DecrementRecursionDepth();
+      }
+    }
+
+    public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
+    {
+      oprot.IncrementRecursionDepth();
+      try
+      {
+        var tmp10 = new TStruct("BonusValue");
+        await oprot.WriteStructBeginAsync(tmp10, cancellationToken);
+        var tmp11 = new TField();
+        if((Bonusvalues != null) && __isset.@bonusvalues)
+        {
+          tmp11.Name = "bonusvalues";
+          tmp11.Type = TType.Map;
+          tmp11.ID = 1;
+          await oprot.WriteFieldBeginAsync(tmp11, cancellationToken);
+          await oprot.WriteMapBeginAsync(new TMap(TType.I32, TType.Struct, Bonusvalues.Count), cancellationToken);
+          foreach (int _iter12 in Bonusvalues.Keys)
+          {
+            await oprot.WriteI32Async(_iter12, cancellationToken);
+            await Bonusvalues[_iter12].WriteAsync(oprot, cancellationToken);
+          }
+          await oprot.WriteMapEndAsync(cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        await oprot.WriteFieldStopAsync(cancellationToken);
+        await oprot.WriteStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        oprot.DecrementRecursionDepth();
+      }
+    }
+
+    public override bool Equals(object that)
+    {
+      if (!(that is BonusValue other)) return false;
+      if (ReferenceEquals(this, other)) return true;
+      return ((__isset.@bonusvalues == other.__isset.@bonusvalues) && ((!__isset.@bonusvalues) || (TCollections.Equals(Bonusvalues, other.Bonusvalues))));
+    }
+
+    public override int GetHashCode() {
+      int hashcode = 157;
+      unchecked {
+        if((Bonusvalues != null) && __isset.@bonusvalues)
+        {
+          hashcode = (hashcode * 397) + TCollections.GetHashCode(Bonusvalues);
+        }
+      }
+      return hashcode;
+    }
+
+    public override string ToString()
+    {
+      var tmp13 = new StringBuilder("BonusValue(");
+      int tmp14 = 0;
+      if((Bonusvalues != null) && __isset.@bonusvalues)
+      {
+        if(0 < tmp14++) { tmp13.Append(", "); }
+        tmp13.Append("Bonusvalues: ");
+        Bonusvalues.ToString(tmp13);
+      }
+      tmp13.Append(')');
+      return tmp13.ToString();
+    }
+  }
+
+}

compiled_output/csharp/Byway/Thrift/Data/BonusValueItem.cs

@@ -0,0 +1,480 @@
+/**
+ * <auto-generated>
+ * Autogenerated by Thrift Compiler (0.22.0)
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * </auto-generated>
+ */
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Thrift;
+using Thrift.Collections;
+using System.Runtime.Serialization;
+using Thrift.Protocol;
+using Thrift.Protocol.Entities;
+using Thrift.Protocol.Utilities;
+using Thrift.Transport;
+using Thrift.Transport.Client;
+
+
+#pragma warning disable IDE0079  // remove unnecessary pragmas
+#pragma warning disable IDE0017  // object init can be simplified
+#pragma warning disable IDE0028  // collection init can be simplified
+#pragma warning disable IDE0305  // collection init can be simplified
+#pragma warning disable IDE0034  // simplify default expression
+#pragma warning disable IDE0066  // use switch expression
+#pragma warning disable IDE0090  // simplify new expression
+#pragma warning disable IDE0290  // use primary CTOR
+#pragma warning disable IDE1006  // parts of the code use IDL spelling
+#pragma warning disable CA1822   // empty DeepCopy() methods still non-static
+#pragma warning disable IDE0083  // pattern matching "that is not SomeType" requires net5.0 but we still support earlier versions
+
+namespace Byway.Thrift.Data
+{
+
+  [DataContract(Namespace="")]
+  public partial class BonusValueItem : TBase
+  {
+    private int _Id;
+    private string _Type;
+    private int _SortId;
+    private double _Price;
+    private string _Reward;
+    private double _OldPrice;
+
+    [DataMember(Order = 0)]
+    public int Id
+    {
+      get
+      {
+        return _Id;
+      }
+      set
+      {
+        __isset.Id = true;
+        this._Id = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public string Type
+    {
+      get
+      {
+        return _Type;
+      }
+      set
+      {
+        __isset.Type = true;
+        this._Type = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public int SortId
+    {
+      get
+      {
+        return _SortId;
+      }
+      set
+      {
+        __isset.SortId = true;
+        this._SortId = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public double Price
+    {
+      get
+      {
+        return _Price;
+      }
+      set
+      {
+        __isset.Price = true;
+        this._Price = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public string Reward
+    {
+      get
+      {
+        return _Reward;
+      }
+      set
+      {
+        __isset.Reward = true;
+        this._Reward = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public double OldPrice
+    {
+      get
+      {
+        return _OldPrice;
+      }
+      set
+      {
+        __isset.OldPrice = true;
+        this._OldPrice = value;
+      }
+    }
+
+
+    [DataMember(Order = 1)]
+    public Isset __isset;
+    [DataContract]
+    public struct Isset
+    {
+      [DataMember]
+      public bool Id;
+      [DataMember]
+      public bool Type;
+      [DataMember]
+      public bool SortId;
+      [DataMember]
+      public bool Price;
+      [DataMember]
+      public bool Reward;
+      [DataMember]
+      public bool OldPrice;
+    }
+
+    #region XmlSerializer support
+
+    public bool ShouldSerializeId()
+    {
+      return __isset.Id;
+    }
+
+    public bool ShouldSerializeType()
+    {
+      return __isset.Type;
+    }
+
+    public bool ShouldSerializeSortId()
+    {
+      return __isset.SortId;
+    }
+
+    public bool ShouldSerializePrice()
+    {
+      return __isset.Price;
+    }
+
+    public bool ShouldSerializeReward()
+    {
+      return __isset.Reward;
+    }
+
+    public bool ShouldSerializeOldPrice()
+    {
+      return __isset.OldPrice;
+    }
+
+    #endregion XmlSerializer support
+
+    public BonusValueItem()
+    {
+    }
+
+    public BonusValueItem DeepCopy()
+    {
+      var tmp0 = new BonusValueItem();
+      if(__isset.Id)
+      {
+        tmp0.Id = this.Id;
+      }
+      tmp0.__isset.Id = this.__isset.Id;
+      if((Type != null) && __isset.Type)
+      {
+        tmp0.Type = this.Type;
+      }
+      tmp0.__isset.Type = this.__isset.Type;
+      if(__isset.SortId)
+      {
+        tmp0.SortId = this.SortId;
+      }
+      tmp0.__isset.SortId = this.__isset.SortId;
+      if(__isset.Price)
+      {
+        tmp0.Price = this.Price;
+      }
+      tmp0.__isset.Price = this.__isset.Price;
+      if((Reward != null) && __isset.Reward)
+      {
+        tmp0.Reward = this.Reward;
+      }
+      tmp0.__isset.Reward = this.__isset.Reward;
+      if(__isset.OldPrice)
+      {
+        tmp0.OldPrice = this.OldPrice;
+      }
+      tmp0.__isset.OldPrice = this.__isset.OldPrice;
+      return tmp0;
+    }
+
+    public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
+    {
+      iprot.IncrementRecursionDepth();
+      try
+      {
+        TField field;
+        await iprot.ReadStructBeginAsync(cancellationToken);
+        while (true)
+        {
+          field = await iprot.ReadFieldBeginAsync(cancellationToken);
+          if (field.Type == TType.Stop)
+          {
+            break;
+          }
+
+          switch (field.ID)
+          {
+            case 1:
+              if (field.Type == TType.I32)
+              {
+                Id = await iprot.ReadI32Async(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 2:
+              if (field.Type == TType.String)
+              {
+                Type = await iprot.ReadStringAsync(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 3:
+              if (field.Type == TType.I32)
+              {
+                SortId = await iprot.ReadI32Async(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 4:
+              if (field.Type == TType.Double)
+              {
+                Price = await iprot.ReadDoubleAsync(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 5:
+              if (field.Type == TType.String)
+              {
+                Reward = await iprot.ReadStringAsync(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 6:
+              if (field.Type == TType.Double)
+              {
+                OldPrice = await iprot.ReadDoubleAsync(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            default: 
+              await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              break;
+          }
+
+          await iprot.ReadFieldEndAsync(cancellationToken);
+        }
+
+        await iprot.ReadStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        iprot.DecrementRecursionDepth();
+      }
+    }
+
+    public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
+    {
+      oprot.IncrementRecursionDepth();
+      try
+      {
+        var tmp1 = new TStruct("BonusValueItem");
+        await oprot.WriteStructBeginAsync(tmp1, cancellationToken);
+        var tmp2 = new TField();
+        if(__isset.Id)
+        {
+          tmp2.Name = "Id";
+          tmp2.Type = TType.I32;
+          tmp2.ID = 1;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteI32Async(Id, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if((Type != null) && __isset.Type)
+        {
+          tmp2.Name = "Type";
+          tmp2.Type = TType.String;
+          tmp2.ID = 2;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteStringAsync(Type, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if(__isset.SortId)
+        {
+          tmp2.Name = "SortId";
+          tmp2.Type = TType.I32;
+          tmp2.ID = 3;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteI32Async(SortId, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if(__isset.Price)
+        {
+          tmp2.Name = "Price";
+          tmp2.Type = TType.Double;
+          tmp2.ID = 4;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteDoubleAsync(Price, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if((Reward != null) && __isset.Reward)
+        {
+          tmp2.Name = "Reward";
+          tmp2.Type = TType.String;
+          tmp2.ID = 5;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteStringAsync(Reward, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if(__isset.OldPrice)
+        {
+          tmp2.Name = "OldPrice";
+          tmp2.Type = TType.Double;
+          tmp2.ID = 6;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteDoubleAsync(OldPrice, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        await oprot.WriteFieldStopAsync(cancellationToken);
+        await oprot.WriteStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        oprot.DecrementRecursionDepth();
+      }
+    }
+
+    public override bool Equals(object that)
+    {
+      if (!(that is BonusValueItem other)) return false;
+      if (ReferenceEquals(this, other)) return true;
+      return ((__isset.Id == other.__isset.Id) && ((!__isset.Id) || (global::System.Object.Equals(Id, other.Id))))
+        && ((__isset.Type == other.__isset.Type) && ((!__isset.Type) || (global::System.Object.Equals(Type, other.Type))))
+        && ((__isset.SortId == other.__isset.SortId) && ((!__isset.SortId) || (global::System.Object.Equals(SortId, other.SortId))))
+        && ((__isset.Price == other.__isset.Price) && ((!__isset.Price) || (global::System.Object.Equals(Price, other.Price))))
+        && ((__isset.Reward == other.__isset.Reward) && ((!__isset.Reward) || (global::System.Object.Equals(Reward, other.Reward))))
+        && ((__isset.OldPrice == other.__isset.OldPrice) && ((!__isset.OldPrice) || (global::System.Object.Equals(OldPrice, other.OldPrice))));
+    }
+
+    public override int GetHashCode() {
+      int hashcode = 157;
+      unchecked {
+        if(__isset.Id)
+        {
+          hashcode = (hashcode * 397) + Id.GetHashCode();
+        }
+        if((Type != null) && __isset.Type)
+        {
+          hashcode = (hashcode * 397) + Type.GetHashCode();
+        }
+        if(__isset.SortId)
+        {
+          hashcode = (hashcode * 397) + SortId.GetHashCode();
+        }
+        if(__isset.Price)
+        {
+          hashcode = (hashcode * 397) + Price.GetHashCode();
+        }
+        if((Reward != null) && __isset.Reward)
+        {
+          hashcode = (hashcode * 397) + Reward.GetHashCode();
+        }
+        if(__isset.OldPrice)
+        {
+          hashcode = (hashcode * 397) + OldPrice.GetHashCode();
+        }
+      }
+      return hashcode;
+    }
+
+    public override string ToString()
+    {
+      var tmp3 = new StringBuilder("BonusValueItem(");
+      int tmp4 = 0;
+      if(__isset.Id)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("Id: ");
+        Id.ToString(tmp3);
+      }
+      if((Type != null) && __isset.Type)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("Type: ");
+        Type.ToString(tmp3);
+      }
+      if(__isset.SortId)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("SortId: ");
+        SortId.ToString(tmp3);
+      }
+      if(__isset.Price)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("Price: ");
+        Price.ToString(tmp3);
+      }
+      if((Reward != null) && __isset.Reward)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("Reward: ");
+        Reward.ToString(tmp3);
+      }
+      if(__isset.OldPrice)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("OldPrice: ");
+        OldPrice.ToString(tmp3);
+      }
+      tmp3.Append(')');
+      return tmp3.ToString();
+    }
+  }
+
+}

compiled_output/csharp/Byway/Thrift/Data/CardDetailCfg.cs

@@ -0,0 +1,214 @@
+/**
+ * <auto-generated>
+ * Autogenerated by Thrift Compiler (0.22.0)
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * </auto-generated>
+ */
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Thrift;
+using Thrift.Collections;
+using System.Runtime.Serialization;
+using Thrift.Protocol;
+using Thrift.Protocol.Entities;
+using Thrift.Protocol.Utilities;
+using Thrift.Transport;
+using Thrift.Transport.Client;
+
+
+#pragma warning disable IDE0079  // remove unnecessary pragmas
+#pragma warning disable IDE0017  // object init can be simplified
+#pragma warning disable IDE0028  // collection init can be simplified
+#pragma warning disable IDE0305  // collection init can be simplified
+#pragma warning disable IDE0034  // simplify default expression
+#pragma warning disable IDE0066  // use switch expression
+#pragma warning disable IDE0090  // simplify new expression
+#pragma warning disable IDE0290  // use primary CTOR
+#pragma warning disable IDE1006  // parts of the code use IDL spelling
+#pragma warning disable CA1822   // empty DeepCopy() methods still non-static
+#pragma warning disable IDE0083  // pattern matching "that is not SomeType" requires net5.0 but we still support earlier versions
+
+namespace Byway.Thrift.Data
+{
+
+  [DataContract(Namespace="")]
+  public partial class CardDetailCfg : TBase
+  {
+    private Dictionary<int, global::Byway.Thrift.Data.CardDetailCfgItem> _carddetailcfgs;
+
+    [DataMember(Order = 0)]
+    public Dictionary<int, global::Byway.Thrift.Data.CardDetailCfgItem> Carddetailcfgs
+    {
+      get
+      {
+        return _carddetailcfgs;
+      }
+      set
+      {
+        __isset.@carddetailcfgs = true;
+        this._carddetailcfgs = value;
+      }
+    }
+
+
+    [DataMember(Order = 1)]
+    public Isset __isset;
+    [DataContract]
+    public struct Isset
+    {
+      [DataMember]
+      public bool @carddetailcfgs;
+    }
+
+    #region XmlSerializer support
+
+    public bool ShouldSerializeCarddetailcfgs()
+    {
+      return __isset.@carddetailcfgs;
+    }
+
+    #endregion XmlSerializer support
+
+    public CardDetailCfg()
+    {
+    }
+
+    public CardDetailCfg DeepCopy()
+    {
+      var tmp5 = new CardDetailCfg();
+      if((Carddetailcfgs != null) && __isset.@carddetailcfgs)
+      {
+        tmp5.Carddetailcfgs = this.Carddetailcfgs.DeepCopy();
+      }
+      tmp5.__isset.@carddetailcfgs = this.__isset.@carddetailcfgs;
+      return tmp5;
+    }
+
+    public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
+    {
+      iprot.IncrementRecursionDepth();
+      try
+      {
+        TField field;
+        await iprot.ReadStructBeginAsync(cancellationToken);
+        while (true)
+        {
+          field = await iprot.ReadFieldBeginAsync(cancellationToken);
+          if (field.Type == TType.Stop)
+          {
+            break;
+          }
+
+          switch (field.ID)
+          {
+            case 1:
+              if (field.Type == TType.Map)
+              {
+                {
+                  var _map6 = await iprot.ReadMapBeginAsync(cancellationToken);
+                  Carddetailcfgs = new Dictionary<int, global::Byway.Thrift.Data.CardDetailCfgItem>(_map6.Count);
+                  for(int _i7 = 0; _i7 < _map6.Count; ++_i7)
+                  {
+                    int _key8;
+                    global::Byway.Thrift.Data.CardDetailCfgItem _val9;
+                    _key8 = await iprot.ReadI32Async(cancellationToken);
+                    _val9 = new global::Byway.Thrift.Data.CardDetailCfgItem();
+                    await _val9.ReadAsync(iprot, cancellationToken);
+                    Carddetailcfgs[_key8] = _val9;
+                  }
+                  await iprot.ReadMapEndAsync(cancellationToken);
+                }
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            default: 
+              await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              break;
+          }
+
+          await iprot.ReadFieldEndAsync(cancellationToken);
+        }
+
+        await iprot.ReadStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        iprot.DecrementRecursionDepth();
+      }
+    }
+
+    public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
+    {
+      oprot.IncrementRecursionDepth();
+      try
+      {
+        var tmp10 = new TStruct("CardDetailCfg");
+        await oprot.WriteStructBeginAsync(tmp10, cancellationToken);
+        var tmp11 = new TField();
+        if((Carddetailcfgs != null) && __isset.@carddetailcfgs)
+        {
+          tmp11.Name = "carddetailcfgs";
+          tmp11.Type = TType.Map;
+          tmp11.ID = 1;
+          await oprot.WriteFieldBeginAsync(tmp11, cancellationToken);
+          await oprot.WriteMapBeginAsync(new TMap(TType.I32, TType.Struct, Carddetailcfgs.Count), cancellationToken);
+          foreach (int _iter12 in Carddetailcfgs.Keys)
+          {
+            await oprot.WriteI32Async(_iter12, cancellationToken);
+            await Carddetailcfgs[_iter12].WriteAsync(oprot, cancellationToken);
+          }
+          await oprot.WriteMapEndAsync(cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        await oprot.WriteFieldStopAsync(cancellationToken);
+        await oprot.WriteStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        oprot.DecrementRecursionDepth();
+      }
+    }
+
+    public override bool Equals(object that)
+    {
+      if (!(that is CardDetailCfg other)) return false;
+      if (ReferenceEquals(this, other)) return true;
+      return ((__isset.@carddetailcfgs == other.__isset.@carddetailcfgs) && ((!__isset.@carddetailcfgs) || (TCollections.Equals(Carddetailcfgs, other.Carddetailcfgs))));
+    }
+
+    public override int GetHashCode() {
+      int hashcode = 157;
+      unchecked {
+        if((Carddetailcfgs != null) && __isset.@carddetailcfgs)
+        {
+          hashcode = (hashcode * 397) + TCollections.GetHashCode(Carddetailcfgs);
+        }
+      }
+      return hashcode;
+    }
+
+    public override string ToString()
+    {
+      var tmp13 = new StringBuilder("CardDetailCfg(");
+      int tmp14 = 0;
+      if((Carddetailcfgs != null) && __isset.@carddetailcfgs)
+      {
+        if(0 < tmp14++) { tmp13.Append(", "); }
+        tmp13.Append("Carddetailcfgs: ");
+        Carddetailcfgs.ToString(tmp13);
+      }
+      tmp13.Append(')');
+      return tmp13.ToString();
+    }
+  }
+
+}

compiled_output/csharp/Byway/Thrift/Data/CardDetailCfgItem.cs

@@ -0,0 +1,651 @@
+/**
+ * <auto-generated>
+ * Autogenerated by Thrift Compiler (0.22.0)
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * </auto-generated>
+ */
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Thrift;
+using Thrift.Collections;
+using System.Runtime.Serialization;
+using Thrift.Protocol;
+using Thrift.Protocol.Entities;
+using Thrift.Protocol.Utilities;
+using Thrift.Transport;
+using Thrift.Transport.Client;
+
+
+#pragma warning disable IDE0079  // remove unnecessary pragmas
+#pragma warning disable IDE0017  // object init can be simplified
+#pragma warning disable IDE0028  // collection init can be simplified
+#pragma warning disable IDE0305  // collection init can be simplified
+#pragma warning disable IDE0034  // simplify default expression
+#pragma warning disable IDE0066  // use switch expression
+#pragma warning disable IDE0090  // simplify new expression
+#pragma warning disable IDE0290  // use primary CTOR
+#pragma warning disable IDE1006  // parts of the code use IDL spelling
+#pragma warning disable CA1822   // empty DeepCopy() methods still non-static
+#pragma warning disable IDE0083  // pattern matching "that is not SomeType" requires net5.0 but we still support earlier versions
+
+namespace Byway.Thrift.Data
+{
+
+  [DataContract(Namespace="")]
+  public partial class CardDetailCfgItem : TBase
+  {
+    private int _Id;
+    private int _PictureAlbum;
+    private string _Icon;
+    private int _Color;
+    private int _Star;
+    private string _ImageRes;
+    private int _IsGold;
+    private string _Name;
+    private int _Round;
+
+    [DataMember(Order = 0)]
+    public int Id
+    {
+      get
+      {
+        return _Id;
+      }
+      set
+      {
+        __isset.Id = true;
+        this._Id = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public int PictureAlbum
+    {
+      get
+      {
+        return _PictureAlbum;
+      }
+      set
+      {
+        __isset.PictureAlbum = true;
+        this._PictureAlbum = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public string Icon
+    {
+      get
+      {
+        return _Icon;
+      }
+      set
+      {
+        __isset.Icon = true;
+        this._Icon = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public int Color
+    {
+      get
+      {
+        return _Color;
+      }
+      set
+      {
+        __isset.Color = true;
+        this._Color = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public int Star
+    {
+      get
+      {
+        return _Star;
+      }
+      set
+      {
+        __isset.Star = true;
+        this._Star = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public string ImageRes
+    {
+      get
+      {
+        return _ImageRes;
+      }
+      set
+      {
+        __isset.ImageRes = true;
+        this._ImageRes = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public int IsGold
+    {
+      get
+      {
+        return _IsGold;
+      }
+      set
+      {
+        __isset.IsGold = true;
+        this._IsGold = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public string Name
+    {
+      get
+      {
+        return _Name;
+      }
+      set
+      {
+        __isset.Name = true;
+        this._Name = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public int Round
+    {
+      get
+      {
+        return _Round;
+      }
+      set
+      {
+        __isset.Round = true;
+        this._Round = value;
+      }
+    }
+
+
+    [DataMember(Order = 1)]
+    public Isset __isset;
+    [DataContract]
+    public struct Isset
+    {
+      [DataMember]
+      public bool Id;
+      [DataMember]
+      public bool PictureAlbum;
+      [DataMember]
+      public bool Icon;
+      [DataMember]
+      public bool Color;
+      [DataMember]
+      public bool Star;
+      [DataMember]
+      public bool ImageRes;
+      [DataMember]
+      public bool IsGold;
+      [DataMember]
+      public bool Name;
+      [DataMember]
+      public bool Round;
+    }
+
+    #region XmlSerializer support
+
+    public bool ShouldSerializeId()
+    {
+      return __isset.Id;
+    }
+
+    public bool ShouldSerializePictureAlbum()
+    {
+      return __isset.PictureAlbum;
+    }
+
+    public bool ShouldSerializeIcon()
+    {
+      return __isset.Icon;
+    }
+
+    public bool ShouldSerializeColor()
+    {
+      return __isset.Color;
+    }
+
+    public bool ShouldSerializeStar()
+    {
+      return __isset.Star;
+    }
+
+    public bool ShouldSerializeImageRes()
+    {
+      return __isset.ImageRes;
+    }
+
+    public bool ShouldSerializeIsGold()
+    {
+      return __isset.IsGold;
+    }
+
+    public bool ShouldSerializeName()
+    {
+      return __isset.Name;
+    }
+
+    public bool ShouldSerializeRound()
+    {
+      return __isset.Round;
+    }
+
+    #endregion XmlSerializer support
+
+    public CardDetailCfgItem()
+    {
+    }
+
+    public CardDetailCfgItem DeepCopy()
+    {
+      var tmp0 = new CardDetailCfgItem();
+      if(__isset.Id)
+      {
+        tmp0.Id = this.Id;
+      }
+      tmp0.__isset.Id = this.__isset.Id;
+      if(__isset.PictureAlbum)
+      {
+        tmp0.PictureAlbum = this.PictureAlbum;
+      }
+      tmp0.__isset.PictureAlbum = this.__isset.PictureAlbum;
+      if((Icon != null) && __isset.Icon)
+      {
+        tmp0.Icon = this.Icon;
+      }
+      tmp0.__isset.Icon = this.__isset.Icon;
+      if(__isset.Color)
+      {
+        tmp0.Color = this.Color;
+      }
+      tmp0.__isset.Color = this.__isset.Color;
+      if(__isset.Star)
+      {
+        tmp0.Star = this.Star;
+      }
+      tmp0.__isset.Star = this.__isset.Star;
+      if((ImageRes != null) && __isset.ImageRes)
+      {
+        tmp0.ImageRes = this.ImageRes;
+      }
+      tmp0.__isset.ImageRes = this.__isset.ImageRes;
+      if(__isset.IsGold)
+      {
+        tmp0.IsGold = this.IsGold;
+      }
+      tmp0.__isset.IsGold = this.__isset.IsGold;
+      if((Name != null) && __isset.Name)
+      {
+        tmp0.Name = this.Name;
+      }
+      tmp0.__isset.Name = this.__isset.Name;
+      if(__isset.Round)
+      {
+        tmp0.Round = this.Round;
+      }
+      tmp0.__isset.Round = this.__isset.Round;
+      return tmp0;
+    }
+
+    public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
+    {
+      iprot.IncrementRecursionDepth();
+      try
+      {
+        TField field;
+        await iprot.ReadStructBeginAsync(cancellationToken);
+        while (true)
+        {
+          field = await iprot.ReadFieldBeginAsync(cancellationToken);
+          if (field.Type == TType.Stop)
+          {
+            break;
+          }
+
+          switch (field.ID)
+          {
+            case 1:
+              if (field.Type == TType.I32)
+              {
+                Id = await iprot.ReadI32Async(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 2:
+              if (field.Type == TType.I32)
+              {
+                PictureAlbum = await iprot.ReadI32Async(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 3:
+              if (field.Type == TType.String)
+              {
+                Icon = await iprot.ReadStringAsync(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 4:
+              if (field.Type == TType.I32)
+              {
+                Color = await iprot.ReadI32Async(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 5:
+              if (field.Type == TType.I32)
+              {
+                Star = await iprot.ReadI32Async(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 6:
+              if (field.Type == TType.String)
+              {
+                ImageRes = await iprot.ReadStringAsync(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 7:
+              if (field.Type == TType.I32)
+              {
+                IsGold = await iprot.ReadI32Async(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 8:
+              if (field.Type == TType.String)
+              {
+                Name = await iprot.ReadStringAsync(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 9:
+              if (field.Type == TType.I32)
+              {
+                Round = await iprot.ReadI32Async(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            default: 
+              await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              break;
+          }
+
+          await iprot.ReadFieldEndAsync(cancellationToken);
+        }
+
+        await iprot.ReadStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        iprot.DecrementRecursionDepth();
+      }
+    }
+
+    public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
+    {
+      oprot.IncrementRecursionDepth();
+      try
+      {
+        var tmp1 = new TStruct("CardDetailCfgItem");
+        await oprot.WriteStructBeginAsync(tmp1, cancellationToken);
+        var tmp2 = new TField();
+        if(__isset.Id)
+        {
+          tmp2.Name = "Id";
+          tmp2.Type = TType.I32;
+          tmp2.ID = 1;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteI32Async(Id, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if(__isset.PictureAlbum)
+        {
+          tmp2.Name = "PictureAlbum";
+          tmp2.Type = TType.I32;
+          tmp2.ID = 2;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteI32Async(PictureAlbum, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if((Icon != null) && __isset.Icon)
+        {
+          tmp2.Name = "Icon";
+          tmp2.Type = TType.String;
+          tmp2.ID = 3;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteStringAsync(Icon, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if(__isset.Color)
+        {
+          tmp2.Name = "Color";
+          tmp2.Type = TType.I32;
+          tmp2.ID = 4;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteI32Async(Color, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if(__isset.Star)
+        {
+          tmp2.Name = "Star";
+          tmp2.Type = TType.I32;
+          tmp2.ID = 5;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteI32Async(Star, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if((ImageRes != null) && __isset.ImageRes)
+        {
+          tmp2.Name = "ImageRes";
+          tmp2.Type = TType.String;
+          tmp2.ID = 6;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteStringAsync(ImageRes, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if(__isset.IsGold)
+        {
+          tmp2.Name = "IsGold";
+          tmp2.Type = TType.I32;
+          tmp2.ID = 7;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteI32Async(IsGold, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if((Name != null) && __isset.Name)
+        {
+          tmp2.Name = "Name";
+          tmp2.Type = TType.String;
+          tmp2.ID = 8;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteStringAsync(Name, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if(__isset.Round)
+        {
+          tmp2.Name = "Round";
+          tmp2.Type = TType.I32;
+          tmp2.ID = 9;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteI32Async(Round, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        await oprot.WriteFieldStopAsync(cancellationToken);
+        await oprot.WriteStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        oprot.DecrementRecursionDepth();
+      }
+    }
+
+    public override bool Equals(object that)
+    {
+      if (!(that is CardDetailCfgItem other)) return false;
+      if (ReferenceEquals(this, other)) return true;
+      return ((__isset.Id == other.__isset.Id) && ((!__isset.Id) || (global::System.Object.Equals(Id, other.Id))))
+        && ((__isset.PictureAlbum == other.__isset.PictureAlbum) && ((!__isset.PictureAlbum) || (global::System.Object.Equals(PictureAlbum, other.PictureAlbum))))
+        && ((__isset.Icon == other.__isset.Icon) && ((!__isset.Icon) || (global::System.Object.Equals(Icon, other.Icon))))
+        && ((__isset.Color == other.__isset.Color) && ((!__isset.Color) || (global::System.Object.Equals(Color, other.Color))))
+        && ((__isset.Star == other.__isset.Star) && ((!__isset.Star) || (global::System.Object.Equals(Star, other.Star))))
+        && ((__isset.ImageRes == other.__isset.ImageRes) && ((!__isset.ImageRes) || (global::System.Object.Equals(ImageRes, other.ImageRes))))
+        && ((__isset.IsGold == other.__isset.IsGold) && ((!__isset.IsGold) || (global::System.Object.Equals(IsGold, other.IsGold))))
+        && ((__isset.Name == other.__isset.Name) && ((!__isset.Name) || (global::System.Object.Equals(Name, other.Name))))
+        && ((__isset.Round == other.__isset.Round) && ((!__isset.Round) || (global::System.Object.Equals(Round, other.Round))));
+    }
+
+    public override int GetHashCode() {
+      int hashcode = 157;
+      unchecked {
+        if(__isset.Id)
+        {
+          hashcode = (hashcode * 397) + Id.GetHashCode();
+        }
+        if(__isset.PictureAlbum)
+        {
+          hashcode = (hashcode * 397) + PictureAlbum.GetHashCode();
+        }
+        if((Icon != null) && __isset.Icon)
+        {
+          hashcode = (hashcode * 397) + Icon.GetHashCode();
+        }
+        if(__isset.Color)
+        {
+          hashcode = (hashcode * 397) + Color.GetHashCode();
+        }
+        if(__isset.Star)
+        {
+          hashcode = (hashcode * 397) + Star.GetHashCode();
+        }
+        if((ImageRes != null) && __isset.ImageRes)
+        {
+          hashcode = (hashcode * 397) + ImageRes.GetHashCode();
+        }
+        if(__isset.IsGold)
+        {
+          hashcode = (hashcode * 397) + IsGold.GetHashCode();
+        }
+        if((Name != null) && __isset.Name)
+        {
+          hashcode = (hashcode * 397) + Name.GetHashCode();
+        }
+        if(__isset.Round)
+        {
+          hashcode = (hashcode * 397) + Round.GetHashCode();
+        }
+      }
+      return hashcode;
+    }
+
+    public override string ToString()
+    {
+      var tmp3 = new StringBuilder("CardDetailCfgItem(");
+      int tmp4 = 0;
+      if(__isset.Id)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("Id: ");
+        Id.ToString(tmp3);
+      }
+      if(__isset.PictureAlbum)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("PictureAlbum: ");
+        PictureAlbum.ToString(tmp3);
+      }
+      if((Icon != null) && __isset.Icon)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("Icon: ");
+        Icon.ToString(tmp3);
+      }
+      if(__isset.Color)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("Color: ");
+        Color.ToString(tmp3);
+      }
+      if(__isset.Star)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("Star: ");
+        Star.ToString(tmp3);
+      }
+      if((ImageRes != null) && __isset.ImageRes)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("ImageRes: ");
+        ImageRes.ToString(tmp3);
+      }
+      if(__isset.IsGold)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("IsGold: ");
+        IsGold.ToString(tmp3);
+      }
+      if((Name != null) && __isset.Name)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("Name: ");
+        Name.ToString(tmp3);
+      }
+      if(__isset.Round)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("Round: ");
+        Round.ToString(tmp3);
+      }
+      tmp3.Append(')');
+      return tmp3.ToString();
+    }
+  }
+
+}

compiled_output/csharp/Byway/Thrift/Data/CardPackCfg.cs

@@ -0,0 +1,214 @@
+/**
+ * <auto-generated>
+ * Autogenerated by Thrift Compiler (0.22.0)
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * </auto-generated>
+ */
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Thrift;
+using Thrift.Collections;
+using System.Runtime.Serialization;
+using Thrift.Protocol;
+using Thrift.Protocol.Entities;
+using Thrift.Protocol.Utilities;
+using Thrift.Transport;
+using Thrift.Transport.Client;
+
+
+#pragma warning disable IDE0079  // remove unnecessary pragmas
+#pragma warning disable IDE0017  // object init can be simplified
+#pragma warning disable IDE0028  // collection init can be simplified
+#pragma warning disable IDE0305  // collection init can be simplified
+#pragma warning disable IDE0034  // simplify default expression
+#pragma warning disable IDE0066  // use switch expression
+#pragma warning disable IDE0090  // simplify new expression
+#pragma warning disable IDE0290  // use primary CTOR
+#pragma warning disable IDE1006  // parts of the code use IDL spelling
+#pragma warning disable CA1822   // empty DeepCopy() methods still non-static
+#pragma warning disable IDE0083  // pattern matching "that is not SomeType" requires net5.0 but we still support earlier versions
+
+namespace Byway.Thrift.Data
+{
+
+  [DataContract(Namespace="")]
+  public partial class CardPackCfg : TBase
+  {
+    private Dictionary<int, global::Byway.Thrift.Data.CardPackCfgItem> _cardpackcfgs;
+
+    [DataMember(Order = 0)]
+    public Dictionary<int, global::Byway.Thrift.Data.CardPackCfgItem> Cardpackcfgs
+    {
+      get
+      {
+        return _cardpackcfgs;
+      }
+      set
+      {
+        __isset.@cardpackcfgs = true;
+        this._cardpackcfgs = value;
+      }
+    }
+
+
+    [DataMember(Order = 1)]
+    public Isset __isset;
+    [DataContract]
+    public struct Isset
+    {
+      [DataMember]
+      public bool @cardpackcfgs;
+    }
+
+    #region XmlSerializer support
+
+    public bool ShouldSerializeCardpackcfgs()
+    {
+      return __isset.@cardpackcfgs;
+    }
+
+    #endregion XmlSerializer support
+
+    public CardPackCfg()
+    {
+    }
+
+    public CardPackCfg DeepCopy()
+    {
+      var tmp5 = new CardPackCfg();
+      if((Cardpackcfgs != null) && __isset.@cardpackcfgs)
+      {
+        tmp5.Cardpackcfgs = this.Cardpackcfgs.DeepCopy();
+      }
+      tmp5.__isset.@cardpackcfgs = this.__isset.@cardpackcfgs;
+      return tmp5;
+    }
+
+    public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
+    {
+      iprot.IncrementRecursionDepth();
+      try
+      {
+        TField field;
+        await iprot.ReadStructBeginAsync(cancellationToken);
+        while (true)
+        {
+          field = await iprot.ReadFieldBeginAsync(cancellationToken);
+          if (field.Type == TType.Stop)
+          {
+            break;
+          }
+
+          switch (field.ID)
+          {
+            case 1:
+              if (field.Type == TType.Map)
+              {
+                {
+                  var _map6 = await iprot.ReadMapBeginAsync(cancellationToken);
+                  Cardpackcfgs = new Dictionary<int, global::Byway.Thrift.Data.CardPackCfgItem>(_map6.Count);
+                  for(int _i7 = 0; _i7 < _map6.Count; ++_i7)
+                  {
+                    int _key8;
+                    global::Byway.Thrift.Data.CardPackCfgItem _val9;
+                    _key8 = await iprot.ReadI32Async(cancellationToken);
+                    _val9 = new global::Byway.Thrift.Data.CardPackCfgItem();
+                    await _val9.ReadAsync(iprot, cancellationToken);
+                    Cardpackcfgs[_key8] = _val9;
+                  }
+                  await iprot.ReadMapEndAsync(cancellationToken);
+                }
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            default: 
+              await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              break;
+          }
+
+          await iprot.ReadFieldEndAsync(cancellationToken);
+        }
+
+        await iprot.ReadStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        iprot.DecrementRecursionDepth();
+      }
+    }
+
+    public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
+    {
+      oprot.IncrementRecursionDepth();
+      try
+      {
+        var tmp10 = new TStruct("CardPackCfg");
+        await oprot.WriteStructBeginAsync(tmp10, cancellationToken);
+        var tmp11 = new TField();
+        if((Cardpackcfgs != null) && __isset.@cardpackcfgs)
+        {
+          tmp11.Name = "cardpackcfgs";
+          tmp11.Type = TType.Map;
+          tmp11.ID = 1;
+          await oprot.WriteFieldBeginAsync(tmp11, cancellationToken);
+          await oprot.WriteMapBeginAsync(new TMap(TType.I32, TType.Struct, Cardpackcfgs.Count), cancellationToken);
+          foreach (int _iter12 in Cardpackcfgs.Keys)
+          {
+            await oprot.WriteI32Async(_iter12, cancellationToken);
+            await Cardpackcfgs[_iter12].WriteAsync(oprot, cancellationToken);
+          }
+          await oprot.WriteMapEndAsync(cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        await oprot.WriteFieldStopAsync(cancellationToken);
+        await oprot.WriteStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        oprot.DecrementRecursionDepth();
+      }
+    }
+
+    public override bool Equals(object that)
+    {
+      if (!(that is CardPackCfg other)) return false;
+      if (ReferenceEquals(this, other)) return true;
+      return ((__isset.@cardpackcfgs == other.__isset.@cardpackcfgs) && ((!__isset.@cardpackcfgs) || (TCollections.Equals(Cardpackcfgs, other.Cardpackcfgs))));
+    }
+
+    public override int GetHashCode() {
+      int hashcode = 157;
+      unchecked {
+        if((Cardpackcfgs != null) && __isset.@cardpackcfgs)
+        {
+          hashcode = (hashcode * 397) + TCollections.GetHashCode(Cardpackcfgs);
+        }
+      }
+      return hashcode;
+    }
+
+    public override string ToString()
+    {
+      var tmp13 = new StringBuilder("CardPackCfg(");
+      int tmp14 = 0;
+      if((Cardpackcfgs != null) && __isset.@cardpackcfgs)
+      {
+        if(0 < tmp14++) { tmp13.Append(", "); }
+        tmp13.Append("Cardpackcfgs: ");
+        Cardpackcfgs.ToString(tmp13);
+      }
+      tmp13.Append(')');
+      return tmp13.ToString();
+    }
+  }
+
+}

compiled_output/csharp/Byway/Thrift/Data/CardPackCfgItem.cs

@@ -0,0 +1,480 @@
+/**
+ * <auto-generated>
+ * Autogenerated by Thrift Compiler (0.22.0)
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * </auto-generated>
+ */
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Thrift;
+using Thrift.Collections;
+using System.Runtime.Serialization;
+using Thrift.Protocol;
+using Thrift.Protocol.Entities;
+using Thrift.Protocol.Utilities;
+using Thrift.Transport;
+using Thrift.Transport.Client;
+
+
+#pragma warning disable IDE0079  // remove unnecessary pragmas
+#pragma warning disable IDE0017  // object init can be simplified
+#pragma warning disable IDE0028  // collection init can be simplified
+#pragma warning disable IDE0305  // collection init can be simplified
+#pragma warning disable IDE0034  // simplify default expression
+#pragma warning disable IDE0066  // use switch expression
+#pragma warning disable IDE0090  // simplify new expression
+#pragma warning disable IDE0290  // use primary CTOR
+#pragma warning disable IDE1006  // parts of the code use IDL spelling
+#pragma warning disable CA1822   // empty DeepCopy() methods still non-static
+#pragma warning disable IDE0083  // pattern matching "that is not SomeType" requires net5.0 but we still support earlier versions
+
+namespace Byway.Thrift.Data
+{
+
+  [DataContract(Namespace="")]
+  public partial class CardPackCfgItem : TBase
+  {
+    private int _Id;
+    private string _Icon;
+    private int _Color;
+    private string _Name;
+    private int _RewardCnt;
+    private int _GoldRate;
+
+    [DataMember(Order = 0)]
+    public int Id
+    {
+      get
+      {
+        return _Id;
+      }
+      set
+      {
+        __isset.Id = true;
+        this._Id = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public string Icon
+    {
+      get
+      {
+        return _Icon;
+      }
+      set
+      {
+        __isset.Icon = true;
+        this._Icon = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public int Color
+    {
+      get
+      {
+        return _Color;
+      }
+      set
+      {
+        __isset.Color = true;
+        this._Color = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public string Name
+    {
+      get
+      {
+        return _Name;
+      }
+      set
+      {
+        __isset.Name = true;
+        this._Name = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public int RewardCnt
+    {
+      get
+      {
+        return _RewardCnt;
+      }
+      set
+      {
+        __isset.RewardCnt = true;
+        this._RewardCnt = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public int GoldRate
+    {
+      get
+      {
+        return _GoldRate;
+      }
+      set
+      {
+        __isset.GoldRate = true;
+        this._GoldRate = value;
+      }
+    }
+
+
+    [DataMember(Order = 1)]
+    public Isset __isset;
+    [DataContract]
+    public struct Isset
+    {
+      [DataMember]
+      public bool Id;
+      [DataMember]
+      public bool Icon;
+      [DataMember]
+      public bool Color;
+      [DataMember]
+      public bool Name;
+      [DataMember]
+      public bool RewardCnt;
+      [DataMember]
+      public bool GoldRate;
+    }
+
+    #region XmlSerializer support
+
+    public bool ShouldSerializeId()
+    {
+      return __isset.Id;
+    }
+
+    public bool ShouldSerializeIcon()
+    {
+      return __isset.Icon;
+    }
+
+    public bool ShouldSerializeColor()
+    {
+      return __isset.Color;
+    }
+
+    public bool ShouldSerializeName()
+    {
+      return __isset.Name;
+    }
+
+    public bool ShouldSerializeRewardCnt()
+    {
+      return __isset.RewardCnt;
+    }
+
+    public bool ShouldSerializeGoldRate()
+    {
+      return __isset.GoldRate;
+    }
+
+    #endregion XmlSerializer support
+
+    public CardPackCfgItem()
+    {
+    }
+
+    public CardPackCfgItem DeepCopy()
+    {
+      var tmp0 = new CardPackCfgItem();
+      if(__isset.Id)
+      {
+        tmp0.Id = this.Id;
+      }
+      tmp0.__isset.Id = this.__isset.Id;
+      if((Icon != null) && __isset.Icon)
+      {
+        tmp0.Icon = this.Icon;
+      }
+      tmp0.__isset.Icon = this.__isset.Icon;
+      if(__isset.Color)
+      {
+        tmp0.Color = this.Color;
+      }
+      tmp0.__isset.Color = this.__isset.Color;
+      if((Name != null) && __isset.Name)
+      {
+        tmp0.Name = this.Name;
+      }
+      tmp0.__isset.Name = this.__isset.Name;
+      if(__isset.RewardCnt)
+      {
+        tmp0.RewardCnt = this.RewardCnt;
+      }
+      tmp0.__isset.RewardCnt = this.__isset.RewardCnt;
+      if(__isset.GoldRate)
+      {
+        tmp0.GoldRate = this.GoldRate;
+      }
+      tmp0.__isset.GoldRate = this.__isset.GoldRate;
+      return tmp0;
+    }
+
+    public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
+    {
+      iprot.IncrementRecursionDepth();
+      try
+      {
+        TField field;
+        await iprot.ReadStructBeginAsync(cancellationToken);
+        while (true)
+        {
+          field = await iprot.ReadFieldBeginAsync(cancellationToken);
+          if (field.Type == TType.Stop)
+          {
+            break;
+          }
+
+          switch (field.ID)
+          {
+            case 1:
+              if (field.Type == TType.I32)
+              {
+                Id = await iprot.ReadI32Async(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 2:
+              if (field.Type == TType.String)
+              {
+                Icon = await iprot.ReadStringAsync(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 3:
+              if (field.Type == TType.I32)
+              {
+                Color = await iprot.ReadI32Async(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 4:
+              if (field.Type == TType.String)
+              {
+                Name = await iprot.ReadStringAsync(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 5:
+              if (field.Type == TType.I32)
+              {
+                RewardCnt = await iprot.ReadI32Async(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 6:
+              if (field.Type == TType.I32)
+              {
+                GoldRate = await iprot.ReadI32Async(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            default: 
+              await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              break;
+          }
+
+          await iprot.ReadFieldEndAsync(cancellationToken);
+        }
+
+        await iprot.ReadStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        iprot.DecrementRecursionDepth();
+      }
+    }
+
+    public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
+    {
+      oprot.IncrementRecursionDepth();
+      try
+      {
+        var tmp1 = new TStruct("CardPackCfgItem");
+        await oprot.WriteStructBeginAsync(tmp1, cancellationToken);
+        var tmp2 = new TField();
+        if(__isset.Id)
+        {
+          tmp2.Name = "Id";
+          tmp2.Type = TType.I32;
+          tmp2.ID = 1;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteI32Async(Id, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if((Icon != null) && __isset.Icon)
+        {
+          tmp2.Name = "Icon";
+          tmp2.Type = TType.String;
+          tmp2.ID = 2;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteStringAsync(Icon, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if(__isset.Color)
+        {
+          tmp2.Name = "Color";
+          tmp2.Type = TType.I32;
+          tmp2.ID = 3;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteI32Async(Color, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if((Name != null) && __isset.Name)
+        {
+          tmp2.Name = "Name";
+          tmp2.Type = TType.String;
+          tmp2.ID = 4;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteStringAsync(Name, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if(__isset.RewardCnt)
+        {
+          tmp2.Name = "RewardCnt";
+          tmp2.Type = TType.I32;
+          tmp2.ID = 5;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteI32Async(RewardCnt, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if(__isset.GoldRate)
+        {
+          tmp2.Name = "GoldRate";
+          tmp2.Type = TType.I32;
+          tmp2.ID = 6;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteI32Async(GoldRate, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        await oprot.WriteFieldStopAsync(cancellationToken);
+        await oprot.WriteStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        oprot.DecrementRecursionDepth();
+      }
+    }
+
+    public override bool Equals(object that)
+    {
+      if (!(that is CardPackCfgItem other)) return false;
+      if (ReferenceEquals(this, other)) return true;
+      return ((__isset.Id == other.__isset.Id) && ((!__isset.Id) || (global::System.Object.Equals(Id, other.Id))))
+        && ((__isset.Icon == other.__isset.Icon) && ((!__isset.Icon) || (global::System.Object.Equals(Icon, other.Icon))))
+        && ((__isset.Color == other.__isset.Color) && ((!__isset.Color) || (global::System.Object.Equals(Color, other.Color))))
+        && ((__isset.Name == other.__isset.Name) && ((!__isset.Name) || (global::System.Object.Equals(Name, other.Name))))
+        && ((__isset.RewardCnt == other.__isset.RewardCnt) && ((!__isset.RewardCnt) || (global::System.Object.Equals(RewardCnt, other.RewardCnt))))
+        && ((__isset.GoldRate == other.__isset.GoldRate) && ((!__isset.GoldRate) || (global::System.Object.Equals(GoldRate, other.GoldRate))));
+    }
+
+    public override int GetHashCode() {
+      int hashcode = 157;
+      unchecked {
+        if(__isset.Id)
+        {
+          hashcode = (hashcode * 397) + Id.GetHashCode();
+        }
+        if((Icon != null) && __isset.Icon)
+        {
+          hashcode = (hashcode * 397) + Icon.GetHashCode();
+        }
+        if(__isset.Color)
+        {
+          hashcode = (hashcode * 397) + Color.GetHashCode();
+        }
+        if((Name != null) && __isset.Name)
+        {
+          hashcode = (hashcode * 397) + Name.GetHashCode();
+        }
+        if(__isset.RewardCnt)
+        {
+          hashcode = (hashcode * 397) + RewardCnt.GetHashCode();
+        }
+        if(__isset.GoldRate)
+        {
+          hashcode = (hashcode * 397) + GoldRate.GetHashCode();
+        }
+      }
+      return hashcode;
+    }
+
+    public override string ToString()
+    {
+      var tmp3 = new StringBuilder("CardPackCfgItem(");
+      int tmp4 = 0;
+      if(__isset.Id)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("Id: ");
+        Id.ToString(tmp3);
+      }
+      if((Icon != null) && __isset.Icon)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("Icon: ");
+        Icon.ToString(tmp3);
+      }
+      if(__isset.Color)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("Color: ");
+        Color.ToString(tmp3);
+      }
+      if((Name != null) && __isset.Name)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("Name: ");
+        Name.ToString(tmp3);
+      }
+      if(__isset.RewardCnt)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("RewardCnt: ");
+        RewardCnt.ToString(tmp3);
+      }
+      if(__isset.GoldRate)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("GoldRate: ");
+        GoldRate.ToString(tmp3);
+      }
+      tmp3.Append(')');
+      return tmp3.ToString();
+    }
+  }
+
+}

compiled_output/csharp/Byway/Thrift/Data/CardStickerExchangeCfg.cs

@@ -0,0 +1,214 @@
+/**
+ * <auto-generated>
+ * Autogenerated by Thrift Compiler (0.22.0)
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * </auto-generated>
+ */
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Thrift;
+using Thrift.Collections;
+using System.Runtime.Serialization;
+using Thrift.Protocol;
+using Thrift.Protocol.Entities;
+using Thrift.Protocol.Utilities;
+using Thrift.Transport;
+using Thrift.Transport.Client;
+
+
+#pragma warning disable IDE0079  // remove unnecessary pragmas
+#pragma warning disable IDE0017  // object init can be simplified
+#pragma warning disable IDE0028  // collection init can be simplified
+#pragma warning disable IDE0305  // collection init can be simplified
+#pragma warning disable IDE0034  // simplify default expression
+#pragma warning disable IDE0066  // use switch expression
+#pragma warning disable IDE0090  // simplify new expression
+#pragma warning disable IDE0290  // use primary CTOR
+#pragma warning disable IDE1006  // parts of the code use IDL spelling
+#pragma warning disable CA1822   // empty DeepCopy() methods still non-static
+#pragma warning disable IDE0083  // pattern matching "that is not SomeType" requires net5.0 but we still support earlier versions
+
+namespace Byway.Thrift.Data
+{
+
+  [DataContract(Namespace="")]
+  public partial class CardStickerExchangeCfg : TBase
+  {
+    private Dictionary<int, global::Byway.Thrift.Data.CardStickerExchangeCfgItem> _cardstickerexchangecfgs;
+
+    [DataMember(Order = 0)]
+    public Dictionary<int, global::Byway.Thrift.Data.CardStickerExchangeCfgItem> Cardstickerexchangecfgs
+    {
+      get
+      {
+        return _cardstickerexchangecfgs;
+      }
+      set
+      {
+        __isset.@cardstickerexchangecfgs = true;
+        this._cardstickerexchangecfgs = value;
+      }
+    }
+
+
+    [DataMember(Order = 1)]
+    public Isset __isset;
+    [DataContract]
+    public struct Isset
+    {
+      [DataMember]
+      public bool @cardstickerexchangecfgs;
+    }
+
+    #region XmlSerializer support
+
+    public bool ShouldSerializeCardstickerexchangecfgs()
+    {
+      return __isset.@cardstickerexchangecfgs;
+    }
+
+    #endregion XmlSerializer support
+
+    public CardStickerExchangeCfg()
+    {
+    }
+
+    public CardStickerExchangeCfg DeepCopy()
+    {
+      var tmp5 = new CardStickerExchangeCfg();
+      if((Cardstickerexchangecfgs != null) && __isset.@cardstickerexchangecfgs)
+      {
+        tmp5.Cardstickerexchangecfgs = this.Cardstickerexchangecfgs.DeepCopy();
+      }
+      tmp5.__isset.@cardstickerexchangecfgs = this.__isset.@cardstickerexchangecfgs;
+      return tmp5;
+    }
+
+    public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
+    {
+      iprot.IncrementRecursionDepth();
+      try
+      {
+        TField field;
+        await iprot.ReadStructBeginAsync(cancellationToken);
+        while (true)
+        {
+          field = await iprot.ReadFieldBeginAsync(cancellationToken);
+          if (field.Type == TType.Stop)
+          {
+            break;
+          }
+
+          switch (field.ID)
+          {
+            case 1:
+              if (field.Type == TType.Map)
+              {
+                {
+                  var _map6 = await iprot.ReadMapBeginAsync(cancellationToken);
+                  Cardstickerexchangecfgs = new Dictionary<int, global::Byway.Thrift.Data.CardStickerExchangeCfgItem>(_map6.Count);
+                  for(int _i7 = 0; _i7 < _map6.Count; ++_i7)
+                  {
+                    int _key8;
+                    global::Byway.Thrift.Data.CardStickerExchangeCfgItem _val9;
+                    _key8 = await iprot.ReadI32Async(cancellationToken);
+                    _val9 = new global::Byway.Thrift.Data.CardStickerExchangeCfgItem();
+                    await _val9.ReadAsync(iprot, cancellationToken);
+                    Cardstickerexchangecfgs[_key8] = _val9;
+                  }
+                  await iprot.ReadMapEndAsync(cancellationToken);
+                }
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            default: 
+              await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              break;
+          }
+
+          await iprot.ReadFieldEndAsync(cancellationToken);
+        }
+
+        await iprot.ReadStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        iprot.DecrementRecursionDepth();
+      }
+    }
+
+    public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
+    {
+      oprot.IncrementRecursionDepth();
+      try
+      {
+        var tmp10 = new TStruct("CardStickerExchangeCfg");
+        await oprot.WriteStructBeginAsync(tmp10, cancellationToken);
+        var tmp11 = new TField();
+        if((Cardstickerexchangecfgs != null) && __isset.@cardstickerexchangecfgs)
+        {
+          tmp11.Name = "cardstickerexchangecfgs";
+          tmp11.Type = TType.Map;
+          tmp11.ID = 1;
+          await oprot.WriteFieldBeginAsync(tmp11, cancellationToken);
+          await oprot.WriteMapBeginAsync(new TMap(TType.I32, TType.Struct, Cardstickerexchangecfgs.Count), cancellationToken);
+          foreach (int _iter12 in Cardstickerexchangecfgs.Keys)
+          {
+            await oprot.WriteI32Async(_iter12, cancellationToken);
+            await Cardstickerexchangecfgs[_iter12].WriteAsync(oprot, cancellationToken);
+          }
+          await oprot.WriteMapEndAsync(cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        await oprot.WriteFieldStopAsync(cancellationToken);
+        await oprot.WriteStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        oprot.DecrementRecursionDepth();
+      }
+    }
+
+    public override bool Equals(object that)
+    {
+      if (!(that is CardStickerExchangeCfg other)) return false;
+      if (ReferenceEquals(this, other)) return true;
+      return ((__isset.@cardstickerexchangecfgs == other.__isset.@cardstickerexchangecfgs) && ((!__isset.@cardstickerexchangecfgs) || (TCollections.Equals(Cardstickerexchangecfgs, other.Cardstickerexchangecfgs))));
+    }
+
+    public override int GetHashCode() {
+      int hashcode = 157;
+      unchecked {
+        if((Cardstickerexchangecfgs != null) && __isset.@cardstickerexchangecfgs)
+        {
+          hashcode = (hashcode * 397) + TCollections.GetHashCode(Cardstickerexchangecfgs);
+        }
+      }
+      return hashcode;
+    }
+
+    public override string ToString()
+    {
+      var tmp13 = new StringBuilder("CardStickerExchangeCfg(");
+      int tmp14 = 0;
+      if((Cardstickerexchangecfgs != null) && __isset.@cardstickerexchangecfgs)
+      {
+        if(0 < tmp14++) { tmp13.Append(", "); }
+        tmp13.Append("Cardstickerexchangecfgs: ");
+        Cardstickerexchangecfgs.ToString(tmp13);
+      }
+      tmp13.Append(')');
+      return tmp13.ToString();
+    }
+  }
+
+}

compiled_output/csharp/Byway/Thrift/Data/CardStickerExchangeCfgItem.cs

@@ -0,0 +1,423 @@
+/**
+ * <auto-generated>
+ * Autogenerated by Thrift Compiler (0.22.0)
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * </auto-generated>
+ */
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Thrift;
+using Thrift.Collections;
+using System.Runtime.Serialization;
+using Thrift.Protocol;
+using Thrift.Protocol.Entities;
+using Thrift.Protocol.Utilities;
+using Thrift.Transport;
+using Thrift.Transport.Client;
+
+
+#pragma warning disable IDE0079  // remove unnecessary pragmas
+#pragma warning disable IDE0017  // object init can be simplified
+#pragma warning disable IDE0028  // collection init can be simplified
+#pragma warning disable IDE0305  // collection init can be simplified
+#pragma warning disable IDE0034  // simplify default expression
+#pragma warning disable IDE0066  // use switch expression
+#pragma warning disable IDE0090  // simplify new expression
+#pragma warning disable IDE0290  // use primary CTOR
+#pragma warning disable IDE1006  // parts of the code use IDL spelling
+#pragma warning disable CA1822   // empty DeepCopy() methods still non-static
+#pragma warning disable IDE0083  // pattern matching "that is not SomeType" requires net5.0 but we still support earlier versions
+
+namespace Byway.Thrift.Data
+{
+
+  [DataContract(Namespace="")]
+  public partial class CardStickerExchangeCfgItem : TBase
+  {
+    private int _Id;
+    private string _Icon;
+    private int _Cost;
+    private string _RewardId;
+    private string _RewardCnt;
+
+    [DataMember(Order = 0)]
+    public int Id
+    {
+      get
+      {
+        return _Id;
+      }
+      set
+      {
+        __isset.Id = true;
+        this._Id = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public string Icon
+    {
+      get
+      {
+        return _Icon;
+      }
+      set
+      {
+        __isset.Icon = true;
+        this._Icon = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public int Cost
+    {
+      get
+      {
+        return _Cost;
+      }
+      set
+      {
+        __isset.Cost = true;
+        this._Cost = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public string RewardId
+    {
+      get
+      {
+        return _RewardId;
+      }
+      set
+      {
+        __isset.RewardId = true;
+        this._RewardId = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public string RewardCnt
+    {
+      get
+      {
+        return _RewardCnt;
+      }
+      set
+      {
+        __isset.RewardCnt = true;
+        this._RewardCnt = value;
+      }
+    }
+
+
+    [DataMember(Order = 1)]
+    public Isset __isset;
+    [DataContract]
+    public struct Isset
+    {
+      [DataMember]
+      public bool Id;
+      [DataMember]
+      public bool Icon;
+      [DataMember]
+      public bool Cost;
+      [DataMember]
+      public bool RewardId;
+      [DataMember]
+      public bool RewardCnt;
+    }
+
+    #region XmlSerializer support
+
+    public bool ShouldSerializeId()
+    {
+      return __isset.Id;
+    }
+
+    public bool ShouldSerializeIcon()
+    {
+      return __isset.Icon;
+    }
+
+    public bool ShouldSerializeCost()
+    {
+      return __isset.Cost;
+    }
+
+    public bool ShouldSerializeRewardId()
+    {
+      return __isset.RewardId;
+    }
+
+    public bool ShouldSerializeRewardCnt()
+    {
+      return __isset.RewardCnt;
+    }
+
+    #endregion XmlSerializer support
+
+    public CardStickerExchangeCfgItem()
+    {
+    }
+
+    public CardStickerExchangeCfgItem DeepCopy()
+    {
+      var tmp0 = new CardStickerExchangeCfgItem();
+      if(__isset.Id)
+      {
+        tmp0.Id = this.Id;
+      }
+      tmp0.__isset.Id = this.__isset.Id;
+      if((Icon != null) && __isset.Icon)
+      {
+        tmp0.Icon = this.Icon;
+      }
+      tmp0.__isset.Icon = this.__isset.Icon;
+      if(__isset.Cost)
+      {
+        tmp0.Cost = this.Cost;
+      }
+      tmp0.__isset.Cost = this.__isset.Cost;
+      if((RewardId != null) && __isset.RewardId)
+      {
+        tmp0.RewardId = this.RewardId;
+      }
+      tmp0.__isset.RewardId = this.__isset.RewardId;
+      if((RewardCnt != null) && __isset.RewardCnt)
+      {
+        tmp0.RewardCnt = this.RewardCnt;
+      }
+      tmp0.__isset.RewardCnt = this.__isset.RewardCnt;
+      return tmp0;
+    }
+
+    public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
+    {
+      iprot.IncrementRecursionDepth();
+      try
+      {
+        TField field;
+        await iprot.ReadStructBeginAsync(cancellationToken);
+        while (true)
+        {
+          field = await iprot.ReadFieldBeginAsync(cancellationToken);
+          if (field.Type == TType.Stop)
+          {
+            break;
+          }
+
+          switch (field.ID)
+          {
+            case 1:
+              if (field.Type == TType.I32)
+              {
+                Id = await iprot.ReadI32Async(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 2:
+              if (field.Type == TType.String)
+              {
+                Icon = await iprot.ReadStringAsync(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 3:
+              if (field.Type == TType.I32)
+              {
+                Cost = await iprot.ReadI32Async(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 4:
+              if (field.Type == TType.String)
+              {
+                RewardId = await iprot.ReadStringAsync(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 5:
+              if (field.Type == TType.String)
+              {
+                RewardCnt = await iprot.ReadStringAsync(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            default: 
+              await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              break;
+          }
+
+          await iprot.ReadFieldEndAsync(cancellationToken);
+        }
+
+        await iprot.ReadStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        iprot.DecrementRecursionDepth();
+      }
+    }
+
+    public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
+    {
+      oprot.IncrementRecursionDepth();
+      try
+      {
+        var tmp1 = new TStruct("CardStickerExchangeCfgItem");
+        await oprot.WriteStructBeginAsync(tmp1, cancellationToken);
+        var tmp2 = new TField();
+        if(__isset.Id)
+        {
+          tmp2.Name = "Id";
+          tmp2.Type = TType.I32;
+          tmp2.ID = 1;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteI32Async(Id, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if((Icon != null) && __isset.Icon)
+        {
+          tmp2.Name = "Icon";
+          tmp2.Type = TType.String;
+          tmp2.ID = 2;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteStringAsync(Icon, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if(__isset.Cost)
+        {
+          tmp2.Name = "Cost";
+          tmp2.Type = TType.I32;
+          tmp2.ID = 3;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteI32Async(Cost, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if((RewardId != null) && __isset.RewardId)
+        {
+          tmp2.Name = "RewardId";
+          tmp2.Type = TType.String;
+          tmp2.ID = 4;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteStringAsync(RewardId, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if((RewardCnt != null) && __isset.RewardCnt)
+        {
+          tmp2.Name = "RewardCnt";
+          tmp2.Type = TType.String;
+          tmp2.ID = 5;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteStringAsync(RewardCnt, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        await oprot.WriteFieldStopAsync(cancellationToken);
+        await oprot.WriteStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        oprot.DecrementRecursionDepth();
+      }
+    }
+
+    public override bool Equals(object that)
+    {
+      if (!(that is CardStickerExchangeCfgItem other)) return false;
+      if (ReferenceEquals(this, other)) return true;
+      return ((__isset.Id == other.__isset.Id) && ((!__isset.Id) || (global::System.Object.Equals(Id, other.Id))))
+        && ((__isset.Icon == other.__isset.Icon) && ((!__isset.Icon) || (global::System.Object.Equals(Icon, other.Icon))))
+        && ((__isset.Cost == other.__isset.Cost) && ((!__isset.Cost) || (global::System.Object.Equals(Cost, other.Cost))))
+        && ((__isset.RewardId == other.__isset.RewardId) && ((!__isset.RewardId) || (global::System.Object.Equals(RewardId, other.RewardId))))
+        && ((__isset.RewardCnt == other.__isset.RewardCnt) && ((!__isset.RewardCnt) || (global::System.Object.Equals(RewardCnt, other.RewardCnt))));
+    }
+
+    public override int GetHashCode() {
+      int hashcode = 157;
+      unchecked {
+        if(__isset.Id)
+        {
+          hashcode = (hashcode * 397) + Id.GetHashCode();
+        }
+        if((Icon != null) && __isset.Icon)
+        {
+          hashcode = (hashcode * 397) + Icon.GetHashCode();
+        }
+        if(__isset.Cost)
+        {
+          hashcode = (hashcode * 397) + Cost.GetHashCode();
+        }
+        if((RewardId != null) && __isset.RewardId)
+        {
+          hashcode = (hashcode * 397) + RewardId.GetHashCode();
+        }
+        if((RewardCnt != null) && __isset.RewardCnt)
+        {
+          hashcode = (hashcode * 397) + RewardCnt.GetHashCode();
+        }
+      }
+      return hashcode;
+    }
+
+    public override string ToString()
+    {
+      var tmp3 = new StringBuilder("CardStickerExchangeCfgItem(");
+      int tmp4 = 0;
+      if(__isset.Id)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("Id: ");
+        Id.ToString(tmp3);
+      }
+      if((Icon != null) && __isset.Icon)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("Icon: ");
+        Icon.ToString(tmp3);
+      }
+      if(__isset.Cost)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("Cost: ");
+        Cost.ToString(tmp3);
+      }
+      if((RewardId != null) && __isset.RewardId)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("RewardId: ");
+        RewardId.ToString(tmp3);
+      }
+      if((RewardCnt != null) && __isset.RewardCnt)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("RewardCnt: ");
+        RewardCnt.ToString(tmp3);
+      }
+      tmp3.Append(')');
+      return tmp3.ToString();
+    }
+  }
+
+}

compiled_output/csharp/Byway/Thrift/Data/CatTrickData.cs

@@ -0,0 +1,214 @@
+/**
+ * <auto-generated>
+ * Autogenerated by Thrift Compiler (0.22.0)
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * </auto-generated>
+ */
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Thrift;
+using Thrift.Collections;
+using System.Runtime.Serialization;
+using Thrift.Protocol;
+using Thrift.Protocol.Entities;
+using Thrift.Protocol.Utilities;
+using Thrift.Transport;
+using Thrift.Transport.Client;
+
+
+#pragma warning disable IDE0079  // remove unnecessary pragmas
+#pragma warning disable IDE0017  // object init can be simplified
+#pragma warning disable IDE0028  // collection init can be simplified
+#pragma warning disable IDE0305  // collection init can be simplified
+#pragma warning disable IDE0034  // simplify default expression
+#pragma warning disable IDE0066  // use switch expression
+#pragma warning disable IDE0090  // simplify new expression
+#pragma warning disable IDE0290  // use primary CTOR
+#pragma warning disable IDE1006  // parts of the code use IDL spelling
+#pragma warning disable CA1822   // empty DeepCopy() methods still non-static
+#pragma warning disable IDE0083  // pattern matching "that is not SomeType" requires net5.0 but we still support earlier versions
+
+namespace Byway.Thrift.Data
+{
+
+  [DataContract(Namespace="")]
+  public partial class CatTrickData : TBase
+  {
+    private Dictionary<int, global::Byway.Thrift.Data.CatTrickDataItem> _cattrickdatas;
+
+    [DataMember(Order = 0)]
+    public Dictionary<int, global::Byway.Thrift.Data.CatTrickDataItem> Cattrickdatas
+    {
+      get
+      {
+        return _cattrickdatas;
+      }
+      set
+      {
+        __isset.@cattrickdatas = true;
+        this._cattrickdatas = value;
+      }
+    }
+
+
+    [DataMember(Order = 1)]
+    public Isset __isset;
+    [DataContract]
+    public struct Isset
+    {
+      [DataMember]
+      public bool @cattrickdatas;
+    }
+
+    #region XmlSerializer support
+
+    public bool ShouldSerializeCattrickdatas()
+    {
+      return __isset.@cattrickdatas;
+    }
+
+    #endregion XmlSerializer support
+
+    public CatTrickData()
+    {
+    }
+
+    public CatTrickData DeepCopy()
+    {
+      var tmp5 = new CatTrickData();
+      if((Cattrickdatas != null) && __isset.@cattrickdatas)
+      {
+        tmp5.Cattrickdatas = this.Cattrickdatas.DeepCopy();
+      }
+      tmp5.__isset.@cattrickdatas = this.__isset.@cattrickdatas;
+      return tmp5;
+    }
+
+    public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
+    {
+      iprot.IncrementRecursionDepth();
+      try
+      {
+        TField field;
+        await iprot.ReadStructBeginAsync(cancellationToken);
+        while (true)
+        {
+          field = await iprot.ReadFieldBeginAsync(cancellationToken);
+          if (field.Type == TType.Stop)
+          {
+            break;
+          }
+
+          switch (field.ID)
+          {
+            case 1:
+              if (field.Type == TType.Map)
+              {
+                {
+                  var _map6 = await iprot.ReadMapBeginAsync(cancellationToken);
+                  Cattrickdatas = new Dictionary<int, global::Byway.Thrift.Data.CatTrickDataItem>(_map6.Count);
+                  for(int _i7 = 0; _i7 < _map6.Count; ++_i7)
+                  {
+                    int _key8;
+                    global::Byway.Thrift.Data.CatTrickDataItem _val9;
+                    _key8 = await iprot.ReadI32Async(cancellationToken);
+                    _val9 = new global::Byway.Thrift.Data.CatTrickDataItem();
+                    await _val9.ReadAsync(iprot, cancellationToken);
+                    Cattrickdatas[_key8] = _val9;
+                  }
+                  await iprot.ReadMapEndAsync(cancellationToken);
+                }
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            default: 
+              await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              break;
+          }
+
+          await iprot.ReadFieldEndAsync(cancellationToken);
+        }
+
+        await iprot.ReadStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        iprot.DecrementRecursionDepth();
+      }
+    }
+
+    public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
+    {
+      oprot.IncrementRecursionDepth();
+      try
+      {
+        var tmp10 = new TStruct("CatTrickData");
+        await oprot.WriteStructBeginAsync(tmp10, cancellationToken);
+        var tmp11 = new TField();
+        if((Cattrickdatas != null) && __isset.@cattrickdatas)
+        {
+          tmp11.Name = "cattrickdatas";
+          tmp11.Type = TType.Map;
+          tmp11.ID = 1;
+          await oprot.WriteFieldBeginAsync(tmp11, cancellationToken);
+          await oprot.WriteMapBeginAsync(new TMap(TType.I32, TType.Struct, Cattrickdatas.Count), cancellationToken);
+          foreach (int _iter12 in Cattrickdatas.Keys)
+          {
+            await oprot.WriteI32Async(_iter12, cancellationToken);
+            await Cattrickdatas[_iter12].WriteAsync(oprot, cancellationToken);
+          }
+          await oprot.WriteMapEndAsync(cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        await oprot.WriteFieldStopAsync(cancellationToken);
+        await oprot.WriteStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        oprot.DecrementRecursionDepth();
+      }
+    }
+
+    public override bool Equals(object that)
+    {
+      if (!(that is CatTrickData other)) return false;
+      if (ReferenceEquals(this, other)) return true;
+      return ((__isset.@cattrickdatas == other.__isset.@cattrickdatas) && ((!__isset.@cattrickdatas) || (TCollections.Equals(Cattrickdatas, other.Cattrickdatas))));
+    }
+
+    public override int GetHashCode() {
+      int hashcode = 157;
+      unchecked {
+        if((Cattrickdatas != null) && __isset.@cattrickdatas)
+        {
+          hashcode = (hashcode * 397) + TCollections.GetHashCode(Cattrickdatas);
+        }
+      }
+      return hashcode;
+    }
+
+    public override string ToString()
+    {
+      var tmp13 = new StringBuilder("CatTrickData(");
+      int tmp14 = 0;
+      if((Cattrickdatas != null) && __isset.@cattrickdatas)
+      {
+        if(0 < tmp14++) { tmp13.Append(", "); }
+        tmp13.Append("Cattrickdatas: ");
+        Cattrickdatas.ToString(tmp13);
+      }
+      tmp13.Append(')');
+      return tmp13.ToString();
+    }
+  }
+
+}

compiled_output/csharp/Byway/Thrift/Data/CatTrickDataItem.cs

@@ -0,0 +1,366 @@
+/**
+ * <auto-generated>
+ * Autogenerated by Thrift Compiler (0.22.0)
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * </auto-generated>
+ */
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Thrift;
+using Thrift.Collections;
+using System.Runtime.Serialization;
+using Thrift.Protocol;
+using Thrift.Protocol.Entities;
+using Thrift.Protocol.Utilities;
+using Thrift.Transport;
+using Thrift.Transport.Client;
+
+
+#pragma warning disable IDE0079  // remove unnecessary pragmas
+#pragma warning disable IDE0017  // object init can be simplified
+#pragma warning disable IDE0028  // collection init can be simplified
+#pragma warning disable IDE0305  // collection init can be simplified
+#pragma warning disable IDE0034  // simplify default expression
+#pragma warning disable IDE0066  // use switch expression
+#pragma warning disable IDE0090  // simplify new expression
+#pragma warning disable IDE0290  // use primary CTOR
+#pragma warning disable IDE1006  // parts of the code use IDL spelling
+#pragma warning disable CA1822   // empty DeepCopy() methods still non-static
+#pragma warning disable IDE0083  // pattern matching "that is not SomeType" requires net5.0 but we still support earlier versions
+
+namespace Byway.Thrift.Data
+{
+
+  [DataContract(Namespace="")]
+  public partial class CatTrickDataItem : TBase
+  {
+    private int _Type;
+    private int _Duration;
+    private int _Diamond;
+    private int _Energy;
+
+    [DataMember(Order = 0)]
+    public int Type
+    {
+      get
+      {
+        return _Type;
+      }
+      set
+      {
+        __isset.Type = true;
+        this._Type = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public int Duration
+    {
+      get
+      {
+        return _Duration;
+      }
+      set
+      {
+        __isset.Duration = true;
+        this._Duration = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public int Diamond
+    {
+      get
+      {
+        return _Diamond;
+      }
+      set
+      {
+        __isset.Diamond = true;
+        this._Diamond = value;
+      }
+    }
+
+    [DataMember(Order = 0)]
+    public int Energy
+    {
+      get
+      {
+        return _Energy;
+      }
+      set
+      {
+        __isset.Energy = true;
+        this._Energy = value;
+      }
+    }
+
+
+    [DataMember(Order = 1)]
+    public Isset __isset;
+    [DataContract]
+    public struct Isset
+    {
+      [DataMember]
+      public bool Type;
+      [DataMember]
+      public bool Duration;
+      [DataMember]
+      public bool Diamond;
+      [DataMember]
+      public bool Energy;
+    }
+
+    #region XmlSerializer support
+
+    public bool ShouldSerializeType()
+    {
+      return __isset.Type;
+    }
+
+    public bool ShouldSerializeDuration()
+    {
+      return __isset.Duration;
+    }
+
+    public bool ShouldSerializeDiamond()
+    {
+      return __isset.Diamond;
+    }
+
+    public bool ShouldSerializeEnergy()
+    {
+      return __isset.Energy;
+    }
+
+    #endregion XmlSerializer support
+
+    public CatTrickDataItem()
+    {
+    }
+
+    public CatTrickDataItem DeepCopy()
+    {
+      var tmp0 = new CatTrickDataItem();
+      if(__isset.Type)
+      {
+        tmp0.Type = this.Type;
+      }
+      tmp0.__isset.Type = this.__isset.Type;
+      if(__isset.Duration)
+      {
+        tmp0.Duration = this.Duration;
+      }
+      tmp0.__isset.Duration = this.__isset.Duration;
+      if(__isset.Diamond)
+      {
+        tmp0.Diamond = this.Diamond;
+      }
+      tmp0.__isset.Diamond = this.__isset.Diamond;
+      if(__isset.Energy)
+      {
+        tmp0.Energy = this.Energy;
+      }
+      tmp0.__isset.Energy = this.__isset.Energy;
+      return tmp0;
+    }
+
+    public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
+    {
+      iprot.IncrementRecursionDepth();
+      try
+      {
+        TField field;
+        await iprot.ReadStructBeginAsync(cancellationToken);
+        while (true)
+        {
+          field = await iprot.ReadFieldBeginAsync(cancellationToken);
+          if (field.Type == TType.Stop)
+          {
+            break;
+          }
+
+          switch (field.ID)
+          {
+            case 1:
+              if (field.Type == TType.I32)
+              {
+                Type = await iprot.ReadI32Async(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 2:
+              if (field.Type == TType.I32)
+              {
+                Duration = await iprot.ReadI32Async(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 3:
+              if (field.Type == TType.I32)
+              {
+                Diamond = await iprot.ReadI32Async(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            case 4:
+              if (field.Type == TType.I32)
+              {
+                Energy = await iprot.ReadI32Async(cancellationToken);
+              }
+              else
+              {
+                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              }
+              break;
+            default: 
+              await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
+              break;
+          }
+
+          await iprot.ReadFieldEndAsync(cancellationToken);
+        }
+
+        await iprot.ReadStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        iprot.DecrementRecursionDepth();
+      }
+    }
+
+    public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
+    {
+      oprot.IncrementRecursionDepth();
+      try
+      {
+        var tmp1 = new TStruct("CatTrickDataItem");
+        await oprot.WriteStructBeginAsync(tmp1, cancellationToken);
+        var tmp2 = new TField();
+        if(__isset.Type)
+        {
+          tmp2.Name = "Type";
+          tmp2.Type = TType.I32;
+          tmp2.ID = 1;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteI32Async(Type, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if(__isset.Duration)
+        {
+          tmp2.Name = "Duration";
+          tmp2.Type = TType.I32;
+          tmp2.ID = 2;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteI32Async(Duration, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if(__isset.Diamond)
+        {
+          tmp2.Name = "Diamond";
+          tmp2.Type = TType.I32;
+          tmp2.ID = 3;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteI32Async(Diamond, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        if(__isset.Energy)
+        {
+          tmp2.Name = "Energy";
+          tmp2.Type = TType.I32;
+          tmp2.ID = 4;
+          await oprot.WriteFieldBeginAsync(tmp2, cancellationToken);
+          await oprot.WriteI32Async(Energy, cancellationToken);
+          await oprot.WriteFieldEndAsync(cancellationToken);
+        }
+        await oprot.WriteFieldStopAsync(cancellationToken);
+        await oprot.WriteStructEndAsync(cancellationToken);
+      }
+      finally
+      {
+        oprot.DecrementRecursionDepth();
+      }
+    }
+
+    public override bool Equals(object that)
+    {
+      if (!(that is CatTrickDataItem other)) return false;
+      if (ReferenceEquals(this, other)) return true;
+      return ((__isset.Type == other.__isset.Type) && ((!__isset.Type) || (global::System.Object.Equals(Type, other.Type))))
+        && ((__isset.Duration == other.__isset.Duration) && ((!__isset.Duration) || (global::System.Object.Equals(Duration, other.Duration))))
+        && ((__isset.Diamond == other.__isset.Diamond) && ((!__isset.Diamond) || (global::System.Object.Equals(Diamond, other.Diamond))))
+        && ((__isset.Energy == other.__isset.Energy) && ((!__isset.Energy) || (global::System.Object.Equals(Energy, other.Energy))));
+    }
+
+    public override int GetHashCode() {
+      int hashcode = 157;
+      unchecked {
+        if(__isset.Type)
+        {
+          hashcode = (hashcode * 397) + Type.GetHashCode();
+        }
+        if(__isset.Duration)
+        {
+          hashcode = (hashcode * 397) + Duration.GetHashCode();
+        }
+        if(__isset.Diamond)
+        {
+          hashcode = (hashcode * 397) + Diamond.GetHashCode();
+        }
+        if(__isset.Energy)
+        {
+          hashcode = (hashcode * 397) + Energy.GetHashCode();
+        }
+      }
+      return hashcode;
+    }
+
+    public override string ToString()
+    {
+      var tmp3 = new StringBuilder("CatTrickDataItem(");
+      int tmp4 = 0;
+      if(__isset.Type)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("Type: ");
+        Type.ToString(tmp3);
+      }
+      if(__isset.Duration)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("Duration: ");
+        Duration.ToString(tmp3);
+      }
+      if(__isset.Diamond)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("Diamond: ");
+        Diamond.ToString(tmp3);
+      }
+      if(__isset.Energy)
+      {
+        if(0 < tmp4++) { tmp3.Append(", "); }
+        tmp3.Append("Energy: ");
+        Energy.ToString(tmp3);
+      }
+      tmp3.Append(')');
+      return tmp3.ToString();
+    }
+  }
+
+}