Newsgroup: it.comp.lang.visual-basic
Titolo: [?]Scrivere codice veloce

Domanda da un milione di dollari. Sono un principiante, quindi i miei
programmi sono sempre piuttosto semplici: nonostante ciò, ho spesso
l'impressione che essi siano "un pò lenti", sia nel caricarsi, sia
nell'esecuzione, rispetto ad altri programmi ben più complessi che capita di
usare. Può darsi che questa sia solo una mia impressione (oltretutto il mio
computer è un 166Mhz, sebbene con 96Mb di memoria), ma comunque la cosa mi
interessa: dove posso trovare dei consigli, delle "astuzie" o qualunque cosa
possa aiutare a scrivere del codice veloce ed efficace? Non ditemi di usare
un altro linguaggio, che faccio già fatica ad imparare questo! :)
--
Ciao a tutti
Cesare Nicola
http://digilander.iol.it/cesare
L'indirizzo del sito comune è:
http://www.murialdo.it:8000/it_lang_vb/

 ha scritto nel messaggio
news:85lgpk$4s5$1...@lacerta.tiscalinet.it...


 wrote in message


Ciao,
se vuoi ci sono tantissime astuzie che ti possono permettere di spremere
qualcosa in più da VB, tieni presente che VB ha comunque in linea di massima
prestazioni inferiori a linguaggi a basso livello come il C++.
Su MSDN se cerchi sotto ottimizzazione, troverai parecchie voci che
potrebbero aiutarti.
Al momento direi la cosa che VB gestisce peggio sono le stringhe, sono
mortalmente lente, quindi cerca di limitarle, dove possibile ovvio. Codice
come
If miaStringa="" Then
è più lento che
If Len(miaStringa)=0 then
perhcé nel primo caso involontariamente istanzi una seconda stringa ""
appunto.
Dove puoi usa variabili Long invece che Integer per esempio, vengono gestite
meglio.
Nelle routine a cui devi passare dei parametri, se non è necessario passali
per valore e non per riferimento, VB se non lo specifichi utilizza byRef:
Public Sub Mia Sub(ByVal x&)
meglio di
Public Sub SizeControls(x&)
Non utilizzare mai variabili Variant, sono piuttosto lente e affamate di
risorse. Ottima regola è dichiarare sempre le variabili (usa Option Explicit
ti obbliga a farlo) perché se ometti la dichiarazione, VB la variabile che
trova la dichiara Variant, anche se dichiari una variabile e non ne
specifichi il tipo viene caricata come Variant
Se fai diverse volte l'accesso alle stesse proprietà di un'oggetto, è meglio
e più veloce salvarla una volta in una variabile ed andare poi a leggere la
variabile, es:
x=Me.ScaleHeight
a=x
b=x-10
c=x-20
meglio di:
a=Me.ScaleHeight
b=me.ScaleHeight-10
c=Me.ScaleHeight-20
Lo so che è un esempio stupido ma non mi è venuto altro in mente :-))
Dove puoi usa With... End With per limitare l'accesso allo stesso oggetto:
With Text1
    .Locked=False
    .Text="Prova"
    .BackColor=RGB(255,255,255)
End With
meglio di
Text1.Locked=False
Text1.Text="Prova"
Text1.BackColor=RGB(255,255,255)
Se devi dichiarare delle variabili oggetto non usare la forma
Dim mioOggetto as New Oggetto
meglio
Dim mioOggetto as Oggetto
Set mioOggetto =New Oggetto
e distruggi sempre la variabile
Set mioOggetto=Nothing
ricordati di distruggere anche i form nellìevento Form_Unload
Set mioForm=Nothing
...
Ce ne sarebbero tante altre, queste sono solo le basi, come l'utilizzo degli
insiemi, o di file di risorse per salvare stringhe e grafica, soprattutto
per la grafica è un molto più veloce e snello, l'utilizzo delle costanti...
Beh spero che questi suggerimenti ti aiutino un pochino, per il resto
consulta MSDN.
Ciao Luca



Che differenza c'é tra i 2 ?
Nel secondo inoltre usi 2 righe invece di una.
Ciao e grazie, DaVe

-> Dave <- <daveg...@ticino.moc> wrote in message
news:85neip$mhd$1...@bw107zhb.bluewin.ch...

