using System;
using System.IO;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Введите имя счетчика и нажмите ENTER:");
            
            string fileName = Console.ReadLine();

            // Если файла не существует -- нужно создать.
            // Может не быть доступа к файлу
            // Имя счетчика может быть некорректным -- с этим что-то нужно сделать
            string text = File.ReadAllText(fileName);

            int count = int.Parse(text);

            Console.WriteLine("Значение счетчика: ", count);

            count++;

            // Может быть запрещена запись в файл
            File.WriteAllText(fileName, count.ToString());
        }
    }
}

using System;
using System.IO;
using System.Security;
using System.Security.Permissions;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            var w = new Worker();
            w.Error += w_Error;
            w.Info += w_Info;
            w.Run();
            Console.ReadKey();
        }

        static void w_Info(string obj)
        {
            Console.WriteLine(obj);
        }

        static void w_Error(string obj)
        {
            var oldColor = Console.ForegroundColor;
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(obj);
            Console.ForegroundColor = oldColor;
        }
    }

    public class Worker
    {
        public event Action<string> Error = delegate { };

        public event Action<string> Info = delegate { };

        public void Run()
        {
            try
            {
                InternalRun();
            }
            catch (Exception ex)
            {
                WriteToLog(ex);
                Error(string.Format("Упс, не предвиденная ошибка: {0}. Обратитесь в службу поддержки.", ex.Message));
            }
        }

        protected void WriteToFile(string fileName, int count)
        {
            if (!CheckAccessForFile(fileName, FileIOPermissionAccess.Write))
            {
                Info("Запись в файл не возможна.");
                return;
            }
            File.WriteAllText(fileName, count.ToString());
        }

        protected virtual string ReadFileName()
        {
            Console.WriteLine("Введите имя счетчика и нажмите ENTER:");

            var fileName = Console.ReadLine();
            return Path.Combine(Environment.CurrentDirectory, fileName + "");
        }

        private void InternalRun()
        {
            bool goodFile;
            string fileName;
            do
            {
                goodFile = true;
                fileName = ReadFileName();
                if (!FileNameIsCorrect(fileName))
                {
                    Info("Имя файла не корректно, повторите ввод.");
                    goodFile = false;
                    continue;
                }

                if (!File.Exists(fileName))
                {
                    var fs =File.Create(fileName);
                    fs.Close();
                }

                if (!CheckAccessForFile(fileName, FileIOPermissionAccess.Read))
                {
                    Info("Прочитать файл невозможно.");
                    goodFile = false;
                    continue;
                }
            } while (!goodFile);

            var text = File.ReadAllText(fileName);

            int count;
            if (!int.TryParse(text, out count))
            {
                Info("Счет записан не корректно. Значение выставлено в 0");
                count = 0;
            }

            Info(string.Format("Значение счетчика: {0}", count));

            count++;

            WriteToFile(fileName, count);
        }

        private static bool CheckAccessForFile(string fileName, FileIOPermissionAccess fileIoPermissionAccess)
        {
            var f2 = new FileIOPermission(fileIoPermissionAccess, fileName);
            var bOk = true;
            try
            {
                f2.Demand();
            }
            catch (SecurityException)
            {
                bOk = false;
            }
            return bOk;
        }

        private static void WriteToLog(Exception exception)
        {
            //Console.WriteLine(exception.ToString());
        }

        private static bool FileNameIsCorrect(string fileName)
        {
            var bOk = false;
            try
            {
                new FileInfo(fileName);
                bOk = true;
            }
            catch (ArgumentException)
            {
            }
            catch (PathTooLongException)
            {
            }
            catch (NotSupportedException)
            {
            }
            return bOk;
        }
    }
}

using System;
using System.IO;
using System.Reflection;

namespace ConsoleApplication1 {
    #region Presentation
    class Program {
        static void Main(string[] args) {
            bool exitProgram = false;

            do {
                try {
                    Console.WriteLine("Enter the name of a counter and press ENTER:");
                    string fileName = Console.ReadLine();
                    var incrementor = new Incrementor((new FileNameGenerator()).GenerateFileName(fileName));
                    var result = incrementor.PerformIncrement();
                    Console.WriteLine("Value of counter: {0}", result.PreviousValue);
                    exitProgram = true;
                    Console.WriteLine("Press enter for exit.");
                    Console.ReadLine();
                } catch (Exception ex) {
                    var myFriend = new FriendlyMessageGenerator();
                    var msg = myFriend.GetFriendly(ex);
                    Console.WriteLine("Friendly message: {0}", msg.Message);
                    Console.WriteLine("Error details: {0}", msg.Details);
                    
                    Console.WriteLine("Would you like to try again?");
                    if (Console.ReadLine().Equals("n", StringComparison.OrdinalIgnoreCase)) {
                        exitProgram = true;
                    }
                }
            } while (!exitProgram);

        }
    }
    #endregion

