Method chaining – why is it a good practice, or not?

by

I agree that this is subjective. For the most part I avoid method chaining, but recently I also found a case where it was just the right thing – I had a method which accepted something like 10 parameters, and needed more, but for the most time you only had to specify a few. With overrides this became very cumbersome very fast. Instead I opted for the chaining approach:

MyObject.Start()
    .SpecifySomeParameter(asdasd)
    .SpecifySomeOtherParameter(asdasd)
    .Execute();

The method chaining approach was optional, but it made writing code easier (especially with IntelliSense). Mind you that this is one isolated case though, and is not a general practice in my code.

The point is – in 99% cases you can probably do just as well or even better without method chaining. But there is the 1% where this is the best approach.

More Related Contents:

  1. PHP method chaining or fluent interface?
  2. What is polymorphism, what is it for, and how is it used?
  3. Why doesn’t Rust support trait object upcasting?
  4. Inheritance vs. Aggregation [closed]
  5. Difference between abstraction and encapsulation?
  6. Constructors vs Factory Methods [closed]
  7. Why would I want to use Interfaces? [closed]
  8. What is the exact problem with multiple inheritance?
  9. Why can’t I seem to grasp interfaces?
  10. HAS-A, IS-A terminology in object oriented language
  11. Functional programming vs Object Oriented programming [closed]
  12. Explanation of the UML arrows
  13. What is the rationale behind having companion objects in Scala?
  14. Where do I use delegates? [closed]
  15. What is the dependency inversion principle and why is it important?
  16. Difference Between Cohesion and Coupling
  17. Do write-only properties have practical applications?
  18. Polymorphism – Define In Just Two Sentences [closed]
  19. DDD – the rule that Entities can’t access Repositories directly
  20. Are Polymorphism , Overloading and Overriding similar concepts? [closed]
  21. If-less programming (basically without conditionals) [closed]
  22. Are there any rules for OOP?
  23. When to implement an interface and when to extend a superclass?
  24. Difference between value parameter and reference parameter?
  25. Mixin vs inheritance
  26. Does the Single Responsibility Principle work in OOP?
  27. What is immutability and why should I worry about it?
  28. What does ‘low in coupling and high in cohesion’ mean
  29. Learning/Implementing Design Patterns (For Newbies) [closed]
  30. Is it possible to extend a default method implementation of a trait in a struct?

Leave a Comment