We Keep Coding

Force base class virtual method call inside of base class

Don't get me wrong: I do not want to force an overriding method to call the base class like already asked 1000...times before :)
I wondered if there is any way to force the call of the base class implementation of a method inside the base class.
Example:
using System;
public class Program
{
public static void Main()
{
var c = new SubClass();
c.CallInfo();
}
internal class BaseClass {
protected virtual void Info(){
Console.WriteLine("BaseClass");
}
internal virtual void CallInfo() {
this.Info();
}
}
internal class SubClass : BaseClass {
protected override void Info() {
Console.WriteLine("SubClass");
}
internal override void CallInfo() {
base.CallInfo();
}
}
}
Output obviously would be SubClass. Is there any way to force the CallInfo method of BaseClass to call its own Info method so that the output would be BaseClass?

By marking your Info() method as virtual you are specifically asking for this type of inheritance behaviour to occur.
If you want to ensure that a method call in your base class is not overridden, you'll need to use a non-virtual method, e.g.
internal class BaseClass {
protected virtual void Info(){
this.FinalInfo();
}
protected void FinalInfo() {
Console.WriteLine("BaseClass");
}
internal virtual void CallInfo() {
this.FinalInfo();
}
}

No, you can't do that. The purpose of virtual methods is that derived classes can override the implementation and that the implementation is used even when called it from base classes.
If that causes problems then the method you want to run should not be a virtual method.
This would work, while it won't force an implementation by a subclass like virtual it'll allow you to override it.
public class Program
{
public static void Main()
{
var c = new SubClass();
c.CallInfo();
}
internal class BaseClass
{
protected void Info()
{
Console.WriteLine("BaseClass");
}
internal virtual void CallInfo()
{
this.Info();
}
}
internal class SubClass : BaseClass
{
protected new void Info()
{
Console.WriteLine("SubClass");
}
internal override void CallInfo()
{
base.CallInfo();
}
}
}

C# call method before override method

Good day,
I have a base class with a virtual method that needs to be overridden per implementation, but I would like to call the base method first before overriding.
Is there a way to accomplish this without having to actually call the method.
public class Base
{
public virtual void Method()
{
//doing some stuff here
}
}
public class Parent : Base
{
public override void Method()
{
base.Method() //need to be called ALWAYS
//then I do my thing
}
}
I cannot always rely that the base.Method() will be called in the override, so I would like to enforce it somehow. This might be a design pattern of some kind, any approach to accomplish the result will do.

One way is to define a public method in the base class, which calls another method that can be (or must be) overridden:
public class Base
{
public void Method()
{
// Do some preparatory stuff here, then call a method that might be overridden
MethodImpl()
}
protected virtual void MethodImpl() // Not accessible apart from child classes
{
}
}
public class Parent : Base
{
protected override void MethodImpl()
{
// ToDo - implement to taste
}
}

You can use the decorator design pattern, applying this pattern you can attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality:
public abstract class Component
{
public abstract void Operation();
}
public class ConcreteComponent1 : Component
{
public override void Operation()
{
//logic
}
}
public abstract class ComponentDecorator : Component
{
protected readonly Component Component;
protected ComponentDecorator(Component component)
{
Component = component;
}
public override void Operation()
{
if(Component != null)
Component.Operation();
}
}
public class ConcreteDecorator : ComponentDecorator
{
public ConcreteDecorator(Component component) : base(component)
{
}
public override void Operation()
{
base.Operation();
Console.WriteLine("Extend functionality");
}
}
Hope this helps!

Method Overloading or method overriding?

In my C# application i have a base class, which contains a function Myfunction.
I have a derived class from the above base class which also contains the same function as in base class, is this concept is correct implementation?
public class BaseClass
{
public void MyFunction()
{
Console.WriteLine("");
}
}
public class DerivedClass:BaseClass
{
public void MyFunction()
{
Console.WriteLine("");
}
}
i am a newbee in Programing , sorry for my english