    #region SharedApplicationComponent
    public class FileNameGenerator {
        private const string EXTENSION = ".txt";
        public string GenerateFileName(string counterName) {
            return Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + Path.DirectorySeparatorChar + counterName + EXTENSION;
        }
    }
    public class FriendlyMessageGenerator {
        public FriendlyMessage GetFriendly(Exception ex) {
            string message;
            if (ex is IncrementorException) {
                message = (ex as IncrementorException).Message;
            } else {
                message = "Unexpected error has been happened during executing the task. Please, see the details.";
            }
            return new FriendlyMessage(message, ex);
        }
    }
    public class FriendlyMessage {
        public FriendlyMessage(string message, Exception exception) {
            Message = message;
            Details = exception;
        }
        public string Message { get; private set; }
        public Exception Details { get; private set; }
    }
    #endregion

    #region BusinessLogicComponent
    public class Incrementor {
        private string _counterFileName;
        private const int STARTUP_NUMBER = 0;
        
        public Incrementor(string counterFileName) {
            _counterFileName = counterFileName;
        }
        public Result PerformIncrement() {
            CreateFileIfItDoesNotExist();
            var oldValue = ReadCurrentValue();
            var newValue = oldValue + 1;
            WriteNewValue(newValue);
            return new Result(oldValue, newValue);
        }
        private int ReadCurrentValue() {
            try {
                return int.Parse(File.ReadAllText(_counterFileName));
            } catch (Exception ex) {
                throw new IncrementorException("Error during reading current value", ex);
            }
        }
        private void WriteNewValue(int newValue) {
            try {
                File.WriteAllText(_counterFileName, newValue.ToString());
            } catch (Exception ex) {
                throw new IncrementorException("Error during writing new value", ex);
            }
        }
        private void CreateFileIfItDoesNotExist() {
            if (!File.Exists(_counterFileName)) {
                try {
                    File.Create(_counterFileName).Close();
                    File.WriteAllText(_counterFileName, STARTUP_NUMBER.ToString());
                } catch (Exception ex) {
                    throw new IncrementorException("Error during file creating", ex);
                }
            }
        }
    }
    public class IncrementorException : Exception {
        public IncrementorException() { }
        public IncrementorException(string message) : base(message) { }
        public IncrementorException(string message, Exception inner) : base(message, inner) { }
        protected IncrementorException(
          System.Runtime.Serialization.SerializationInfo info,
          System.Runtime.Serialization.StreamingContext context)
            : base(info, context) { }
    }
    public class Result {
        public Result(int previousValue, int newValue) {
            PreviousValue = previousValue;
            NewValue = newValue;
        }
        public int PreviousValue { get; private set; }
        public int NewValue { get; private set; }
    }
    #endregion
}

        private void WriteNewValue(int newValue) {
            try {
                File.WriteAllText(_counterFileName, newValue.ToString());
            } catch (Exception ex) {
                throw new IncrementorException("Error during writing new value", ex);
            }
        }

M>Файл вполне доступен, только видимо слишком большой для программы. Ничего не "разжёвывается".

---------------------------
Open
---------------------------
File C:\#$# does not exist.

Verify that the correct file name was given.
---------------------------
OK
---------------------------

---------------------------
Open
---------------------------
8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888
The above file name is invalid.
---------------------------
OK
---------------------------

---------------------------
Paint.NET
---------------------------
An I/O error occurred when writing to the file.
---------------------------
OK
---------------------------

---------------------------
Paint.NET
---------------------------
There was an error reading the file from the media.
---------------------------
OK
---------------------------

0K>using System;
0K>using System.IO;

