[C#] Lettura o scrittura file "alla rovescia"

[Neptune]

Salve a tutti,
ho un problema, ovvero devo scrivere delle informazioni su un file, riga per riga, e poi devo poter prendere le 100 informazioni più recenti.

Presupponendo che non so quante righe ci possono essere su un file e che potrebbero essere anche tantissime (quindi no l'idea di leggersele tutte su un array e poi leggersi gli indici all'incotrario) allora mi chiedo se c'è un modo per ovviare il problema:

- O scrivendo sul file "all'incontrario", ovvero invece di appendere a fine file ogni nuova stringa di scriverla in testa;

- O leggendo dalla fine del file verso l'inizio;


Io attualmente per scrivere utilizzo il seguente codice:

   path = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase);
                   fs = new FileStream(path + @nomefile, FileMode.Append, FileAccess.Write);
                   streamwriter = new StreamWriter(fs);
                   streamwriter.WriteLine(linea);
                   streamwriter.Close();

Non c'è qualche modo rapido ed indolore per dirgli semplicemente di scrivere a inizio file e non a fine file?

Per leggere utilizzo analogalmente uno streamreader ed il corrispettivo metodo readline.

Vi ringrazio in anticipo,
Neptune.

[albgen]

Crei un nuovo file in memoria o temporaneo, aggiungi le rige che vuoi, poi fai l'append del file esistente al nuovo file(creato precedentemente), poi sovrascrivi il file temp sopra all'esistente e quindi alla fine hai scritto all'inizio del file.

[Neptune]

Originariamente inviato da albgen
Crei un nuovo file in memoria o temporaneo, aggiungi le rige che vuoi, poi fai l'append del file esistente al nuovo file(creato precedentemente), poi sovrascrivi il file temp sopra all'esistente e quindi alla fine hai scritto all'inizio del file.

Cioè praticamente dovrei creare un file temporaneo e metterci una nuova riga, poi leggere il file "reale" e scriverci sopra riga per riga, e poi alla fine ricopiare di nuovo tutto sul file reale? diciamo che potrebbe andare anche se come soluzione è un pò sporca e dispendiosa se uno pensa che potrebbe avere a che fare con file grandi.

Piccolo dubbio, qui l'end of file come lo trovo? cioè come faccio a ciclare fino alla fine del file mediante lo streamreader?

Ed anche, come faccio poi a cancellare il file temporaneo creato?

[Neptune]

Ho provato a buttare giu questo codice, il file temp me lo scrive bene, ma quando arrivo ad aprire due nuovi stream per riversare quello che ce scritto nel file temporaneo nel file "reale" che a me serve mi dice che è in utilizzo da un'altro processo, eppure mi pare di aver chiuso abbondantemente tutti gli stream:

        public void scrivi(string linea)
        {
            //mi creo uno stremwriter temporaneo
            path = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase);
            string nomefile = "\\temp.txt";
            FileStream temp_fs_writer = new FileStream(path + @nomefile, FileMode.Append, FileAccess.Write);
            StreamWriter temp_stremwriter = new StreamWriter(temp_fs_writer);
            temp_stremwriter.WriteLine(linea);

            //mi creo uno streamreader temporaneo
            FileStream temp_fs_reader = new FileStream(path + this.@file_scrittura, FileMode.OpenOrCreate, FileAccess.Read);
            StreamReader temp_streamreader = new StreamReader(temp_fs_reader);
            string lettura = "";
            while (!temp_streamreader.EndOfStream)
            {
                lettura = temp_streamreader.ReadLine();
                temp_stremwriter.WriteLine(lettura);
            }

            temp_streamreader.Close();
            temp_stremwriter.Close();
            temp_fs_reader.Close();
            temp_fs_writer.Close();
            
            //mi creo uno stremwriter temporaneo
            temp_fs_writer = new FileStream(path + this.@file_scrittura, FileMode.Create, FileAccess.Write);
            temp_stremwriter = new StreamWriter(temp_fs_writer);

            //mi creo uno streamreader temporaneo
            FileStream temp_fs_reader2 = new FileStream(path + nomefile, FileMode.Open, FileAccess.Read);
            StreamReader temp_streamreader2 = new StreamReader(temp_fs_reader2);
            
            while (!temp_streamreader2.EndOfStream)
            {
                lettura = temp_streamreader2.ReadLine();
                temp_stremwriter2.WriteLine(lettura);
            }
            
            temp_streamreader2.Close();
            //temp_stremwriter2.Close();
            temp_fs_reader2.Close();
           // temp_fs_writer2.Close();
            
        }
    }

Secondo voi dove sbaglio? Ma contando che il file temporaneo lo devo riversare totalmente su un'altro file, non c'è un modo di farlo senza dover scandire tutto linea per linea? qualche comando del tipo "cancella file x; rinomina y in x" ?

[Neptune]

Ho accorciato tutto così:

            //mi creo uno stremwriter temporaneo
            path = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase);
            string nomefile = "\\temp.txt";
            FileStream temp_fs_writer = new FileStream(path + @nomefile, FileMode.Append, FileAccess.Write);
            StreamWriter temp_stremwriter = new StreamWriter(temp_fs_writer);
            temp_stremwriter.WriteLine(linea);

            //mi creo uno streamreader temporaneo
            FileStream temp_fs_reader = new FileStream(path + this.@file_scrittura, FileMode.OpenOrCreate, FileAccess.Read);
            StreamReader temp_streamreader = new StreamReader(temp_fs_reader);
            string lettura = "";
            while (!temp_streamreader.EndOfStream)
            {
                lettura = temp_streamreader.ReadLine();
                temp_stremwriter.WriteLine(lettura);
            }

            temp_streamreader.Close();
            temp_stremwriter.Close();
            temp_fs_reader.Close();
            temp_fs_writer.Close();

            File.Delete(path + this.@file_scrittura);
            File.Move(path + @nomefile, path + this.@file_scrittura);

Però arrivato al delete mi dice che non può farlo perchè il file è in uso da qualche altra parte. Ma se prima me l'ha letto tranquillamente, vuol dire che prima non era in uso, dopo averlo letto chiudo tutto il possibile, quindi com'è possibile che il file è in uso ?!?

[albgen]

prova a chiamare il dispose

[cyanuro]

Prova a limitare il blocco (scope) della gestione del file utilizzando due blocchi "using"
Esempio:

  
       using (StreamReader sr = new StreamReader(nomeFile, System.Text.Encoding.GetEncoding(1252)))
                {
                    while (sr.Peek() != -1)
                    {
                        // ciclo di lettura
  
                    }
                    sr.Close();
                }

                using (System.IO.StreamWriter sw = new System.IO.StreamWriter(fileTextBox.Text))
                    {
                         // ciclo di scrittura
                         sw.Close();
 
                    }
                }

Non so se questo avrà effetto, di sicuro è sicuramente meglio di quanto avevi in mente di fare

[albgen]

utilizzare using è come effettuare una chiamata a dispose(con try catch).

[Neptune]

Ho capito qual'era il problema, diciamo che la funziona attuale, chiamiamola B specializzava A e tale funzione creava uno streaming di suo. Così facendo non mi ero accorto che era coinvolto, pur non servendo, un'altro streeaming.

Niente ho rislto ripulendo un pò il codice.

Diciamo che questa soluzione funziona e meglio che nulla ma è davvero lenta, già con file di una decina di righe ci mette almeno 1 secondo a dare l'output, se iniziop a metterci file con dentro 10.000 righe sarà un accrocco lentissimo.

[alka]

Scusa la domanda ma... a cosa può servirti scrivere un file di questo tipo?