Newsgroup: it.comp.lang.visual-basic
Titolo: Non userò mai più vbNullString

Oh ragazzi,
ho passato un sabato mattina di Pasqua a dir poco infernale.
Sono andato da un cliente ad aggiornare il mio applicativo.
Durante la settimana ho sostituito in un *fottuto punto solo* un'istruzione
dentro una classe che faceva così:
Me.TestoAlternativo = ""
nell'equivalente
Me.TestoAlternativo = vbNullString
Non chiedetemi perchè l'ho fatto, per leggibilità, o per fissazione. Io ho
poi anche la fissa che ogni volta che scrivo "" viene istanziata una
variabile, mentre con vbNullString che è una costante no.
Beh, arrivando al sodo, quella riga che prima funzionava, poi con
vbNullString non funzionava più. Dopo quell'assegnamento, andavo a salvare
nel database, che però poi mi dava un errore OLEDB nel database......
incredibile.........e io che pensavo che vbNullString e "" fossero
equivalenti, come è giusto che sia.....
invece evidendentemente qualcosa cambia......perchè è bastato rimettere ""
per far funzionare tutto......
boh, voi sapete come mai? non è che mi interessa molto, diciamo, però è
curiosità......
anche perchè la stessa modifica su altri PC di un altro cliente andava a
meraviglia, e quindi stamattina non avevo motivo di dubitare di questo
malfunzionamento.......
vabbè, good coding e buona pasqua......
-- 
Alletun
"Io lo so che accadrà. La voce sussurra nei miei pensieri
di Jair, Rone, Allanon e soprattutto nelle Mortombre.
Sussurra segreti che mi sono tenuti nascosti, nella grigia
oppressione di questo giorno e nell'oscurità caliginosa
di quello che mi aspetta.
Saremo distrutti. Tutti."
Brin Ohmsford - La Canzone di Shannara - T. Brooks

 è curiosità......
Non uso vbNullString, ma vorrei fare una prova.
Puoi indicarci il tipo/caratteristiche di campo del database di destinazione
e come ne assegni il valore?
Da "Me.TestoAlternativo = vbNullString" non si capisce bene cosa finisca nel
database...
Inoltre, tipo del database, DAO o ADO, controlli data?

 variabile, mentre con vbNullString che è una costante no.
La differenza tra vbNullString e "" è davvero sottile.
Entrambe sono costanti (non essendo state dichiarate ;) non possono che
esserlo).
vbNullString è un puntatore a stringa nulla, "" è una stringa nulla.
Usando l'API, ad es. è più corretto passare un vbNullString quando viene
chiesto una BSTR o un *char.
Usando VB è teoricamente indifferente (ma solo all'interno di VB! se si
passa vbNullString a un componente esterno non si sa come questo lo
gestisca!) perchè assegnandolo a una variabile poi VB lo converte per conto
suo in "".
In pratica io ho notato un notevole aumento di prestazioni nell'assegnamento
di vbNullString piuttosto che "".
L'unico caso in cui vbNullString mi ha dato problemi è stato in un programma
VB4 16bit quando assegnare vbNullString a una cella di una griglia causava
un bel GPF (la stessa app in Vb4 32bit funzionava perfettamente).
Per cui mi lascia un po' perplesso il tuo problema.
Che codice c'è all'assegnazione di TestoAlternativo, se è su quella linea
che va in errore?
Ciao
--
Math Parser : 
http://www.neodatatype.net
Sito Comune : 
http://www.it-lang-vb.net

 ha scritto nel messaggio
news:c58q5e$2ppusf$1...@ID-134521.news.uni-berlin.de...


 esterne
Beh, ma queste due cose sono _profondamente_ diverse.
In ogni caso, in VB (vedi anche il post di Zanna) pare non sia vero perchè
Len(vbNullString) è 0...

 Me.TestoAlternativo = vbNullString
[cut]
Guarda l'url
http://support.microsoft.com/default.aspx?scid=kb;en-us;162622
In particolare l'ultima riga dice:
"Note that using vbNullString is equivalent to passing NULL as the
parameter. This is not the same as passing an empty string ("")"
Ho anche trovato qualcosa di piu' tecnico:
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnw32dev/ht
ml/ora_apiprog6_topic1.asp
dove:
"It is also important not to confuse a null BSTR with an empty BSTR, usually
denoted by a pair of adjacent quotation marks"
Dim s As String
Dim t As String
s = vbNullString
t = ""
Unlike a null string, the empty BSTR t is a pointer that points to some
nonzero memory address. At that address resides the terminating null
character for the empty BSTR, and the preceeding length field also contains
a 0."
Senza offesa, un programmatore C capirebbe subito la differenza! ;)
Ciao
Beppe

