3

I am trying to achieve calling methods of the Base class and the Derived class. However, I am a little confused if I am doing it correctly. I would like to set values from the Base class and use them in the Derived class.

namespace Inheritance
{
    using System;

    public class BaseClass
    {
        public BaseClass() { }

        protected string methodName;
        protected int noOfTimes;
        public void Execute(string MethodName, int NoOfTimes)
        {
            this.methodName = MethodName;
            this.noOfTimes = NoOfTimes;
        }
    }

    public class DerivedClass : BaseClass
    {
        public DerivedClass() : base() { }

        public void Execute()
        {
            Console.WriteLine("Running {0}, {1} times", base.methodName, base.noOfTimes);
        }
    }

    public class Program
    {
        static void Main(string[] args)
        {
            DerivedClass d = new DerivedClass();
            d.Execute("Func", 2);
            d.Execute();

            Console.ReadLine();
        }
    }
}

Question: can I achieve the same as above using only 1 call to Execute instead of 2?

I hope my example above is clear. Please let me know if its otherwise and I will provide additional details.

Thanks

Improve this question
2
  • 1
    Do you want to call the Execute method in both the derived class and the base class by using a single call? Commented May 23, 2012 at 13:55
  • Ove: yes, that is what I was originally trying to do Commented May 23, 2012 at 14:08

4 Answers 4

Reset to default
8

Disclaimer, my answer assumes you wanted a solution revolving around inheritance of the method and it's implementation. Other answers provided are also good solutions to the question.

It sounds like you want to override a method in a derived class. To do this, the base class needs to mark the method virtual or abstract. However, in your case the derived class method signature is different. I will assume that this is an error in not understanding how it would work, so I have corrected it for you.

In this instance, the derived class marks the method with override, a C# keyword. I then call base.Execute(MethodName, NoOfTimes); as I want to use the base class's implementation in my overridden implementation. I then put in my own code.

base is another keyword that lets you access members in the base class immediately below the class you are in without having the inheritance chain push you back into derived members.

abstract is worth reading up on, but is not required in this case (it has different behaviour to virtual but also gets used in conjunction with override).

namespace Inheritance
{
    using System;

    public class Program
    {
        internal protected class BaseClass
        {
            public BaseClass() { }

            protected string methodName;
            protected int noOfTimes;
            public virtual void Execute(string MethodName, int NoOfTimes)
            {
                this.methodName = MethodName;
                this.noOfTimes = NoOfTimes;
            }
        }

        internal class DerivedClass : BaseClass
        {
            public DerivedClass() : base() { }

            public override void Execute(string MethodName, int NoOfTimes)
            {
                base.Execute(MethodName, NoOfTimes);
                Console.WriteLine("Running {0}, {1} times", base.methodName, base.noOfTimes);
            }
        }

        static void Main(string[] args)
        {
            DerivedClass d = new DerivedClass();
            d.Execute("Func", 2);

            Console.ReadLine();
        }
    }
}

There are a few code formatting and naming quirks with this sample, but I will leave this alone to stay as close to your original code as possible.

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

4 Comments

thank you Adam. that's what i was looking for. i will mark your answer as the accepted solution in 8 minutes :)
Adam: i read the disclaimer. originally, this is the answer i was looking for. your answer is what cleared the concept of having "same signature". i am using the template pattern as suggested by Heinzi. i need to locate a reference with such design patterns. they are incredibly useful.
@Vicky Almost all patterns worth looking into are detailed by these guys.
@Vicky Bah! Wrong link, a random band isn't responsible for the large number of good design patterns in modern programming. These guys are, however.
4

This would be an ideal candidate for the template method pattern. Instead of overriding Execute, the base class calls a method doWork which must be supplied by a derived class. That way, you cannot forget to call base.Execute and you can do stuff in the base class before and after the call to doWork.

abstract class BaseClass 
{ 
    public BaseClass() { } 

    protected string methodName; 
    protected int noOfTimes; 
    public void Execute(string MethodName, int NoOfTimes) 
    { 
        this.methodName = MethodName; 
        this.noOfTimes = NoOfTimes;
        doWork();
    } 

    protected abstract void doWork(); // will be provided by derived classes
} 

class DerivedClass : BaseClass 
{ 
    public DerivedClass() : base() { } 

    protected override void doWork()
    {
        Console.WriteLine("Running {0}, {1} times", this.methodName, this.noOfTimes); 
    } 
} 

public class Program   
{   
    static void Main(string[] args) 
    { 
        DerivedClass d = new DerivedClass(); 
        d.Execute("Func", 2); 

        Console.ReadLine(); 
    } 
}

EDIT: As Adam correctly points out in the comments (thanks), it is not necessary to make the base class abstract (it's just convenient, if you don't need to instantiate the base class, since it creates a compile-time error if a subclass does not provide an implementation for doWork). Alternatively, you could specify a default behaviour in the base class:

class BaseClass 
{ 
    public BaseClass() { } 

    protected string methodName; 
    protected int noOfTimes; 
    public void Execute(string MethodName, int NoOfTimes) 
    { 
        this.methodName = MethodName; 
        this.noOfTimes = NoOfTimes;
        doWork();
    } 

    protected virtual void doWork() {
        // default behaviour, can be modified by subclasses
    }
}
Improve this answer

7 Comments

wow, thanks for the great advise. in fact, i had multiple classes that use the base class and this technique will prove to be extremely useful.
I would think that Execute shouldn't be virtual in a model like this.
It is worth pointing out that the template pattern does not rely on the use of abstract, you can easily make a virtual void method that is simply empty as a default (thereby not forcing derived classes to implement the doWork if they don't need it). But +1 for the template pattern.
@Vicky Main needs to be inside of a class; it can't be just in a namespace.
@Vicky: I had a few modifiers too much in my sample. Just replace the "... (abstract) class" with simply "(abstract) class". (I changed it in my answer.)
|
1

Also, you do not need to explicitly call the default constructor in this case.

public DerivedClass() : base() { }

it is sufficient to define it like

public DerivedClass() { }

The base constructor will automatically be called before the derived one.

As for the original question I agree to Adam, he was just quicker to finish his answer. :)

Improve this answer

1 Comment

You're absolutely right @Servy, and I was thinking if I should mention it. I eventually decided that I wanted to stay close to the original question for the sake of simplicity. :-)
1

First of all, in a derived class you can access all the methods, variables and properties defined as public or protected in the base class. This means that there is no need to use base.methodName in the derived class.

base is used (instead of the usually implicit this) to access the version of a method/property defined in the base class instead of its redefinition in the derived class. It's not the case here.

Furthermore, in your case you are defining Execute with different signatures (i.e. different number and/or type of the parameters) in the base and derived class. This means that you must call them separately, since they are different.

You can use virtual and override like pointed out by Adam only if you define the version in the derived class with exactly the same parameters, even if they aren't used by that version. BTW, here you use base since you want to call the version of Execute defined in the base class.

Improve this answer

2 Comments

Your first line is not correct. Private members or internal members when derived across assemblies will not be accessible at all. Just FYI I'm not the downvoter, the remainder of your answer is entirely correct so far as I can see.
I forgot to add the ones marked as public or protected, of course.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.