.Net 4.0 重构现有“if”条件和“is”运算符的优化代码

Question

我有以下 C# 代码。它工作正常；但是GetDestination() 方法使用is operator 会被多个if 条件所干扰。

在 .Net 4.0（或更高版本）中，避免这些“if”条件的最佳方法是什么？

编辑：角色是业务模型的一部分，而目标纯粹是使用该业务模型的特定应用程序的工件。

代码

public class Role { }
public class Manager : Role { }
public class Accountant : Role { }
public class Attender : Role { }
public class Cleaner : Role { }
public class Security : Role { }

class Program
{
    static string GetDestination(Role x)
    {
        string destination = @"\Home";

        if (x is Manager)
        {
            destination = @"\ManagerHomeA";
        }

        if (x is Accountant)
        {
            destination = @"\AccountantHomeC";
        }

        if (x is Cleaner)
        {
            destination = @"\Cleaner";
        }

        return destination;

    }

    static void Main(string[] args)
    {
        string destination = GetDestination(new Accountant());
        Console.WriteLine(destination);
        Console.ReadLine();
    }
}

参考文献

1. Dictionary<T,Delegate> with Delegates of different types: Cleaner, non string method names?
2. Jon Skeet: Making reflection fly and exploring delegates
3. if-else vs. switch vs. Dictionary of delegates
4. Dictionary with delegate or switch?
5. Expression and delegate in c#

Answer 1

拥有将在派生类中被覆盖的virtual 属性应该可以解决问题：

class Role
{
    public virtual string Destination { get { return "Home"; } }
}
class Manager : Role
{
    public override string Destination { get { return "ManagerHome;"; } }
}
class Accountant : Role
{
    public override string Destination { get { return "AccountantHome;"; } }
}
class Attender : Role
{
    public override string Destination { get { return "AttenderHome;"; } }
}
class Cleaner : Role
{
    public override string Destination { get { return "CleanerHome;"; } }
}
class Security : Role { }

我没有将属性抽象化，以便在派生类中未覆盖时提供默认的 Home 值。

用法：

string destination = (new Accountant()).Destination;
Console.WriteLine(destination);
Console.ReadLine();

Answer 2

这是一种选择：

private static readonly Dictionary<Type, string> DestinationsByType =
    new Dictionary<Type, string> 
{
    { typeof(Manager), @"\ManagerHome" },
    { typeof(Accountant), @"\AccountantHome" },
    // etc
};

private static string GetDestination(Role x)
{
    string destination;
    return DestinationsByType.TryGetValue(x.GetType(), out destination)
        ? destination : @"\Home";
}

注意：

• 这不能处理空参数。目前尚不清楚您是否真的需要它。不过，您可以轻松添加 null 处理。
• 这不会与继承一起复制（例如class Foo : Manager）；如有必要，您可以通过提升继承层次结构来做到这一点

这是一个确实处理这两点的版本，但以复杂性为代价：

private static string GetDestination(Role x)
{
    Type type = x == null ? null : x.GetType();
    while (type != null)
    {
        string destination;
        if (DestinationsByType.TryGetValue(x.GetType(), out destination))
        {
            return destination;
        }
        type = type.BaseType;
    }
    return @"\Home";
}

编辑：如果Role 本身有一个Destination 属性会更干净。这可以是虚拟的，也可以由 Rolebase 类提供。

然而，目的地可能真的不是Role 应该关注的事情 - 可能Role 是业务模型的一部分，目的地纯粹是一个特定应用程序使用的工件这种商业模式。在这种情况下，您不应该将其放入Role，因为这会破坏关注点分离。

基本上，在不了解更多上下文的情况下，我们无法判断哪种解决方案最合适——这在设计问题上经常是这样。

Answer 3

方法一（已选）：使用dynamic关键字实现multimethods/double dispatch

方法 2：使用 dictionary 来避免 if 块，如下 Jon Skeet 的回答中所述。

