-2

我搜索了 google 和 stackvoverflow 以获得答案，但这一切都归结为：创建方法。我希望我的代码可以重用。我不想在同一个类中创建其他方法。这个类已经包含了很多代码。如何在拥有可读类的同时降低复杂性？我考虑过创建另一个类并在那里拥有所有新方法。

编码

 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;
        }
4

3 回答 3

1

这个类已经包含了很多代码。...我考虑创建另一个类并在那里拥有所有新方法。

这正是你应该做的。

于 2012-11-13T18:56:00.000 回答
1

遗留代码的可读代码之路非常崎岖。

首先，你应该有完全覆盖你正在重构的代码的测试，否则你最终会在令人眼花缭乱的暴风雪中穿越那条崎岖的道路——这是可能的，但并不有趣而且非常危险。

一旦你在那里覆盖了你的屁股，你就可以开始重构了。总的来说，大多数早期的重构（假设有很多与上面类似的方法）将是Extract Method。从那里开始，一些类行为应该开始变得明显，然后您可以将它们提取出来。

我考虑过创建另一个类并在那里拥有所有新方法。

这类似于将所有东西都推到床下来打扫房间。房间很干净，但你只是隐藏了混乱。不要没有任何想法，否则你最终会得到一个Utility比你现在更糟糕的课程。

从 OOP 的角度来看，通常需要努力实现SOLID解决方案。从传统的角度来看，要关注的关键原则是您的班级的单一责任。如果你有这个，OLID 往往会就位（根据我的经验，虽然我的棕地开发经验比我真正想要的要多得多）。

于 2012-11-13T19:27:12.063 回答
0

正如您所提到的，将代码分解为更小的方法是可行的方法。如何使用静态扩展方法来组织你的代码，看看Issue代码的主题是怎样的：

// top-down:
RestRequest request = GetRequestForIssueOption(issueId, issueOption);
Issue issue = Execute<Issue>(request);

// make it fluent...
return issue.SetVersion()
.SetParent()
.SetUsers()
.SetProject();

我认为静态扩展方法很有意义。就个人而言，我认为使静态扩展流利有助于使代码更加清晰，但不确定这是否是你的一杯茶。

public static Issue SetVersion(this Issue issue_)
{ 
    // code here 
}

public static Issue SetParent(this Issue issue_)
{ 
    // code here 
}

public static Issue SetUsers(this Issue issue_)
{ 
    // code here 
}

public static Issue SetProject(this Issue issue_)
{ 
    // code here 
}
于 2012-11-13T19:25:25.390 回答