Question

有一个类，它有两种方法。（可以找到完整的来源here）

public string SearchAnime(string searchTerm)
{
    // returns string
}

public AnimeSearchResponse SearchAnimeDeserialized(string searchTerm)
{
    // returns an AnimeSearchResponse type object instance
}

我正在尝试创建上述两种方法的异步版本。这意味着需要创建SearchAnimeAsync和SearchAnimeDeserializedAsync等方法。

计划添加更多返回XML或JSON数据的SearchAnime*方法。随着我添加更多SearchAnime*方法，由于异步对应方法，方法的数量将增加两倍。（SearchAnimeXml＆amp; SearchAnimeXmlAsync和SearchAnimeJson＆amp; SearchAnimeJsonAsync）

它变得更糟，因为该类还包含SearchManga和SearchMangaDeserialized，我将为此创建异步版本。

是否有任何解决方案或设计模式可以减轻方法的爆炸性增长？

Answer 1

我想到的一个解决方案是创建一个Searcher抽象基类（包含方法Search和SearchAsync）和一个ISearchResponse接口（指定共同的行为）所有回复）。然后每个Searcher派生类只有两个公开的方法。

public interface ISearchResponse
{
    void Foo();
}

public class AnimeSearchResponse : ISearchResponse
{
    public void Foo() {}
}

public abstract class Searcher
{
    abstract ISearchResponse Search();
    abstract ISearchResponse SearchAsync();
}

public class AnimeSearcher : Searcher
{
    public override ISearchResponse Search(string searchTerm)
    {
        return new AnimeSearchResponse(searchTerm);
    }

    public override ISearchResponse SearchAsync(string searchTerm)
    {
        return new AnimeSearchResponse(searchTerm);
    }
}

最终会有很多类而不是很多方法，但优点是派生类型会更加专业化，并且如果需要可以相互替换。在应用程序的某处，您可以选择使用哪种具体类型的Searcher，例如使用 Factory方法设计模式。

是否有减少方法计数的模式？

1 个答案: