Run a method before all methods of a class

Question

Is it possible to do that in C# 3 or 4? Maybe with some reflection?

class Magic
{

    [RunBeforeAll]
    public void BaseMethod()
    {
    }

    //runs BaseMethod before being executed
    public void Method1()
    {
    }

    //runs BaseMethod before being executed
    public void Method2()
    {
    }
}

EDIT

There is an alternate solution for this, make Magic a singleton and put your code on the getter of the static instance. That's what I did:

public class Magic
{

    private static Magic magic = new Magic();
    public static Magic Instance
    {
        get
        {
            magic.BaseMethod();
            return magic;
        }
    }

    public void BaseMethod()
    {
    }

    //runs BaseMethod before being executed
    public void Method1()
    {
    }

    //runs BaseMethod before being executed
    public void Method2()
    {
    }
}

Answer 1

You can't do this automatically in C# - you should probably be looking at AOP, e.g. with PostSharp.

Answer 2

There is an alternate solution for this, make Magic a singleton and put your code on the getter of the static instance. That's what i did.

public class Magic{

private static Magic magic;
public static Magic Instance{
  get
    {
   BaseMethod();
    return magic;
    }
}

public void BaseMethod(){
}

//runs BaseMethod before being executed
public void Method1(){
}

//runs BaseMethod before being executed
public void Method2(){
}
}

Answer 3

I know it won't answer the question directly. But it's a good approach to use a decorator pattern to solve this problem to make your implementation stay clean.

Create an interface

public interface IMagic
{


    public void Method1()
    {
    }


    public void Method2()
    {
    }
}

Create implementation

public class Magic : IMagic
{

    public void Method1()
    {
    }


    public void Method2()
    {
    }
}

Create Decorator

public class MagicDecorator : IMagic
{
   private IMagic _magic;
   public MagicDecorator(IMagic magic)
   {
       _magic = magic;
   }

   private void BaseMethod()
   {
       // do something important
   }

    public void Method1()
    {
         BaseMethod();
         _magic.Method1();
    }


    public void Method2()
    {
        BaseMethod();
        _magic.Method2();
    }
}

Usage

var magic = new MagicDecorator(new Magic());
magic.Method1();
magic.Method2();

Answer 4

What you want can be done with AOP - some links to .NET C# AOP frameworks:

• http://www.postsharp.org/
• http://www.castleproject.org/dynamicproxy/index.html
• http://www.springframework.net/docs/1.2.0-M1/reference/html/aop.html

Answer 5

If you use a dependency injection framework, to generate the instance, then you can use interceptors for method calls.

public class CallLogger : IInterceptor
{
    TextWriter _output;

    public CallLogger(TextWriter output)
    {
        _output = output;
    }

    public void Intercept(IInvocation invocation)
    {
        _output.Write("Calling method {0} with parameters {1}... ",
        invocation.Method.Name,
        string.Join(", ", invocation.Arguments.Select(a => (a ?? "").ToString()).ToArray()));

        invocation.Proceed();

        _output.WriteLine("Done: result was {0}.", invocation.ReturnValue);
    }
}

You can check autofac's documentation and sample for more info. https://autofaccn.readthedocs.io/en/latest/advanced/interceptors.html

Answer 6

Just to make a thing clear why the following implementation won't work:

public class Magic{

private static Magic magic = new Magic();
public static Magic Instance{
  get
    {
   magic.BaseMethod();
    return magic;
    }
}

public void BaseMethod(){
}

//runs BaseMethod before being executed
public void Method1(){
}

//runs BaseMethod before being executed
public void Method2(){
}
}

in the case you just want to hold a Magic object, the method will be randomly called:

Magic m = Magic.Instance; //this will trigger unwanted call on BaseMethod

and also if one will want to call the BaseMethod, it will be called twice:

Magic.Instance.BaseMethod(); //two calls of the BaseMethod

which of course have a workaround, to return unwanted objects using get:

var unused = Magic.Instance;

Only to summarize: This is not possible (at least yet) in C#.

Answer 7

Yes, you can! with a static constructor, it will run once before the class is referenced and you can do what you like in it.

Like this:

public class Magic{

static Magic()
{
    BaseMethod();
}

public void BaseMethod(){
}

//runs BaseMethod before being executed
public void Method1(){
}

//runs BaseMethod before being executed
public void Method2(){
}
}

Here's the Microsoft doc:

https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/static-constructors

Answer 8

Use https://github.com/Fody/Fody . The licencing model is based on voluntary contributions making it the better option to PostSharp which is a bit expensive for my taste.

[module: Interceptor]
namespace GenericLogging
{

[AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Assembly | AttributeTargets.Module)]
    public class InterceptorAttribute : Attribute, IMethodDecorator
    {
        // instance, method and args can be captured here and stored in attribute instance fields
        // for future usage in OnEntry/OnExit/OnException
        public void Init(object instance, MethodBase method, object[] args)
        {
            Console.WriteLine(string.Format("Init: {0} [{1}]", method.DeclaringType.FullName + "." + method.Name, args.Length));
        }

        public void OnEntry()
        {
            Console.WriteLine("OnEntry");
        }

        public void OnExit()
        {
            Console.WriteLine("OnExit");
        }

        public void OnException(Exception exception)
        {
            Console.WriteLine(string.Format("OnException: {0}: {1}", exception.GetType(), exception.Message));
        }
    }

    public class Sample
    {
        [Interceptor]
        public void Method(int test)
        {
            Console.WriteLine("Your Code");
        }
    }
}

[TestMethod]
public void TestMethod2()
{
    Sample t = new Sample();
    t.Method(1);
}

Answer 9

I've recently had cause to do this. I'll spare you the probably boring details of my use-case, except to state that I want the method DoThisFirst to run before the specific method I'm calling. Still learning C# so probably not the best way to do it...

using System;

namespace ConsoleApp1
{
    class Class1
    {
        public enum MethodToCall
        {
            Method2,
            Method3
        }

        public delegate void MyDelegate(int number = 0, bool doThis = false, double longitude = 32.11);

        public static void DoThisFirst(int number, bool doThis, double longitude)
        {
            Console.WriteLine("DoThisFirst has been called.");
        }

        public static void DoSomethingElse(int number, bool doThis, double longitude)
        {
            Console.WriteLine("DoSomethingElse has been called.");
        }

        public static void DoAnotherThing(int number, bool doThis, double longitude)
        {
            Console.WriteLine("DoAnotherThing has been called.");
        }

        public static void Main()
        {
            void Action(MethodToCall methodToCall)
            {
                MyDelegate myDel;

                myDel = new MyDelegate(DoThisFirst);

                switch (methodToCall)
                {
                    case MethodToCall.Method2:
                        myDel += DoSomethingElse;
                        break;
                    case MethodToCall.Method3:
                        myDel += DoAnotherThing;
                        break;
                }

                myDel.Invoke();
            }

            Action(MethodToCall.Method3);

            Console.ReadKey();
        }
    }
}