Per prima cosa un saluto a tutti e scusate la lunghezza del post....
La differenza è che la prima dichiarazione non crea una istanza di
mioOggetto..essa verrà creata automaticamente da VB nel momento che si
proverà ad accedere ad una proprietà o ad un metodo...
Considera il seguente caso...
    Dim mioOggetto As New Oggetto
    mioOggetto.miaProprietà
    mioOggetto.mioMetodo
Prima di accedere alla proprietà miaProprietà VB si chiede se l'oggetto
mioOggetto sia valido e se non lo è crea una istanza di esso.
Nell'istruzione successiva VB ripete lo stesso ragionamento con evidente
perdita di tempo perchè l'oggetto è già valido ma VB non lo sa!!...
Invece nell'altro caso:
    Dim mioOggetto As Oggetto
    Set mioOggetto = New Oggetto
    mioOggetto.miaProprietà
    mioOggetto.mioMetodo
è compito del programmatore creare l'istanza dell'oggetto e VB accede
direttamente alla proprietà ed al metodo senza chiedersi nulla.
Inoltre la dichiarazione AS NEW crea dei problemi nel momento che si vuole
verificare se l'oggetto è valido...infatti l'istruzione
    IF mioOggetto Is Nothing THEN
non sarà mai verificata perchè VB renderà sempre valido l'oggetto...
Spero di esserti stato di aiuto e non averti confuso di più le idee....
Un saluto
        Andrea
-----------------------------------------------------------
Andrea Magnanimi
Personal E-mail: mailto:
a.mag...@tiscalinet.it
-----------------------------------------------------------

    IF mioOggetto Is Nothing THEN
Oh bella, ma se e' gia' definito, per forza!! Che senso ha fare un
controllo del genere, se io ho indicato ESPLICITAMENTE che non voglio
un riferimento a Nothing MA a un oggetto valido?
Ciao!
Luca Menegotto.

 Luca Menegotto.

Ciao,
ma se tu crei un'istanza ad un oggetto con
Dim mioOggetto as New Oggetto
no potrai mai liberare le risorse, perché se tu imposti Set
mioOggetto=Nothing questo si viene distrutto, ma ne viene ricreato subito
dopo un'altro valido, e quindi le risorse saranno sempre occupate da
un'istanza di un oggetto nuovo che non verrà mai utilizzato e quindi
l'istruzione Set .. =Nothing non è servita a pulire le risorse, se invece
usi la seconda strada set...=Nothing distrugge effettivamente l'oggetto e
stop, quindi sai tu quando hai la necessità di  crearne uno nuovo. Pensa ad
oggetti pesante come quelli di ADO, Dim adoCon as New ADODB.Connection ho
sempre un oggetto Connection istanziato nelle risorse. Che non è proprio una
bellissima cosa.
Ciao

Cito da MSDN sotto Ottimizzazione, Effetti della parola chiave New
...
Dim tdfOrders As New TableDef
tdfOrders.Name = "Ordini"
Nota   Quando si utilizzano variabili dichiarate con la parola chiave New,
l'esecuzione dell'applicazione potrebbe essere rallentata. Per ogni
variabile dichiarata in questo modo, infatti, viene verificato se alla
variabile è già stato assegnato o meno un riferimento all'oggetto.
...

 wrote in message
85nt0g$oal$1...@nslave2.tin.it...


Grazie a tutti! Per il momento va benissimo cosě.
--
Ciao
Cesare Nicola
http://digilander.iol.it/cesare
L'indirizzo del sito comune č:
http://www.murialdo.it:8000/it_lang_vb/

tanto; 
Scusate, ma io ricordo di aver letto da qualche parte che l'end
compiler del VB5 (e successivi) è lo stesso del VC++, e che
il compilatore del VB traduce prima il codice nativo in C e poi passa
tutto questo al compilatore del VC++. Quindi alla fine, in termini di
velocità, non dovrebbe essere poi tanta la differenza fra un
eseguibile generato dal VC++ e quello generato dal VB5.
   Roberto
email: 
ro...@ctonline.it

 eseguibile generato dal VC++ e quello generato dal VB5.
magari...
in qti giorni mi capita di provare delle routine in garfica.
in vb una conversione 16m -> 256 colori puo' impiegare 5-6" per
un'immagine 300*300
mi sa che in c andrebbe un po' (un po' molto) di piu'.

 mi sa che in c andrebbe un po' (un po' molto) di piu'.
Direi che questo è uno di quei casi in cui conviene usare un ocx
o una dll in C. O almeno usare le API.
...hai provato a cercare qualche link su Internet ? ;-)))))))))))
Bye, G.
--
---------------------------------------------
    Le risposte alle tue domande le trovi
    sul Sito Comune di questo NewsGroup:
 
