type
  TPrmName = array[0..127] of AnsiChar;

type
 TPrmBlock = packed record
   PrmName    : TPrmName;  //Имя параметра
   PrmType    : TTypeKind; //Тип параметра
   TypeSize   : Integer;   //Размер параметра
 end;

procedure TUFF<T1, T2, T3, T4>.ReadOrWriteDataToRecordPrm<T>(Param: Pointer; PrmBlock: TPrmBlock; FS: TFileStream; Mode: Byte);
var
  RType     : TRTTIType;
  Fields    : TArray<TRttiField>;
  I         : Integer;
  P         : Pointer;
  RecValue  : TValue;
  ArrLength : NativeInt;
  TypeSize  : NativeInt;
  B         : TArray<Byte>;
  PrmSize   : Integer;
  S         : String;
  pS        : PString;
  NotFound  : Boolean;
begin

  NotFound := true;
  RType := TRTTIContext.Create.GetType(TypeInfo(T));

  Fields := RType.GetFields;
  for I := 0 to High(Fields) do
   begin
       if Assigned(Fields[I].FieldType) then
        begin
                  if UpperCase(Fields[I].Name) = UpperCase(String(PrmBlock.PrmName)) then {Совпали имена параметров}
                    begin

                     if (Fields[I].FieldType.TypeKind = PrmBlock.PrmType){ and
                        (Fields[I].FieldType.TypeSize = PrmBlock.TypeSize)} then {Совпал тип параметра}
                      begin
                       {Получаем указатель на конкретный параметр из record-a}
                       P := Pointer(Integer(Param) + Fields[I].Offset);

                                       case Mode of
                                            ReadMode  : begin
                                                               case Fields[I].FieldType.TypeKind of
                                                                tkUString : begin {String}
                                                                              {Читаем длину строки}
                                                                              FS.Read(PrmSize, SizeOf(PrmSize));
                                                                              {Загружаем строку во временный массив B, и перекодируем в String}
                                                                              SetLength(B, PrmSize);
                                                                              FS.Read(B[Low(B)], PrmSize);
                                                                              S  := TEncoding.UTF8.GetString(B);
                                                                              pS := P;
                                                                              SetLength(pS^, Length(S));
                                                                              move(Pointer(S)^, PPointer(P)^^, Length(S) * StringElementSize(S));
                                                                            end;

                                                                tkDynArray: begin {Динамические массивы}
                                                                             FS.Read(PrmSize, SizeOf(PrmSize));
                                                                             RecValue  := Fields[I].GetValue(Param);
                                                                             TypeSize  := RecValue.TypeInfo.TypeData^.elSize;
                                                                             ArrLength := PrmSize div TypeSize;
                                                                             {Dimension - размерность массива 1- 1D, 2 - 2D и т.д.}
                                                                             if ArrLength > 1024 * 1024 * 10 then
                                                                              begin
                                                                                UpdateMessage('BigSize: ' + IntToStr(PrmSize) + ' - ' + IntToStr(FS.Position));
                                                                                ArrLength := 0;
                                                                              end;
                                                                             DynArraySetLength(PPointer(P)^, RecValue.TypeInfo, 1{Dimension}, @ArrLength);
                                                                             FS.Read(PPointer(P)^^, ArrLength * TypeSize);
                                                                            end;

                                                                            else
                                                                             FS.Read(P^, Fields[I].FieldType.TypeSize);
                                                                end;
                                                        end;

                                            WriteMode : begin
                                                               case Fields[I].FieldType.TypeKind of

                                                                tkUString : begin {String}
                                                                              {Преобразуем строку в UTF8 и помещаем ее в массив}
                                                                              B := TEncoding.UTF8.GetBytes(PPointer(P)^);
                                                                              {Пишем длину строки}
                                                                              PrmSize := Length(B);
                                                                              FS.Write(PrmSize, SizeOf(PrmSize));
                                                                              {Пишем строку в поток в кодировке UTF8}
                                                                              FS.Write(B[Low(B)], Length(B));
                                                                            end;

                                                                tkDynArray: begin {Динамические массивы}
                                                                             RecValue  := Fields[I].GetValue(Param);
                                                                             ArrLength := RecValue.GetArrayLength;
                                                                             TypeSize  := RecValue.TypeInfo.TypeData^.elSize;
                                                                             PrmSize   := ArrLength * TypeSize;
                                                                             {Пишем размер массива байтах}
                                                                             FS.Write(PrmSize, SizeOf(PrmSize));
                                                                             //PPointer(P)^ - указатель на первый(нулевой) элемент массива
                                                                             {Пишем сам массив}
                                                                             FS.Write(PPointer(P)^^, PrmSize);
                                                                            end;

                                                                            else
                                                                             FS.Write(P^, Fields[I].FieldType.TypeSize);
                                                               end;
                                                        end;
                                       end; {end case ...}

                       NotFound := false;
                       break;
                      end else
                      begin
                        if Mode = ReadMode then
                         begin
                               UpdateMessage(rsTUFFReadOrWriteDataToRecordPrm_Msg1 + String(PrmBlock.PrmName));
                               {Если переменная имеет другой тип данных то просто перемещаем позицию в файле на следующий параметр}
                                if (PrmBlock.PrmType = tkUString) or (PrmBlock.PrmType = tkDynArray) then
                                 begin
                                   FS.Read(PrmSize, SizeOf(PrmSize));
                                   {Параметр отсутствует}
                                   FS.Position := FS.Position + PrmSize;
                                 end else
                                 begin
                                     FS.Position := FS.Position + PrmBlock.TypeSize;
                                 end;
                         end;
                      end; {end if (Fields[I].FieldType.TypeKind = PrmBlock.PrmType) then ...}
                    end; {end if UpperCase(Fields[I].Name) = UpperCase(String(PrmBlock.PrmName)) then ...}
        end else
        begin
          UpdateMessage(rsTUFFReadOrWriteDataToRecordPrm_Msg2 + Fields[I].Name + rsTUFFReadOrWriteDataToRecordPrm_Msg3);
         // exit;
        end; {end if Assigned(Fields[I].FieldType) then}
   end; {end for I := 0 to High(Fields) do}

   if NotFound and (Mode = ReadMode) then
     begin
     UpdateMessage(rsTUFFReadOrWriteDataToRecordPrm_Msg4 + String(PrmBlock.PrmName) + rsTUFFReadOrWriteDataToRecordPrm_Msg5);
     {Если параметр несуществует то перемещаем позицию в файле}
      if (PrmBlock.PrmType = tkUString) or (PrmBlock.PrmType = tkDynArray) then
       begin
         FS.Read(PrmSize, SizeOf(PrmSize));
         FS.Position := FS.Position + PrmSize;
       end else
       begin
         FS.Position := FS.Position + PrmBlock.TypeSize;
       end;
    end;
end;