curiosità......
Che avresti facilmente risolto facendo una ricerchina anche sulla
comune documentazione in linea.
vbNullString NON corrisponde a "", ma corrisponde a (riporto dalla
documentazione):
vbNullString 
String having value 0 
Not the same as a zero-length string (""); used for calling external
procedures. 
Qui serve un po' di scuola. Windows e' integralmente scritto in C (in
C++, in realta', ma le API sono in C). In C una stringa altro non è se
un vettore di bytes, e viene passata a una funzione per indirizzo
(quindi viene di fatto passato un puntatore). Di piu': molto spesso in
C si passa il valore NULL come puntatore con il significato di "non ti
ho passato nulla"; fatalità, NULL e' definito come un intero lungo con
valore 0.
A questo punto credo tu abbia capito il problema. vbNullString viene
utilizzato per poter usare le API e passare NULL dove è prevista una
stringa ma dove deve anche essere previsto che tu possa non passarla.
Ciao!
Luca

 ha scritto nel messaggio
news:c58r4u$2olvvo$1...@ID-174464.news.uni-berlin.de...

toh, ti posto un pezzetto della function incriminata.....
Public Function SalvaServizio() As Long
Dim Record As ADODB.Recordset
Set Record = New ADODB.Recordset
Record.Open "SELECT * FROM Calendario WHERE IDServizio=" & Me.IDServizio,
Archivio, adOpenDynamic, adLockOptimistic
....
....
....
If Me.Contratto = True Then
    Record("Contratto") = 1
Else
    Record("Contratto") = 0
End If
If Me.ControFirmato = True Then
    Record("ControFirmato") = 1
Else
    Record("ControFirmato") = 0
End If
If Me.ServizioEsterno = True Then
    Record("ServizioEsterno") = 1
    Record("TestoAlternativo") = Me.TestoAlternativo
Else
    Record("ServizioEsterno") = 0
    Msgbox "Errore!!"
    Record("TestoAlternativo") = vbNullString
End If
If Me.Provvisorio = True Then
    Record("Provvisorio") = 1
Else
    Record("Provvisorio") = 0
End If
Record("PercAgenzia") = Me.PercAgenzia
Record("Note") = Me.Note
Record("Sigla") = Me.Sigla
Record("RoadManager") = Me.RoadManager
Record("Altro") = Me.Altro
Record("NoteVeloci") = Me.NoteVeloci
Record("Intermediario") = Me.Intermediario
Record.Update
SalvaServizio = Record("IDServizio")
Record.Close
Set Record = Nothing
Set ArchivioTemp = Nothing
End Function
in fase di debug dal cliente, vedevo apparire la msgbox "Errore" che si vede
nel codice, poi l'errore bloccante che diceva una cosa tipo:"l'errore si è
verificato in uno o più passaggi nei campi OLEDB" o qualcosa del genere, non
lo ricordo a memoria. So per certo che è lo stesso messaggio che ottengo
(giustamente) se tento di salvare 13 in un campo booleano, per fare un
esempio.
uso ADO, Access 2000, senza controlli data di alcun tipo. l'oggetto Record è
un ADODB.Recordset.
good coding!!!


 ha scritto nel messaggio
news:BySdc.119286$Kc3.3...@twister2.libero.it...
ti ringrazio per gli url che mi hai passato, adesso non ho tempo di leggerli
a fondo....però faccio una osservazione veloce veloce. nella finestra debug
di vb, se scrivo
? vbNullString=""
ottengo True.......per cui....
good coding!!!


 ha scritto nel messaggio
news:c58ves$2oubun$1...@ID-134521.news.uni-berlin.de...
TestoAlternativo è un campo di tipo Testo, lungo 100 caratteri che consente
lunghezza zero.
Il database, come già indicato, è Access 2000.



Credo sia una convenzione. vbNullString serve per passare un puntatore
valorizzato a NULL in una chiamata a funzione che prevede il passaggio
di argomento ByRef (significa che non passo alcun indirizzo valido).
Passare "" significa indicare un indirizzo a un insieme di bytes di
cui i primi 4 (in realta' i soli 4) contengono la lunghezza della
stringa, che in questo caso è 0.
Ricordo peraltro che una stringa di VB è composta dai primi 4 bytes
che indicano la lunghezza della stessa, seguiti dai bytes che
rappresentano la stringa stessa. Inoltre, mi pare di ricordare che per
questioni di compatibilità una stringa vb è comunque seguita da uno o
due caratteri valorizzati a 0 (vbNullChar), pero' di questo non son
sicuro. in ogni caso, su VB2theMax (
www.vb2themax.com
) ci sono due
articoletti molto interessanti.
Ciao!
Luca

 parameter. This is not the same as passing an empty string ("")"
In 
VB.NET
Private str As String = [String].Empty
Campo String.Empty
Il valore di questo campo è la stringa di lunghezza zero "".
-----------
La guida MSDN di .NET per vbNullString :
Membro :  Non disponibile   > Aggiungo io: non utilizzato
Costante: vbNullString
Equivalente: Una stringa con valore 0.
Descrizione: Non equivale a una stringa di lunghezza zero ("") e viene
utilizzata per la chiamata di routine esterne.
Devo concludere che con 
VB.NET
 ci siamo liberati di questo valore mezzo
nullo
Ave
giuseppeD

 news:c58ves$2oubun$1...@ID-134521.news.uni-berlin.de...
...
Grazie, farň delle prove, ma ho la sensazione che i due links postati da
bEPPE siano piů che esaurienti...

 Record č un ADODB.Recordset.
Ho provato con ADO 2.7 e un database Access 97. Cursure Static e lato
Server.
Attenzione al Dynamic (suppongo, per logica, lato Server)...

 Me.TestoAlternativo = vbNullString
Io analizzerei anche il tipo di TestoAlternativo
Se è una variabile stringa, la cosa dovrebbe essere equivalente.
Se invece è un qualcosa per cui ti stai affidando alla proprietà predefinita
(ad esempio un textbox), le mille cose che accadono dietro sono fuori dal
tuo controllo.
Ciao
Alberto

 ottengo True.......per cui....
...per cui viene *interpretato* come una stringa vuota, il che non vuol dire
che coincida esattamente.
Anche ? 0# = 0& restituisce TRUE, pero' uno e' un double e l'altro un
long...
Ciao
--
Luca Dormio - 
luca....@tin.it
________________________________
"Marty, non stai ragionando in maniera quadridimensionale"
Dr. Emmett L. Brown

 good coding!!!
Lo so, avevo fatto anche io delle prove.
Ma credo sia una conversione implicita di VB
(secondo me errata) che come al solito
nasconde molte (troppe?) cose ai programmatori.
Cmq devi tenere presente la guida di riferimento,
non il singolo caso.... senno' come vedi appena esci
dallo VB "standard" nascono i casini....
Good coding! ;)
Beppe


 Mha...io direi che...un programmatore capirebbe subito la differenza!
Ciao
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

  Mha...io direi che...un programmatore capirebbe subito la differenza!
Sempre simpatico, eh?! (a proposito, t'aspettavo...)
Mi considero un programmatore e, forse perchè non ho mai usato vbNullString,
non ne ho mai inteso la differenza con "" e, pur dopo aver letto tutto il 3d
(come, suppongo, avresti dovuto fare tu) mi permetto di affermare che
vbNullString e "", in Visual Basic, sono la stessa identica cosa.
La differenza, sottile, ma sostanziale, fra vbNullString e "" c'è solo
quando si esce dall'ambiente VB, per esempio verso API.
Io, scusa l'ardire, continuo a considerarmi un programmatore.

 stringa, che in questo caso è 0.
Incuriosito da questo, in ambiente VB, ho fatto l'ennesima prova (oltre al
Len di vbNullString, ho anche provato ad assegnare vbNullString a un campo
di database testo che non ammette Null, ma ammette lunghezza nulla, non
s'arrabbia perchè lo intende "", non Null, nè, tantomeno, Chr(0)):
Private Sub Form_Load()
    Dim a As String
    a = vbNullString
    Call x(a)
End Sub
Sub x(ByRef s As String)
    Stop        'Qui s vale "", stessa cosa se passato ByVal
End Sub
Da quello che ho capito, la differenza è solo per "ambienti esterni" a VB...

 Io, scusa l'ardire, continuo a considerarmi un programmatore.
Direi di no, se di fronte alla guida chiara e puntuale della stessa MS
continui a sostenere il contrario!!!
Ciao
Beppe


Appunto. Credo che VB, quando il vbNullString venga impiegato in una
serie di circostanze applichi delle conversioni implicite. Cosa che a
me non piace, al pari di come non mi piace il casino della conversione
tra string e array of byte. In realta' non hai mai immediatamente la
percezione di cio' che stai facendo, ma ci devi sempre ragionare sopra
- e molto spesso non hai la certezza che il tuo ragionamento sia
corretto - .
Ciao!
Luca

 Beppe

 programmatori.
E, per essere piů chiaro, mi piacerebbe un esempio in VB (solo VB, nessun
altro mondo esterno, l'ho detto, eh?!) in cui vbNullString determina un
comportamento diverso da "". Poi torno a vendere panini.


 Ma...mica ho fatto il tuo nome/nickname!!!
Buona Pasqua


 comportamento diverso da "". Poi torno a vendere panini.
Duro eh?
La spiegazione puntuale e precisa sono i link che ho gia' fornito
e che sono LA GUIDA UFFICIALE DI VISUAL BASIC.
Se guardi il mio precedente intervento, ho riportato alcune NOTE
che dicono esattamente quello che dico io...
Se questo non ti basta....
E non c'entra un fico se si parla di "VB" o "VB piu' mondo esterno"
"VB con DBMS", "VB con patate" ecc... Che poi VB per fare 4 cose stupide *ti
protegga*
e' un'altra cosa. Ma dire che vbNullString="" e' ERRATO.SEMPRE.
Esempi? ogni volta che usi una API Wi32 e confondi le due cose :)
Certo che se fai solo Textbox + button, magari *ti va bene*
Cmq non devo evangelizzare nessuno, pero':
- se segui vbNullString<>"" puoi fare tutto senza pensare, scindendo i due
concetti
- se segui vbNullString=""  devi sempre pensare se puo' fare casini o no.
Fai tex ;)
Cia'
Beppe


 A titolo di cronaca
Private Sub Command1_Click()
Dim temp As String
temp = vbNullString
Me.Print VarPtr(temp) & " - " & StrPtr(temp)
temp = ""
Me.Print VarPtr(temp) & " - " & StrPtr(temp)
End Sub


 ha

E quindi?
Fermo restando la differenza sostanziale fuori da VB, quale sarebbe il
comportamento diverso in VB?

 no. Fai tex ;)
