Copia di una directory di file

[efn82]

Ciao a tutto il Forum

avrei necessità di creare una piccola utility che esegue una copia di una intera directory su un altro PC connesso in rete...

Qualcuno mi puo aiutare?

[Debiru]

Gran bella domanda, come ben sai c'è la classe System.IO.Directory

Tale classe, stranamente, ha i metodi Delete e Move... ma non Copy

Ho provato, incuriosito a cercare sul web, ho trovato una discussione in inglese che ne parlava, un tizio inca**ato come una bestia non capiva perchè non esiste il metodo Copy, ma Move e Delete si.

Quindi l'unica soluzione è fare, magari, un metodo ricorsivo che utilizzi i metodi Copy di System.IO.File e CreateDirectory di System.IO.Directory.

Prova a vedere, magari vedi anche di settare gli attributi giusti al file copiato

Ciao

[cassano]

infatti grave mancanza...... nn mi dire che se lo sono dimenticato......

[Debiru]

Se anche se lo fossero solo banalmente dimenticato non lo ammetterebbero mai, addurrebbero scuse tipo "è un comando dannoso per l'applicazione (e tirano giù un nome allucinante e fuorviante ricco di numeri e x) e quindi non è stata inserito" e non lo inseriranno mai, pur sapendo che è una cavolata inserirlo, pur di restare in linea con la propria politica di infallibili.

[Jupy64]

ma..veramente, in vb.net 2005, c'è la possibilità...
My.Computer.FileSystem.CopyDirectory(...)

[Debiru]

Vabbhè, ma in C# non c'è.

Mica si può pretendere che mi offri in un pacchetto diversi linguaggi analoghi dove in uno c'è una simile mancaza, in C# poi che secondo me è superiore a VB.NET.....

[Il Totem]

C'è la possibilità di scrivere una procedura che copia una directory tramite un metodo ricorsivo... Questo codice è tratto da una delle mie applicazioni:

    Public Function GetDirName(ByVal Dir As String) As String
        Return Dir.Remove(0, Dir.LastIndexOf("\") + 1)
    End Function
    Public Sub CopyDirectory(ByVal Dir As String, ByVal Destination As String)
        Dim Dirs() As String = Directory.GetDirectories(Dir)
        Dim Files() As String = Directory.GetFiles(Dir)
        Dim S As String
        ' Dim Size As Double = GetDirSize(Dir)
        ' Dim Index As Double

        ' lblStatus.Text = "Copia dei file in corso..."

        Try
            MkDir(Destination)
        Catch IOE As IOException
            MsgBox("Errore di accesso alla cartella: assicurarsi che non esista una cartella con lo stesso nome e di non " + _
            "stare modificando la suddetta mentre vengono eseguite le azioni di copia, quindi riprovare.", MsgBoxStyle.Exclamation)
        End Try
        For Each S In Files
            Application.DoEvents()
            FileCopy(S, Destination + "\" + Path.GetFileName(S))
            ' Index += FileLen(S)
            ' lblAll.Text = "Copia dei file: " & CInt(Index * 100 / Size) & "%"
            ' prgAll.Value = CInt(Index * 100 / Size)
        Next
        For Each S In Dirs
            CopyDirectory(S, Destination + "\" + GetDirName(S))
        Next
    End Sub

[cassano]

infatti nel C# non è presente l'ogetto my.

[Debiru]

Alla fine me la sono creata da solo una classe per copiare la directory, l'ho testata e va abbastanza bene, su può compilare per creare una DLL.

E' una classe statica con un solo metodo pubblico statico che è Copy, prende la cartella di origine e destinazione, se una delle due non esiste caccia errore, cmq vedete voi.

Ho tentato, nel caso di creazione di nuova cartella (quando esegue la copia) di settare nella cartella creata gli stessi attributi di quella di origine, ma per ora non funziona.

Usufruite

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

namespace DirectoryDX
{
    public static class DirectoryDX
    {
        public static void Copy(String Source, String Destination)
        {
            try
            {
                Destination = Destination.Replace('/', '\\');
                Source = Source.Replace('/', '\\');
                if (!Directory.Exists(Source))
                    throw new IOException("Cartella sorgente inesistente");
                if (!Directory.Exists(Destination))
                    throw new IOException("Cartella di destinazione inesistente");
                if (Destination.Substring(Destination.Length - 1).Equals(@"\"))
                    Destination = Destination.Substring(0, Destination.Length - 1);
                if (Source.Substring(Source.Length - 1).Equals(@"\"))
                    Source = Source.Substring(0, Source.Length - 1);
                if (DirectoryDX.VerificaRicorsione(Source, Destination))
                    DirectoryDX.Copia(Source, Destination);
            }
            catch
            {
                throw;
            }
        }

        private static Boolean VerificaRicorsione(String Sorgente, String Destinazione)
        {
            try
            {
                String temp;
                if (Sorgente.ToLower().Equals(Destinazione.ToLower()))
                    throw new IOException("Non puoi copiare una cartella dentro se stessa. Non avrebbe senso.");
                temp = Destinazione;
                while (temp.ToLower().Length<=3)
                {
                    temp = Directory.GetParent(temp).ToString();
                    if(temp.ToLower().Equals(Sorgente.ToLower()))
                        throw new IOException("Non puoi copiare una cartella dentro una cartella contenuta in essa. Si creerebbe una ridondanza.");
                }
                return true;
            }
            catch
            {
                throw;
            }
        }
        
        private static void Copia(String Sorgente, String Destinazione)
        {
            try
            {
                String Attuale;
                String[] cartelle = Directory.GetDirectories(Sorgente);
                String[] files;
                for (int i = 0; i <= cartelle.GetUpperBound(0); i++)
                {
                    Attuale = Destinazione + cartelle[i].Substring(cartelle[i].LastIndexOf('\\'));
                    if (!Directory.Exists(Destinazione + cartelle[i].Substring(cartelle[i].LastIndexOf('\\'))))
                    {
                        Directory.CreateDirectory(Attuale);
                        Directory.SetAccessControl(Attuale, Directory.GetAccessControl(Sorgente));
                    }
                    Copia(cartelle[i], Destinazione + cartelle[i].Substring(cartelle[i].LastIndexOf('\\')));
                }
                files = Directory.GetFiles(Sorgente);
                for (int i = 0; i <= files.GetUpperBound(0); i++)
                {
                    File.Copy(files[i], Destinazione + files[i].Substring(files[i].LastIndexOf('\\')));
                }
            }
            catch
            {
                throw;
            }
        }
    }
}

[Jupy64]

ma..scusate, questo post non era riferito a vb.net?
infatti la mia risposta era stata data in base al titolo del post...e con la premessa che sia 2005.