Есть ли способ добавить 2 массива в один?

Из-за двух полей string в каждой записи TPerson вы не можете просто использовать двоичное «перемещение», так как вы испортите подсчет ссылок string, особенно в многопоточной среде.

Вы можете сделать это вручную — это быстро и красиво:

TPerson = record
  Birthday: TDate;
  Name, Surname: string;
end;

TPeople = array of TPerson;

var A, B, C: TPeople;

// do C:=A+B
procedure Sum(const A,B: TPeople; var C: TPeople);
begin
var i, nA,nB: integer;
begin
  nA := length(A);
  nB := length(B);
  SetLength(C,nA+nB);
  for i := 0 to nA-1 do
    C[i] := A[i];
  for i := 0 to nB-1 do
    C[i+nA] := B[i];
end;

Или вы можете использовать наш TDynArray оболочка, в которой есть метод для обработки таких случаев:

procedure AddToArray(var A: TPeople; const B: TPeople);
var DA: TDynArray;
begin
  DA.Init(TypeInfo(TPeople),A);
  DA.AddArray(B); // A := A+B
end;

Метод AddArray может добавить подпорт исходного массива:

/// add elements from a given dynamic array
// - the supplied source DynArray MUST be of the same exact type as the
// current used for this TDynArray
// - you can specify the start index and the number of items to take from
// the source dynamic array (leave as -1 to add till the end)
procedure AddArray(const DynArray; aStartIndex: integer=0; aCount: integer=-1);

Обратите внимание, что с такими записями он будет использовать функцию System._CopyRecord RTL, которая не так оптимизирована по скорости. Я написал более быструю версию — см. эту статью в блоге или в этой ветке форума.

Если вы используете динамические массивы в функциях/процедурах, не забудьте явно использовать параметры const или var (как я закодировал выше), иначе он будет делать временную копию при каждом вызове, поэтому он может быть медленным.

В нем нет ничего, что позволяло бы объединять динамические массивы.

Вы можете рассмотреть возможность использования одного из универсальных классов контейнеров, найденных в Generics.Collections, TList.

В вашем случае у вас будет 3 экземпляра TList, скажем, A, B и C. Тогда вы можете написать

A.Clear;
A.AddRange(B);
A.AddRange(C);

Я думаю, что это максимально близко к тому, что вы хотите, с тем, что поставляется из коробки.

Если вы готовы немного написать код самостоятельно, вы можете использовать перегрузку операторов, чтобы использовать точный синтаксис, который вам нужен. Объявите запись, содержащую массив TPerson с приватной видимостью. Затем вам нужно реализовать оператор Add, свойство Count и свойство Items[] по умолчанию. Это также можно сделать общим, поэтому вам нужно написать его только один раз.

TTurboArray = record<T>
private
  FItems: array of T;
  //property accessors here
 public
   class operator Add(a, b: TTurboArray<T>): TTurboArray<T>;
   property Count: Integer read GetCount write SetCount;
   property Items[Index: Integer]: T read GetItem write SetItem; default;
end;

Эта идея может быть расширена до очень мощной структуры данных по вашему усмотрению.

Есть быстрый и грязный способ сделать это. Это ужасный хак, но он должен работать и даже позаботиться о подсчете ссылок:

function ConcatPeople(const A, B: TPeople): TPeople;
var
  Temp: TPeople;
  ALen, BLen: Integer;
begin
  Result := Copy(A);
  BLen := Length(B);
  if BLen = 0 then
    Exit;
  ALen := Length(A);
  Temp := Copy(B);
  SetLength(Result, ALen + BLen);
  Move(Temp[0], Result[ALen], BLen * SizeOf(B[0]));
  FillChar(Temp[0], BLen * SizeOf(B[0]), 0);
end;

По сути, данные в Temp «заменяются» пустыми записями в Result, поэтому баланс сохраняется, а подсчет ссылок продолжает работать.

Обновлять

Для чего это стоит: это, по-видимому, тот же метод, который используется в этом принят ответ SO и, например, TList‹T›.Вставить. Я удалил этот ответ, но я все еще думаю, что он действителен, поэтому я снова удалил его. Это может быть связано с блокировкой вокруг блока Move/FillChar, чтобы никто не мог получить доступ к элементам, когда они «заменяются местами». Я добавлю это.

Вот как я справился с этим, хотя для использования TArray потребовалась небольшая (но, надеюсь, несущественная для вас) модификация исходного кода:

(проверено в XE2)

uses
  Generics.Collections;

type
  TArrayExt = class(TArray)
    class function Concat<T>(const First, Second: array of T): TArray<T>; overload;
  end;

class function TArrayExt.Concat<T>(const First, Second: array of T): TArray<T>;
var
  i: Integer;
  l: Integer;
begin
  l := Length(First);
  SetLength(Result, l + Length(Second));
  for i := Low(First) to High(First) do
    Result[i] := First[i];
  for i := Low(Second) to High(Second) do
    Result[l + i] := Second[i];
end;

type
  TPerson = record
    Birthday: TDate;
    Name, Surname: String;
  end;

  TPeople = TArray<TPerson>;

var
  A, B, C: TPeople;
begin
  C := TArrayExt.Concat<TPerson>(A, B);

Основное отличие здесь в том, что я использую «TArray», а не «массив TPerson». Это можно использовать для строк массивов, записей и т. д. Я считаю, что основное преимущество этого способа заключается в том, что он действительно делает копию, а не перемещение. И я использую «обычные» функции Delphi вместо таких вещей, как массовые копии памяти, которые могут вызвать у меня раздражение.

Конечно, если вы делали это в тесном цикле и нуждались в производительности, этот способ может быть не лучшим для вас. Но я думаю, что это лучше всего подходит для большинства других ситуаций, особенно с точки зрения обслуживания и удобочитаемости.

(Если кто-то не опубликует комментарий о том, что здесь есть какая-то ужасная скрытая утечка памяти. Надеюсь, нет!)

Ваш код отлично работает в новейшей версии delphi C := A+B;.

Но для динамических массивов в старых версиях можно использовать функцию concat. Пример:

C := Concat(A, B);