can we define a method in parent class which can be called within a child but not the other one

Question

i ran into into a problem , i want to have a method(M) in a parent class (A) then B and C extend the class A . in this situation i want method(M) can be accessible by B but not C . any solution?

public class A
{
    ????? string M()
    {
        return "Hi there";
    }
}
public class B:A
{
}
public class C:A
{
}
B newClassB = new B();
C newClassC = new C();
Console.WriteLine(newClassB.M()); //the correct one
Console.WriteLine(newClassC.M()); //the incorrect one

no you can not, they both extend same base class. What you *can* do instead, is that `C` class, even if its method is called, would have an empty run. — Tigran, Jul 13 '17 at 17:54
Seems like you should read up on the Liskov substitution principle. If a "C" inherits from "A", it is 100% an "A" but with a little "C" added to it. If you want "C" to not have specific "A" parts, then it shouldn't inherit "A" — maccettura, Jul 13 '17 at 17:57

maccettura · Answer 1 · 2017-07-13T18:34:45.423

Some of the other answers seem to encourage you to violate the Liskov Substitution Principle, which is very poor practice and will only lead to awful code.

What you have here is a design problem. If you want C to inherit A then it should behave exactly like an A but with added or modified functionality.

The Liskov Principle states:

"Objects in a program should be replaceable with instances of their subtypes without altering the correctness of that program."

With what you want to do, you could potentially break things. Lets say you have a method that accepts your parent class A, but you pass it a derived class C. What happens when your method attempts to call C.M()?

What you need to do is re-think your class design. Is a C really a subtype of an A if you aren't supposed to call M() from C?

Your question's code is very vague so I cannot propose an alternate solution to your class structure, but I will edit if you can make your code less ambiguous.

Some cases are justified. See `System.IO.Stream.Seek` and `CanSeek` for instance. — InBetween, Jul 13 '17 at 18:45

InBetween · Accepted Answer · 2017-07-13T18:40:56.410

Ok, a useful answer (my previous one was not).

No, you can't and you shouldn't do this, due to the Liskov Substitution Principle already pointed out in other answers and comments.

However, there are cases where it can be justified, and as a matter of fact, some classes in NET do implement the following pattern:

public class A
{
    public virtual bool CanCallM => true;
    public void M() {
        if (!CanCallM) throw new NotSupportedException();
        //do whatever }
}

public class B: A { }

public class C: A
{
    public override bool CanCallM => false;
}

Pretty? Not much, but you do give the consumer a way to know beforehand if M can be called, and you are ensuring at runtime that c.M fails.

I personally prefer this pattern to simply doing nothing because the later is probably a bug in the code; someone is calling M with an expectation that is not met.

score -1 · Answer 3 · answered Jul 13 '17 at 17:59

-1

in this situation i want method(M) can be accessible by B but not C . any solution?

You can't do that, as I said in the comment, but you can do something like:

class A 
{

  public virtual bool Before() { return false; }

  public void BaseMethod () 
  {         
      if(Before())
         Console.WriteLine("Called method AMethod");
  }
}

class B : A 
{    
    public override bool Before() {return true; }
}

class C : A 
{    
}

void Main()
{
    var c = new C(); 
    var b = new B(); 

    c.BaseMethod(); 
    b.BaseMethod();
}

In this case BaseMethod() will be void execution for C instance.

answered Jul 13 '17 at 17:59

Tigran

61,654
8
86
123

@InBetween: `B` extends `A` and is not nested type, by requirement of the question. – Tigran Jul 13 '17 at 18:14
I don't like this pattern, its bug prone; someone can be calling `M` with expectations that are not met. I'd prefer simply throwing giving the consumer a way to know beforehand if you are going to throw or not. – InBetween Jul 13 '17 at 18:42
The thing is that you have freedom of control. You want to raise an exception, if the wrong method called, `throw` an exception inside overridden method, which is not meant to be called. – Tigran Jul 13 '17 at 18:44

can we define a method in parent class which can be called within a child but not the other one

3 Answers3