Using the EditorBrowsable attribute like so will cause a method not to be shown in IntelliSense: [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] public void MyMethod() { }
Ideally, you shouldn’t need to unit test private methods at all. All a consumer of your class should care about is the public interface, so that’s what you should test. If a private method has a bug, it should be caught by a unit test that invokes some public method on the class which eventually … Read more
As of PHP 7.1, there are real private constants. private const PRIVATE_CONST = 0; See the Class Constant Visibility RFC for more information.
Typically, Python code strives to adhere to the Uniform Access Principle. Specifically, the accepted approach is: Expose your instance variables directly, allowing, for instance, foo.x = 0, not foo.set_x(0) If you need to wrap the accesses inside methods, for whatever reason, use @property, which preserves the access semantics. That is, foo.x = 0 now invokes … Read more
If the class contains any template member functions you can specialize that member function to suit your needs. Even if the original developer didn’t think of it. safe.h class safe { int money; public: safe() : money(1000000) { } template <typename T> void backdoor() { // Do some stuff. } }; main.cpp: #include <safe.h> #include … Read more
Abstraction is a process where you show only “relevant” data and “hide” unnecessary details of an object from the user. Consider your mobile phone, you just need to know what buttons are to be pressed to send a message or make a call, What happens when you press a button, how your messages are sent, … Read more
Encapsulation: hiding data using getters and setters etc. Abstraction: hiding implementation using abstract classes and interfaces etc.
In short, the generic list does not have virtual methods for Add, Remove etc, as it was designed to be fast, not extensible. This means that you cannot swap this concrete implementation out for a useful subclass (even though you can subclass it as it is not sealed). Therefore, by exposing the List itself, you … Read more
One important aspect seems to be missing from the answers so far: When an IEnumerable<T> is returned to the caller, they must consider the possibility that the returned object is a “lazy stream”, e.g. a collection built with “yield return”. That is, the performance penalty for producing the elements of the IEnumerable<T> may have to … Read more
You could return an Integer instead of an int, returning null on parse failure. It’s a shame Java doesn’t provide a way of doing this without there being an exception thrown internally though – you can hide the exception (by catching it and returning null), but it could still be a performance issue if you’re … Read more