How do I create a method or property in C# that is public, yet not inheritable?

Question

Here is an example. I have two classes, one inherited, and both have a function with the same name, but different arguments:

public class MyClass
{
    //public class members

    public MyClass()
    {
        //constructor code
    }

    public void Copy(MyClass classToCopy)
    {
        //copy code
    } 
}

public class InheritedClass : MyClass
{
    //public class members

    public InheritedClass():base()
    {
        //constructor code
    }

    public void Copy(InheritedClass inheritedClassToCopy)
    {
        //copy code
    } 
}

My question is how do I make the base class' copy method (MyClass.Copy) non-inheritable or non-visible in InheritedClass? I don't want to be able to do this:

MyClass a;
InheritedClass b;
b.Copy(a);

Does this make sense, or should I keep this functionality in there? Can what I'm asking even be done?

Answer 1

Does this make sense, or should I keep this functionality in there? Can what I'm asking even be done?

Trying to hide a public method like this when used by a base class is problematic. You're purposely trying to violate the Liskov substitution principle.

Answer 2

You can't do what you are wanting to do here; C# does not allow negative variance in inherited members. (almost no languages truly do, actually)

It may be that you don't want an inherited class here at all, though; what you may really want is an interface. Or... your two classes here may not have the correct relationship; perhaps they should both instead be common siblings of a third class, which is their parent.

Answer 3

You can use explicit interface implementation to hide this method from the inheritor. But you will need to add an interface of course and you will need to cast your type to the interface to call your method:

public interface MyInterface
{
    void Copy(MyClass classToCopy)
}

public class MyClass : MyInterface
{
    void MyInterface.Copy(MyClass classToCopy)
    {
        //copy code
    } 
}

Answer 4

This is not possible. An inherited class inherits all public and protected members, methods and properties. Using the sealed modifier with make it non-overridable, but still accessible to your inherited class.

Answer 5

What everyone else said, but if I am inferring your goal correctly, it is to make sure that InheritedClass users never use the MyClass method. In that case, exclude it from MyClass and make two classes that inherit it.

Make MyBaseClass abstract if it should not be instantiated (most likely).

(Edited -- you probably would want to include copy code for anything that's part of the base class in the base class)

public abstract class MyBaseClass
{
    public MyClass()
    {
        //constructor code
    }
    protected void Copy(MyBaseClass classToCopy)
    {
        //copy code
    }
    // other methods that all inherited classes can use
}

public class MyClass: MyBaseClass
{
    public MyClass():base()
    {
        //constructor code
    }
    public void Copy(MyClass myClassToCopy)
    {
        base.Copy(myClassToCopy);
        //specific copy code for this extensions in this class
    } 
}

public class InheritedClass : MyBaseClass
{
    public InheritedClass():base()
    {
        //constructor code
    }
    public void Copy(InheritedClass inheritedClassToCopy)
    {
        base.Copy(myClassToCopy);
        //specific copy code for this extensions in this class
    } 
}