Il blog di Nicola

Innanzitutto occorre importare la libreria:

Domino_TLB

poi dichiarare le variabili:

_session:TNotesSesion;
_notesdb:IDatabase;
_views: OleVariant;
_view: IView;
_documents: IDocumentCollection;
_document: IDocument;

ed ecco un pò di codice di esempio:

begin
 
  CoInitializeEx(nil, COINIT_APARTMENTTHREADED);
 
  try
 
      // Creo la sessione
      _session := TNotesSession.Create(nil);
      // La inizializzo con la mia password notes
      _session.Initialize('password');
 
      // Creo l'oggetto database 
      _notesdb := _session.GetDatabase('server','database',False);
 
      // Ecco come ottenere l'elenco di tutte le viste
      _views := _notesdb.Views;
      for I := 0 to VarArrayHighBound(_views, 1) - VarArrayLowBound(_views, 1) do
      begin
        _view := IView(IUnknown(_views[I]));
        writeln(_view.Name);
       end;
 
      // Esempio di utilizzo della proprietà GetAllDocumentsByKey di una vista
      _view := _notesdb.GetView('Lamiavista');
      if _view <> nil then
      begin
        _documents := _view.GetAllDocumentsByKey('Valore della chiave',true);
        //adesso che ho una collezione di documenti, la ciclo, ed estraggo il
        // valore del campo 'pippo' di ogni documento
        _document := _documents.GetFirstDocument;
        while _document <> nil do
        begin
          writeln(String(_document.GetItemValue('pippo')[0]));
          _document := _documents.GetNextDocument(_document);
        end;
      end;
 
    readln;
end;

Questo secondo esempio sulla gestione degli eventi in Delphi permette di registrare più classi ad uno stesso evento. Questo viene fatto utilizzando un oggetto TList; non ho idea se sia la soluzione migliore, ma può essere un buono spunto per capire meglio il meccanismo.
Anche in questo caso tutto il castello si regge sul tipo di dato procedurale, che si definisce in questo modo:

TDecollo = procedure(Sender:TObject) of object;

TDecollo non è altro che un puntatore ad una procedura, che ancora deve essere specificata. E’ lo stesso meccanismo con cui si gestiscono gli eventi in C#, utilizzando i delegate.

In questo esempio abbiamo:

• La classe TorreDiControllo che genera un evento “decollo”.
• Più Shuttle che si registra all’evento e partono quando arriva il segnale.

Per implementare l’evento multicast la classe TorreDiControllo mantiene al suo interno un lista di oggetti ShuttleProntoAlDecollo, che hanno al loro interno il riferimento alla procedura da chiamare:

    ShuttleProntoAlDecollo = class
 
    decollo: TDecollo;
    property OnDecollo: TDecollo read decollo write decollo;
 
    end;

Per registrarsi all’evento gli Shuttle usano questo metodo:

   procedure TorreDiControllo.AddShuttleProntoAlDecollo(proc: TDecollo);
      var s: ShuttleProntoAlDecollo;
    begin
 
    s := ShuttleProntoAlDecollo.Create;
 
    s.decollo := proc;
 
    // La TList
    ShuttlesProntiAlDecollo.Add(s);
 
  end;

dove:

• viene creto un nuovo oggetto ShuttleProntoAlDecollo
• viene associata alla sua proprietà decollo (che è un puntatore ad un procedura) la procedura specificata dal chiamante
• viene inserito l’oggetto creato nella lista

La procedura Decollo della TorreDiControllo richiama tutte le procedure registrate:

  for p in ShuttlesProntiAlDecollo do
    begin
 
      // Estraggo la classe ShuttleProntoAlDecollo dal TList
      s := ShuttleProntoAlDecollo(p);
 
      // Estraggo il puntatore alla procedura da chiamare
      f := s.decollo;
 
 
      // Chiamata della procedura indicata dallo shuttle
      if Assigned(f) then
        f(self);
 
    end;

Qui è possibile scaricare il progetto contenente le classi sopra descritte.

Questo è un piccolo esempio di come creare in delphi un evento, e di come registrarsi ad esso.
Tutto il meccanismo si basa sul tipo di dato procedurale, che si definisce in questo modo:

TDecollo = procedure(Sender:TObject) of object;

TDecollo in questo caso non è altro che un puntatore ad una procedura, che ancora deve essere specificata. E’ lo stesso meccanismo con cui si gestiscono gli eventi in C#, utilizzando i delegate.

In questo esempio abbiamo:

• La classe TorreDiControllo che genera un evento “decollo”.
• La classe Shuttle che si registra all’evento e parte quando arriva il segnale.

Come prima cosa occorre definire il puntatore:

TDecollo = procedure(Sender:TObject) of object;

Per poter assegnare una procedura a questo puntatore occorre che questa rispetti il numero ed il tipo dei parametri in ingresso, in questo caso un parametro di tipo TObject.

Questa è la definizione della classe TorreDiControllo:

TorreDiControllo = class
 
    FOnDecollo: TDecollo;
 
    public
      procedure Decollo;
 
      property OnDecollo : TDecollo read FOnDecollo write FOnDecollo;
 
  end;

Quindi, al puntatore FOnDecollo potra essere assegnata, tramite la proprietà OnDecollo, la procedura che verrà eseguita.

La procedura Decollo invece, è la seguente:

procedure TorreDiControllo.Decollo;
  begin
 
    Writeln('Torre di controllo: segnale di decollo inviato');
 
    if Assigned(OnDecollo) then
      OnDecollo(self);
 
  end;

Non fa altro che verificare con il metodo Assigned che la procedura a cui punta OnDecollo sia stata valorizzata. Se lo è allora la esegue.

La classe Shuttle non fa altro che dichiarare una procedura in questo modo:

procedure OnSegnaleDiDecollo(Sender: TObject);

In questo esempio, il program non fa altro che:

• Istanziare le classi TorreDiControllo e Shuttle

       Torre := TorreDiControllo.Create;
       apollo13 := Shuttle.Create;

• Registrare lo shuttle all’evento Decollo

  Torre.OnDecollo := apollo13.OnSegnaleDiDecollo;

• Chiamare la procedura Decollo della torre di controllo

  Torre.Decollo;

• Osservare ammirati la fase di lancio dello Shuttle

Qui è possibile scaricare il progetto contenente le classi sopra descritte.

Delphi non supporta la gestione di eventi multipli, ovvero, in questo esempio, non si possono registrare più classi Shuttle all’evento Decollo. E’ possibile farlo gestendo all’interno della classe che genera l’evento una lista, per esempio una TList.