How do I hide a method so it's not called by programmers but still usable in code?
c#, inheritance
Solution
The exact scenario you describe isn't possible. You can restrict access to the `FurtherValidate` method to only derived classes by using the `protected` access modifier. You could also restrict it to only classes in the same assembly by using the `internal` modifier, but this would still allow the programmer writing the derived class to call FurtherValidate any time they wish. Using both protected and internal combines the two and really means that is restricted to derived classes or classes defined in the same assembly.
Using the [EditorBrowsable] attribute is an IDE trick that will hide the method from IntelliSense (unless the other programmer has turned on the right options in VS). That will effectively prevent most people from calling it (if they can't see it, it doesn't exist).
You could possibly achieve this using reflection to interrogate who your caller is, but I think the performance costs of doing this would be too high compared to the benefit.
Problem
I have a class called `Ship` and a class called `Lifeboat` Lifeboat inherits from Ship. Ship contains a method called `Validate()` which is called before save and it has an abstract method called `FurtherValidate()` which it calls from Validate. The reason this is in place is so when you call validate on the base it also validates the class that is inheriting. So we have ``` public class Ship public bool Validate() { //validate properties only found on a ship FurtherValidate(); } public abstract bool FurtherValidate(); ``` So `Lifeboat` has ``` public override bool FurtherValidate() { //validate properties only found on a lifeboat } ``` This means anyone implementing `Ship` also needs to provide their own validation for their class and it's guaranteed to be called on the save as the base ship. `Validate()` is called which in turns calls the inherited validate. How can we re work this so we still force inherited classes to implement `FurtherValidate()` but `FurtherValidate()` can never be called by the programmer. Currently you can called `Lifeboat.FurtherValidate()` and I want to somehow prevent this.