Newsgroup: it.comp.lang.visual-basic
Titolo: Conta elementi

Salve a tutti c'è in Vb una funzione che conta gli elementi (files)
che sono in una cartella? Grazie ciao

 che sono in una cartella? Grazie ciao
prova con
FileSystemObject
Progetto > Riferimenti > Microsoft Scripting Runtime
giuseppeD

 Salve a tutti c'č in Vb una funzione che conta gli elementi (files)


 [...] cerca  Insieme Files, del FileSystemObject, proprietà count
Se non sbaglio non esiste una proprietà dell'oggetto Folder che restituisca
TUTTO ciò che è contenuto nella cartella, ma soltanto gli elementi di primo
livello (cioè i "figli" diretti).
Se ti basta, ok, altrimenti può scrivere due righe ricorsive che vadano a
leggere la "discendenza" completa.
Ciao,
Carlo.

On Sat, 10 Nov 2001 18:11:07 GMT, 
l.ri...@tiscalinet.it
 wrote:
grazi a tutti

 leggere la "discendenza" completa.
Creato l' oggetto Folder si possono ottenere un oggetto Folders tramite la
proprietą SubFolders che contiene tutte le cartelle di Folder, anche quelle
nascoste,  e un oggetto files.
    Dim Myfold, myFoldFiles, myFoldFolders, fs, totElementi
    Set fs = CreateObject("Scripting.FileSystemObject")
    Set MyFold = fs.GetFolder("C:\Programmi")
    Set myFoldFolders= MyFold.SubFolders
    Set myFoldFiles = MyFold.Files
   totElementi =myFoldFolders.count + myFoldFiles.count
  (codice scritto al volo non provato)
Ciao
g.c.

 ha scritto nel
messaggio news:Y9vH7.35249$zu5.1...@news1.tin.it...
[snip]
Ma non bastava un loop di 4 (quattro) righe sul comando Dir$?
Si evitavano pesanti accessi a COM, un codice lungo e dispersivo, una DLL di
diversi 151k che va aggiunta al pacchetto (con tutto quello che ne consegue
in questi casi) o che comunque non si è mai sicuri che sul PC di
destinazione sia installata...
Ciao

 destinazione sia installata...
Esatto.
E' quello che dico sempre: perchè usare un elefante per schiacciare una
noce?
Il problema è sempre il solito "ufficio complicazione cose semplici"  :-)
ciao
ugo

 Il problema è sempre il solito "ufficio complicazione cose semplici"  :-)
Se le 4 (quattro) righe si riferiscono al conteggio di tutti i file presenti
in una cartella (subdirectory incluse) siete i più grandi programmatori
sulla faccia della terra ;-))
Ciao,
Carlo.
P.S. Ovviamente i ":" non valgono :-P

 ha scritto nel messaggio
news:9smil4$ihk$1...@pegasus.tiscalinet.it...

Ho dovuto fartela un po' più lunga perchè non avevo capito che volevi anche
il numero di files delle
subdir e quindi si deve tenere conto dei problemi di ricorsività della
funzione dir.
Spero vorrai perdonarmi...
Function TotFiles(sDir As String) As Long
    Dim sName As String
    Dim aDirs() As Variant
    Dim nn As Long
    ReDim aDirs(0)
    TotFiles = 0
    sName = Dir(sDir, vbDirectory)
    Do While sName <> ""
        If sName <> "." And sName <> ".." Then
            If (GetAttr(sDir & sName) And vbDirectory) = vbDirectory Then
                ReDim Preserve aDirs(UBound(aDirs) + 1)
                aDirs(UBound(aDirs)) = sDir & sName & "\"
            Else
                TotFiles = TotFiles + 1
            End If
        End If
        sName = Dir
    Loop
    For nn = 1 To UBound(aDirs)
        TotFiles = TotFiles + TotFiles(aDirs(nn) & "\")
    Next nn
End Function
Naturalmente è tutt'altro che perfetta: scritta troppo di fretta.
Tra gli altri difetti, devi chiamarla passandole il "\" finale della dir...
perdonami anche questo.
Btw: non è che volevo dimostrare niente di più che "c'è sempre una soluzione
più semplice".
Niente a che vedere con i migliori programmatori del mondo che sono ben
altri...
ciao
ugo

 Si evitavano pesanti accessi a COM, un codice lungo e dispersivo
Test effettuato sul mio Pentium II 400 MHz, 192M di RAM;
Lettura di tutti i file della cartella "C:\Programmi" per 10 volte per x
ripetizioni alternando A e B (con x sufficientemente grande, come mamma
statistica insegna):
Codice A: media di 19.7 secondi
Codice B: media di 48.6 secondi
Ciao,
Carlo.
P.S: La funzione B restituisce un numero di file pari a 11750, la A e la
gestione risorse di Windows 11930. E' troppo tardi per investigare dove sia
la ragione. Se ho sbagliato qualcosa, era a fin di bene ;-)
Buonanotte...

 Se ho sbagliato qualcosa, era a fin di bene ;-)