Non uso vbNullString e non la userò (se non quando necessario per, appunto,
qualche API), ma sono convinto (e scommetterei anche per il problema di
Alletun del post iniziale che ha aperto questo topic, chi vivrà vedrà) che,
nel solo ambiente VB, non sia diversa, ok, siamo più precisi, non abbia
comportamenti diversi da "".

  Ma...mica ho fatto il tuo nome/nickname!!!
E ci mancava pure...
Quello che voglio dire è che io, pur rischiando di manifestare tutta la mia
ignoranza, reagisco e mi metto in gioco. Specialmente quando qualcuno, pur
indirettamente, mette in dubbio quello che, esattamente come tanti altri
qui, mi considero. Io reagisco e me ne accollo tutti i rischi (anche
dichiarando quel che tecnicamente è falso, o tale è stato frainteso), mi
sorprendo del fatto che un post come il tuo non abbia fatto scattare altri,
più, o meno, preparati di me, ma che, come me, si considerano
programmatori...
Insomma, non credo che tutti, prima d'ora, conoscessero, al di là di VB, la
tecnica differenza fra vbNullString e ""..., ma credo che molti di questi si
considerino, ancora, programmatori.

 esempio verso API.
Idem, agli inizi mi son creato alcune basi, e vbnullstring in Vb lo strauso
!
a volte mentre creo scrivo "" per velocita' ma prima dei debug vado di
replace e metto tutto a posto, pero' e' vero, viene molto spesso di
confondere vbnullstring con "" ! Dovevano crearci anche il vbEmptyString, ma
almeno questo e' un lato positivo delle conversioni implicite che spesso ci
fa disperare !
PS: l'ho sempre usato anche nei DB appunto per non passare null e funziona,
il classico :
"!campo = valore"
,che genera errore di null non ammesso, diventa
!campo = valore & vbnullstring e ha SEMPRE funzionato con Dao e Access97.
-- 
<Gigio2K>
--- 
http://www.g2kweb.it/gigio2k
 ---
