In neueren Delphi-Versionen können Klassen geschachtelt werden. Beispiel:

type
      TOuterClass = class
       strict private
          myField: Integer;
       public
          type
             TInnerClass = class
              public
                myInnerField: Integer;
                procedure innerProc;
             end;
         procedure outerProc;
       end;

implementation

procedure TOuterClass.TInnerClass.innerProc;
begin
  // ...
end;

procedure foo;
var
   x: TOuterClass;
   y: TOuterClass.TInnerClass;
begin
   x := TOuterClass.Create;
   x.outerProc;
   //...
   y := TOuterClass.TInnerClass.Create;
   y.innerProc;
end;   

Delphi2C# converts this to:

class TOuterClass : public System::TObject
{
  typedef System::TObject inherited;
private:
  int myField;
public:
  class TInnerClass : public System::TObject
  {
    typedef System::TObject inherited;
  public:
    int myInnerField;
    void innerProc();
    void InitMembers(){myInnerField = 0;}
public:
    TInnerClass() {InitMembers();}
  };  
  void outerProc();
  void InitMembers(){myField = 0;}
public:
  TOuterClass();
};

TOuterClass::TOuterClass() {InitMembers();}

void TOuterClass::TInnerClass::innerProc()
{
  // ...
}

void foo()
{
  TOuterClass* x = nullptr;
  TOuterClass::TInnerClass* y = nullptr;
  x = new TOuterClass();
  x->outerProc();
   //...
  y = new TOuterClass::TInnerClass();
  y->innerProc();
}