0K>namespace ConsoleApplication1
0K>{
0K>    class Program
0K>    {
0K>        static void Main(string[] args)
0K>        {
0K>01            Console.WriteLine("Введите имя счетчика и нажмите ENTER:");
            
0K>02            string fileName = Console.ReadLine();

0K>            // Если файла не существует -- нужно создать.
0K>            // Может не быть доступа к файлу
0K>            // Имя счетчика может быть некорректным -- с этим что-то нужно сделать
0K>03            string text = File.ReadAllText(fileName);

0K>04            int count = int.Parse(text);

0K>05            Console.WriteLine("Значение счетчика: ", count);

0K>06            count++;

0K>            // Может быть запрещена запись в файл
0K>07            File.WriteAllText(fileName, count.ToString());
0K>        }
0K>    }
0K>}
0K>

Console.WriteLine("Введите имя счетчика и нажмите ENTER:");
string fileName = Console.ReadLine();
string text = "";
try
{
    text = File.ReadAllText(fileName);
}
catch (NotFoundException e)
{
    text = "-1"
}

int count = 0;
try
{
    count = int.Parse(text);
}
catch (FormatException e)
{
    count = -1;
}

static void Main(string[] args)
{
    Console.WriteLine("Введите имя счетчика и нажмите ENTER:");
    
    string fileName = Console.ReadLine();

    string text = "";
    try
    {
        text = File.ReadAllText(fileName);
        Console.WriteLine("Счётчик '{0}' найден.", text);
    }
    catch (NotFoundException e)
    {
        text = "-1"
        Console.WriteLine("Счётчик '{0}' не найден и будет создан.", text);
    }

    int count = 0;
    try
    {
        count = int.Parse(text);
    }
    catch (FormatException e)
    {
        count = -1;
    }

    Console.WriteLine("Значение счетчика: ", count);

    count++;

    try
    {
        File.WriteAllText(fileName, count.ToString());
    }
    catch (SecurityException e)
    {
        Console.WriteLine("Счётчик '{0}' обновить не удалось.", text);
        throw;
    }
}

static void Main(string[] args)
{
    Console.WriteLine("Введите имя счетчика и нажмите ENTER:");
    
    string fileName = Console.ReadLine();

    string text = "";
    try
    {
        text = File.ReadAllText(fileName);
    }
    catch (NotFoundException e)
    {
        text = "-1"
    }

    int count = 0;
    try
    {
        count = int.Parse(text);
    }
    catch (FormatException e)
    {
        count = -1;
    }

    Console.WriteLine("Значение счетчика: ", count);

    count++;

    File.WriteAllText(fileName, count.ToString());
}

A>int count = 0;
A>try
A>{
A>    count = int.Parse(text);
A>}
A>catch (FormatException e)
A>{
A>    count = -1;
A>}
A>

int count = 0;
if(!int.TryParse(text, out count))
  count = -1;

# It hides bugs

# Handling all exceptions without exception-specific handling logic will leave the application in an unknown state.

# It circumvents higher-level exception handling.

A higher-level exception handler may know exactly what to do with a certain type of exception; possibly much better than your code. By using catch(Exception) you circumvent that and end up with the above--the application may be in a unknown state.

                    string fileName = Console.ReadLine();
                    var incrementor = new Incrementor((new FileNameGenerator()).GenerateFileName(fileName));
                    try {
                        var result = incrementor.PerformIncrement();
                    } catch (FileNotFoundException ex)  {
                        Console.WriteLine("The file [{0}] was not found", fileName);
                    }

Console.WriteLine("Значение счетчика: ", count);

Значение счетчика:

Программа должна быть не демо, а реальной. Т.е. считайте что вы пишите реальный проект, которым будут пользоваться тысячи людей.

class Program
{
    static void Main()
    {
        var filename = ConfigurationManager.AppSettings["FileName"];
        var count = int.Parse(File.ReadAllText(filename)) + 1;
        File.WriteAllText(filename, count.ToString());
    }
}

using System;
using System.IO;

