type
  TMyArray = ARRAY[0..5] OF Byte;

  { Array bspw. als Eigenschaft von TForm1 }
  TForm1 = class(TForm)
    { ... }
    PROCEDURE ChangeArray(Sender: TObject); // Beispiel für Ereignisbehandlung
  private
    FMyArray : TMyArray; // Hier das Array selbst
    FOnChangeArray : TNotifyEvent; // Event
  public
    PROCEDURE SetMyArray(Value: TMyArray); OVERLOAD; // Routinen zum
    PROCEDURE SetMyArray(index, Value: Byte); OVERLOAD; // Schreiben und
    FUNCTION GetMyArray : TMyArray; // Lesen des Arrays
    PROPERTY OnChangeArray : TNotifyEvent READ FOnChangeArray WRITE FOnChangeArray; // Event
  end;

{...}

{ ************ Array besetzen ************  }
PROCEDURE TForm1.SetMyArray(Value: TMyArray);
BEGIN
  FMyArray := Value;
  IF Assigned(FOnChangeArray) THEN FOnChangeArray(NIL); // <<--- HIER wird Event "ausgelöst"
END;
{ ----------------------}
PROCEDURE TForm1.SetMyArray(index, Value: Byte);
BEGIN
  FMyArray[index] := Value;
  IF Assigned(FOnChangeArray) THEN FOnChangeArray(NIL); // <<--- HIER wird Event "ausgelöst"
END;

{ ************ Array auslesen ************  }
FUNCTION TForm1.GetMyArray : TMyArray;
BEGIN
  result := FMyArray;
END;

{ ********** Beispielanwendung ***********  }
procedure TForm1.Button1Click(Sender: TObject);
VAR
  arr : TMyArray;
  i : Byte;
begin
  // Beispielwerte
  FOR i:=Low(arr) TO High(arr) DO arr[i] := i;
  // Array setzen
  SetMyArray(arr);
  // Einezelnes Feld im Array setzen
  SetMyArray(2,99);
  // Array zurückgeben lassen
  arr := GetMyArray;
  // Ergebnis anzeigen
  ShowMessage(IntToStr(arr[0]) + #10#13 +
              IntToStr(arr[1]) + #10#13 +
              IntToStr(arr[2]) + #10#13 +
              IntToStr(arr[3]) + #10#13 +
              IntToStr(arr[4]) + #10#13);
end;


{ ******* Eregnisbehandlung zuweisen ********  }
procedure TForm1.Button2Click(Sender: TObject);
begin
  OnChangeArray := ChangeArray;
end;

{ *********** Eregnisbehandlung *************  }
procedure TForm1.ChangeArray(Sender: TObject);
begin
  ShowMessage('Array geändert!');
end;

  private
    FMyArray : TMyArray;
    FOnChangeArray : TNotifyEvent;
    PROCEDURE SetMyArray(Value: TMyArray);
    FUNCTION GetMyArray : TMyArray;
  public
    PROPERTY OnChangeArray : TNotifyEvent READ FOnChangeArray WRITE FOnChangeArray;
    PROPERTY MyArray : TMyArray READ GetMyArray WRITE SetMyArray;
  end;

    TArrayWrapper = class;
  TArr = array of integer;
  TOnChanged = procedure (sender:TArrayWrapper) of object;
  
  TArrayWrapper = class(TObject)
  private
    FArr:TArr;
    FOnChanged: TOnChanged;
    function getCount: integer;
    procedure SetCount(const Value: integer);
    function GetItems(Index: Integer): integer;
    procedure SetItems(Index: Integer; const Value: integer);
  public
    constructor Create(aOnChange:TOnChanged);
    destructor Destroy; override;
    property OnChange:TOnChanged read FOnChanged write FOnChanged;
    property Count:integer read getCount write SetCount;
    property Items[Index: Integer]: integer read Getitems write Setitems; default;
  end;
      


implementation



{ TArrayWrapper }

constructor TArrayWrapper.Create(aOnChange: TOnChanged);
begin
  FOnChanged := aOnChange;
end;

destructor TArrayWrapper.Destroy;
begin
  count := 0;
  inherited;
end;

function TArrayWrapper.getCount: integer;
begin
  result := length(FArr);
end;

procedure TArrayWrapper.SetCount(const Value: integer);
begin
  setLength(FArr,Value);
end;

function TArrayWrapper.Getitems(Index: Integer): integer;
begin
  result := FArr[Index];
end;

procedure TArrayWrapper.Setitems(Index: Integer; const Value: integer);
begin
  FArr[Index] := Value;
  if assigned(OnChange) then OnChange(self); // event aufrufen!!!
end;