方法 3： 如果存在不相等的条件（例如，如果输入 HashList 和 delegates。参考how to refactor a set of <= , >= if...else statements into a dictionary or something like that

方法 4： 下面 MarcinJuraszek 的回答中提到的虚拟功能。

MultiMethods / Double Dispatch 使用动态关键字的方法

基本原理：这里的算法会根据类型而变化。也就是说，如果输入是 Accountant，则要执行的功能与 Manager 不同。

    public static class DestinationHelper
    {
        public static string GetDestinationSepcificImplm(Manager x)
        {
            return @"\ManagerHome";
        }

        public static string GetDestinationSepcificImplm(Accountant x)
        {
            return @"\AccountantHome";
        }

        public static string GetDestinationSepcificImplm(Cleaner x)
        {
            return @"\CleanerHome";
        }
    }

   class Program
    {
        static string GetDestination(Role x)
        {

            #region Other Common Works
            //Do logging
            //Other Business Activities
            #endregion

            string destination = String.Empty;
            dynamic inputRole = x;
            destination = DestinationHelper.GetDestinationSepcificImplm(inputRole);
            return destination;
        }

        static void Main(string[] args)
        {
            string destination = GetDestination(new Security());
            Console.WriteLine(destination);
            Console.WriteLine("....");
            Console.ReadLine();
        }

    }

Answer 4

这是一种强类型的命令式语言，因此if 语句和类型检查将会发生。

话虽如此，您是否考虑过Role 上的virtual 方法可以被覆盖以提供目标string？

另一种选择，查找表！

Dictionary<Type, string> paths = new Dictionary<TYpe, string>()
{
    { typeof(Manager),  @"\ManagerHomeA" }
    { typeof(Accountant),  @"\AccountantHomeC" }
    { typeof(Cleaner),  "Cleaner" }
}

string path = @"\Home";
if(paths.ContainsKey(x.GetType())
    path = paths[x];

Answer 5

一种方法是使用地图而不是 if：

//(psuedocode)
private Dictionary<Type, string> RoleMap;

void SomeInitializationCodeThatRunsOnce()
{
  RoleMap.Add(typeof(Manager), @"\ManagerHome");
  RollMap.Add(typeof(Accountant), @"\AccountantHome");
  // ect...
}

string GetDestination(Role x)
{
  string destination;
  if(!RoleMap.TryGet(x.GetType(), out destination))
    destination = @"\Home";
  return destination;
}

延伸阅读：http://www.hanselman.com/blog/BackToBasicsMovingBeyondForIfAndSwitch.aspx

Answer 6

角色应该有一个可以返回目的地的虚函数：

public virtual string GetDestination()
{
     return "Home";
}

所有的类都应该重写这个函数并返回正确的字符串。然后在你的代码中：

var role = new Accountant();
string destination = role.GetDestination();

我希望这会有所帮助。可能有错别字，我是从头写的。

Answer 7

您可以使用接口定义或抽象方法/属性

带接口：

public interface IDestinationProvider
{
    sting Destination { get; }
}

string GetDestination(Role role)
{
    var provider = role as IDestinationProvider;
    if (provider != null)
        return provider.Destination;
    return "Default";
}

带有抽象基类

abstract class Role 
{ 
    public abstract string GetDestination();
}

class Manager : Role
{
    public virtual string GetDestination() { return "ManagerHomeA"; }
}

string GetDestination(Role role)
{
    return @"\" + role.GetDestination();
}

或带有属性：

[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
public class DestinationAttribute : Attribute
{
    public DestinationAttribute() { this.Path = @"\Home"; }
    public string Path { get; set; }
}

[Destination(Path = @"\ManagerHome")]
public class Manager : Role { }

string GetDestination(Role role)
{
    var destination = role.GetType().GetCustomAttributes(typeof(DestinationAttribute), true).FirstOrDefault();
    if (destination != null)
        return destination.Path;

    return @"\Home";
}