Newsgroup: it.comp.lang.visual-basic
Titolo: VB6: Err object viene "ripulito" se invocato su VBA.ObjPtr

I have a routine with this prototype in a *.dll
Ho una routine in una classe "global multiUse" compilata come *.dll,
che ha la seguente interfaccia.
Public Sub RaiseError(ByRef vError As Variant, _
                      ByVal sRoutine As String, _
                      ByVal sApplicationVersion As String, _
                      Optional ByVal sDetail As String =
VBA.Constants.vbNullStrin
    'Verifica la congruenza dell'input.
    If AndAlso(VBA.ObjPtr(vErrore) <> VBA.ObjPtr(Err), _
               Not TypeOf vErrore Is IObjectError) Then
        Exit Sub
    End If
    'Verifica se è necessario segnalare un errore.
    If vErrore.number = 0& Then Exit Sub
	...
      'FA ALTRE COSE
     '...
End Sub
Il parametro di input vError, viene controllato in maniera che
supporti un'interfaccia personalizzata (IObjectError),
oppure coincida con il singleton Err.
Referenzio questa *.dll da miei progetti vb6.
Se dal progetto invoco il metodo precendete passando come input vError
l'oggetto Err, ho notato che Err
mantiene il suo stato congruente finchè non arriva all'istruzione IF,
in particolare quando viene valutata la
condizione  VBA.ObjPtr(vErrore) <> VBA.ObjPtr(Err).
cleared. Commentando questa istruzione, tutto funziona come previsto.
Qualche idea su questo comportamento?


Oddio, tutto il tuo post è un po' "pasticciato", prova a rileggerlo...
Comunque... cos'è AndAlso? (in .NET lo so, in VB6?)
Non è che è lì l'inghippo?
Bye
Raf 

 Raf
No! E' una mia routine che simula l'operatore AndAlso di .Net in Vb6.

 No! E' una mia routine che simula l'operatore AndAlso di .Net in Vb6.
E come funziona? Forse non č lģ il problema, perņ sono curioso ugualmente...
Ciao 

 Ciao
Ciao Raf.
Il problema non è quello: è che usando la routine nascossta VBA.ObjPtr
sul singleton Err ricevuto come parametro ByRef dalla routine, Err
stesso viene "azzerato" (perde lo stato, come se venisse chiamato il
metodo .Clear()).
Ciao e grazie lo stesso.
La routine AndAlso (che simula l'operatore) è invece questa:
Public Function AndAlso(ParamArray abConditions() As Variant) As
Boolean
    Dim ii                      As Long
    On Error GoTo GESTIONE_ERRORI
    'Verifica di congruenza.
    If UBound(abConditions) <= 0& Then
        Call VBA.Information.Err.Raise(eSharedErrors.dwAndAlso, _
                                       Err.Source(), _
                                       "AndAlso requires at least two
terms.")
    End If
    For ii = 0 To UBound(abConditions) 'L'oggetto paramArray è sempre
a base 0.
        'Out::
        AndAlso = abConditions(ii)
        If Not AndAlso Then Exit For
    Next ii
    Exit Function
GESTIONE_ERRORI:
    'Solleva l'eccezione al chiamante.
    Call VBA.Information.Err.Raise(eSharedErrors.dwAndAlso, _
                                   Err.Source() & VBA.Constants.vbCrLf
& _
                                   "UTO_Dedalus.Shared.AndAlso()", _
                                   Err.description())
End Function

 End Function
Comunque, se mi posso permettere un'osservazione: questa tua routine AndAlso 
potrà forse rendere un po' più leggibile il codice, ma (oltre a resettarti 
Err) non fa assolutamente la cosiddetta "short-circuit evaluation" (quella 
di AndAlso e OrElse di 
VB.NET
).
Infatti VB6 valuta *prima* tutti i parametri che passi ad una funzione, 
prima di invocare la funzione stessa, mentre AndAlso (di 
VB.NET
), se il 
primo operando è valutato False, non valuta nemmeno il secondo.
Prova così:
Dim c As Collection
    If AndAlso(Not c Is Nothing, c.Count > 0) Then
    ...
Questa dà errore "object variable not set", senza neanche entrare in 
AndAlso.
(
VB.NET
)
Dim c As Microsoft.VisualBasic.Collection
    If (Not c Is Nothing) AndAlso (c.Count > 0) Then
    ...
Questa invece no.
Bye
Raf
 

 potrà forse rendere un po' più leggibile il codice...
Infatti, ha essenzialmente questo scopo, in quanto in vb6 non posso
definire operatori :-(
e dovendo ricorrere a routine è inevitabile che succeda quello che
dici tu!
Comunque grazie lo stesso.
Ciao. :-)


Per il fatto de "On Error Goto" hai perfettamente ragione: ormai
consideravo la mia AndAlso come un operatore e non come una routine...
purtroppo questo è il contrappasso per dover programmare sia in .Net
che in VB6. Se non ti avessi postato la routine, non me ne sarei
accorto.
Ciao e grazie.


Ti capisco, è dura in effetti anche per me :-/,  ma ormai mi sto abituando a 
"mantenere il piede in due scarpe"... se non in 3!
Ciao
Raf