Question

I have a class

public class MyService  
{  
   public IList<Exception> ExList {get; private set;}

   public bool HasErrors { get { return ExList.Count > 0; } }

   public MyMethod()
   {
       ExList.Clear();
       //- do some logic ---
   }

}

And I want to call MyMethod() and check if errors was occured. Something like this

var service = new MyService();

service.MyMethod();

if(service.HasErrors)
{
    // - do some logic
}

service.MyMethod();

if(service.HasErrors)
{
    // - do some logic
}

But I have to write “ExList.Clear();” row manualy for every method in MyService class.
And the question is – Are any solution to avoid this?

I need something like

public class MyService  
{  
   public IList<Exception> ExList {get; private set;}

   public bool HasErrors { get { return ExList.Count > 0; } }

   private void Precondition()
   {
       ExList.Clear();
   }

   public MyMethod()
   {           
       //- do some logic ---
   }

}

And Precondition() would be invoked automatically for each method’s call.

Answer 1

Another tool you could look into is PostSharp. PostSharp is an AOP frawework that allows you to define custom aspects (attributes).

You’ll be interested in OnMethodBoundaryAspect. Something like below should do the trick. args.Instance will be “the instance on which the method is being executed”

public class ClearListPrecondition : OnMethodBoundaryAspect
{
    public override void OnEntry(MethodExecutionArgs args)
    {
        MyService service = args.Instance as MyService;
        if (service == null)
        {
            throw new InvalidOperationException(
              "This aspect can only execute on types of MyService");
        }

        service.ExList.Clear();
        base.OnEntry(args);
    }
}

You would then decorate your service methods with this aspect:

[ClearListPrecondition]
public void MyMethod()
{
}

If you choose to take the path of AOP for such a trivial task, I strongly recommend you re-thinking your design.

Firstly, throwing exceptions should be preferred, but if you insist, you could return a result from your method.

E.g.

public MethodResult MyMethod()
{
    ....
     if(errorHasOccured)
     {
          return new MethodResult() {Exceptions = exception};
     }
    ....
     return new MethodResult() {ResultOfMethod = ...};
}

public class MethodResult
{
   public IList<Exception> Exceptions {get; set;}
   public bool HasErrors { get { return ExList.Count > 0; } } 
   public string ResultOfMethod {get;set;}

}

Your consumers can check the result of a method call:

var service = new MyService();

var result1 = service.MyMethod();

if(result1.HasErrors)
{
    // - do some logic
}

var result2 = service.MyMethod();

if(result2.HasErrors) 
{
    // - do some logic
}

This removes the need to reset the state of your service as it becomes stateless (and therefore threadsafe)