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
Yeah, this can be a little confusing sometimes. Let’s go step by step: First, you need to understand What is encapsulation and why is it used.? Encapsulation is one of the four fundamental OOP concepts.Encapsulation is the technique of making the fields in a class private and providing access to the fields via public methods. … Read more
When foo receives a FooBase reference, the compiler doesn’t know whether the argument is a descendant of Foo, so it has to assume it’s not. Foo has access to inherited protected members of other Foo objects, not all other sibling classes. Consider this code: class FooSibling: public FooBase { }; FooSibling sib; Foo f; f.foo(sib); … Read more
The DateTime instances returned by ExampleBundle\Entity\User#getServiceExpiresAt() are the same objects stored in the entity itself, which breaks encapsulation. The UnitOfWork in Doctrine ORM applies strict comparison for changesets, which basically means that in the case of properties of entities containing objects, if the object instance hasn’t changed, the ORM does not detect a change. In … Read more
Encapsulation helps in isolating implementation details from the behavior exposed to clients of a class (other classes/functions that are using this class), and gives you more control over coupling in your code. Consider this example, similar to the one in Robert Martin’s book Clean Code: public class Car { //… public float GetFuelPercentage() { /* … Read more
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
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
It depends. This is one of those issues that must be decided pragmatically. Suppose I had a class for representing a point. I could have getters and setters for the X and Y coordinates, or I could just make them both public and allow free read/write access to the data. In my opinion, this is … Read more
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() { }
Here’s a way, not recommended though class Weak { private: string name; public: void setName(const string& name) { this->name = name; } string getName()const { return this->name; } }; struct Hacker { string name; }; int main(int argc, char** argv) { Weak w; w.setName(“Jon”); cout << w.getName() << endl; Hacker *hackit = reinterpret_cast<Hacker *>(&w); hackit->name … Read more