Nokia -> I.T.H.N. -> 
http://www.ithn.it/
VB -> I.C.L.VB -> 
http://www.it-lang-vb.net/

 considerino, ancora, programmatori.
In effetti conoscere questa differenza è molto importante solo per chi è
solito usare chiamate all'API di sistema. Usando "solo VB" la loro
diversità (perché in effetti le due cose sono molto diverse) è
mascherata dall'ambiente ed in effetti il programmatore può usarle come
fossero la stessa cosa.
Ciao.
-- 
BSD is for UNIX lovers -- linux is for Windows haters.


 Be nel primo caso StrPtr(temp) restituisce un valore = a 0 ( e restituirà
sempre 0 ), nel secondo un valore <> da 0 ( a anche questo sarà sempre cosi
)!
Quindi due comportamenti diversi nel caso di vbNullString e di "", come tu
avevi chiesto.


 come tu avevi chiesto.
Pensa che io, nella documentazione di VB in linea, non trovo VarPtr, nè
StrPtr...



Infatti non sono documentate :)
Devi cercarle in MSDN al di fuori dell'insieme VB.
Ciao
--
Math Parser : 
http://www.neodatatype.net
Sito Comune : 
http://www.it-lang-vb.net

 Devi cercarle in MSDN al di fuori dell'insieme VB.