namespace ConsoleApplication1 {
    internal class Program {
        private static void Main() {
            ConsoleMessanger messanger = new ConsoleMessanger();
            do {
                try {
                    messanger.WriteLine("Введите имя счетчика и нажмите ENTER:");
                    string fileName = messanger.ReadLine();
                    IIncrementor incrementor = new FileIncrementor(FileIncrementor.CreateFileInfo(fileName), messanger);
                    incrementor.Read();
                    messanger.WriteLine("Значение счетчика: {0}", incrementor.Value);
                    incrementor.Increment();
                    incrementor.Write();
                }
                catch (IncrementorException ex) {
                    messanger.WriteLine(ex.Message);
                }
                catch (Exception ex) {
                    messanger.WriteLine("Произошла непредвиденная ошибка. Обратитесь к разработчику.");
                    messanger.Log(ex);
                }
                messanger.WriteLine("Еще раз? (y/Y/д/Д/Ввод = ДА, остальное = НЕТ)");
            } while ("yд".Contains(messanger.ReadLine().ToLower()));
        }
    }

    internal interface IIncrementor {
        /*
         * Интерфейс счетчика.
         */

        void Read();
        int Value { get; }
        void Increment();
        void Write();
    }

    internal class FileIncrementor : IIncrementor {
        /*
         * Класс файлового счетчика.
         */

        private readonly FileInfo _fileInfo;
        private readonly IMessanger _messanger;
        private int _value;

        public FileIncrementor(FileInfo fileInfo, IMessanger messanger) {
            _fileInfo = fileInfo;
            _messanger = messanger;
        }

        public int Value {
            get { return _value; }
        }

        public void Read() {
            try {
                using (StreamReader reader = _fileInfo.OpenText()) {
                    if (!int.TryParse(reader.ReadToEnd(), out _value))
                        _messanger.WriteLine("Файл '{0}' поврежден. Значение счетчика сброшено.", _fileInfo.FullName);
                    reader.Close();
                }
                return;
            }
            catch (FileNotFoundException) {
                _messanger.WriteLine("Файл '{0}' не найден и будет создан.", _fileInfo.FullName);
            }
            catch (UnauthorizedAccessException ex) {
                throw new IncrementorException(ex, "'{0}' это директория. Ожидается имя файла.", _fileInfo.FullName);
            }
            catch (DirectoryNotFoundException ex) {
                throw new IncrementorException(ex, "Путь к файлу '{0}' не найден.", _fileInfo.FullName);
            }
        }

        public void Increment() {
            _value++;
        }

        public void Write() {
            try {
                if (!_fileInfo.Exists)
                    using (FileStream stream = _fileInfo.Create()) stream.Close();
                using (StreamWriter writer = _fileInfo.CreateText()) {
                    writer.Write(_value);
                    writer.Close();
                }
            }
            catch (IOException ex) {
                throw new IncrementorException(ex, "Файл '{0}' защищен от записи.", _fileInfo.FullName);
            }
            catch (UnauthorizedAccessException ex) {
                throw new IncrementorException(ex, "Файл '{0}' защищен от записи.", _fileInfo.FullName);
            }
        }

        public static FileInfo CreateFileInfo(string fileName) {
            try {
                return new FileInfo(fileName);
            }
            catch (ArgumentNullException ex) {
                throw new IncrementorException(ex, "Имя файла пустое.");
            }
            catch (ArgumentException ex) {
                throw new IncrementorException(ex, "Имя файла '{0}' содержит некорректные символы.", fileName);
            }
            catch (NotSupportedException ex) {
                throw new IncrementorException(ex, "Имя файла '{0}' содержит некорректные символы.", fileName);
            }
            catch (UnauthorizedAccessException ex) {
                throw new IncrementorException(ex, "Файл '{0}' недоступен.", fileName);
            }
            catch (PathTooLongException ex) {
                throw new IncrementorException(ex, "Имя файла '{0}' слишком длинное.", fileName);
            }
        }
    }

    internal class IncrementorException : Exception {
        /*
         * Класс обертка для "пользовательских" исключений.
         * Остальные исколючения пробрасываются в вызывающий код.
         */

        public IncrementorException(Exception innerException, string format, params object[] args) : base(string.Format(format, args), innerException) {}
    }

    internal interface IMessanger {
        /*
         * Интерфейс взаимодействия с пользователем и разработчиком.
         */

        string ReadLine();
        void WriteLine(string format, params object[] args);
        void Log(Exception ex);
    }

    internal class ConsoleMessanger : IMessanger {
        /*
         * Класс взаимодействия с пользователем и разработчиком через консоль.
         */

        public string ReadLine() {
            return Console.ReadLine();
        }

        public void WriteLine(string format, params object[] args) {
            Console.WriteLine(format, args);
        }