http://www.murialdo.it/it_lang_vb
       ... e nell'help in linea !
---------------------------------------------
Real E-address: 
gaet...@hotmail.com

 o una dll in C. O almeno usare le API.
il dramma e' che le sto gia' usando.
uso del codice di jim deutch, che mi ha spiegato sul ng passo passo, e
dell'altro di vbaccelerator.
il primo e' buono e anche abbastanza veloce. ma la palette in alcuni casi e'
un massacro.
con quello di vbacc ci sono quattro possibilita' di conversione. con
l'ottimale ho provato su un'immagine grande e credevo fosse morto il pc. poi
e' resuscitato e ho capito.
e' che vb non e' proprio fatto per questo. mi serve farlo via codice per
aggiungere la generazione di startlogo al mio freeware "v". trattandosi di
320*400 a questo punto penso di poterlo fare senza che l'utente mi maledica,
ma non e' immediato.
certo se qualcuno conosce una dll che faccia, presto e bene, praticamente
solo la riduzione a 256 colori, gliene saro' _molto_ grato.


wrote:


...


 Public Sub SizeControls(x&)
[...]
mi da' qualche perplessita' perche' avrei detto, a naso, fosse vero il
contrario. C'e' poi una frase nella pagina della Guida (VB4) "Passaggio
degli argomenti in modo efficiente" che fa vacillare un po' le mie
(vacillanti) convinzioni:
"In generale, è possibile fare riferimento in modo più rapido agli argomenti
passati con ByVal ed è possibile passare in modo più rapido gli argomenti
con ByRef."
Hai la possibilita' di spendere qualche parola in piu'?
Ciao.
Maurizio

 wrote in message
86daub$1tp$1...@nslave1.tin.it...


 Hai la possibilita' di spendere qualche parola in piu'?
Visto che ti hanno già risposto discorsivamente, ti farò una considerazione
di carattere tecnico.
Il problema è legato alle istruzioni in linguaggio macchina.
Il passaggio di un parametro alla routine consiste nel mettere nello stack
il dato e chiamare la funzione. La funzione recupera il dato e poi lo usa.
Questo è quello che accade quando passi un valore, ma se passi un
riferimento al valore (puntatore), la funzione deve leggere il riferimento e
poi usarlo per un accesso indiretto (puntato) alla memoria. Quindi fa 2
operazioni invece di una.
Riassumendo: ogni volta che usi quel valore, il tempo di accesso è doppio.
Mi pare però di ricordare che l'assembler del Pentium permetta di usare EBP
(il puntatore allo stack) anche per le operazioni di accesso indiretto alla
memoria, quindi utilizzando le ottimizzazioni Pentium forse questo problema
non esiste più. Dipende comunque tutto da come il compilatore genera il
codice, cioè se ad esempio usa EBP come base per la lettura dei parametri o
se fa una POP dallo stack e si salva il puntatore in locale, se si ricorda
di allineare i dati e il codice alla DWord, se è ottimizzato contro lo stall
delle pipeline del Pentium, e robette simili.
In ogni caso il problema è insuperabile quando si tratta di stringhe, che
sono a loro volta dei puntatori ad un array di byte. In questo caso con la
ByRef passi un puntatore ad un puntatore e devi fare 2 accessi alla memoria
solo per sapere dove sta il dato. Poi ti serve un altro accesso per
recuperarlo.
Se hai voglia di fare qualche prova di timing... 8-)
Ciao
*Roby*


Cerco di spiegarti questa frase.
"Far riferimento" agli argomenti significa leggere gli argomenti che si
ricevono.
Se l'argomento era ByVal posso leggerlo direttamente.
Se era ByRef leggo l'indirizzo dell'argomento che poi uso per accedervi.
Quindi questa operazione e' piu' veloce con ByVal.
"Passare" gli argomenti significa trasmetterli alla funzione che chiamo.
Se l'argomento e' ByVal devo trasmettere alla funzione tutto il contenuto
della variabile.
Se l'argomento e' ByRef devo trasmettere solo l'indirizzo della variabile.
Quindi questa operazione e' piu' veloce con ByRef.
Ora, riassumendo, possiamo dire che quando dobbiamo passare una variabile
conviene usare ByVal se la sua dimensione e' inferiore a quella di un
indirizzo, ByRef se invece e' maggiore.
Questo a rigor di logica, ma ora non so se VB segue la logica :-(