Если во время работы програмы файл открыт("ручками", например), то выдается ошибка

string f=@"d:\somefile.csv";
 try 
          //.....................
                StreamWriter sr = new StreamWriter(f, false, System.Text.Encoding.GetEncoding(1251)); 
                sr.WriteLine("..............") //запись данных
            //..........................
            }
            catch(Exception ex)
            {  Console.Write(ex.Message);
                Console.ReadKey();
            }
            finally{}*/

                const string file = @"d:\somefile.csv";
 
                using (var fs = new FileStream(file, FileMode.OpenOrCreate, FileAccess.Write))
                {
                    using (var sw = new StreamWriter(fs, Encoding.GetEncoding(1251)))
                    {
                        sw.WriteLine(/* данные */);
                        // В случае наличия объемного потока непрерывно записываемых данных, можно поставить:
                        // Thread.Sleep(/* задержка */);
                    }
                }

File.Copy(@"C:\Docs\1.txt", @"C:\Docs\2.txt", true);

            try
            {
                using (StreamWriter strw = new StreamWriter(@"C:\1.txt", true))
                {
                    strw.WriteLine("1");
                }
            }
            catch
            {
                File.Copy(@"C:\Docs\1.txt", @"C:\Docs\2.txt", true);             
                using (StreamWriter strw = new StreamWriter(@"C:\2.txt", true))
                {
                    strw.WriteLine("1");
                }
            }

File.Copy(sourceStr, targetStr, true); //sorceStr, targetStr - две строки с именами файлов

System.IO.FileSystemWatcher

using (FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.ReadWrite, FileShare.Read))
{
   // Производим здесь запись.
}

using (FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
   // Производим здесь чтение.
}

public static void Write(String pathToFile, String data)
    {
        Mutex fileLock;
 
        try
        {
            Mutex.OpenExisting("WriteMutex");
            return;
        }
        catch (Exception)
        {
            using (fileLock = new Mutex(false, "WriteMutex"))
            {
                try
                {
                    fileLock.WaitOne();
 
                    using (var fs = new FileStream(pathToFile, FileMode.Append, FileAccess.Write, FileShare.None))
                    {
                        using (var sw = new StreamWriter(fs))
                        {
                            sw.WriteLine(data);
                        }
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex);
                }
                finally
                {
                    fileLock.ReleaseMutex();
                }
            }
        }
    }

public static string Read(String pathToFile)
    {
        Mutex fileLock;
 
        try
        {
            Mutex.OpenExisting("ReadMutex");
            return null;
        }
        catch (Exception)
        {
            using (fileLock = new Mutex(false, "ReadMutex"))
            {
                try
                {
                    fileLock.WaitOne();
                    using (var fs = new FileStream(pathToFile, FileMode.OpenOrCreate, FileAccess.Read, FileShare.Read))
                    {
                        using (var sr = new StreamReader(fs))
                        {
                            return sr.ReadToEnd();
                        }
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex);
                }
                finally
                {
                    fileLock.ReleaseMutex();
                }
            }
        }
 
        return null;
    }

public static bool Write(String pathToFile, String data)
    {
        Mutex fileLock;
 
        try
        {
            Mutex.OpenExisting("WriteMutex");
            return false;
        }
        catch (Exception)
        {
            using (fileLock = new Mutex(false, "WriteMutex"))
            {
                try
                {
                    fileLock.WaitOne();
 
                    using (var fs = new FileStream(pathToFile, FileMode.Append, FileAccess.Write, FileShare.None))
                    {
                        using (var sw = new StreamWriter(fs))
                        {
                            sw.WriteLine(data);
                        }
                    }
                }
                catch (Exception)
                {
                    return false;
                }
                finally
                {
                    fileLock.ReleaseMutex();
                }
            }
        }
 
        return true;
    }