Appunto, al di fuori di VB...


 Quindi?


  Quindi?
Quindi insisto nel dire che, all'interno del puro e solo VB, vbNullString e
"" hanno identico comportamento. Quando, nel solo VB (insisto!), usi un
pointer o l'allocazione di una variabile?


 ok
Ciao


 come tu avevi chiesto.
scusa ma mancano le definizioni di VarPtr e StrPtr , in msdn non si trovano,
cosa sono ?
Quel ptr mi sa di Puntatore e in VB (come aveva chiesto lupo) non si usano
direttamente o sbaglio ?


 ha scritto nel messaggio
news:c58q5e$2ppusf$1...@ID-134521.news.uni-berlin.de...
<quoting>
ciao a tutti, mi è un po' dispiaciuto di non poter seguire tutto il thread
causa....Pasqua...
vabbè, ho capito, non userò più vbNullString come l'ho sempre usato
praticamente da sempre......e vi assicuro che programmo da un bel po' di
tempo. Però continuo a non capire, nella mia voglia di ricercare la
semplicità.....
Per me, e lo dico con forza "" è uguale a vbNullString. Punto e stop.
Tant'è vero che, ripeto, l'ho sempre usato e non ho mai avuto problemi di
alcun tipo.
Sono più propenso a pensare che ci sia qualche altro problema da qualche
altra parte.
Come ho accennato ero andato mercoledì scorso da un altro cliente, a Milano,
con lo stesso EXE, stessa data di compilazion e NESSUN PROBLEMA. Quindi mi
viene da pensare a qualche dll di vb, qualche dipendenza, qualcosa, insomma,
che ora mi sfugge.......
Tutte le osservazioni che sono state fatte, e per questo ringrazio un po'
tutti, sono sicuramente valide. Però, ripeto, credo che queste
considerazioni siano nate perchè è nato questo thread: non credo che molti
sapessero realmente che c'è differenza tra "" e vbNullString.
Continuo ad essere perplesso, comunque......
riporto qua alcune informazioni che mi erano state richieste.....
<lupo>
Me.ServizioEsterno è una variabile membro della classe Servizio. E' un tipo
booleano, e può quindi valere True o False. A seconda di questa variabile,
imposto Me.TestoAlternativo, che invece è un String.
</lupo>
non sono molto d'accordo nemmeno sul discorso, brevemente, vbNullString vale
"" all'interno di vb. Quando si comincia a parlare di ambienti esterni a VB,
questa equivalenza non vale più.
Scusatemi, ma non posso essere d'accordo. L'exe finale lo compila visual
basic, per cui il compilatore vb dovrebbe quantomeno ricercare le occorrenze
di vbNullString e sostituirle con "". Usare vbNullString dovrebbe servire
per migliorare la leggibilità del codice, per usare una costante che
dovrebbe garantire una maggior facilità di manutenzione, e maggiori
prestazioni, credo.....
in fondo, se MS avesse voluto dare significati differenti, avrebbe creato
due costanti, invece no.
mah, comunque, bon, ormai lo so e non si finisce mai di imparare,
cacchiolina.....
good coding a tutti e buon rientro!!!
-- 
Alletun
"Io lo so che accadrà. La voce sussurra nei miei pensieri di Jair, Rone,
Allanon e soprattutto nelle Mortombre.
Sussurra segreti che mi sono tenuti nascosti, nella grigia oppressione
di questo giorno e nell'oscurità caliginosa di quello che mi aspetta.
Saremo distrutti. Tutti."
Brin Ohmsford - La Canzone di Shannara - T. Brooks

 qualche altra parte.
Anch'io...
Fermo restando che con "" tutto funziona, non sei curioso di capire dove e a
chi la vbNullString desse fastidio?

 ha scritto nel messaggio
news:c5g79f$16r9o$1...@ID-174464.news.uni-berlin.de...

