I have a method Hello in class A, which should be overridden by class B.
Therefore the overridden method in B has to call the base method to prepare something.
The method DoSomeThing is the additional functionality of this method. Now I want to override B.Hello in the new class C in order to change logic of B.DoSomeThing.
Requirements:
C.Hello needs the method call of A.Hello, too, in order to do some basic preparations
Only B.DoSomeThing should be replaced width new functionality, defined in C.DoSomeThing2
I am not allowed to change code inside A and B
public class A
{
protected virtual void Hello() {}
}
public class B : A
{
protected override void Hello() {
base.Hello();
DoSomeThing();
}
}
public class C : B
{
protected override void Hello() {
???????????????
DoSomeThing2();
}
}
I cannot call the base method of class A. What would be the best solution for my problem?
Simply copy and paste the code of A.Hello wouldn't work because of private methods in A.
EDIT: class C has to inherit from class B.
Related
We have the following code:
public class A
{
protected virtual void Method()
{
Console.Write("A");
}
}
public class B : A
{
protected override void Method()
{
Console.Write("B");
}
}
public class C : B
{
public void Some()
{
//How to call Method() from class A?
}
}
How to call Method() from class A in Some() method from class C?
We will assume that A and B are classes from the library and we can not change them.
Solution: https://stackoverflow.com/a/438952/8081796
B overrides Method() and A its marked as virtual and protected, the only way to call it (in its current format) is if B calls it somehow
public class B : A
{
protected override void Method()
{
base.Method();
Console.Write("B");
}
}
Or derived from A directly
public class C : A
{
public void Some()
{
Method();
}
}
virtual (C# Reference) | Microsoft Docs
The virtual keyword is used to modify a method, property, indexer, or
event declaration and allow for it to be overridden in a derived
class. For example, this method can be overridden by any class that
inherits it:
Furthermore
When a virtual method is invoked, the run-time type of the object is
checked for an overriding member. The overriding member in the most
derived class is called, which might be the original member, if no
derived class has overridden the member.
protected (C# Reference)
A protected member is accessible within its class and by derived class
instances.
If you really want Method of A to be called here (without changing implementation of A or B's Method), you have to make below changes.
Change access specifier of Method of B class to new from override.
override will override the base class method. Making it new won't do it.
Change access specifier of A and B class Methods to public instead of protected
protected members of A won't be accessible inside your C class.
With this changes, check out below code. You will see that Method from class A is getting called.
static void Main()
{
var c = new C();
c.Some();
Console.ReadKey();
}
public class A
{
public virtual void Method()
{
Console.Write("A");
}
}
public class B : A
{
public new void Method()
{
Console.Write("B");
}
}
public class C : B
{
public void Some()
{
//How to call Method() from class A?
((A)this).Method();
}
}
If you cannot make the changes described as above, then I'm afraid you can't call A's Method :O .
This is impossible, because
The implementation of a virtual member can be changed by an overriding
member in a derived class.
B change implementation of A, therefore C have only B implementation as base and have not implementation of A.
Solution: https://stackoverflow.com/a/438952/8081796
In C# it's possible to mark a virtual method abstract to force inherited class to implement it.
class A
{
public virtual void Method()
{
Console.WriteLine("A method call");
}
}
abstract class B : A
{
// Class inherited from B are forced to implement Method.
public abstract override void Method();
}
I would like to call the A implementation of Method from a class inherited from B.
class C : B
{
public override void Method()
{
// I would like to call A implementation of Method like this:
// base.base.Method();
}
}
The best way I find to do this is to add a protected method "MethodCore" in A implementation and call it when needed.
class A
{
public virtual void Method()
{
MethodCore();
}
protected void MethodCore()
{
Console.WriteLine("A method call");
}
}
abstract class B : A
{
public abstract override void Method();
}
class C : B
{
public override void Method()
{
MethodCore();
}
}
Is there any other way to do this ?
The best way I find to do this is to add a protected method "MethodCore" in A implementation and call it when needed.
Yes. Since you can't call an abstract method using base, all possible solutions are going to require you to eventually call Method in A using an A instance.
That said, it looks like you are looking for a way to provide a default implementation of Method in B such that any subclass of B that does not implement the method should simply use the implementation present in A. A better solution would be to not mark Method as abstract in B. Instead, make Method in B redirect to Method in A using base.Method()
abstract class B : A {
// Class inherited from B are forced to implement Method.
public virtual void Method() {
base.Method()//calls Method in A
}
}
This way, any subclass of B that wants to call Method from A can simply say base.Method().
If i am creating method with "override" property, derived method will not call base method implementation automatically and i will need to call it manually using "base" keyword like this:
public class A
{
public virtual void Say()
{
Console.Write("A");
}
}
public class B : A
{
public override void Say()
{
base.Say();
Console.Write("B");
}
}
So only in this case string "A" and "B" will be written to console. So the question is how can i get rid of "base.Say();" line? So i want to force every derived method "Say" to call base method from base class. Is it possible? I am looking for any solutions, even if i will be forced to use other keywords
Although it is not possible to achieve this directly, you could get the same effect by writing your own method that is not virtual, which calls the virtual after performing some fixed operation:
public class A
{
public void Say()
{
Console.Write("A");
SayImpl();
}
protected virtual void SayImpl()
{
// Do not write anything here:
// for the base class the writing is done in Say()
}
}
public class B : A
{
protected override void SayImpl()
{
Console.Write("B");
}
}
Now any class inheriting from A and implementing SayImpl() would have A prepended to its printout.
In order to call the base virtual method from its overridden one, how should I define the instance?
Assume I have class Derived which extends Base class. I have a virtual method in Base which is overrided in class Derived.
Like this : Base instance = new Derived();
or like this: Derived instance = new Derived();
For sure I shall not use Base instance = new Based(); for it call the virtual methos and not its override.
Whether a method override calls the implementation of the base class does not depend on the type of variable you use. So, as soon as you add base.MethodName() to the implementation of the override, the first two ways you describe will be ok.
As you also mention, the third approach will not work as it does not call the overridden version of the method.
Here is a grotty way you can do that. You'll have to expose a method which calls base version. IMO don't do that. but... It is possible.
void Main()
{
B b = new B();
b.DoSomething();
b.CallAVersionDoSomething();
}
class A
{
public virtual void DoSomething()
{
Console.WriteLine("A DoSomething");
}
}
class B : A
{
public override void DoSomething()
{
Console.WriteLine("B DoSomething");
}
public virtual void CallAVersionDoSomething()
{
base.DoSomething();
}
}
Or if you want to expose it really you can expose another method in Base class which does the job for you. Here's how you go
class A
{
public virtual void DoSomething()
{
ActualDoSomething();
}
public void ActualDoSomething()
{
Console.WriteLine("A DoSomething");
}
}
class B : A
{
public override void DoSomething()
{
Console.WriteLine("B DoSomething");
}
}
and you can use instance.ActualDoSomething() which can't be overridden so you get base class version all the time.
class base_c
{
public virtual void a() {}
public virtual void b() {}
public virtual void c() {}
public virtual void d() {}
}
class other_c : base_c
{
public void a() {}
public new void b() {}
public override void c() {}
public override void d() {base.d();}
}
class Program
{
static void Main()
{
base_c game2 = new other_c();
game2.a();
game2.b();
game2.c();
game2.d();
}
}
'd' has the desired behaviour that the more general base_c function occurs as well as the more specific other_c, although it would nice if the order was the other way round. To see this in effect, use the debugger and step though the program.
Is 'd' the best way to achieve this result?
Although it could be changed in this example "base_c game2 = ..." must remain base_c and cannot be changed to other_c.
Yes, if your intent is for the child class to extend the inherited behavior in method D, then the pattern is to call base.d() in the child's override of d.
If your intent is to replace the inherited behavior (not extend), then you would not call the base method.
You also have the choice of whether to call the base method first before doing anything in your overriding method, or call the base in the middle or after your code in your overriding method.
All of these are valid techniques in the appropriate situations.