type
  DosString = type AnsiString(866);

ss := TStringStream.Create('', TEncoding.ANSI.GetEncoding(866));

const
  DefCodePage = 1251;

type
  MyString = packed record
    private
      ss: TStringStream;
      function GetData(a: integer): Char;
      procedure SetData(a: integer; const Value: Char);
    public
      class operator Implicit(a: String): MyString;
      property Data[a: integer]: Char Read GetData Write SetData; Default;
      Constructor Create(const CodePage: Cardinal);
      procedure Free;
  end;

implementation

{ MyString }

constructor MyString.Create(const CodePage: Cardinal);
begin
  ss := TStringStream.Create('', TEncoding.ANSI.GetEncoding(CodePage));
end;

procedure MyString.Free;
begin
  FreeAndNil(Self.ss);
end;

function MyString.GetData(a: integer): Char;
begin
  Result := ss.DataString[a];
end;

class operator MyString.Implicit(a: String): MyString;
var
  r: MyString;
begin
  R.Create(DefCodePage);
  R.ss.Clear;
  R.ss.WriteString(a);
  Result := r;
  //R.Free;
end;

procedure MyString.SetData(a: integer; const Value: Char);
var
  s: string;
begin
  s := ss.DataString;
  s[a] := Value;
  ss.Clear;
  ss.WriteString(s);
end;

var
  ds: MyString;
  i: Integer;
begin
  ds := MyString.Create(866);
  for i := 1 to 100 do
    ds := 'Проверка связи';
  //ds := ds + ' 123';
  ShowMessage('ds[1] = ' + ds[1]);
end;

TMyRecord = record
  obj: TMyObject;
  guard: IInterface;
end;

rec.obj := TMyObject.Create;
rec.guard := rec.obj;

  TInterfacedStringStream = class(TStringStream, IInterface)
{$IFNDEF AUTOREFCOUNT}
  private const
    objDestroyingFlag = Integer($80000000);
    function GetRefCount: Integer; inline;
{$ENDIF}
  protected
{$IFNDEF AUTOREFCOUNT}
    [Volatile] FRefCount: Integer;
    class procedure __MarkDestroying(const Obj); static; inline;
{$ENDIF}
    function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall;
    function _AddRef: Integer; stdcall;
    function _Release: Integer; stdcall;
  public
{$IFNDEF AUTOREFCOUNT}
    procedure AfterConstruction; override;
    procedure BeforeDestruction; override;
    class function NewInstance: TObject; override;
    property RefCount: Integer read GetRefCount;
{$ENDIF}
  end;

...

{ TInterfacedStringStream }

{$IFNDEF AUTOREFCOUNT}
function TInterfacedStringStream.GetRefCount: Integer;
begin
  Result := FRefCount and not objDestroyingFlag;
end;

class procedure TInterfacedStringStream.__MarkDestroying(const Obj);
var
  LRef: Integer;
begin
  repeat
    LRef := TInterfacedStringStream(Obj).FRefCount;
  until AtomicCmpExchange(TInterfacedStringStream(Obj).FRefCount, LRef or objDestroyingFlag, LRef) = LRef;
end;

procedure TInterfacedStringStream.AfterConstruction;
begin
// Release the constructor's implicit refcount
  AtomicDecrement(FRefCount);
end;

procedure TInterfacedStringStream.BeforeDestruction;
begin
  if RefCount <> 0 then
    Error(reInvalidPtr);
end;

// Set an implicit refcount so that refcounting during construction won't destroy the object.
class function TInterfacedStringStream.NewInstance: TObject;
begin
  Result := inherited NewInstance;
  TInterfacedStringStream(Result).FRefCount := 1;
end;

{$ENDIF AUTOREFCOUNT}

function TInterfacedStringStream.QueryInterface(const IID: TGUID; out Obj): HResult;
begin
  if GetInterface(IID, Obj) then
    Result := 0
  else
    Result := E_NOINTERFACE;
end;

function TInterfacedStringStream._AddRef: Integer;
begin
{$IFNDEF AUTOREFCOUNT}
  Result := AtomicIncrement(FRefCount);
{$ELSE}
  Result := __ObjAddRef;
{$ENDIF}
end;

function TInterfacedStringStream._Release: Integer;
begin
{$IFNDEF AUTOREFCOUNT}
  Result := AtomicDecrement(FRefCount);
  if Result = 0 then
  begin
    // Mark the refcount field so that any refcounting during destruction doesn't infinitely recurse.
    __MarkDestroying(Self);
    Destroy;
  end;
{$ELSE}
  Result := __ObjRelease;
{$ENDIF}
end;

ss: TInterfacedStringStream {TStringStream};