Newsgroup: it.comp.lang.vo-clipper
Titolo: Come si usano i seguenti Metodi! Aiuto x cortesia!

Salve a tutto il Ng.
Chiedo UMILMENTE PERDONO e Mi scuso x tutte le "ROTTURE" che do e darò.
Ringrazio TUTTI QUELLI CHE AVRANNO LA PAZIENZA DI LEGGERE TUTTO CIO' E KE MI 
AIUTERANNO A CAPIRE!!!
GRAZIE!!! IN ANTICIPIO!!!
Eccomi sempre alle prese con VO e con i soliti problemi.
Come Integro questi metodi alla mia applicazione?
Riporto i seguenti esempi dal Libro IL MANUALE CA VISUAL OBJECT.
Capitolo 11 APPLICAZIONI MULTIUTENTE
DALLA PAGINA 446 ALLA PAGINA 447
********************  Metodo NetUse() x una corretta apertura del DBF
METHOD NetUse (xDBF) CLASS DataWindow
    Local lStatus :=  TRUE AS LOGIC
    self:Use(xDBF)
    //controlla se l'apertura ha avurto successo
        if self:sever:Status != NULL_OBJECT
            lStatus := FALSE
                //  da errore
            self:Error(self:server:Status)
    endif
RETURN lStatus
********************  Metodo AddRec() x aggiungere un record senza errori 
per un numero di tentativi definiti dal programmatore
METHOD AddRec(nAttempts) CLASS DBServer
        Local nOldCollegeTry :=  1 AS WORD
        Local lStatus := False AS LOGIC
        WHILE lStatus .and. OldCollegeTry++ <= nAttempts
                    lStatus := oDBAppend()
        ENDDO
return( lStatus)
*********************
********************* Metodo FileLock() x ottenere il blocco di un file 
senza errori.
METHOD FileLock(nAttempts) CLASS DBServer
        Local nOldCollegeTry :=  1 AS WORD
        Local lStatus := False AS LOGIC
        WHILE lStatus .and. OldCollegeTry++ <= nAttempts
                    lStatus := oDB:FLock()
        ENDDO
return( lStatus)
********************* Metodo RecLock() x ottenere il blocco di un record 
senza errori.
METHOD RecLock(nAttempts) CLASS DBServer
        Local nOldCollegeTry :=  1 AS WORD
        Local lStatus := False AS LOGIC
        If Empty(nAttempts)     // NULL o 0
            nAttempts := 3         // default per sicurezza
        endif
        WHILE lStatus .and. OldCollegeTry++ <= nAttempts
                    lStatus := oDB:LockCurrentRecord()
        ENDDO
return( lStatus)
************************
Ho Creato una piccola applicazione cosi strutturata:
Gestione Modalità Pagamento
L'archivio database in uso si chiama AnModPag - Anagrafica Modalità 
Pagamento
Indici in uso sono:
AMPINDP // Anagrafica Modalità Pagamento Indice Descrizione Pagamento
AMPINCP // Anagrafica Modalità Pagamento Indice Codice Pagamento
1) Desidero Inserire un record nuovo
2) Desidero Modificare un record selezionato
3) Desidero Cancellare un record selezionato
4) Desidero fare Zap su un Archivio in Uso.
Il tutto in modalità MultiUtente.
1) ShellWindow
 METHOD Start() CLASS App
 LOCAL oMyShellWindow AS MyShellWindow
               Enable3dControls()
                SetCentury(On)
                  SetDateCountry(6)
    SetExclusive(FALSE)
                      SetDeleted(TRUE)
      oMyShellWindow := MyShellWindow{ SELF  }
      oMyShellWindow:Show(  SHOWZOOMED )
     SELF:Exec()
2) Un Menu con un'unica voce: "Gestione Modalità Pagamento"
Clikkando su Gestione Modalità Pagamenti si la Finestra Gestione Generale 
Modalità Pagamento
Con i seguenti PushButton
Inserimento    - ButtonIns        // Mostra Finestra Gestione Inserimento 
Nuova Modalità Pagamento
METHOD ButtonIns() CLASS MyShellWindow
 LOCAL oGestInseModPagWin AS GestInseModPagWin
 oGestInseModPagWin:=GestInseModPagWin{SELF}
 oGestInseModPagWin:Show()
 RETURN NIL
**********************************************************
Modificare    -  ButtonMod     // Mostra Finestra Gestione Modifica 
Modalità Pagamento
METHOD ButtonMod() CLASS MyShellWindow
 LOCAL oGestModiModPagWin AS GestModiModPagWin
 oGestModiModPagWin:=GestModiModPagWin{SELF}
 oGestModiModPagWin:mCodiPaga  := Self:Server:CodiPaga
 oGestModiModPagWin:mDescPaga  :=Self:Server:DescPaga
 oGestModiModPagWin:mNScaPaga :=Self:Server:NScaPaga
 oGestModiModPagWin:Show()
 RETURN NIL
****************************************************************
Eliminare       -  ButtonCanc    // Mostra Finestra Gestione Elimina 
Modalità Pagamento
METHOD ButtonMod() CLASS MyShellWindow
 LOCAL oGestElimModPagWin AS GestElimModPagWin
 oGestModiElimPagWin:=GestModiElimPagWin{SELF}
 oGestModiElimPagWin:Show()
 RETURN NIL
