Method overriding or interception

Question

In my project, I have many DLL assemblies referenced. One of those DLL's contains the bool method that I want to change. I do not have the original source for the DLL and using a Reflector to decompile a project seems impractical. All I want to do is intercept or override this method or method call so that I can change it's return value to match my own method outside of said DLL.

Any such way to do this? Thanks!

Edit:

Here is an example:

public virtual bool isOwner()
{
    return false;
}

Essentially, I just want to change getOwner to return true;

Answer 1

You can use "new" modifier. See example on http://msdn.microsoft.com/en-us/library/435f1dw2.aspx

Or this:

class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(new ClassA().IsEvenDayToday()); // Result: true 
            Console.WriteLine(new ClassB().IsEvenDayToday()); // Result: false

            Console.ReadKey();
        }
    }

    public class ClassA : ClassB
    {
        public new bool IsEvenDayToday()
        {
            return DateTime.Now.Day % 2 == 0;
        }
    }

    public class ClassB
    {
        public bool IsEvenDayToday()
        {
            return DateTime.Now.Day % 2 != 0;
        }
    }

Answer 2

If the class is public and the method is marked as virtual, then you can simply override it with this syntax:

public MyClass : TheClass
{
    public override ReturnType MethodName(Arguments)
    {
        //class the base class implementation if needed
        //base.MethodName(Arguments)

        //do your own stuff and return whatever is needed
    }
}

Hope this helps

EDIT: A word of caution though, this won't replace the calling code within the DLL. It will only work if you instantiate the derived class yourself and call it from your code.

Answer 3

Is there a general way to do what you want, built into .NET?

Yes, and no.

If you want every usage of class X' method Y to be replaced by some other code, then no, there is nothing built into .NET class system or compiler that will do this.

If you can inherit from class X, overriding method Y, and then ensure that all places where class X is used, your new class is used instead, then yes, that is the proper way to do this.

This is easily done:

public class YourFixedClass : TheProblematicClass
{
    public override string YourProblematicMethod()
    {
        // probably call the problematic method through base.
        // and fix the return value, or fix the parameters
        // or don't call it at all, re-doing whatever it does
    }
}

Or, if you can make a new class that implements all the same interfaces, wrapping (delegating) all the methods and properties of the original (problematic) class, then that might be doable, but this requires all actual usage of the class to go through the interfaces.

As this:

public class Wrapper : IInterface1, IInterface2
{
    private readonly YourProblematicClass _C;

    public Wrapper(YourProblematicClass c)
    {
        _C = c;
    }

    public string YourProblematicMetho()
    {

        // probably call the problematic method through _C.
        // and fix the return value, or fix the parameters
        // or don't call it at all, re-doing whatever it does
    }
}

If, on the other hand, you don't have control of where all the code is that calls the class/method, then no, you can't do any of this.

So what else is there? Well, there is always the debugger interfaces. You can make a program that is somehow the debugger of itself, patching in the right code upon demand, but this is likely to be extraordinary difficult to get right.

In short, no, there is no way to do what you want. You need to find a different way to accomplish this.

Have you thought about changing the original assembly in the first place? I understand that you don't have the source code for it, but is that because:

1. You lost it
2. You didn't make it

In point 1, I would really work towards recreating the source code, either through a decompiler or similar, and get a new project going to fix that.

In point 2, have you thought about contacting the people that made it and asking them for help?

Answer 4

Uhm Ok you can do something like this:

public class MyNameClass : MyDllname.MyClassName
{
      public bool isOwner()
      {
           return !base.isOwner();
      }
}

Then you have override the method and you can use all the other methods in the DLL simply using an istance(if there aren't static) of the MyNameClass