You've actually hidden BaseClass.MyFunction by doing it that way.
If you want to override properly, you must declare the base version as virtual (or abstract) and then specify override:
public class BaseClass
{
public virtual void MyFunction() { }
}
public class DerivedClass:BaseClass
{
public override void MyFunction() { }
}
Overloading and overriding are different things. The above shows overriding. Overloading refers to when there are multiple methods with the same name, but different parameters. E.g. if you have these methods:
public void MyFunction(int i) {}
public void MyFunction(decimal d) {}
You would say that there are two overloads of MyFunction.

No, this is wrong implementation for method overloading.
If you create a method with same name, and same parameters then it will be method overriding.
If you create a method with same name, but different parameters then it will be method overloading.
If you need to implement your example for method overriding, then add a override keyword on your derived class method and add a virtual keyword with your base class method:
public class BaseClass
{
public virtual void MyFunction()
{
Console.WriteLine("");
}
}
public class DerivedClass:BaseClass
{
public override void MyFunction()
{
Console.WriteLine("");
}
}
If you want to implement an example of overloading, then you will just have to change the parameters of your both methods. Change means they must be different from each other. e.g. :
public class BaseClass
{
public void MyFunction()
{
Console.WriteLine("");
}
}
public class DerivedClass:BaseClass
{
public void MyFunction(string input)
{
Console.WriteLine("");
}
}

In this example, MyFunction in DerivedClass overrides MyFunction in BaseClass.
If you had another MyFunction, this time 'MyFunction(int parameter)', you would have overloaded MyFunction.

You must overload/overrieds methods in this way
public class derived_Class : mybaseclass
{
public override void mymethod()
{
// IF you want to call the base class function as well then you call base.mymethod() ;
base.mymethod();
}
}
class mybaseclass
{
// When you want to overide a method , you must use Virtual keyword
public virtual void mymethod()
{
}
// This is an overload of overload_method
// when you write many methods from same name with different arguments, it's an overload of the method
public void overload_method()
{
}
public void overload_method(string m)
{
}
// When you use an overload
public void use()
{
overload_method();
overload_method(null);
}
}

Inherit classes in c#

I have an abstract class and two classes derivated of this principal class:
abstract class MainClass
{
public void DoSomething() {
if(isEdit())
Edit();
else if(isNew())
New();
else if(isDelete())
Delete();
else if(isSearch())
Search();
else if(isExit())
Exit();
}
public abstract void Edit();
public abstract void New();
public abstract void Delete();
public abstract void Search();
public abstract void Exit();
}
abstract class FirstClass : MainClass
{
public abstract void Edit();
public abstract void New();
public abstract void Delete();
}
abstract class SecondClass : MainClass
{
public abstract void Search();
public abstract void Exit();
}
When you need to extend from FirstClass Edit(), New() and Delete() must be declared, and methods Search() and Exit() can be declared but should not be mandatory. Is there any way to do that?

When you need to extend from FirstClass Edit(), New() and Delete() must be declared, and methods Search() and Exit() can be declared but should not be mandatory.
That is possible:
abstract class FirstClass : MainClass
{
//public abstract void Edit();
//public abstract void New();
//public abstract void Delete();
public override void Search() { }
public override void Exit() { }
}
Edit(), New() and Delete() are already declared as abstract (must override) in the MainClass so FirstClass should leave them alone.

Implement the optional methods as overrides:
abstract class FirstClass : MainClass
{
public override void Search(){}
public override void Exit(){}
}
Since they are implemented in MainClass, you don't need to implement in any inheriting class, but if you want to, you can override them.
Note that you do not need to redeclare Edit, New and Delete again - they are already inherited by FirstClass and will need to be implemented by any non-abstract inheritor of it.

The abstract keyword indicates that a method MUST be implemented by an inheriting class. The virtual keyword indicates that it MAY be implemented.
Mark Save() and Exit() as virtual and provide a default (possibly empty) implementation of them.

You can override the non-mandatory methods that have been declared in MainClass which is the baseclass for FirstClass, and provide default functionality for it:
abstract class FirstClass : MainClass
{
public override void Search(){}
public override void Exit() {}
}
The mandatory methods should not be declared in FirstClass, since they're already declared as abstract in the MainClass. They remain abstract in FirstClass

