// A catch blokkok sorrendje: a SZŰKEBB (specifikus) típus ELŐL, az általános (IOException) mögötte.
// FileNotFoundException és DirectoryNotFoundException az IOException leszármazottja:
// ha az általános áll elöl, a szűkebb ág sosem fut (a fordító hibát jelez).
try
{
    File.WriteAllText(ut, tartalom);
}
catch (UnauthorizedAccessException) { /* jogosultság, írásvédett */ }
catch (DirectoryNotFoundException) { /* hiányzó mappa */ }
catch (PathTooLongException) { /* hosszú útvonal */ }
catch (IOException ex) { /* zár, lemez, hálózat: az ok a HResult-ból */ }
catch (ArgumentException) { /* érvénytelen útvonal */ }
catch (NotSupportedException) { /* érvénytelen formátum */ }

// az IOException okának azonosítása a Windows hibakódból (a HResult alsó 16 bitje)
private static bool ZarHiba(IOException ex)
{
    int kod = ex.HResult & 0xFFFF;

    return kod == 32 || kod == 33;   // 32: ERROR_SHARING_VIOLATION, 33: ERROR_LOCK_VIOLATION
}

private static bool LemezTele(IOException ex)
{
    int kod = ex.HResult & 0xFFFF;

    return kod == 39 || kod == 112;   // 39: ERROR_HANDLE_DISK_FULL, 112: ERROR_DISK_FULL
}

public static class FajlHiba
{
    // a kivételből érthető üzenet; az ujraProbalhato jelzi, érdemes-e a „Újra” gombot felkínálni
    public static string Szoveg(Exception ex, string muvelet, string fajl, out bool ujraProbalhato)
{
    ujraProbalhato = false;
    string nev = Path.GetFileName(fajl);

    if (ex is UnauthorizedAccessException)
    {
        return muvelet + " nem sikerült: nincs jogosultság a(z) " + nev + " fájlhoz, vagy a fájl írásvédett. Válassz másik helyet, vagy szüntesd meg az írásvédelmet.";
    }

    if (ex is DirectoryNotFoundException || ex is DriveNotFoundException)
    {
        return muvelet + " nem sikerült: a mappa vagy a meghajtó nem érhető el (kihúzott pendrive?). Ellenőrizd a helyet, és próbáld újra.";
    }

    if (ex is FileNotFoundException) { return muvelet + " nem sikerült: a(z) " + nev + " fájl nem található (időközben törölték vagy áthelyezték)."; }
    if (ex is PathTooLongException) { return muvelet + " nem sikerült: az útvonal túl hosszú. Válassz rövidebb nevet vagy kevésbé mély mappát."; }

    IOException io = ex as IOException;

    if (io != null)
    {
        int kod = io.HResult & 0xFFFF;

        if (kod == 32 || kod == 33)
        {
            ujraProbalhato = true;
            return muvelet + " nem sikerült: a(z) " + nev + " fájlt másik program használja. Zárd be, majd próbáld újra.";
        }

        if (kod == 39 || kod == 112) { return muvelet + " nem sikerült: nincs elég szabad hely a lemezen. Szabadíts fel helyet, vagy válassz másik meghajtót."; }

        ujraProbalhato = true;
        return muvelet + " nem sikerült (" + ex.Message + "). Ellenőrizd a meghajtót, és próbáld újra.";
    }

    return muvelet + " közben váratlan hiba történt: " + ex.Message;
    }
}

public static class BiztonsagosFajl
{
    public static void Ment(string ut, string tartalom)
    {
        string mappa = Path.GetDirectoryName(Path.GetFullPath(ut));
        Directory.CreateDirectory(mappa);

        string ideiglenes = Path.Combine(mappa, Path.GetFileName(ut) + "." + Guid.NewGuid().ToString("N") + ".tmp");

        try
        {
            using (FileStream fs = new FileStream(ideiglenes, FileMode.CreateNew, FileAccess.Write, FileShare.None))
            using (StreamWriter iro = new StreamWriter(fs, new UTF8Encoding(false)))
            {
                iro.Write(tartalom);
                iro.Flush();      // a StreamWriter puffere a FileStream-be
                fs.Flush(true);    // a lemezre (az operációs rendszer gyorsítótárából is)
            }

            if (File.Exists(ut)) { File.Replace(ideiglenes, ut, ut + ".bak"); }   // csere + a régi biztonsági másolata
            else { File.Move(ideiglenes, ut); }
        }
        finally
        {
            try { if (File.Exists(ideiglenes)) { File.Delete(ideiglenes); } }   // hiba esetén nem marad szemét
            catch (IOException) { }
        }
    }

    // betöltés: előbb a főfájl, hiba (sérült) esetén a .bak másolat; a hívó eldönti, mit tekint sérültnek
    public static string Betolt(string ut, Func<string, bool> ervenyes, out bool tartalekbol)
    {
        tartalekbol = false;

        foreach (string jelolt in new[] { ut, ut + ".bak" })
        {
            if (!File.Exists(jelolt)) { continue; }

            try
            {
                string szoveg = File.ReadAllText(jelolt, Encoding.UTF8);

                if (ervenyes(szoveg)) { tartalekbol = jelolt != ut; return szoveg; }
            }
            catch (IOException) { }   // a következő jelölt
        }

        return null;   // egyik sem használható
    }
}

// legfeljebb darab próbálkozás, a szünet minden körben nő; csak az átmeneti (zár) hibákra
public static void Ujraproba(Action muvelet, int darab = 3, int szunetMs = 200)
{
    for (int i = 1; ; i++)
    {
        try
        {
            muvelet();
            return;
        }
        catch (IOException ex) when (ZarHiba(ex) && i < darab)   // kivétel-szűrő: csak a zár hibára, és amíg van próba
        {
            Thread.Sleep(szunetMs * i);   // 200, 400, 600 ms... (a felületi szálat blokkolja: csak rövid ideig!)
        }
        // az utolsó próba hibája, vagy más hiba: továbbmegy a hívóhoz
    }
}

// használat
try
{
    BiztonsagosFajl.Ujraproba(() => BiztonsagosFajl.Ment(ut, tartalom));
}
catch (Exception ex) when (ex is IOException || ex is UnauthorizedAccessException)
{
    bool ujra;
    string uzenet = FajlHiba.Szoveg(ex, "A mentés", ut, out ujra);

    Naploz(ex.ToString());   // a teljes kivétel a naplóba

    if (MessageBox.Show(this, uzenet + (ujra ? Environment.NewLine + Environment.NewLine + "Újrapróbálod?" : ""), "Mentés", ujra ? MessageBoxButtons.RetryCancel : MessageBoxButtons.OK, MessageBoxIcon.Warning) == DialogResult.Retry)
    {
        MentGomb();   // újra
    }
}