public void SetValue(SecsIndexType type, object value, UInt32 lb = 0)
  {
      switch (type)
      {
          case SecsIndexType.U1:
          case SecsIndexType.B: // Binary - often treated as a byte or byte array
          case SecsIndexType.Boolean:
              if (value is byte[] byteArray)
              {
                  if (type == SecsIndexType.Boolean && byteArray.Length != 1)
                  {
                      throw new ArgumentException($"For Boolean type, byte array length must be 1, but got {byteArray.Length}. Value: {BitConverter.ToString(byteArray).Replace("-", "")}", nameof(value));
                  }
                  if (type == SecsIndexType.Boolean && !(byteArray[0] == 0 || byteArray[0] == 1))
                  {
                      throw new ArgumentOutOfRangeException(nameof(value), $"Boolean byte value '{byteArray[0]}' is not 0 or 1.");
                  }

                  if (type == SecsIndexType.U1) Set_U1(byteArray, lb);
                  else if (type == SecsIndexType.B) Set_B(byteArray, lb);
                  else if (type == SecsIndexType.Boolean) Set_Boolean(byteArray, lb);
              }
              else if (value is byte singleByte)
              {
                  if (type == SecsIndexType.Boolean && !(singleByte == 0 || singleByte == 1))
                  {
                      throw new ArgumentOutOfRangeException(nameof(value), $"Boolean byte value '{singleByte}' is not 0 or 1.");
                  }
                  byte[] vbytes = new byte[1] { singleByte };
                  if (type == SecsIndexType.U1) Set_U1(vbytes, lb);
                  else if (type == SecsIndexType.B) Set_B(vbytes, lb);
                  else if (type == SecsIndexType.Boolean) Set_Boolean(vbytes, lb);
              }
              else
              {
                  byte byteToSet = 0; // Initialize to prevent CS0165
                  bool conversionOk = false;

                  if (value is int i)
                  {
                      if (i >= 0 && i <= 255) { byteToSet = (byte)i; conversionOk = true; }
                      else { throw new ArgumentOutOfRangeException(nameof(value), $"Integer value '{i}' is out of byte range (0-255) for SECS type {type}."); }
                  }
                  else if (value is long l)
                  {
                      if (l >= 0 && l <= 255) { byteToSet = (byte)l; conversionOk = true; }
                      else { throw new ArgumentOutOfRangeException(nameof(value), $"Long value '{l}' is out of byte range (0-255) for SECS type {type}."); }
                  }
                  else if (value is uint ui)
                  {
                      if (ui <= 255) { byteToSet = (byte)ui; conversionOk = true; }
                      else { throw new ArgumentOutOfRangeException(nameof(value), $"UInt value '{ui}' is out of byte range (0-255) for SECS type {type}."); }
                  }
                  else if (value is string s)
                  {
                      // Consider NumberStyles and CultureInfo for robust parsing
                      if (byte.TryParse(s, System.Globalization.NumberStyles.Integer, System.Globalization.CultureInfo.InvariantCulture, out byteToSet)) { conversionOk = true; }
                      else { throw new ArgumentException($"String value '{s}' cannot be converted to byte for SECS type {type}.", nameof(value)); }
                  }
                  else if (type == SecsIndexType.Boolean && value is bool boolVal)
                  {
                      byteToSet = Convert.ToByte(boolVal);
                      conversionOk = true;
                  }

                  if (conversionOk)
                  {
                      if (type == SecsIndexType.Boolean && !(byteToSet == 0 || byteToSet == 1))
                      {
                          throw new ArgumentOutOfRangeException(nameof(value), $"Converted Boolean value '{byteToSet}' is not 0 or 1.");
                      }
                      byte[] vbytes = new byte[1] { byteToSet };
                      if (type == SecsIndexType.U1) Set_U1(vbytes, lb);
                      else if (type == SecsIndexType.B) Set_B(vbytes, lb);
                      else if (type == SecsIndexType.Boolean) Set_Boolean(vbytes, lb);
                  }
                  else
                  {
                      throw new ArgumentException($"Value '{value}' (type: {value?.GetType().FullName}) cannot be converted to byte for SECS type {type}.", nameof(value));
                  }
              }
              break;

          case SecsIndexType.U2:
              if (value is ushort[] valUshortArray) { Set_U2(valUshortArray, lb); }
              else if (value is short[] valShortArray) { Set_U2(Array.ConvertAll(valShortArray, Convert.ToUInt16), lb); }
              else if (value is int[] valIntArrayForU2)
              {
                  Set_U2(Array.ConvertAll(valIntArrayForU2, i => {
                      if (i < ushort.MinValue || i > ushort.MaxValue) throw new ArgumentOutOfRangeException(nameof(value), $"Integer value '{i}' is out of UInt16 range for SECS type {type}.");
                      return Convert.ToUInt16(i);
                  }), lb);
              }
              else if (value is ushort valUshort) { Set_U2(new ushort[] { valUshort }, lb); }
              else if (value is short valShort) { Set_U2(new ushort[] { Convert.ToUInt16(valShort) }, lb); } // Add range check if necessary
              else if (value is int valIntForU2)
              {
                  if (valIntForU2 < ushort.MinValue || valIntForU2 > ushort.MaxValue) throw new ArgumentOutOfRangeException(nameof(value), $"Integer value '{valIntForU2}' is out of UInt16 range for SECS type {type}.");
                  Set_U2(new ushort[] { Convert.ToUInt16(valIntForU2) }, lb);
              }
              else { throw new ArgumentException($"Value '{value}' (type: {value?.GetType().FullName}) cannot be converted for SECS type {type}.", nameof(value)); }
              break;
          case SecsIndexType.U4:
              if (value is uint[] valUintArray) { Set_U4(valUintArray, lb); }
              else if (value is int[] valIntArrayForU4)
              {
                  Set_U4(Array.ConvertAll(valIntArrayForU4, i => {
                      if (i < 0 && (long)i + uint.MaxValue + 1 != 0) { /* check for negative numbers that cannot be cast to uint without data loss, simple i < 0 is not enough for int.MinValue */ }
                      // A direct cast (uint)i for negative numbers will wrap around.
                      // Depending on desired behavior, either throw or convert carefully.
                      // For simplicity, let's assume positive or use Convert.ToUInt32 which throws for negatives.
                      return Convert.ToUInt32(i); // This will throw OverflowException for negative i
                  }), lb);
              }
              else if (value is uint valUint) { Set_U4(new uint[] { valUint }, lb); }
              else if (value is int valIntForU4) { Set_U4(new uint[] { Convert.ToUInt32(valIntForU4) }, lb); } // Will throw for negative
              else { throw new ArgumentException($"Value '{value}' (type: {value?.GetType().FullName}) cannot be converted for SECS type {type}.", nameof(value)); }
              break;
          case SecsIndexType.U8:
              if (value is ulong[] valUlongArray) { Set_U8(valUlongArray, lb); }
              else if (value is long[] valLongArrayForU8) { Set_U8(Array.ConvertAll(valLongArrayForU8, Convert.ToUInt64), lb); } // Throws for negative
              else if (value is ulong valUlong) { Set_U8(new ulong[] { valUlong }, lb); }
              else if (value is long valLongForU8) { Set_U8(new ulong[] { Convert.ToUInt64(valLongForU8) }, lb); } // Throws for negative
              else { throw new ArgumentException($"Value '{value}' (type: {value?.GetType().FullName}) cannot be converted for SECS type {type}.", nameof(value)); }
              break;

          case SecsIndexType.I1:
              if (value is sbyte[] valSbyteArray) { Set_I1(valSbyteArray, lb); }
              else if (value is byte[] valByteArrayForI1) { Set_I1(Array.ConvertAll(valByteArrayForI1, Convert.ToSByte), lb); } // Throws if > 127
              else if (value is int[] valIntArrayForI1)
              {
                  Set_I1(Array.ConvertAll(valIntArrayForI1, i => {
                      if (i < SByte.MinValue || i > SByte.MaxValue) throw new ArgumentOutOfRangeException(nameof(value), $"Integer value '{i}' is out of SByte range for SECS type {type}.");
                      return Convert.ToSByte(i);
                  }), lb);
              }
              else if (value is sbyte valSbyte) { Set_I1(new sbyte[] { valSbyte }, lb); }
              else if (value is byte valByteForI1) { Set_I1(new sbyte[] { Convert.ToSByte(valByteForI1) }, lb); } // Throws if > 127
              else if (value is int valIntForI1)
              {
                  if (valIntForI1 < SByte.MinValue || valIntForI1 > SByte.MaxValue) throw new ArgumentOutOfRangeException(nameof(value), $"Integer value '{valIntForI1}' is out of SByte range for SECS type {type}.");
                  Set_I1(new sbyte[] { Convert.ToSByte(valIntForI1) }, lb);
              }
              else { throw new ArgumentException($"Value '{value}' (type: {value?.GetType().FullName}) cannot be converted for SECS type {type}.", nameof(value)); }
              break;
          case SecsIndexType.I2:
              if (value is short[] valShortArrayForI2) { Set_I2(valShortArrayForI2, lb); }
              else if (value is int[] valIntArrayForI2)
              {
                  Set_I2(Array.ConvertAll(valIntArrayForI2, i => {
                      if (i < short.MinValue || i > short.MaxValue) throw new ArgumentOutOfRangeException(nameof(value), $"Integer value '{i}' is out of Int16 range for SECS type {type}.");
                      return Convert.ToInt16(i);
                  }), lb);
              }
              else if (value is short valShortForI2) { Set_I2(new short[] { valShortForI2 }, lb); }
              else if (value is int valIntForI2)
              {
                  if (valIntForI2 < short.MinValue || valIntForI2 > short.MaxValue) throw new ArgumentOutOfRangeException(nameof(value), $"Integer value '{valIntForI2}' is out of Int16 range for SECS type {type}.");
                  Set_I2(new short[] { Convert.ToInt16(valIntForI2) }, lb);
              }
              else { throw new ArgumentException($"Value '{value}' (type: {value?.GetType().FullName}) cannot be converted for SECS type {type}.", nameof(value)); }
              break;
          case SecsIndexType.I4:
              if (value is int[] valIntArrayForI4) { Set_I4(valIntArrayForI4, lb); }
              else if (value is int valIntForI4) { Set_I4(new int[] { valIntForI4 }, lb); }
              else { throw new ArgumentException($"Value '{value}' (type: {value?.GetType().FullName}) cannot be converted for SECS type {type}.", nameof(value)); }
              break;
          case SecsIndexType.I8:
              if (value is long[] valLongArrayForI8) { Set_I8(valLongArrayForI8, lb); }
              else if (value is long valLongForI8) { Set_I8(new long[] { valLongForI8 }, lb); }
              else { throw new ArgumentException($"Value '{value}' (type: {value?.GetType().FullName}) cannot be converted for SECS type {type}.", nameof(value)); }
              break;

          case SecsIndexType.F4:
              if (value is float[] valFloatArray) { Set_F4(valFloatArray, lb); }
              else if (value is double[] valDblArrayForF4) { Set_F4(Array.ConvertAll(valDblArrayForF4, Convert.ToSingle), lb); }
              else if (value is float valFloat) { Set_F4(new float[] { valFloat }, lb); }
              else if (value is double valDblForF4) { Set_F4(new float[] { Convert.ToSingle(valDblForF4) }, lb); }
              else { throw new ArgumentException($"Value '{value}' (type: {value?.GetType().FullName}) cannot be converted for SECS type {type}.", nameof(value)); }
              break;
          case SecsIndexType.F8:
              if (value is double[] valDblArrayForF8) { Set_F8(valDblArrayForF8, lb); }
              else if (value is float[] valFltArrayForF8) { Set_F8(Array.ConvertAll(valFltArrayForF8, f => (double)f), lb); }
              else if (value is double valDblForF8) { Set_F8(new double[] { valDblForF8 }, lb); }
              else if (value is float valFltForF8) { Set_F8(new double[] { (double)valFltForF8 }, lb); }
              else { throw new ArgumentException($"Value '{value}' (type: {value?.GetType().FullName}) cannot be converted for SECS type {type}.", nameof(value)); }
              break;

          case SecsIndexType.List:
              if (value is int listLength)
              {
                  if (listLength < 0) throw new ArgumentOutOfRangeException(nameof(value), $"List length '{listLength}' cannot be negative for SECS type {type}.");
                  Set_List(listLength, lb);
              }
              else if (value is uint listLengthUint)
              { // Allow uint for length too
                  if (listLengthUint > int.MaxValue) throw new ArgumentOutOfRangeException(nameof(value), $"List length '{listLengthUint}' is too large for SECS type {type}.");
                  Set_List((int)listLengthUint, lb);
              }
              else { throw new ArgumentException($"List length value '{value}' (type: {value?.GetType().FullName}) must be a non-negative integer for SECS type {type}.", nameof(value)); }
              break;

          case SecsIndexType.A:
          case SecsIndexType.Ax:
          case SecsIndexType.J:
          case SecsIndexType.Jx:
              string strValue = value?.ToString() ?? string.Empty;  // 將 null 轉換為空字串
              if (type == SecsIndexType.A) Set_A(strValue, lb);
              else if (type == SecsIndexType.Ax) Set_Ax(strValue, lb);
              else if (type == SecsIndexType.J) Set_J(strValue, lb);
              else if (type == SecsIndexType.Jx) Set_Jx(strValue, lb);
              break;

          case SecsIndexType.A2: // Array of UInt16
              if (value is ushort[] valUshortArrayForA2) { Set_A2(valUshortArrayForA2, lb); }
              else if (value is int[] valIntArrayForA2)
              {
                  Set_A2(Array.ConvertAll(valIntArrayForA2, i => {
                      if (i < ushort.MinValue || i > ushort.MaxValue) throw new ArgumentOutOfRangeException(nameof(value), $"Integer value '{i}' is out of UInt16 range for SECS type {type}.");
                      return Convert.ToUInt16(i);
                  }), lb);
              }
              // Potentially convert string to ushort[] if A2 represents wide characters
              else { throw new ArgumentException($"Value '{value}' (type: {value?.GetType().FullName}) cannot be converted for SECS type {type}.", nameof(value)); }
              break;

          default:
              throw new NotSupportedException($"SECS type {type} is not currently supported in SetValue operation.");
      }
  }