*****************************************************************
Uscita           -  ButtonEsci      // Esce dalla Finestra Gestione Generale 
Modalità Pagamento e ritorna alla ShellWindow
METHOD ButtonEsci() CLASS GestGeneModPagWin
 SELF:Destroy()
 RETURN NIL
**********************************************************
Ogni Finestra ha 2 PushButton
Conferma - ButtonOk -------> per confermare Se è un inserimento di un nuovo 
record o la modifica di un record esistente o la cancellazione di un record 
esistente
Annulla     - ButtonEsci ------------> esce dalla Finestra e ritorna alla 
Finestra Gestione Generale Modalità Pagamento
METHOD ButtonOk() CLASS GestInseModPagWin   // Conferma i dati inseriti 
nelle single line edit e registra il record nel database AnModpag
1) Come faccio ad utilizzare il Metodo NetUse() x l'archivio AnModPag al 
posto di Use()?
2) Come faccio ad utlizzare il Metodo AddRec() x aggiungere un record 
correttamente al posto del normale Append()
La sintassi normale x un'applicazione non MultiUtente sarebbe:
 Self:Append()
    Self:Server:CodiPaga :=Self:mCodiPaga            // Inserisce Codice 
Pagamento
    Self:Server:DescPaga :=Self:mDescPaga           // Inserisce Descrizione 
Pagamento
    Self:Server:NScaPaga :=Self:mNScaPaga        // Inserisce Numero delle 
Scadenze del Pagamento
Self:Server:Commit()
Self:Destroy()
Return
******************************
************************
METHOD ButtonOk() CLASS GestModiModPagWin   // Conferma i dati e aggiorna il 
record nel database AnModPag
1) Come faccio ad utilizzare il Metodo RecLock x  ottenere il blocco del un 
record prima ke questi venga modificato?
La sintassi normale x un'applicazione non MultiUtente sarebbe:
    Self:Server:CodiPaga :=Self:mCodiPaga            // Inserisce Codice 
Pagamento
    Self:Server:DescPaga :=Self:mDescPaga           // Inserisce Descrizione 
Pagamento
    Self:Server:NScaPaga :=Self:mNScaPaga        // Inserisce Numero delle 
Scadenze del Pagamento
Self:Server:Commit()
Self:Destroy()
Return
******************************
METHOD ButtonOk() CLASS GestElimModPagWin   // Conferma il record 
selezionato
1) Come faccio ad utilizzare il Metodo RecLock x  ottenere il blocco di un 
record prima ke questi venga cancellato?
La sintassi normale x un'applicazione non MultiUtente sarebbe:
  LOCAL oServer  AS  AnModPag
            oServer := AnModPag{,FALSE}       // per cancellare  il record 
corrente aprire il server esclusivo
            oServer : Delete()
            oServer : Pack()
            oServer : commit()
            oServer : Close()
RETURN NIL
******************************
1) Come faccio ad utilizzare il Metodo FileLock() x ottenere il blocco di un 
File senza errori  x effettuare Zap?
La sintassi normale x un'applicazione non MultiUtente sarebbe:
  LOCAL oServer  AS  AnModPag
            oServer := AnModPag{,FALSE}       // per Zap l'archivio database 
aprire il server esclusivo
            oServer : Zap()
            oServer : Close()
RETURN NIL
Come Integro questi metodi ai Metodi della  mia applicazione?
Spero di essere stato il + chiaro possibile.
Ringrazio e saluto tutto il Ng
Buon lavoro a tutti
Giuseppe Squitieri

Ciao Giuseppe,
quando utilizzavo i dbf adottavo un approccio diverso alla multiutenza, non 
facevo il lock ma se dovevo bloccare un file lo aprivo in modalità esclusiva 
con questa funzione, gentilmente scritta tanti anni fa da Franco Signore.
FUNCTION FS_Apriesclusivo(oOwner AS window , oDBServer AS dbserver , oDBApri 
AS SYMBOL)
LOCAL nTime := 0 AS INT
LOCAL aRet AS ARRAY
LOCAL lBloccato := FALSE AS LOGIC
LOCAL oTB AS WarningBox
LOCAL nTimeOut AS WORD
LOCAL oReturn AS OBJECT
WHILE lBloccato = FALSE
 nTimeOut := 100
    DO WHILE nTime <= nTimeOut .AND. .NOT. lBloccato
  oDBServer := CreateInstance(oDBApri,, DBEXCLUSIVE )
  oREturn := oDBServer:Status
  lBloccato := oReturn = NULL_OBJECT
  nTime++
 ENDDO
 IF lBloccato == FALSE
  oTb := WarningBox{oOwner, "Apertura esclusiva file" , "Il file è 
temporaneamente bloccato...ritento l'apertura? Se si risponde NO è possibile 
perdere i dati inseriti!"}
  oTb:Type := BOXICONQUESTIONMARK + BUTTONYESNO
    IF oTb:Show()== BOXREPLYYES
           nTime := 0
     LOOP
     ELSE
    EXIT
    ENDIF
  ELSE
          EXIT
   ENDIF
  ENDDO
 aRet := {oDbServer, lBloccato}
RETURN aRet
Per i record inserivo sempre un campo logico RETE che utilizzavo per vedere 
se il record era in uso o meno, credo sia più efficace del semplice lock ed 
anche molto più sicuro.
Spero ti sia stato d'aiuto.
Ciao.
                                            Francesco Leo