Evitar variables globales....

[Paoti]

El (1) no funciona, como variable privada, debe ser de la forma como está la clase expuesta por mi anteriormente.

el (2) es otra forma, usando propiedades estáticas simuladas.

Ahora, el ejemplo anterior, del post, es cómo usar otro tipo de Variables Globales, sí no quieres usar la forma tradicional.

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

Empezado por Paoti

El (1) no funciona, como variable privada, debe ser de la forma como está la clase expuesta por mi anteriormente.

Correcto.
En ese caso hay que definir una variable global del tipo TGlobales, como comenté antes.

De todas formas, sigo viéndolo "raro".

[roman]

Es que no hay que definir ninguna variable del tipo TGlobales. Simplemente se hace:

Código Delphi [-]
TGlobales.Usuario := 'roman';

Edito:

¡Ah! Veo que Chris ya lo mencionó

// Saludos

[roman]

Sólo añadir que, con esta técnica, dado que el acceso es vía métodos de una clase, se puede tener un mejor control, validación, etc. Incluso pueden implementarse variables "globales" de sólo lectura, por ejemplo.

// Saludos

[Paoti]

¡Hola compañeros!

Me gusta tu idea roman, para evitar usar ahora sí, variables globales


Por ejemplo, una idea sería la siguiente:

Código Delphi [-]

TGlobales.CadenaConexion := 'lcoalhost:baseDatos';
TGlobales.Inicializa('usario', 'pAssW0rd');
TieneAcceso := TGLobales.Activo;
Perfil := TGloables.Perfil;
ultimoAcceso := TGlobales.FEchaUltAcceso

el método Inicializa(), incializa los valores de las propiedades de clase, que serán Globales, y de solo lectura. en base a los datos de la base de datos. y están disponibles en todos lados donde se haga referencia la unidad.

[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.

[roman]

La diferencia es que en tu caso debes crear un objeto de esa clase siendo que los datos a los que accedes no dependen realmente de un objeto en particular sino de la clase en sí.

Idealmente se tendría algo así:

Código Delphi [-]
type
  TGlobal = class
  private
    class var FUsuario: String; // <--- Esto no es posible
    class function GetUsuario: String;

  public
    property Usuario: String read GetUsuario;
    class procedure Inicializa;
  end;

implementation

class function TGlobal.GetUsuario: String;
begin
  Result := FUsuario;
end;

class procedure TGlobal.Inicializa;
begin
{
  Aquí se leen los valores de un archivo INI o de la base de datos, etc.

  Este método podría llamarse, por ejemplo, en la inicialización de la unidad.
}
end;

Y, entonces, para usar esos datos lo haces directamente de la clase:

Código Delphi [-]
Caption := TGlobal.Usuario;

Pero, como delphi no permitía las variables de clase, es que se simulan haciendo lo que dice Paoti.

Desde luego que la clase, tal como la usas tú, instanciando un objeto, tampoco es que esté mal. Al final de cuentas cumple con el objetivo de evitar el uso de variables globales.

// Saludos