重构两个基础类

Question

您将如何重构这两个类以抽象出相似之处？ 抽象类？ 简单继承？ 重构后的类会是什么样子？

public class LanguageCode
{
    /// <summary>
    /// Get the lowercase two-character ISO 639-1 language code.
    /// </summary>
    public readonly string Value;

    public LanguageCode(string language)
    {
        this.Value = new CultureInfo(language).TwoLetterISOLanguageName;
    }

    public static LanguageCode TryParse(string language)
    {
        if (language == null)
        {
            return null;
        }

        if (language.Length > 2)
        {
            language = language.Substring(0, 2);
        }

        try
        {
            return new LanguageCode(language);
        }
        catch (ArgumentException)
        {
            return null;
        }
    }
}

public class RegionCode
{
    /// <summary>
    /// Get the uppercase two-character ISO 3166 region/country code.
    /// </summary>
    public readonly string Value;

    public RegionCode(string region)
    {
        this.Value = new RegionInfo(region).TwoLetterISORegionName;
    }

    public static RegionCode TryParse(string region)
    {
        if (region == null)
        {
            return null;
        }

        if (region.Length > 2)
        {
            region = region.Substring(0, 2);
        }

        try
        {
            return new RegionCode(region);
        }
        catch (ArgumentException)
        {
            return null;
        }
    }
}

Answer 1

除非您有充分的理由进行重构（因为您将在不久的将来添加更多类），否则为这样一个小而人为的示例更改设计的代价将克服这种情况下维护或开销的收益。 无论如何，这是一个基于泛型和 lambda 表达式的可能设计。

public class TwoLetterCode<T>
{
    private readonly string value;

    public TwoLetterCode(string value, Func<string, string> predicate)
    {
        this.value = predicate(value);
    }

    public static T TryParse(string value, Func<string, T> predicate)
    {
        if (value == null)
        {
            return default(T);
        }

        if (value.Length > 2)
        {
            value = value.Substring(0, 2);
        }

        try
        {
            return predicate(value);
        }
        catch (ArgumentException)
        {
            return default(T);
        }
    }

    public string Value { get { return this.value; } }
}

public class LanguageCode : TwoLetterCode<LanguageCode>  {
    public LanguageCode(string language)
        : base(language, v => new CultureInfo(v).TwoLetterISOLanguageName)
    {
    }

    public static LanguageCode TryParse(string language)
    {
        return TwoLetterCode<LanguageCode>.TryParse(language, v => new LanguageCode(v));
    }
}

public class RegionCode : TwoLetterCode<RegionCode>
{
    public RegionCode(string language)
        : base(language, v => new CultureInfo(v).TwoLetterISORegionName)
    {
    }

    public static RegionCode TryParse(string language)
    {
        return TwoLetterCode<RegionCode>.TryParse(language, v => new RegionCode(v));
    }
}

Answer 2

这取决于，如果他们不打算做更多的事情，那么我可能会让他们保持原样 - 恕我直言，在这种情况下，分解东西可能会更复杂。

Answer 3

我确信有更好的基于泛型的解决方案。 但还是试了一下。

编辑：正如评论所说，静态方法不能被重写，因此一种选择是保留它并使用 TwoLetterCode 对象并强制转换它们，但是，正如其他人已经指出的那样，这是相当无用的。

这个怎么样？

public class TwoLetterCode {
    public readonly string Value;
    public static TwoLetterCode TryParseSt(string tlc) {
        if (tlc == null)
        {
            return null;
        }

        if (tlc.Length > 2)
        {
            tlc = tlc.Substring(0, 2);
        }

        try
        {
            return new TwoLetterCode(tlc);
        }
        catch (ArgumentException)
        {
            return null;
        }
    }
}
//Likewise for Region
public class LanguageCode : TwoLetterCode {
    public LanguageCode(string language)
    {
        this.Value = new CultureInfo(language).TwoLetterISOLanguageName;
    }
    public static LanguageCode TryParse(string language) {
        return (LanguageCode)TwoLetterCode.TryParseSt(language);
    }
}

Answer 4

就目前而言，这两个方法由于静态方法而无法很好地重构。

您要么最终在基类上使用某种工厂方法，该方法返回该基类的类型（随后需要转换），要么您需要某种额外的帮助程序类。

考虑到额外的代码量以及随后转换为适当的类型，这是不值得的。

Answer 5

1. 创建通用基类（例如 AbstractCode）

2. 添加抽象方法，例如

   protected T GetConstructor(字符串代码); 
     

3. 在基类中重写

   受保护的覆盖 RegionCode GetConstructor(字符串代码) 
     { 
         返回新的区域代码（代码）； 
     } 
     

4. 最后，对 string GetIsoName(string code) 执行相同的操作，例如

   受保护的覆盖 GetIsoName（字符串代码） 
     { 
         返回新的 RegionCode(code).TowLetterISORegionName; 
     } 
     

这将重构两者。 克里斯·金普顿确实提出了一个重要问题：这种努力是否值得。

Answer 6

您可以将它们组合成一个 Locale 类，该类存储语言代码和区域代码，具有区域和语言的访问器以及一个解析函数，该函数还允许像“en_gb”这样的字符串...

这就是如何我见过各种框架中处理语言环境的情况。

Answer 7

这是一个相当简单的问题，对我来说，这就像一个家庭作业。

您显然可以看到代码中的公共位，并且我很确定您可以通过将这些东西放入超类中来自己尝试。