sì, son curioso anche io, e molto. direi ADO, senza dubbio, perchè l'errore
me lo dà sulla riga:
Record("TestoAlternativo") = vbNullString
riassumo che:
Record è un ADODB.Recordset
TestoAlternativo è un campo testo da 100 caratteri che ammette stringhe
vuote, nulle, "", insomma
purtroppo dato che l'errore me lo dà solo da quel cliente, e adesso
ovviamente non sono lì. Ci dovrei/potrei tornare presto, ma fino ad allora
mi sa che mi terrò il dubbio......;-)
good coding!!!


 good coding!!!

 e riprova
allora, mi piace parlare con te, per cui proseguo.
Quando ero dal cliente, nel tentativo di capire/risolvere il problema, ho
collegato il mio portatile alla lan del cliente. ho aperto vb+sorgenti dal
mio portatile, ho configurato il mio programma per far usare il db del
cliente e nessun problema. Ho sempre usato lo stesso exe, fino a quando non
ho capito il problema e ho dovuto ovviamente ricompilare tutto.
Poi ho fatto anche l'inverso. Ho usato un qualsiasi PC del cliente, ho usato
il db *sul mio portatile* (che SO PER CERTO che è a posto) e il problema
l'avevo ancora. Ho pensato anche io ad installare mdac_typ.exe, l'ho fatto,
prendendolo dal mio portatile: ho installato mdac 2.8 su tutti e 3 i client,
ma il problema è rimasto......
Il campo infine ti assicuro che ammette "".
boh, bad coding???


 boh, bad coding???
Mah, resta solo un dubbio: la versione di Jet sul tuo portatile e quella
sulla macchina (/e) dell'utente...
Sicuro e strasicuro che sia quella la riga che provoca l'errore?
Indice, codice e descrizione esatta dell'errore? (vedi mio terzo post)

 Indice, codice e descrizione esatta dell'errore? (vedi mio terzo post)
