static void Rethrow(Exception ex)
{
    if (ex == null)
    {
        return;
    }

    if (ex.GetType().IsSerializable)
    {
        BinaryFormatter formatter = new BinaryFormatter(null, new StreamingContext(StreamingContextStates.CrossAppDomain));
        MemoryStream stream = new MemoryStream();
        formatter.Serialize(stream, ex);
        stream.Position = 0;

        throw (Exception)formatter.Deserialize(stream);
    }
            
    FieldInfo remoteStackTraceString = typeof(Exception).GetField("_remoteStackTraceString", BindingFlags.Instance | BindingFlags.NonPublic);
    remoteStackTraceString.SetValue(ex, ex.StackTrace + Environment.NewLine);

    throw ex;
}

void DoAnything()
  { 
    Trace(()=>{
      Trace(()=>DoAction1());
      Trace(()=>DoAction2());
      Trace(()=>DoAction3());
    });
  }

S>Слабое утешение... Потом код читать сложно...

        public bool IsNeedToPayBonus(Context context)
        {
            if (context == null)
            {
                Warning("Я имел в виду что тут контекст всегда задан");
                return;
            }

            if (context.CurrentOrder == null)
            {
                Warning("Я имел в виду что тут у контекста есть ордер");
                return;
            }

            return context.CurrentOrder.Price > 1000;
        }

        public bool IsNeedToPayBonus(Context context)
        {
            //...
            if (context.CurrentOrder.IsPremium)
            {
                Trace("Используется алгоритм премиального рассчета");
                return context.CurrentOrder.Price > 100;
            }
            else
            {
                Trace("Используется алгоритм обычного рассчета");
                return context.CurrentOrder.Price > 1000;
            }            
        }

        public bool IsNeedToPayBonus(Context context)
        {
            try
            {
                //...
            }
            catch (Exception e)
            {
                Error(e.Message + e.StackTrace);
                throw;
            }
        }

        public bool IsNeedToPayBonus(Context context)
        {    
            //...
            Save(context.CurrentOrder);
            Trace("Сохранил в базу ордер {0}. Цена - {1}", context.CurrentOrder.Id, context.CurrentOrder.Price);
            //...
        }

try
{
    // some logic here
}
catch
{
    // Simply re-throwing all exceptions
    // in order to show that the base class catches the exceptions and
    // fails appropriately.
    throw;
}

 1: class Program
 2: {
 3:    static void f(bool b)
 4:    {
 5:        if (b)
 6:            throw new ApplicationException();
 7:    }
 8:
 9:    static void RunTest()
10:    {
11:        try
12:        {
13:            f(false);
14:            f(true);
15:            f(false);
16:        }
17:        catch
18:        {
19:            throw;
20:        }
21:    }
22:    
23:    static void Main(string[] args)
24:    {
25:        try
26:        {
27:            RunTest();
28:        }
29:        catch (Exception e)
30:        {
31:            string s = e.ToString();
32:        }
33:    }
34: }

try
{
    // some logic here
}
catch (Exception e)
{
    throw e;
}

 1: class Program
 2: {
 3:    static void f(bool b)
 4:    {
 5:        if (b)
 6:            throw new ApplicationException();
 7:    }
 8:
 9:    static void RunTest()
10:    {
11:        try
12:        {
13:            f(false);
14:            f(true);
15:            f(false);
16:        }
17:        catch
18:        {
19:            throw e;
20:        }
21:    }
22:    
23:    static void Main(string[] args)
24:    {
25:        try
26:        {
27:            RunTest();
28:        }
29:        catch (Exception e)
30:        {
31:            string s = e.ToString();
32:        }
33:    }
34: }

try
{
    // some logic here
}
catch (SomeException e)
{
    // log some more info here
    throw new SomeException("descriptive message", e);
}

void DoAnything()
  { 
    Trace(()=>{
      Trace(()=>DoAction1());
      DoAction2();
      Trace(()=>DoAction3());
    });
  }

AN>        public bool IsNeedToPayBonus(Context context)
AN>        {
AN>            try
AN>            {
AN>                //...
AN>            }
AN>            catch (Exception e)
AN>            {
AN>                Error(e.Message + e.StackTrace);
AN>                throw;
AN>            }
AN>        }
AN>

class MyClass
{
  ILogger _logger;
  ...
  void DoAnything()
  {
    _logger.Info("Начато выполнение действия...");

    _logger.Info("Выполняется DoAction1...");
    DoAction1();
    _logger.Info("DoAction1 выполнено успешно");

    _logger.Info("Выполняется DoAction2...");
    DoAction2();
    _logger.Info("DoAction2 выполнено успешно");

    _logger.Info("Выполняется DoAction3...");
    DoAction3();
    _logger.Info("DoAction3 выполнено успешно")

    _logger.Info("Действие выполнено успешно");
  }
  void DoAction1()
  { ... }
  void DoAction2()
  { ... }
  void DoAction3()
  { ... }
}

class MyClass
{
  ILogger _logger;
  ...
  void DoAnything()
  {
    _logger.Info("Начато выполнение действия...");

    DoAction1();
    DoAction2();
    DoAction3();

    _logger.Info("Действие выполнено успешно");
  }
  void DoAction1()
  {
    _logger.Info("Выполняется DoAction2...");
    ...
    _logger.Info("DoAction1 выполнено успешно");
  }
  void DoAction2()
  {
    _logger.Info("Выполняется DoAction2...");
    ...
    _logger.Info("DoAction1 выполнено успешно");
  }
  void DoAction3()
  {
    _logger.Info("Выполняется DoAction3...");
    ...
    _logger.Info("DoAction3 выполнено успешно");
  }
}

a> try
a> {
a>     // some logic here
a> }
a> catch
a> {
Кстати, именно здесь и был лог, насколько я помню, в предыдущем примере
a>     // Simply re-throwing all exceptions
a>     // in order to show that the base class catches the exceptions and
a>     // fails appropriately.
a>     throw;
a> }
a>

try
{
 ...
}
catch
{
  // по барабану
}

a>  1: class Program
a>  2: {
a>  3:    static void f(bool b)
a>  4:    {
a>  5:        if (b)
a>  6:            throw new ApplicationException();
Давайте всегда и везде кидать просто ApplicationException :)
a>  7:    }
...
a>

a> try
a> {
a>     // some logic here
a> }
a> catch (SomeException e)
a> {
a>     // log some more info here
a>     throw new SomeException("descriptive message", e);
a> }
a>

        public bool IsNeedToPayBonus(Context context)
        {
            try
            {
                //...
            }
            catch (Exception e)
            {
                Error(e.Message + e.StackTrace);
                throw;
            }
        }

if (a())
{
 return b();
}