Question

I’ve searched google and stackvoverflow to get the answers but it all boils down to: Create methods.
I want my code to be reusable. I don’t want to create other methods in the same class. This class already contains a lot of code. How can I reduce the complexity while have a readable class?
I thought about creating another class and having all the new methods there.

The code

 public Issue GetIssue(int issueId, IssueOption issueOption)
        {
            string resource = "issues/{id}.xml?";

            if (issueOption.IncludeRelation)
            {
                resource += "include=relations&";
            }
            if (issueOption.IncludeChildren)
            {
                resource += "include=children";
            }

            //To fetch multiple associations use comma (e.g ?include=relations,journals

            RestRequest request = new RestRequest(resource);
            request.AddParameter("id", issueId, ParameterType.UrlSegment);

            Issue issue = Execute<Issue>(request);

            if (issueOption.IncludeVersion)
            {
                issue.Fixed_version = GetVersion(issue.Project.Id);
            }

            if (issue.Parent != null && issueOption.IncludeParent)
            {
                issue.Parent = GetIssue(issue.Parent.Id, issueOption);
            }

            if (issueOption.IncludeUsers)
            {
                if (issue.Author.Id == issue.Assigned_to.Id)
                {
                    issue.Author = GetUser(issue.Author.Id);
                    issue.Assigned_to = issue.Author;
                }
                else
                {
                    issue.Author = GetUser(issue.Author.Id);
                    if (issue.Assigned_to != null)
                    {
                        issue.Assigned_to = GetUser(issue.Assigned_to.Id);
                    }
                }
            }

            if (issueOption.IncludeProject)
            {
                issue.Project = GetProject(issue.Project.Id);
            }

            return issue;
        }

Answer 1

The road to readable code is very rough out of legacy code.

First off, you should have tests that fully cover the code you are refactoring otherwise you end up traversing that rough road in a blinding blizzard — it’s possible but not fun and very dangerous.

Once you’ve covered your butt there, you can start the refactorings. By and large, most of the early refactorings (assuming a lot of similar methods to what you have above) will be Extract Method. From there, some class behaviors should start becoming apparent and you can extract them out then.

I thought about creating another class and having all the new methods there.

This is analogous to cleaning your room by pushing everything under the bed. The room is clean but you’ve only hidden the mess. Don’t do without any thought otherwise you’ll end up with a Utility class that’s even worse than what you have now.

From an OOP-perspective, working towards a SOLID solution is generally desired. The key tenet to focus on from a legacy standpoint is Single Responsibility for your classes. If you have that, the O-L-I-D tend to just fall into place (from my experience, though I’ve had way more brownfield development experience than I’d really like).