Override methods which could be optionally declared in child classes (other methods will be inherited from MainClass and stay abstract):
abstract class FirstClass : MainClass
{
public override void Search() { /* default implementation */ }
public override void Exit() { /* default implementation */ }
}
Then
class ThirdClass : FirstClass
{
// Must implement abstract methods
public override void Edit() { }
public override void New() { }
public override void Delete() { }
// Optionally override
public override void Exit() { /* custom implementation */ }
}

How to enforce a method call (in the base class) when overriding method is invoked?

I have this situation that when AbstractMethod method is invoked from ImplementClass I want to enforce that MustBeCalled method in the AbstractClass is invoked. I’ve never come across this situation before. Thank you!
public abstract class AbstractClass
{
public abstract void AbstractMethod();
public void MustBeCalled()
{
//this must be called when AbstractMethod is invoked
}
}
public class ImplementClass : AbstractClass
{
public override void AbstractMethod()
{
//when called, base.MustBeCalled() must be called.
//how can i enforce this?
}
}

An option would be to have the Abstract class do the calling in this manner. Otherwise, there is no way in c# to require an inherited class to implement a method in a certain way.
public abstract class AbstractClass
{
public void PerformThisFunction()
{
MustBeCalled();
AbstractMethod();
}
public void MustBeCalled()
{
//this must be called when AbstractMethod is invoked
}
//could also be public if desired
protected abstract void AbstractMethod();
}
public class ImplementClass : AbstractClass
{
protected override void AbstractMethod()
{
//when called, base.MustBeCalled() must be called.
//how can i enforce this?
}
}
Doing this creates the desired public facing method in the abstract class, giving the abstract class over how and in what order things are called, while still allowing the concrete class to provide needed functionality.

How about
public abstract class AbstractClass
{
public void AbstractMethod()
{
MustBeCalled();
InternalAbstractMethod();
}
protected abstract void InternalAbstractMethod();
public void MustBeCalled()
{
//this must be called when AbstractMethod is invoked
}
}
public class ImplementClass : AbstractClass
{
protected override void InternalAbstractMethod()
{
//when called, base.MustBeCalled() must be called.
//how can i enforce this?
}
}

Why can't you just call the method in the AbstractMethod() of Implement class?

One thing the preceding solutions ignore is that ImplementClass can redefine MethodToBeCalled and not call MustBeCalled -
public abstract class AbstractClass
{
public abstract void AbstractMethod();
private void MustBeCalled()
{
//will be invoked by MethodToBeCalled();
Console.WriteLine("AbstractClass.MustBeCalled");
}
public void MethodToBeCalled()
{
MustBeCalled();
AbstractMethod();
}
}
public class ImplementClass : AbstractClass
{
public override void AbstractMethod()
{
Console.WriteLine("ImplementClass.InternalAbstractMethod");
}
public new void MethodToBeCalled() {
AbstractMethod();
}
}
If only C# allowed non-overridden methods to be sealed - like Java's final keyword!
The only way I can think of to overcome this is to use delegation rather than inheritance, because classes can be defined as sealed. And I'm using a namespace and the "internal" access modifier to prevent providing a new implementation on implementing classes. Also, the method to override must be defined as protected, otherwise users could call it directly.
namespace Something
{
public sealed class OuterClass
{
private AbstractInnerClass inner;
public OuterClass(AbstractInnerClass inner)
{
this.inner = inner;
}
public void MethodToBeCalled()
{
MustBeCalled();
inner.CalledByOuter();
}
public void MustBeCalled()
{
//this must be called when AbstractMethod is invoked
System.Console.WriteLine("OuterClass.MustBeCalled");
}
}
public abstract class AbstractInnerClass
{
internal void CalledByOuter()
{
AbstractMethod();
}
protected abstract void AbstractMethod();
}
}
public class ImplementInnerClass : Something.AbstractInnerClass
{
protected override void AbstractMethod()
{
//when called, base.MustBeCalled() must be called.
//how can i enforce this?
System.Console.WriteLine("ImplementInnerClass.AbstractMethod");
}
public new void CalledByOuter()
{
System.Console.WriteLine("doesn't work");
}
}