allora, sicuro e strasicuro no. Può essere o lì, oppure sulla riga che fa il
.Update.
Sono assolutamente stra-assolutamente sicuro che però la riga incriminata è
quella, perchè mi è bastata risolvere quel "conflitto" per risolvere il
problema.
L'errore??? Bella domanda, lo ricordo vagamente a memoria, ero un po' di
fretta, l'ho letto a video, l'ho riconosciuto....era una cosa tipo (spero
che qualcuno di voi possa riportarlo con esattezza):
"l'elenco dei valori degli stati del provider OLEDB bla bla bla"
:-((( sono seriamente rattristato, ma non ricordo nulla di più.....
uff, good coding!!!


 Per me, e lo dico con forza "" è uguale a vbNullString. Punto e stop.
Stiamo cazzeggiando da non so quanti post su una minchiata.
Il creatore del linguaggio (Microsoft) dice che sono diversi,
voi dite che sono uguali... fate voi...
Il fatto che *vi vada bene* 99.99 volte su 100, non vuol dire
che una cosa sia corretta (e che il problema sia altrove:DLL, dipendenze
ecc...).
vbNullString<>"". Lo dice la Bibbia di VB. Punto e stop.
Cia'
Beppe

[bEPPE = 
circa_b...@tiscali.it
 in
7wXec.124067$
Kc3.4...@twister2.libero.it
] ha scritto:

Vedi, non si tratta di insistere a tutti i costi, ma di comprendere le
verità, indiscutibili, nel contesto.
Da non so quanti post non riesci a farmi un esempio in puro VB dove
vbNullString e "" manifestino la loro differenza.
Quale sarebbe la Bibbia di VB? Quella che parla delle API che VB non sono?

 Quale sarebbe la Bibbia di VB? Quella che parla delle API che VB non sono?
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnw32dev/ht
ml/ora_apiprog6_topic1.asp
e' sul sito della MS, parla di sto cavolo di costante e dice che e' diverso
da "".
b.

 diverso da "".
Ancora lui? Hai visto il titolo di testa? "Win32 API Programming with Visual
Basic "
Ora, con VB si possono usare le API e pure Windows, e pure il PC.
Ma esuliamo dal mondo VB.

(intero 3ad)
Che caciara !
Aggiungo l'ultima frase prima di buttarmi a nanna che domani si torna a
lavoro :
vbNullString la si usa in VB perche' inplicitamente viene convertita in ""
Tutto questo perche' nessuno ha pensato di creare una vbEmptyString !!!
io la uso e devo dire che questo 3ad mi ha fatto ricordare della differenza
tra "" e vbnullstring , sapete com'e' , a furia di usare costanti o tipi di
funzioni si automatizza l'azione e si da per Scontato il perche' si fa'
cosi. Per me ad esempio "" era diventato SEMPRE uguale a vbnullstring , lo
uso tutt'ora nei Db e devo dire che il post iniziale mi ha messo una certa
fifa addosso sull'uso della costante !
L'unica soluzione forse e' creare una var globale tipo
public const  myVbEmptyString = ""
cosi ci togliamo ogni dubbio e come velocita' dovrebbe essere meglio di ""
in quanto punta sempre ad una istanza di una var e non ne crea una nuova ( o
sbaglio ? )


 Ma esuliamo dal mondo VB.
Il punto della faccenda comunque e' che vbNullString non esisteva nelle
versioni precedenti di VB ed e' stato creato *espressamente* per l'utilizzo
con le funzioni dell'API... persino nel Visualizzatore Oggetti se evidenzi
la costante viene riportato in basso
"Costante da utilizzare per le chiamate a routine esterne che richiedono una
stringa di valore zero"
quindi il fatto che in VB "puro" venga interpretato alla stregua di "" e' un
dettaglio; in questo contesto, secondo me, l'utilizzo e' comunque scorretto
(tanto e' vero che il nodo e' venuto al pettine...)
Ciao
--
Luca Dormio - 
luca....@tin.it
________________________________
"Marty, non stai ragionando in maniera quadridimensionale"
Dr. Emmett L. Brown

 comunque scorretto (tanto e' vero che il nodo e' venuto al pettine...)
Non sono d'accordo, nel senso che le istruzioni pubblicate da Alletun non
provocano, direttamente, alcun problema. Le ho provate e vanno
tranquillamente, con vbNullString o con "".
Probabilmente il problema dovuto all'uso di vbNullString sta da un'altra
parte...


Scusa, io questa non la capisco.
Una cosa potenzialmente pericolosa - e la documentazione stessa lo
dice, visto che afferma come questa vbNullString vada usata solo in
particolari circostanze - non si usa. Punto.
Non vedo perche' sia necessario usarla a tutti i costi, oltre tutto in
considerazione del fatto che si puň fare con pochissimo sforzo una
cosa viceversa MOLTO sicura:
Public Const EMPTY_STRING = ""
Ciao!
Luca

 particolari circostanze - non si usa. Punto.
Ok, ma da come è stata usata (per quel solo codice pubblicato da Alletun)
non deve provocare problemi, non direttamente almeno. Questo volevo solo
dire perchè ho provato quel codice.
E altri (perchè io non la uso) hanno scritto che mettono vbNullString al
posto di "" e non hanno problemi.

 posto di "" e non hanno problemi.
Non puoi basare una "verita'" (vbNullString funziona all'"interno" di VB, e
non funziona all'"esterno") su qualche esempio. Come gia' detto dovresti
provare gli esempi che esautorano tutti i casi possibili.
Cmq il fatto principale e' che non hai i sorgento di vbnullstring:
in mancanza di questi non puoi dire che cosa fa vbNullString *in assoluto*.
Magari la usi 1000 volte e ti va bene, poi vai dal cliente e non va.
Credi che sia cosi' raro? ;)
Altra cosa: dovresti definire cosa e' "interno a VB", e cosa e' "esterno" ;)
Ciao
Beppe

 Soviet-Mario
Ciao
beppe

 sbaglio ? )
Ma guarda, come ho gia' detto non credo che i compilatori siano cosi'
stupidi
da farsi fregare da un "". Alla fine credo che assegni sempre la stessa area
di memoria nello stesso modo... a parte tutto, credo che questo problema sia
*l'ultimissimo* di cui tenere conto.
sono quelle cose (ottimizzazioni?) che le fai in un sistema dove non ci sta
nenache il runtime di VB ;)
lo sai vero, che ottimizzare troppo all'inizio e' sintomo di una cosa che
nasce male? ;)
PS: non lo dico io, se vuoi di trovo i post di gente veramente in gamba e
valutata che lo dice...
Ciao
beppe

 Altra cosa: dovresti definire cosa e' "interno a VB", e cosa e' "esterno"
;)
Ancora? L'esterno di VB sono le API e tutti i link (pochi, 2/3?) che avete
indicato. Dimostrano inequivocabilmente che vbNullString e "" non sono la
stessa cosa, ma non mettono minimamente in dubbio il fatto che le due cose,
all'interno di VB, abbiano comportamenti identici. Per questo chiedevo un
esempio...
Questo è il mio ultimo post su questo argomento, tranne nuove notizie
(Alletun che ha scoperto cos'era, l'esempio che irresponsabilmente ho
chiesto o documentazione che riguardi VB e solo VB). Non potrei, certo per
mia carenza espressiva più che di volontà, tentare di essere più chiaro. Se
io rileggessi i miei post in questo topic mi direi "ma che coglioni, l'hai
già detto, bastaaaa..."

 Basic "