        public void Log(Exception ex) {
            WriteLine("{0}", ex);
        }
    }
}

try {
                using (StreamReader reader = _fileInfo.OpenText()) {
                    if (!int.TryParse(reader.ReadToEnd(), out _value))
                        _messanger.WriteLine("Файл '{0}' поврежден. Значение счетчика сброшено.", _fileInfo.FullName);
                    reader.Close();
                }
                return;
            }
            catch (FileNotFoundException) {
                _messanger.WriteLine("Файл '{0}' не найден и будет создан.", _fileInfo.FullName);
            }

    _messanger.WriteLine("Файл '{0}' поврежден. Значение счетчика сброшено.", _fileInfo.FullName);

                if (!_fileInfo.Exists)
                    using (FileStream stream = _fileInfo.Create()) stream.Close()

N>    _messanger.WriteLine("Файл '{0}' поврежден. Значение счетчика сброшено.", _fileInfo.FullName);
N>

N>                if (!_fileInfo.Exists)
N>                    using (FileStream stream = _fileInfo.Create()) stream.Close()
N>

Произошла непредвиденная ошибка. Обратитесь к разработчику.
System.IO.IOException: The process cannot access the file 'C:\Users\User\AppDat
a\Local\Temporary Projects\ConsoleApplication1\bin\Debug\f' because it is being
used by another process.
at System.IO.__Error.WinIOError(Int32 errorCode, String maybeFullPath)
at System.IO.FileStream.Init(String path, FileMode mode, FileAccess access, I
nt32 rights, Boolean useRights, FileShare share, Int32 bufferSize, FileOptions o
ptions, SECURITY_ATTRIBUTES secAttrs, String msgPath, Boolean bFromProxy, Boolea
n useLongPath)
at System.IO.FileStream..ctor(String path, FileMode mode, FileAccess access,
FileShare share, Int32 bufferSize, FileOptions options)
at System.IO.StreamReader..ctor(String path, Encoding encoding, Boolean detec
tEncodingFromByteOrderMarks, Int32 bufferSize)
at System.IO.FileInfo.OpenText()
at ConsoleApplication1.FileIncrementor.Read() in C:\Users\User\AppData\Local
\Temporary Projects\ConsoleApplication1\Program.cs:line 76
at ConsoleApplication1.Program.Main() in C:\Users\User\AppData\Local\Tempora
ry Projects\ConsoleApplication1\Program.cs:line 18
Еще раз? (y/Y/д/Д/Ввод = ДА, остальное = НЕТ)

class OracleIncrementor : IIncrementor
{
    public Increment()
    {
        var dbManager = Ioc.Resolve<IDbManager>();
        //провести инкрементацию чего надо через dbManager.
    }
}

class Main
{
    public User LoginUser( string login, string pass )
    {
        try
        {
            var dbManager = Ioc.Resolve<IDbManager>();
            var user = dbManager.SearchUserByLoginAndPass( login, pass );
            if( user == null )
            {
                throw new NoAccessException("Пользователь с таким логином или паролем не зарегистрирован в системе");
            }

            using( var tran = dbManager.BeginTransaction() )
            {
                //у пользователя обновляем дату последного захода в систему
                user.LastLoginTime = DateTime.Now;
                dbManager.Save(user);
                
                //при логине мы так же обновляем специальный сторонний счетчик заходов
                try
                {
                    var incrementor = Ioc.Resolve<IIncrementor>( "userLogons" );
                    incrementor.Increment();
                }
                catch( IncrementorException iex )
                {
                    //тут решаем что делать с ошибкой инкрементации. 
                    //считается, что сюда попадают только те ошибки, которые не смог решить сам инкрементор.
                    //Если нам эта инкрементация не очень-то и важна, то просто пишем в лог и подавляем ошибку.
                    //а если важна (может быть для какой-то интеграции) и работа без нее продолжена быть не может
                    //то этого блока try/catch тут просто не будет и ошибка сама собой уйдет выше. 
                }
                
                tran.CommitTransaction();
                return user;
            }
        }        
        catch( DbException dex )
        {
            //а вот это уже для нас серьезно - у нас сбой базы данных. То ли не можем приконнектиться
            //то ли структура базы не соответствует ожидаемой
            //в общем - надо думать
            //как минимум можно переложить идею подумать пользователю, вывалив ему эту ошибку наверх
            //а можно попробовать покопаться в кишках DbException и понять
            //что именно у нас произошло, и можно ли сделать что-то для исправления
            //(например, у нас может быть требование к программе, что при сбое соединения, надо подождать, 
            //и еще два раза попробовать соединиться, и только потом уже отключаться). 
            //или можно запустить обновлятор базы и если он успешно что-то обновит - то попробовать провести повторный логин.
            
            //и совсем даже не факт, что это должно обрабатываться в данном методе а не где-то выше.
        }
    }
}

