Comment puis-je écrire dans un fichier caché?

Question

J'utilise le TextWriter pour essayer d'écrire dans un fichier caché, et il jette une exception. Je ne peux pas sembler comprendre comment écrire dans un fichier caché.

using (TextWriter tw = new StreamWriter(filename))
{
    tw.WriteLine("foo");
    tw.Close();
}

Exception:

Unhandled Exception: System.UnauthorizedAccessException: 
Access to the path 'E:\*\media\Photos\2006-08\.picasa.ini' is denied.

Comment puis-je écrire dans un fichier caché?

Answer 1

EDIT 2: Cette réponse résoudre le problème, mais pas la bonne façon de traiter le problème. Vous devriez chercher la réponse de Lucero.

---

A pris cette réponse de: http: / /www.dotnetspark.com/Forum/314-accessing-hidden-files-and-write-it.aspx

1- Définir fichier comme visible il peut être écrasé

// Get file info
FileInfo myFile= new FileInfo(Environment.CurrentDirectory + @"\hiddenFile.txt");

// Remove the hidden attribute of the file
myFile.Attributes &= ~FileAttributes.Hidden;

2- Modifiez le fichier

// Do foo...

3- fichier rétrogradé à caché

// Put it back as hidden
myFile.Attributes |= FileAttributes.Hidden;

EDIT: je fixe un problème sur ma réponse tel que signifié par briler

Answer 2

Il semble que le problème est ce genre d'un chèque de File.Exists() est fait en interne, qui échoue si le fichier est caché (par exemple essaie de faire un FileMode.Create sur un fichier qui existe déjà).

Par conséquent, utilisez FileMode.OpenOrCreate pour vous assurer que le fichier est ouvert ou créé, même si elle est cachée, ou tout simplement FileMode.Open si vous ne voulez pas créer si elle n'existe pas.

Lorsque FileMode.OpenOrCreate est utilisé cependant, le fichier ne sera pas tronqué, vous devez donc définir sa longueur à la fin pour vous assurer qu'il n'y a pas de surplus après la fin du texte.

using (FileStream fs = new FileStream(filename, FileMode.Open)) {
  using (TextWriter tw = new StreamWriter(fs)) {
    // Write your data here...
    tw.WriteLine("foo");
    // Flush the writer in order to get a correct stream position for truncating
    tw.Flush();
    // Set the stream length to the current position in order to truncate leftover text
    fs.SetLength(fs.Position);
  }
}

Si vous utilisez .NET 4.5 ou plus tard, il y a une nouvelle surcharge qui empêche la disposition du StreamWriter de disposer également le flux sous-jacent. Le code pourrait alors être écrit de manière plus intuitive slighly comme ceci:

using (FileStream fs = new FileStream(filename, FileMode.Open)) {
  using (TextWriter tw = new StreamWriter(fs, Encoding.UTF8, 1024, true)) {
    // Write your data here...
    tw.WriteLine("foo");
  }
  // Set the stream length to the current position in order to truncate leftover text
  fs.SetLength(fs.Position);
}

Answer 3

Edit: Pierre-Luc Champigny réponse était inccorect, mais maintenant fixé en fonction de la mienne, Je laisse derrière comme référence

myFile.Attributes |= FileAttributes.Normal;

ne supprime pas l'attribut caché du fichier. afin d'éliminer l'utilisation de l'attribut unhidden:

FileInfo .Attributes &= ~FileAttributes.Hidden; 

Ce code vérifie si le fichier existe, il faire unhidden. avant d'écrire une fois terminé, il la définir comme nouveau caché. J'ai également mis l'attribut normal dans le cas où le n'existait pas - vous ne devez pas utiliser

// if do not exists it creates it.
FileInfo FileInfo = new FileInfo(FileName);
if (true == FileInfo .Exists)
{
   // remove the hidden attribute from the file
   FileInfo .Attributes &= ~FileAttributes.Hidden; 
} //if it doesn't exist StreamWriter will create it
using (StreamWriter fileWriter = new StreamWriter(FileName))
{
   fileWriter.WriteLine("Write something");
}
 // set the file as hidden
FileInfo.Attributes |= FileAttributes.Hidden;

Answer 4

Si c'est une option pour vous, vous pouvez essayer d'utiliser File.SetAttributes pour supprimer l'attribut caché temporairement, faire votre travail, puis le remettre à l'état précédent.

Answer 5

Vous pouvez réafficher le fichier avant d'écrire dans et après l'écriture de peau complète à nouveau.

Answer 6

Une fois que vous avez ouvert un fichier, vous pouvez modifier ses attributs (y compris en lecture seule) et continuer à écrire à elle. Ceci est une façon d'empêcher un fichier d'être remplacée par d'autres processus.

Il semble possible de réafficher le fichier, ouvrez-le, puis le remettre à caché, même pendant que vous l'avez ouvert.

Par exemple, le code suivant fonctionne:

public void WriteToHiddenFile(string fname)
{
    TextWriter    outf;
    FileInfo      info;  

    info = new FileInfo(fname);
    info.Attributes = FileAttributes.Normal;    // Set file to unhidden
    outf = new StreamWriter(fname);             // Open file for writing
    info.Attributes = FileAttributes.Hidden;    // Set back to hidden
    outf.WriteLine("test output.");             // Write to file
    outf.Close();                               // Close file
}

Notez que le fichier reste caché alors que le processus lui écrit.