Guarda ancora piu' semplice: scrivi vbnullstring in VB, premi F1 se hai MSDN
installata
e c'e' scritto:
- String having value 0
- Not the same as a zero-length string ("")
- Used for calling external procedures
Forse la seconda risponde ai dubbi di tutti
Ciao

 se rileggi il post iniziale secondo me cambi idea ;)
No, stracazzo. Il problema non è in quel codice! L'ho provato! Lo affermo!

[bEPPE = 
circa_b...@tiscali.it
 in
SYBfc.4715$
Qc.1...@twister1.libero.it
] ha scritto:

Io NON HO MAI DETTO CHE vbNullString e "" sono la stessa cosa.
Non lo sono, ok?! Ho detto che in VB si comportano identicamente!
Leggi, la terza, per favore. Lo dico da una vita!

 L'ho provato! Lo affermo!
Caro Lupo,
lungi da me evangelizzarti sull'uso di una metodologia piuttosto che
un'altra, pero' mi sembra assurdo che tu insisti ad "affermare" che in VB
l'uso di una o l'altra produca un comportamento identico (e quindi sia
sostanzialmente identico).
Quello che tu hai provato ed affermi, lo hai provato sul tuo pc con
_determinate_ caratteristiche d'ambiente (SO+SP vari del SO) ed in un
programma con _determinati_ controlli (tipo controllo, versione, ecc.).
vbNullString e' un _puntatore_ (quindi una variabile che indica una zona di
memoria) mentre "" e' una costante stringa di lunghezza 0. Mentre alcune
funzioni di VB ed alcuni "controlli" (occhio che non parlo di API)
_accettano_ come valore vbNullString (nel senso che lo convertono
implicitamente in un oggetto stringa di lunghezza zero) altri (molto
raramente) non lo fanno, provocando errori generalmente non riconducibili
all'uso di quella costante piuttosto che di una stringa vuota. E l'ho
sperimentato sulla mia pelle. Il software (compilato o no che fosse) non
funzionava su un pc (e solo quello fra i 5 dove girava il software) per aver
passato vbNullString ad un metodo di un ocx piuttosto che "".
Questo ha una spiegazione *logica* e che fornisce un *valido* motivo per non
utilizzare vbNullString: tutti i programmi sono riconducibili ad istruzioni
elementari e a chiamate di funzioni (API), anche quelli scritti in VB puro.
Non puoi affermare che vbNullString si comportera' "bene" con qualunque tipo
di funzione/controllo, di qualunque tipo di versione e su qualunque SO. E
non puoi nel senso che ti richiederebbe tempo ~infinito provare _tutte_ le
possibili combinazioni. Io (ed anche Alletun) posso darti la certezza che
esiste almeno UNA di queste combinazioni che genera un errore, ma non sarei
in grado di dirti con esattezza quale, semplicemente perche' non ho indagato
ne' intendo perdere tempo a farlo, viste le premesse.
Spero di averti convinto che non sia necessario _sperimentare_ una
combinazione "crashante" (anche perche' probabilmente non sarebbe
riproducibile su sistemi diversi) per decidere di non utilizzare
vbNullString ad eccezione dei casi in cui e' previsto.
Lokar
-- 
Sito Comune: 
http://www.it-lang-vb.net/
Manifesto: 
http://www.it-lang-vb.net/docs/Manifesto.txt
Statuto: 
http://www.it-lang-vb.net/docs/Statuto.txt
UGIdotNET - 
http://www.ugidotnet.org

 quindi sia sostanzialmente identico).
Questa era un'ipotesi, certo, con annessa scommessa.
La prima volta che ho usato vbNullString è stato per simulare il codice di
Alletun.
Va bene e funziona. Quindi, più d'una volta, ho ipotizzato che il problema
stia da un'altra parte, dove, pur in VB, la vbNullString manifesta la sua
sostanziale differenza (mai negata) con "".
Sono dispostissimo a perdere la scommessa, vorrei solo un esempio.
Sino ad allora mi sentirò di dire (pur non usandola, nè prima nè ora) che,
in VB, vbNullString si comporta identicamente a "".
Sono sinceramente  dispiaciuto del fatto che chi usa vbNullString l'abbia
solo detto e non abbia più partecipato per ribadirlo..., ma, si sa, io sono
cocciuto.