idem
ciao e buonanotte.
ugo

 la ragione. Se ho sbagliato qualcosa, era a fin di bene ;-)
Perchè vbDirectory trova solo le directory senza attributi. :)
Ciao

 ha scritto nel messaggio

Io uo usato un approccio simile.
Te la mostro in due versioni.
La prima fa come la vostra: conteggio della somma files+cartelle.
La seconda divide i files dalle cartelle.
Accodo anche la tua ver. corretta
Ovviamente per giocare con la Dir$() cercando anche le subdir occorre
rimettersi alla clemenza dello string manager di VB (lentissimo) e
considerare che Dir$() non è ricorsiva (il che è un bello svantaggio).
I miei test dimostrano che il FSO è in questo caso il più veloce.
La tua soluzione è circa 2.5 volte più lenta del FSO
La mia seconda è poco meno di 3.3 volte più lenta del FSO
La mia prima è poco meno di 3 volte più lenta del FSO.
Teniamo presente che ricorrendo a funzioni ricorsive quali la
FindFirstFile() il codice si riduce e la velocità prende una bella
impennata, presumibilmente raggiungendo se non superando il FSO.
Se vogliamo ammettiamo pure che il FSO è più efficiente (efficienza =
efficacia / risorse usate).
Ma sono comunque contrario a qualsiasi utilizzo di mezzi esterni se non sono
assolutamente necessari.
Private Function CountDir(sDir As String) As Long
    Dim s As String
    Dim sCompleteDir As String
    Dim sStack As String
    Dim Conta   As Boolean
    s = Dir$(sDir, vbDirectory Or vbArchive Or vbHidden Or vbReadOnly Or
vbSystem)
    Do While Len(s) > 0
        sCompleteDir = sDir & s
        If (GetAttr(sCompleteDir) And vbDirectory) <> 0 Then
            If (Asc(s) <> Asc(".")) Then
                CountDir = CountDir + 1
                sStack = sCompleteDir & "\"
                CountDir = CountDir + CountDir(sCompleteDir & "\")
                s = Dir$(sDir, vbDirectory Or vbArchive Or vbHidden Or
vbReadOnly Or vbSystem)
                Do While StrComp((sDir & s & "\"), sStack) <> 0
                    s = Dir$()
                Loop
            End If
        Else
            CountDir = CountDir + 1
        End If
        s = Dir$
    Loop
End Function
Private Sub CountDir2(sDir As String, CountDir As Long, CountFile As Long)
    Dim s As String
    Dim sCompleteDir As String
    Dim sStack As String
    Dim Conta   As Boolean
    ' directory
    s = Dir$(sDir, vbDirectory Or vbArchive Or vbHidden Or vbReadOnly Or
vbSystem)
    Do While Len(s) > 0
        sCompleteDir = sDir & s
        If (GetAttr(sCompleteDir) And vbDirectory) <> 0 Then
            If (Asc(s) <> Asc(".")) Then
                CountDir = CountDir + 1
                sStack = sCompleteDir & "\"
                Call CountDir2(sCompleteDir & "\", CountDir, CountFile)
                s = Dir$(sDir, vbDirectory Or vbArchive Or vbHidden Or
vbReadOnly Or vbSystem)
                Do While StrComp((sDir & s & "\"), sStack) <> 0
                    s = Dir$()
                Loop
            End If
        End If
        s = Dir$()
    Loop
    s = Dir$(sDir, vbReadOnly Or vbArchive Or vbHidden Or vbSystem)
    Do While Len(s)
        CountFile = CountFile + 1
        s = Dir$()
    Loop
End Sub
Function TotFiles(sDir As String) As Long
    Dim sName As String
    Dim aDirs() As String  '<< -- no variant! :)
    Dim nn As Long
    ReDim aDirs(0)
    TotFiles = 0
    sName = Dir(sDir, vbDirectory Or vbArchive Or vbHidden Or vbReadOnly Or
vbSystem)
                ' ^^^^ Anche files e dir con attributi!
    Do While sName <> ""
        If sName <> "." And sName <> ".." Then
            If (GetAttr(sDir & sName) And vbDirectory) = vbDirectory Then
                ReDim Preserve aDirs(UBound(aDirs) + 1)
                aDirs(UBound(aDirs)) = sDir & sName & "\"
            Else
                TotFiles = TotFiles + 1
            End If
        End If
        sName = Dir
    Loop
    For nn = 1 To UBound(aDirs)
        TotFiles = TotFiles + 1 ' << Contiamo anche le dir, non solo i files
contenuti
        TotFiles = TotFiles + TotFiles(aDirs(nn)) '<< La barra l'hai già
messa sopra
    Next nn
End Function


[cut]
Grazie per le rettifiche.
Confesso che si trattava di una func buttata lě al volo, senza neppure
rileggere.
Chiedo venia... :-(
ciao
ugo

 se l'unico uso cui lo destini è un conteggio di files...
Premessa: io, il FileSystemObject, non lo uso praticamente mai. Ho scritto
quella function solo per curiosità e poi mi sono accorto delle buone
prestazioni (non dovute a caching) e mi è sembrato utile postare sul NG.
Mi permetto di fare due osservazioni:
1) Prestazioni più che triplicate, ove possano essere utili, giustificano
ben altro che una piccola dll da 150k. Tutto dipende da cosa si deve
realizzare.
2) E' quantomeno curioso vedere sviluppatori VB, che notoriamente sono
sommersi da dll, ocx e compagnia da installare insieme ai loro applicativi,
che spesso si pongono problemi ad aggiungere qualcosa. Voglio dire:
installare 33 file + l'eseguibile oppure 34 file + l'eseguibile, cosa
cambia? Tanto il pacchetto di installazione lo si deve fare comunque, no?
Ancora buonanotte,
Carlo.

 cambia? Tanto il pacchetto di installazione lo si deve fare comunque, no?
Certo, però cerco di metterci il meno possibile.
Sostituisco anche la commondialog con chiamate alle dll...
figurati se installo fso per fare una dir...
a meno che debba loopare (visti i test) 3 volte all'ora sulla winpath...
:-)
ciao
ugo

 possono raccontare i commerciali che vendono la roba per ieri.
E' la differenza di prospettiva fra i programmatori e i liberi
professionisti che programmano. Purtroppo alla fine qualcosa bisogna
mangiare!...
Ciao,
Carlo.

 cambia? Tanto il pacchetto di installazione lo si deve fare comunque, no?
Già, il fare non è un problema.
Installarlo comincia ad esserlo.
"Non ho paura di volare con l'aereo: ho paura di schiantarmi al suolo con
l'aereo".
Comunque, queste sono tutte scelte, se uno si trova bene così può continuare
a farlo.
A me piace tenere traccia il più possibile di tutto quello che mi succede
sotto i piedi (come dice il detto "fa in fretta a scapparti un piede").
Ciao

 mangiare!...
Hai perfettamente ragione.
Quello che intendo č che risparmiare tempo prima per poi trovarsi incasinati
poi (e perderne molto di piů dopo) non č conveniente come sembra.
e con questa concludo, i thread lunghi mi mettono una tristezza :)
Ciao

 a farlo.
Sì, ma i NG servono anche per migliorare...
Con questa chiudo anch'io.
Ciao,
Carlo.

 Carlo.
Parole sante!
Anche  perchè non si dovrebbero distribuire nemmeno quelli sviluppati da
noi, ma inserirli sempre nel progetto come componenti privati! Cosi si
avrebbero migliaia di "Public Function faiQualcosa(...)" ma questo,
naturalmente, non è uno spreco di risorse!