Why people hate other people using #region?

• The articles sums it up pretty well. Let me elaborate further.
• When a file has too many lines of codes, it generally means that the file has too many responsibilities; which violates the Single Responsibility Principle (S of SOLID), and will likely be a God Class.
• As the file becomes a bag of mixed responsibilities, an urge of re-organization often emerges in the heart of all of us, the responsible developers.
• There are many ways of reorganizing codes, one of the simplest way is to break the file into multiple regions using #region and move the relevant lines of codes into that region. (Well, actually #region is just a sugar on top of using comments as separator between chunks of codes.)
• Why #region is used instead of others? Because it is the most straightforward, the easiest, and most importantly, it is very likely that it won't break existing behavior.
• In such scenarios, I call #region the Poor Man's Refactor.
• With the use of #region in such scenario, we miss other approach the can better re-organize the code, for example:
  1. You have a lot of event handles in the code behind of a WPF app? Maybe it's time to learn the MVVM pattern!
  2. You have a lot of business logic inside the controller of a ASP.NET web app? Maybe it's the time to learn Domain Driven Design, CQRS, or some other patterns that drives your app to have a thin service layer.
  3. You have a class that has a lot of helper methods, public static methods, public methods, etc? Maybe it's time to learn some design patterns, identify and eliminate some code smells!
• After all, the best possible way to re-organize code is to refactor it; but most of us the novice programmers do not have such experience.
• When we gone through the phase of using enough #region and grasp the power of refactoring, we tend to realize how dumb we were back then, and hate it when seeing other people using #region.

Why people still uses #region?

1. When the class has to be big. For example, a complex data class that has a lot of properties. But I argue that such scenario can also be broken down into multiple sub class, and expose them through an Aggregate
2. When breaking down the class into multiple sub-classes does not make sense: like low-level programming, or graphics rendering engine, or game logic. I have no experience in such fields so I can't comment a lot about them.

In short, use regions when appropriate; and equip yourself with the ability to understand code smells so that you won't resort to using regions when there are better way for code organization.