Question

I would like to provide encapsulation of actions/methods generically. I think this should be possible in C# but I’m not able to produce it so it compiles…

The following briefly demonstrates what I want. Is this possible somehow, perhaps by generalizing the class?

Required is:

• I want to execute the function/action (see method type) and ‘do something’ when an error occurs
• I want to return the value of the function if the method is a function (otherwise return void if possible)

• I want to ‘do something’ if the return type of the function is a boolean and the value is false.

  public class Encapsulator {
      private Action _action;
      private Func<T> _function;
      private MethodType _type; //Action || Function
  
      public Encapsulator(Action action) {
          this._action = action;
          this._type = MethodType.Action;
      }
      public Encapsulator(Func<T> func) { //This is not accepted
          this._function = func;
          this._type = MethodType.Function;        
      }
  
      public void Execute() {
          try {
              this._action();
          }
          catch(Exception ex) {
              //do something
              throw;
          }
      }
  
      public T Execute<T>() {
          try {
              var r = this._function();
  
              if(typeof(r) == bool) {
                  if(!r)
                    //do something
              }
  
              return r;
  
          } catch(Exception ex) {
              //do something
              throw;
          }
      }
  }
  

Answer 1

New Approach: The action Encapsulator will now return a dummy result (always true).

public class Encapsulator
{
    public static Encapsulator<bool> CreateEncapsulator(Action action)
    {
        return new Encapsulator<bool>(() =>
            {
                action();
                return true;
            });
    }

    public static Encapsulator<T> CreateEncapsulator<T>(Func<T> func)
    {
        return new Encapsulator<T>(func);
    }
}

public class Encapsulator<T>
{
    private Func<T> _function;

    internal Encapsulator(Func<T> func)
    {
        this._function = func;
    }

    public T Execute()
    {
        try
        {
            object res = this._function();
            Nullable<bool> bres = res as Nullable<bool>;

            if (bres.HasValue)
            {
                if (!bres.Value)
                    Console.WriteLine("NOT TRUE!");
                //do something
            }

            return (T)res;

        }
        catch (Exception ex)
        {
            //do something
            throw;
        }
    }
}

Calling the code:

var withDummyReturn = Encapsulator.CreateEncapsulator(() => Console.WriteLine("Great"));
withDummyReturn.Execute();
var withReturn = Encapsulator.CreateEncapsulator<bool>(() => true);
bool res = withReturn.Execute();