Newsgroup: it.comp.lang.visual-basic
Titolo: [?] Per chi ama dire "F1"

Era una giornata buia, tempestosa e piena di Visual Basic; ad un certo
punto, testando il mio codice, ottenni un errore che diceva: "Can't assign
to array".
Non capendo cosa volesse dirmi con ciň (l'istruzione era del tutto valida!)
premetti il mitico tasto "?" che serve per chiamare l'altrettanto mitica
"Guida in linea" adorata dai professionisti-con-le-palle che popolano il
newsgroup (essendo io un pivello ho dovuto consultare la guida in linea...)
e questo ciň che riportava in uno stralcio:
-----------------------------------------------------
You tried to assign a whole array to another array. For example, if Arr1 is
an array and Arr2 is another array, the following two assignments are both
invalid:
Arr1 = Arr2    ' Invalid assignment.
Arr1() = Arr2()    ' Invalid assignment.
To assign one array to another, you must individually assign the elements.
For example:
For count = LBound(Arr2) to UBound(Arr2)
Arr1(count) = Arr2(count)
Next count
-----------------------------------------------------
MA COME?! Proprio leggendo sulla guida "Advanced arrays features" qualche
giorno fa lessi:
-----------------------------------------------------
Assigning Arrays
Just as you can assign the contents of one variable to another, for example
strA = strB, you can also assign the contents of one array to another.
Imagine, for instance, that you wanted to copy an array of bytes from one
location to another. You could do it by copying one byte at a time, like
this:
Sub ByteCopy(oldCopy() As Byte, newCopy() As Byte)
   Dim i As Integer
   ReDim newCopy (Lbound(oldCopy) To UBound(oldCopy)
   For i - Lbound(oldCopy) To Ubound(oldCopy)
      newCopy(i) = oldCopy(i)
   Next
End Sub
A much more efficient way to do this is to assign one array to another:
Sub ByteCopy(oldCopy() As Byte, newCopy() As Byte)
   newCopy = oldCopy
End Sub
-----------------------------------------------------
Lascio a voi le conclusioni, nella speranza che qualcuno mi dica che ho
preso l'ennesima cantonata...
Francesco
P.S. Viviamo in un mondo dove non ci si puň fidare piů di nessuno, NEANCHE
DELL'F1!

 che ho preso l'ennesima cantonata...
Notare bene questo:
<msdn>
To assign one array to another, make sure the array on the left-hand
side of the assignment is resizable and the types of the array match.
</msdn>
<code>
dim a(9) as long
dim b(9) as long '***notare*** indicata la dimensione
dim c() as long    '***notare*** non indicata la dimensione
b = a 'ti restituisce l'errore da te citato
c = a 'funziona
</code>
Ciao.
--
BSD is for UNIX-lovers -- linux is for Windows-haters.

...in realtà l'errore era un altro e l'ho trovato; in pratica un array era
di LONG e un'altro era di DOUBLE.... aveva ragione a lamentarsi! Ma quello
che voglio dire è che sulla guida c'è un informazione FALSA!
Arr1 = Arr2    ' Invalid assignment.
che è smentita da un'altra parte della stessa guida:
A much more efficient way to do this is to assign one array to another:
Sub ByteCopy(oldCopy() As Byte, newCopy() As Byte)
   newCopy = oldCopy
End Sub
Capito?!
Ciao!
Francesco
P.S. Non si possono usare tag HTML nei post al NG... :-)))
P.P.S.: Tutto sommato posso definirmi un Windows Hater, ma Linux non è che
mi piaccia molto... anzi!

 Arr1 = Arr2    ' Invalid assignment.
Devi leggere tutto:
<msdn>
You tried to assign a whole array to another array. For example, if
Arr1 is an array and Arr2 is another array, the following two
assignments are both invalid:
Arr1 = Arr2    ' Invalid assignment.
Arr1() = Arr2()    ' Invalid assignment.
To assign one array to another, make sure the array on the left-hand
side of the assignment is resizable and the types of the array match.
</msdn>
Il che vuole dire che ti è stato restituito questo errore perché hai
cercato di effettuare un assegnamento diretto fra due array; se vuoi
farlo Arr1 deve essere ridimensionabile.
Effettivamente, come ho detto sopra, non è spiegato bene, e sembra
quasi contraddirsi (nella stessa pagina), ma in fondo non dice cose
errate.


