Evitar variables globales....

[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

[[maeyanes]]

Hola...

Y usando el ejemplo de roman en Delphi 2010 y posteriores:

Código Delphi [-]
TGlobal = class
  // ...
public
  class constructor Create; // constructor de clase
end;

implementation

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

  Este constructor se llama automáticamente la primera vez que se quiere usar esta clase.
  }
end;

Saludos...

[roman]

Pero entonces volvemos a lo mismo Si inicializas los valores en el constructor, entonces estás obligado a crear una instancia.

Edito:

¡Ah! No me habia fijado en el comentario. ¡Qué cosa más rara! ¡Constructores de clase! Si de por sí un constructor era un método de clase

// Saludos

[[maeyanes]]

Hola...

Empezado por roman

¡Ah! No me habia fijado en el comentario. ¡Qué cosa más rara! ¡Constructores de clase! Si de por sí un constructor era un método de clase

// Saludos

Así es, son constructores de clase, y también existe class destructor. La diferencia y ventaja de estos es que solo se ejecutan hasta el momento en que se usa por primera vez la clase que lo implementa (y en el caso del destructor solo si se usó la clase en tiempo de ejecución). A diferencia de las secciones initialization y finalization de las unidades que siempre se ejecutan si la unidad está referenciada.


Saludos...

[roman]

Y si tengo un class constructor, ¿lo puedo usar para crear objetos? Si tengo un class constructor y un constructor regular y creo un objeto con el regular, ¿también se ejecuta el de clase? De ser así, ¿cuál se ejecuta primero?

// Saludos