[Neftali [Germán.Estévez]]

Yo personalmente hubiera hecho algo así (en realidad es lo que hago).

Sigues manteniendo las propiedades de lectura/escritura de las diferentes variables (ya que eso te lo da la clase), y colocas las variables "dentro" de la clase en lugar de fuera.

Mantienes una variable Global del tipo TGlobales, pero es que de la otra forma también mantienes en memoria todas las variables necesarias. No le veo diferencia en eso.

Código Delphi [-]
unit Globales;

interface

type
  TGlobales = class
  private
    FUsuario : string;
    FCadenaConexion: string;
    FPassWord: string;

    // procediminto y función para leer la varables
    // se antepone Class, para indicar que son métodos de clase y on de objeto
    function GetUsuario : string;
    procedure SetUsuario(const Value: string);
    function GetPassWord: string;
  protected

  public
    // Es una propiedad de clase y no de objeto, debido a que usa metodos de clase
    property Usuario : string read GetUsuario;
    property Password: string read FPassWord;
    property CadenaConexion:string read FCadenaConexion write FCadenaConexion;

    procedure Inicializa(Us,psw:String);
  published
  { published declarations }
  end;

var
  uGlobales:TGlobales;

implementation

uses
  SysUtils;


function TGlobales.GetUsuario: string;
begin
  Result := FUsuario;
end;

procedure TGlobales.Inicializa(Us, psw: String);
begin
  FUsuario := us;
  FPassWord := psw;
end;

procedure TGlobales.SetUsuario(const Value: string);
begin
  FUsuario := Value;
end;

Initialization
  uGlobales := TGlobales.Create();

Finalization
  FreeAndNil(uGlobales)

end.