HPL,
Non ci giriamo attorno! Nello stralcio di help che ti ho inviato, che è
stato tratto dall'help in linea di Visual Studio 6.0 (quello terra-terra che
si installa con l'installazione del pacchetto) viene riportato quanto ti ho
scritto nel primo post, ossia che NON posso fare:
ArrayDestinazione = ArraySorgente
(FALSO: Si può con le precauzioni che tu stesso mi hai sottolineato)
ma devo fare un ciclo:
for indice=lbound(arraysorgente) to ubound(arraysorgente)
    arraydestinazione(indice)=arraysorgente(indice)
next indice
e non parla di array dinamici o altro! CHE POI la Microsoft si sia accorta
dello svarione e abbia corretto la documentazione online è un altro paio di
maniche!
MA il succo del mio discorso non era quello! Voleva essere semplicemente un
monito a coloro che dicono "F1" a coloro che cercano di capire, senza però
rendersi conto che PURTROPPO anche l'help in linea spesso e volentieri è
laconico, o addirittura errato come in questo caso.
Che poi tu abbia consultato MSDN sulla rete e li abbia riportato
l'informazione corretta... perfettamente d'accordo, ma se un'informazione
l'ho già a disposizione sul mio PC non vado in rete per cercare di
confermarla o confutarla, mi fido di quello che M$ stessa ha scritto...
Capito?!
<HPL>
Si, ma però... vedi...
</HPL>
<Francesco>
Aho! non sarai mica dipendente M$ spero! :-))
</Francesco>
Ciao!
Francesco
"H.P.L." <u...@vaila.ble> ha scritto nel messaggio
news:Dwmi8.50233$Ns4.2...@news2.tin.it...


 stessa ha scritto...
Effettivamente non ho letto MSDN online, ma comunque una versione
aggiornata e non quella fornita con VS e non avevo pensato quella
parte potesse mancare nella guida "originale".


 Non ci giriamo attorno!
Vabbeh, ma che significa?
Anche ammesso che sia effettivamente un errore della guida (non sarebbe
l'unico, d'altra parte MSDN è su 2/3 CD, qualche errore è normale trovarlo),
cosa vorrebbe dire l'object?
Che perchè c'è un errore nella guida allora la buttiamo via e lavoriamo
senza?
Ciao

 [cut]


 un pň banale fatta da un principiante rispondono... "Ah! Premi F1"!
Dipende dalla domanda, ma soprattutto da come viene posta.
Io sono tra i F1-lover, e ho notato che purtroppo finisco per rispondere
"premi F1" anche a chi fa domande solo apparentemente banali.
In questi casi non lo faccio per cattiveria, ma per inerzia: dopo aver letto
una decina di post _davvero_ banali (dove limitarsi a rispondere di premere
F1 č per pura educazione) non si riesce a vedere il vero problema nella
11ma.
Voi che volete imparare sul serio (č nel vostro interesse) prendetevala con
chi azzera il livello del NG (esempio chi chiede come disabilitare un
commandbutton a design time).
Ciao

 Cosa ti succede???
In che senso? Ho davvero questo problema! Guarda il mio post sopra!
Francesco

 laconico, o addirittura errato come in questo caso.
Quando qualcuno risponde di "premere F1", lo fa perché spesso le domande
sono del tipo: "Come faccio a scrivere qualcosa in una text box ?".
E' vero che i NG di aiuto servono per aiutare i novellini, ma è pur vero
che "insegnare" ad usare un prodotto significa anche "rendere l'allievo
indipendente"; quindi, anche insegnare ad usare l'help è un modo
per far crescere qualcuno.
--
Er Roscio.

 per far crescere qualcuno.
Non sono completamente d'accordo con te.
Secondo me se rispondi ad un messaggio mongolo con un premi F1 non rendi
l'allievo indipendente, lo rendi indipendente se dicendogli che troverà
risposte alle sue domande cercando all'interno dell'argomento tal dei tali
su MSDN, perchè chi fa una domanda mongola evidentemente non iresce ad
associare il suo problema al relativo argomento della guida.