Styjun

Summary: B Receives call from A, and automatically starts the start method

Let's say we have class A: A has a function named Start, that start function is initially called from another class (lets refer that class as C) and once it's called, it should call every method from all classes using Start (and using it's base class), with the same method.

And we have B: a class using A as it's base class, it's job is to receive the Start method from A, (initially called by C). Now i could simply do this by calling B's method directly from A, but in this case, B could be named anything, with multiple classes inheriting the same method.

This is useful because i don't want to assign all my variables to one start function. Instead, be able to create a function that allows the same function name to be called.

For example: here's what i was thinking it would look like

class A

 public void Start()
 
 // Call B's Start here...
 


class B : A

 public void Start()
 
 // Receive A's call ... and do stuff here
 



// This time, we also need to access this start method.
// But this class could be named anything
class anotherClass : A

 public void Start()
 
 // Receive A's call
 


class C

 static void Main(string[] args)
 
 A a = new A();

 // Maybe somehow call all start methods here
 a.Start();
 

But as you can see, Start in class A will be called, but it will never call start in class B.

In better context, I need a way for all Start methods from every class to be called.

You have never created a B or anotherClass object. Therefore their Start method cannot be called.

Inheritance works the other way round. A derived class can call its base class members, because it knows its ancestor and inherits all its members (fields, properties, methods). The base class (A) on the other side does not know its descendants.

You must use virtual methods that you can override in derived classes. Example:

class A

 public virtual void Start()
 
 Console.WriteLine("Starting A");
 


class B : A

 public override void Start()
 
 base.Start();
 Console.WriteLine("Starting B");
 

Now you can create a B object and call its Start method

var b = new B();
b.Start();

This will output:

Starting A
Starting B

Since derived types are assignment compatible to their base types, you can also do something like this

var list = new List<A> new B(), new A() ;
foreach (A a in list) 
 a.Start();

Starting A
Starting B
Starting A

where the two first lines are from B.Start() and the last one from A.Start().

But this works only for classes in the direct lineage. You cannot call methods from siblings. Why? Let's make an example:

class C : A

 private string s = "hello";

 public override void Start()
 
 base.Start();
 Console.WriteLine("Starting C: " + s);
 

Assuming that you could do something like this in B:

sibling(C).Start();

Where should the value "hello" of s come from? Neither A, nor B has such a field and a C object was never created. So your requirement to call every method from all classes cannot be fulfilled. But if a field of A was involved this would work, as B inherits this field.

Just use reference to base class:

// or maybe you want to override??
public new void Start()

 base.Start();

Use it in every Start class down in class hierarchy

You cannot invoke methods on uninitialized classes. So calling A.Start() will not be able to call B.Start() unless an instance of B is initialized. Also, B should notify A of its existance. (Unless you'd use reflection, but I don't suppose that is what you want)

You may be able to hook B to a with an event with a custom delegate:

class Program

 static void Main(string[] args) 
 
 var a = new A();
 var b = new B();
 a.StartHandler += b.Start;
 a.Start();

 // Output:
 // A.Start() starting.
 // B.Start() called.
 // A.Start() ending.
 


class A

 public delegate void StartMethod();
 public event StartMethod StartHandler;

 public virtual void Start()
 
 Console.WriteLine("A.Start() starting.");
 if (this.StartHandler != null)
 
 this.StartHandler();
 
 Console.WriteLine("A.Start() ending.");
 


class B : A

 public override void Start()
 
 Console.WriteLine("B.Start() called.");
 

Another simpler option may be (depending on what you want), to do it the other way, with simple inheritance. If you create an instance of B, you can treat it as if it were an instance of A. So you don't have to know you are actually using a B type under the hood:

class A

 public virtual void Start() => Console.WriteLine("A.Start()");


class B : A

 public override void Start()
 
 Console.WriteLine("B.Start()");
 base.Start();
 


// usage:
A a = new B();
a.Start();

// Output:
// B.Start()
// A.Start();