Do not suppress a violation of the rule.

Suppress a message from this rule if you are sure in all cases that the private exception will be caught within its own internal scope

//пусто

void Increment(string fileName)
{
    using(var f = File.Open(fileName, FileMode.OpenOrCreate))
    {
        var reader = new StreamReader(f);
        var content = reader.ReadToEnd();
        
        var counter = 0;
        if(int.TryParse(content, out counter))
        {
            counter = (counter == int.MaxValue) ? 0 : (counter+1)
        }

        f.Seek(0, SeekOrigin.Begin);
        f.SetLength(0);

        var writer = new StreamWriter(f);
        writer.Write(counter);
    }
}

IManager
{
   void Increment();
}

DBManager:IManager
{
   void Increment()
   {
      ...
      catch(SqlException se)
     {
        //анализируем ситуацию
        throw new CustomFormatException("<мессага>",se);
     }
   }
}
FileManager:IManager
{
   void Increment()
   {
      ...
      if(!Какая либо проверка))
        {
             throw new CustomFormatException("<мессага>",se);
        }
   }
}

using System;
using System.Globalization;
using System.IO;
using System.Runtime.Serialization;
using System.Security;

namespace ConsoleApplication1
{
    [Serializable]
    public class CounterException : Exception
    {
        public CounterException() { }
        public CounterException(string message) : base(message) { }
        public CounterException(string message, Exception innerException) : base(message, innerException) { }
        protected CounterException(SerializationInfo info, StreamingContext context)
            : base(info, context) { }
    }

    public class Counter
    {
        private string _path;

        public string Alias { get; protected set; }
        public int Count { get; protected set; }

        protected Counter() { }

        /// <exception cref="ArgumentNullException">alias is null.</exception>
        /// <exception cref="ArgumentOutOfRangeException">alias is empty</exception>
        /// <exception cref="ArgumentException">Invalid character</exception>
        public Counter(string alias)
        {
            if (null == alias)
                throw new ArgumentNullException("alias");

            if (string.IsNullOrEmpty(alias))
                throw new ArgumentOutOfRangeException("alias");

            if (alias.IndexOfAny(Path.GetInvalidFileNameChars()) >= 0)
                throw new ArgumentException("Invalid character.");

            Alias = alias;
            _path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, Alias);
        }

        public static Counter TryParse(string alias)
        {
            try { return new Counter(alias); }
            catch (ArgumentException)
            {
                return null;
            }
        }

        /// <exception cref="CounterException"></exception>
        public void Load()
        {
            int count;

            if (File.Exists(_path))
            {
                try
                {
                    string text = File.ReadAllText(_path);

                    if (!int.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture.NumberFormat, out count))
                        count = 0;
                }
                catch (PathTooLongException exception)
                {
                    throw new CounterException(exception.Message, exception);
                }
                catch (UnauthorizedAccessException exception)
                {
                    throw new CounterException(exception.Message, exception);
                }
                catch (FileNotFoundException)
                {
                    count = 0;
                }
                catch (SecurityException exception)
                {
                    throw new CounterException(exception.Message, exception);
                }
                catch (IOException exception)
                {
                    throw new CounterException(exception.Message, exception);
                }
            }
            else
                count = 0;

