GESTIONE FILE E DIRECTORY
Di seguito sono riportate alcune classi di file e directory comunemente usate nella gestione di file e directory in c sharp:
- File fornisce metodi statici per la creazione, la copia, l’eliminazione, lo spostamento e l’apertura di file.
- FileInfo: fornisce metodi di istanza per la creazione, la copia, l’eliminazione, lo spostamento e l’apertura di file.
- Directory consente di utilizzare metodi statici per la creazione, lo spostamento e l’enumerazione di directory e sottodirectory.
- DirectoryInfo consente di usare metodi di istanza per la creazione, lo spostamento e l’enumerazione di directory e sottodirectory.
- Path: fornisce metodi e proprietà che consentono di elaborare le stringhe di directory indipendentemente dalla piattaforma.
FILE E DIRECTORY IN C SHARP I FLUSSI
La classe di base astratta Stream supporta la lettura e la scrittura di byte. Tutte le classi che rappresentano flussi ereditano dalla classe Stream. La classe Stream e le relative classi derivate forniscono una rappresentazione comune degli archivi e delle origini dati, svincolando così il programmatore dai dettagli specifici del sistema operativo e dai dispositivi sottostanti.
I flussi implicano tre operazioni fondamentali:
- Lettura: trasferimento di dati da un flusso a una struttura di dati, quale una matrice di byte.
- Scrittura: trasferimento di dati da un’origine dati a un flusso.
- Ricerca: interrogazione di un flusso e modifica della posizione corrente al suo interno.
Di seguito sono riportate alcune classi di flusso comunemente usate:
- FileStream: per la lettura e la scrittura su un file.
- MemoryStream: per la lettura e la scrittura in memoria come l’archivio di backup.
- BufferedStream: per migliorare le prestazioni delle operazioni di lettura e scrittura.
- NetworkStream: per la lettura e la scrittura sui socket di rete.
FILE E DIRECTORY IN C SHARP READER E WRITER
Lo spazio dei nomi System.IO fornisce tipi per leggere caratteri codificati dai flussi e per scriverli nei flussi stessi. In genere i flussi sono progettati per l’input e l’output di byte. I tipi reader e writer gestiscono la conversione dei caratteri codificati in byte e viceversa, in modo che il flusso possa completare l’operazione. Ogni classe reader e writer è associata a un flusso, che può essere recuperato tramite la proprietà BaseStream della classe.
Di seguito sono riportate alcune classi comunemente usate di reader e writer:
- BinaryReader e BinaryWriter: per la lettura e la scrittura di tipi di dati primitivi, come ad esempio valori binari.
- StreamReader e StreamWriter: per la lettura e la scrittura di caratteri usando un valore di codifica per la conversione dei caratteri in byte e viceversa.
- StringReader e StringWriter: per la lettura e la scrittura di caratteri da stringhe e viceversa.
- TextReader e TextWriter: fungono da classi base astratte per gli altri reader e writer che leggono e scrivono caratteri e stringhe, ma non dati binari.
LETTURA E SCRITTURA DI UN FILE DI TESTO
using System;
using System.IO;
using System.Threading.Tasks;
namespace FileDirectory
{
class Program
{
static async Task Main(string[] args)
{
String file = await ReadWriteText();
Console.WriteLine(file);
}
//LETTURA E SCRITTURA DI UN FILE DI TESTO
private static async Task<string> ReadWriteText()
{
string buffer;
string output = null;
try
{
using(StreamReader reader = File.OpenText(@”C:\Temp\input.txt”))
{
using(StreamWriter writer = File.CreateText(@”C:\Temp\output.txt”))
{
while((buffer = await reader.ReadLineAsync())!=null)
{
writer.WriteLine(buffer);
output += buffer;
}
}
return output;
}
}
catch(Exception ex)
{
Console.WriteLine(ex.Message);
return null;
}
}
}
}
LISTA DEI FILE IN UNA DIRECTORY
using System;
using System.IO;
using System.Threading.Tasks;
namespace FileDirectory
{
class Program
{
static void Main(string[] args)
{
GetDirectoryFiles();
}
//LISTA DEI FILE IN UNA DIRECTORY
private static void GetDirectoryFiles()
{
string path = @"C:\Temp";
try
{
DirectoryInfo directory = new DirectoryInfo(path);
FileInfo[] files = directory.GetFiles("*.txt");
foreach(var item in files)
Console.WriteLine(item);
}
catch(Exception e)
{
Console.WriteLine(e.Message);
return;
}
}
}
}
COPIARE UNA DIRECTORY
using System.IO;
using System.Threading.Tasks;
namespace FileDirectory
{
class Program
{
static void Main(string[] args)
{
CopyDirectory();
}
//COPIARE UNA DIRECTORY
private static void CopyDirectory()
{
DirectoryInfo source = new DirectoryInfo(@"C:\Temp2");
DirectoryInfo destination = new DirectoryInfo(@"C:\Temp3");
CopyDirectory(source,destination);
}
static void CopyDirectory(DirectoryInfo source, DirectoryInfo destination)
{
if (!destination.Exists)
{
destination.Create();
}
// Copia tutti i file
FileInfo[] files = source.GetFiles();
foreach (var file in files)
file.CopyTo(Path.Combine(destination.FullName,file.Name));
// Processa le sottodirectory
DirectoryInfo[] dirs = source.GetDirectories();
foreach (DirectoryInfo dir in dirs)
{
// Directory di destinazione
//Path.Combine combina due stringhe in un unico pah.
string destinationDir = Path.Combine(destination.FullName, dir.Name);
// Richiama la funzione stessa ricorsivamente
CopyDirectory(dir, new DirectoryInfo(destinationDir));
}
}
}
}
SCRIVERE E LEGGERE UN FILE BINARIO
using System;
using System.IO;
using System.Threading.Tasks;
namespace FileDirectory
{
class Program
{
static async Task Main(string[] args)
{
await ReadWriteBinaryFile();
}
//SCRIVERE E LEGGERE UN FILE BINARIO
private static async Task ReadWriteBinaryFile()
{
byte[] output = new byte[] {0x66, 0x67, 0x68, 0x69, 0x70,0x71,0x72, 0x73, 0x74, 0x75, 0x76,0x77};
try
{
if(File.Exists(@"C:\Temp\outputbinary.txt"))
File.Delete(@"C:\Temp\outputbinary.txt");
//SCRIVERE
using(FileStream stream = new FileStream(@"C:\Temp\outputbinary.txt",FileMode.Create))
{
await stream.WriteAsync(output,0,output.Length);
}
//LEGGERE
using(FileStream stream = new FileStream(@"C:\Temp\outputbinary.txt",FileMode.Open))
{
int count = 0;
int read;
byte[] buffer = new byte[output.Length];
while (count < output.Length)
{
read = await stream.ReadAsync(buffer, 0, output.Length);
Console.Write(Convert.ToChar(buffer.GetValue(count)) + " ");
count++;
}
}
}
catch(Exception e)
{
Console.WriteLine(e.Message);
}
}
}
}
APPROFONDIMENTO
In C#, lavorare con file e directory è un’operazione comune e la piattaforma .NET fornisce diverse classi per facilitare queste operazioni, come File, Directory, FileInfo e DirectoryInfo. Di seguito ti fornirò una spiegazione dettagliata su come utilizzare queste classi.
Classi Principali per la Gestione di File e Directory
1. Classe File: Fornisce metodi statici per la creazione, copia, eliminazione, spostamento e apertura di file. Inoltre, permette di leggere e scrivere direttamente sui file.
2. Classe Directory: Fornisce metodi statici per la creazione, eliminazione e spostamento di directory. Permette anche di ottenere informazioni sulle directory e sui loro contenuti.
3. Classe FileInfo: Fornisce proprietà e metodi di istanza per la manipolazione di file. A differenza della classe File, questa classe deve essere istanziata.
4. Classe DirectoryInfo: Fornisce proprietà e metodi di istanza per la manipolazione di directory. Come FileInfo, anche questa deve essere istanziata.
Operazioni con la Classe File
Ecco alcuni esempi di operazioni comuni usando la classe File.
using System;
using System.IO;
class Program
{
static void Main()
{
string filePath = @”C:\example\myfile.txt“;
// Creare un file e scrivere del testo
File.WriteAllText(filePath, “Hello, world!“);
// Leggere il contenuto di un file
string content = File.ReadAllText(filePath);
Console.WriteLine(content);
// Copiare un file
string copyPath = @”C:\example\myfile_copy.txt“;
File.Copy(filePath, copyPath);
// Eliminare un file
File.Delete(copyPath);
}
}
Operazioni con la Classe Directory
Ecco alcuni esempi di operazioni comuni usando la classe Directory.
using System;
using System.IO;
class Program
{
static void Main()
{
string dirPath = @”C:\example\mydir“;
// Creare una directory
Directory.CreateDirectory(dirPath);
// Verificare se una directory esiste
if (Directory.Exists(dirPath))
{
Console.WriteLine(“La directory esiste.“);
}
// Ottenere i file in una directory
string[] files = Directory.GetFiles(dirPath);
foreach (string file in files)
{
Console.WriteLine(file);
}
// Eliminare una directory
Directory.Delete(dirPath, true); // Il parametro true elimina anche il contenuto della directory
}
}
Utilizzo di FileInfo e DirectoryInfo
Le classi FileInfo e DirectoryInfo offrono metodi simili alle classi statiche File e Directory, ma possono essere utilizzate per operazioni orientate agli oggetti.
using System;
using System.IO;
class Program
{
static void Main()
{
// Utilizzo di FileInfo
FileInfo fileInfo = new FileInfo(@”C:\example\myfile.txt“);
fileInfo.Create().Close(); // Creare un file
fileInfo.WriteAllText(“Hello, world!”); // Scrivere testo nel file
Console.WriteLine(fileInfo.Length); // Ottenere la dimensione del file
// Utilizzo di DirectoryInfo
DirectoryInfo dirInfo = new DirectoryInfo(@”C:\example\mydir“);
dirInfo.Create(); // Creare una directory
Console.WriteLine(dirInfo.FullName); // Ottenere il percorso completo della directory
dirInfo.Delete(true); // Eliminare la directory e il suo contenuto
}
}
Note Importanti
• Quando si lavora con file e directory, è importante gestire le eccezioni per evitare errori di runtime. Ad esempio, se si tenta di leggere un file che non esiste, si otterrà una FileNotFoundException.
• Utilizzare sempre percorsi assoluti o relativi correttamente formattati per evitare errori.
• Fare attenzione ai permessi di file e directory, specialmente quando si eseguono operazioni di scrittura o eliminazione.
Lascia un commento