How to call a method implicitly after every method call?

Question

Sorry for the terrific Title for the post. I am bit curious to know if below problem does have any solutions or not. The situation is I have a function called SaveSecurity(); which I need to call after every function. Like below:

public void AddUser(string ID, string Name, string Password)
{
    ///some codes
    SaveSecurity();
}
public void DeleteUser(User ObjUser)
{
    ///some codes
    SaveSecurity();
}
public void AddPermission(string ID, string Name, AccessType Access)
{
    ///some codes
    SaveSecurity();
}
public void DeletePermission(Permission ObjPermission)
{
    ///some codes
    SaveSecurity();
}
public void AddRole(string ID, string Name)
{
    Roles.AddRole(ID, Name);
    SaveSecurity();
}
public void SaveSecurity()
{
    ///Saves the data
}

And many more. So now if we look there is a similarity to all the function is that at last it calls for the SaveSecurity() after the end of the function. My question is:

Is there a way to call this function after every function with out writing the same line again and again?

My Class Diagram looks like this

Answer 1

You need to look into repository pattern,

Seperate your classes and there operations,

Create another layer (call it business layer) or whatever which will be calling different methods of different classes...

ATM you are trying to follow OOP but all you are doing is functional programming..

Implementing the Repository and Unit of Work Patterns in an ASP.NET MVC Application

Edit After adding class diagram

Your collection classes are actually repository class, you will need to move your methods like deletePermissions, deleteRole to there respective repository classes like permissionsRepo (keep it named as collections if you want) and roleRepo..

So you already have an object class and a repository class of object (can be together) but I like to keep them separate, repostory classes will do what they need to do, like..

// Make changes to DB
// Make changes to AD
// Makes changes to web services etc...

Your manager class may dulicate methods of repository classes but they will only calling them,

PermissionManager.DeletePermissions(PermissionObject);

Then in PermissionManager Class you will have method,

DeletePermissions(Permissions pObject)
{
     PermissionRepo.Delete(pObject);
}

Above is just adding a layer to make your code look more readable and future proof in very short time, but if you have more time to invest you can look into Observer pattern too...

Implement Observer pattern in C#

Each time your object changes it's state you can call SaveSecurity method (which will be in another class (Name it Changes maybe). If you don't want to call SaveSecurity for each change of object, you can add a property to your object e.g. IsSecurityChanged ? if yes then call SaveSecurity.

More to explain but if you look at Observer pattern above you will get an idea.

One more way but I won't personally recommend is, to use IDisposable interface, then in dispose method call SaveSecurity method for the object. BUT ITS NOT RECOMMENDED BY ME.

Answer 2

With just C# you can't, but there are some solutions that might help.

The best I know is PostSharp. It will give you the ability to define actions before and after a method is being called (for example). Some information on it can be found here and here.

The only thing you have to do then is to decorate the methods you want to call SaveSecurity for with an attribute.

If you don't want to use such tools, just keep it as is. It is okay the way it is.

Answer 3

You can use some kind of Aspect oriented programming (don't know how to do it in C#, but try googling it).

Another way that would not be better than simply calling one function at the end of another, would be create helper function with functional parameter that execute its parameter and then call your security function. But then body of each function would look something like (if I remember C# lambda correctly):

CallAndSaveSecurity(() => /* some code */);

So it would contain something extra as much as your original solution.

Btw, maybe you need more in your call anyway. If you want that function to be called even when exception happen, you need

try{
  // some code
} finally {
  SaveSecurity();
}

and hiding that into functional helper makes sense.

Answer 4

using System;

namespace Shweta.Question
{
   public class User
   { }
   public class Permission
   { }

   public enum AccessType
   {
      none,
      full,
      other
   }

   public class Roles
   {
      public static void AddRole(string id, string name)
      {
      }
   }

   public class Shweta
   {
      public void AddUser(string ID, string Name, string Password)
      {
         ///some codes
         SaveSecurity();
      }
      public void DeleteUser(User ObjUser)
      {

      }
      public void AddPermission(string ID, string Name, AccessType Access)
      {

      }
      public void DeletePermission(Permission ObjPermission)
      {

      }
      public void AddRole(string ID, string Name)
      {
         Roles.AddRole(ID, Name);
      }
      public void SaveSecurity()
      {
         ///Saves the data
      }

      public TResult CallMethod<TResult>(Func<TResult> func)
      {
         try
         {
            return func();
         }
         catch (Exception e)
         {
            // Add Handle Exception

            // replace the next line by exception handler
            throw e;
         }
      }

      public void CallMethod(Action method)
      {
         this.CallMethod(() => { method(); return 0; });

         this.SaveSecurity();
      }

      public static void test()
      {
         var s = new Shweta();
         s.CallMethod(() => s.AddRole("theId", "theName"));
         s.CallMethod(() => s.DeleteUser(new User()));
         s.CallMethod(() => s.AddPermission("theId", "theName", AccessType.full));
         s.CallMethod(() => s.DeletePermission(new Permission()));
         s.CallMethod(() => s.AddRole("theId", "theName"));
      }
   }
}