            Count = count;
        }

        public void Increment()
        {
            Count++;
        }

        /// <exception cref="CounterException"></exception>
        public void Save()
        {
            try
            {
                File.WriteAllText(_path, Count.ToString(CultureInfo.InvariantCulture.NumberFormat));
            }
            catch (PathTooLongException exception)
            {
                throw new CounterException(exception.Message, exception);
            }
            catch (UnauthorizedAccessException exception)
            {
                throw new CounterException(exception.Message, exception);
            }
            catch (FileNotFoundException exception)
            {
                throw new CounterException(exception.Message, exception);
            }
            catch (SecurityException exception)
            {
                throw new CounterException(exception.Message, exception);
            }
            catch (IOException exception)
            {
                throw new CounterException(exception.Message, exception);
            }
        }
    }

    public class Program
    {
        static void Main(string[] args)
        {
            const string YES_SYMBOLS = "YyДд";

            bool first = true;
            Counter counter;

            while (true)
            {
                if (!first)
                {
                    Console.WriteLine("Повторить?");

                    if (!YES_SYMBOLS.Contains(Console.ReadLine()))
                        break;

                    Console.Clear();
                }
                else
                    first = false;

                Console.WriteLine("Введите имя счетчика:");
                string alias = Console.ReadLine();

                counter = Counter.TryParse(alias);

                if (null == counter)
                {
                    Console.WriteLine("Некорректное имя счетчика (пояснение каким должно быть правильное имя).");
                    continue;
                }

                try
                {
                    counter.Load();
                }
                catch (CounterException exception)
                {
                    Console.WriteLine("Ошибка при получении значения счетчика." + Environment.NewLine + exception.Message);
                    continue;
                }

                Console.WriteLine("Текущее значение счетчика {0}: {1}.", counter.Alias, counter.Count);

                counter.Increment();

                try
                {
                    counter.Save();
                }
                catch (CounterException exception)
                {
                    Console.WriteLine("Ошибка при сохранении нового значения счетчика." + Environment.NewLine + exception.Message);
                    continue;
                }
            }
        }
    }
}

using System;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Runtime.Serialization;
using System.Security;
using System.Collections.Generic;

namespace ConsoleApplication1
{
    public class Counter
    {
        private string _path;

        public string Alias { get; protected set; }
        public int Count { get; protected set; }

        public Counter(string alias)
        {
            if (null == alias)
                throw new ArgumentNullException("alias");

            if (string.IsNullOrEmpty(alias))
                throw new ArgumentOutOfRangeException("alias");

            if (alias.IndexOfAny(Path.GetInvalidFileNameChars()) >= 0)
                throw new ArgumentException("Invalid character.");

            Alias = alias;
            _path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, Alias);
        }

        public void Load()
        {
            try
            {
                string text = File.ReadAllText(_path);

                int count = 0;
                int.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture.NumberFormat, out count);
                Count = count;
            }
            catch (FileNotFoundException)
            {
                Count = 0;
            }
        }

        public void Increment()
        {
            Count++;
        }

        public void Save()
        {
            File.WriteAllText(_path, Count.ToString(CultureInfo.InvariantCulture.NumberFormat));
        }
    }

    public class Program
    {
        static bool HandleException(Action action, IEnumerable<Type> exceptionsToHandle, Action<Exception> handler)
        {
            try
            {
                action();
                return true;
            }
            catch (Exception e)
            {
                if (exceptionsToHandle.Any(t => t.IsAssignableFrom(e.GetType())))
                {
                    handler(e);
                    return false;
                }
                throw;
            }
        }


        static void Main(string[] args)
        {
            const string YES_SYMBOLS = "YyДд";
            var exeptionTypes = new []
                { typeof(PathTooLongException),
                  typeof(UnauthorizedAccessException),
                  typeof(FileNotFoundException),
                  typeof(SecurityException),
                  typeof(IOException),
                };

            while (true)
            {
                Console.WriteLine("Введите имя счетчика:");
                string alias = Console.ReadLine();

                try
                {
                    var counter = new Counter(alias);

                    if(HandleException(counter.Load, exeptionTypes,
                        e => Console.WriteLine("Ошибка при получении значения счетчика." + Environment.NewLine + e.Message)))
                    {
                        Console.WriteLine("Текущее значение счетчика {0}: {1}.", counter.Alias, counter.Count);

                        counter.Increment();
                        
                        HandleException(counter.Save, exeptionTypes,
                        e => Console.WriteLine("Ошибка при сохранении нового значения счетчика." + Environment.NewLine + e.Message)))
                    }

                }
                catch (ArgumentException)
                {
                    Console.WriteLine("Некорректное имя счетчика (пояснение каким должно быть правильное имя).");
                }

                Console.WriteLine("Повторить?");

                if (!YES_SYMBOLS.Contains(Console.ReadLine()))
                    break;

                Console.Clear();
            }
        }
    }
}