Replacing a class implementation in C#

Question

Can I replace (or override) a class definition with one of my own implementation?

Explanation:

I have a class with a System.Random instance, and I am trying to test it without modifying its original code...
So I am planning to replace Random class with one of my own implementation, that allows controlling generated sequence.. Please see this question.

`

class foo
{
    Random r=new Random();
    double bar()
    {
         double ans=r.NextDouble();
         .....// evaluate ans
         return ans;
    }
}

`

What are the possible ways that I can replace implementation of Random class with another one without changing (or with minimum changes) the original code file??

Edit:
One solution is to inherit Random class and modify it... but that requires changing each Random instance with the inherited one... I do not want to modify the code, because I am just testing it!!
Edit 2:
Can I say in C#: "Each Random class in this file is MyNamespace.Random not System.Random" ??

Can you clarify? Do you want to just replace some if it's members? Do you want to extend it to add new ones? — CodingGorilla
– CodingGorilla, Commented Nov 18, 2010 at 21:16
I am concerned to add a function setNextSequence(double []) to this Random class, so that before calling NextDouble() I set the random numbers to be generated using this function... But I do not want to edit the original code as I am just testing it..!! — Betamoo
– Betamoo, Commented Nov 18, 2010 at 21:19
Wouldn't be great if we could force the CLR types to adhere to interfaces that we specify based on existing methods only. Such that we could force a IRandom { double NextDouble(); } interface into the System.Random type and abstract it in our code. — John Alexiou
– John Alexiou, Commented Nov 18, 2010 at 21:36

Lee · Accepted Answer · 2010-11-18 21:25:02Z

5

EDIT: As ChaosPandion points out, to test the logic in the method it would be better to take a double parameter i.e. double bar(double input) { ... }, but if you have a reason to need to inject your own source of randoms, you could use one of these approaches:

You could modify bar to take a Func<double> to obtain values from:

double bar(Func<double> source)
{
    double ans = source();
    //evaluate ans
    return ans;
}

Then you can inject your own implementation for testing, and in the main program use:

Random r = new Random();
double ans = bar(r.NextDouble);

Alternatively you could create your own IRandom interface and then implement a wrapper around the real Random class and use mocks for testing:

interface IRandom
{
    double Next();
}

public class RandomWrapper : IRandom
{
    private Random r = new Random();
    public double Next()
    {
        return this.r.NextDouble();
    }
}

edited Nov 18, 2010 at 21:25

answered Nov 18, 2010 at 21:19

Lee

145k20 gold badges243 silver badges292 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

ChaosPandion Over a year ago

I up-voted you but I just need to ask, why not take a double as a parameter?

Matt Brunell · Accepted Answer · 2010-11-19 21:49:39Z

3

You can do this and no code changes to the source are necessary.

You can use reflection to inject a mock or derived instance.

Since System.Random is not sealed, your best bet here is to derive a new class, and then you only need to override the desired methods.

I'm assuming that you are using some type of unit testing framework, so the example below is for that.

In your unit test file, do this:

class MyRandom : System.Random 
{
     public override double NextDouble()
     {     
          // return your fake random double here.
     }
}


class TestFixture 
{
     public void UnitTest()
     {
          // Create the unit under test
          foo unit = new foo();

          // use reflection to inject a mock instance
          typeof(foo)
             .GetField("r", BindingFlags.Instance | BindingFlags.NonPublic)
             .SetValue(unit, new MyRandom());

          // ACT: call method
          var result = foo.bar();

          // examine results
      }
 }

answered Nov 19, 2010 at 21:49

Matt Brunell

10.4k3 gold badges37 silver badges46 bronze badges

4 Comments

Betamoo Over a year ago

Wow.. that is nearly what I need... I wonder if this will work on private fields??

Matt Brunell Over a year ago

Yeah, no problem. It depends on how you specify the BindingFlags.

paulm Over a year ago

Will this work everywhere - i.e if I create a class instance of something in the .NET framework and it uses new Random() it will get an instance of MyRandom?

Matt Brunell Over a year ago

Depends on how it is used. If a class's field is set to an instance of new Random(), that can be replaced via reflection. If a new Random() is created within a method, that cannot be replaced.

Brian Dukes · Accepted Answer · 2010-11-18 21:26:55Z

2

I believe that you can replace the implementation of a class like Random using tools such as JustMock or TypeMock.

However, without restructuring your original code to use dependency injection (or otherwise insert a layer of abstraction) you won't be able to do what you're asking using plain C#. That said, restructuring your code to get rid of hard dependencies makes the code cleaner and simpler, so I would say that it should be the preferred route unless you're really unable to perform the necessary restructuring.

answered Nov 18, 2010 at 21:26

Brian Dukes

157k25 gold badges152 silver badges176 bronze badges

Comments

AK. · Accepted Answer · 2010-11-18 21:55:49Z

1

You could derive a class from System.Random and override its methods.

class PseudoRandom : System.Random
{
    public override int Next () {...}
    public override int Next (int maxValue) {...}
    public override int Next (int minValue, int maxValue) {...}
    public override void NextBytes (byte [] buffer) {...}
    public override double NextDouble () {...}
}

Use this class to instantiate from Main.

Random random = new PseudoRandom ();

If you need to determine later on whether you are using the system class or your own derived version, you can check that using the "is" operator. (Probably not the best design, but it's quick and easy)

// We need to see which class we're working with
if (random is PseudoRandom)
{
    // Using our custom class
}
else
{
    // Using default System.Random class
}

edited Nov 18, 2010 at 21:55

answered Nov 18, 2010 at 21:27

AK.

7637 silver badges14 bronze badges

2 Comments

Betamoo Over a year ago

Good idea.. but Can I say in C#: "Each Random class in this file is MyNamespace.Random not System.Random" ??

AK. Over a year ago

Yes, check with the is operator. Updated response.

Stephan · Accepted Answer · 2010-11-18 21:18:15Z

-1

Take a look into using Dependency Injection. It is designed for exactly this circumstance. There are several different DI/IoC frameworks for c#.

Unity and Ninject are both good but there are many others.

answered Nov 18, 2010 at 21:18

Stephan

5,4883 gold badges25 silver badges31 bronze badges

Comments

quentin-starin · Accepted Answer · 2010-11-18 21:19:32Z

-1

You need to add a layer of abstraction.

Create an interface that defines the contract you need your Random classes to support.

Create implementations of that interface, one of which should utilize the original Random class, the other would be your "random" implementation.

Provide the correct implementation when and where needed.

answered Nov 18, 2010 at 21:19

quentin-starin

26.9k7 gold badges70 silver badges87 bronze badges

Collectives™ on Stack Overflow

Replacing a class implementation in C#

6 Answers 6

1 Comment

4 Comments

Comments

2 Comments

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

6 Answers 6

1 Comment

4 Comments

Comments

2 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related