我正在尝试重构所有开关的母亲，我不确定如何做到这一点。这是现有的代码：
bool FieldSave(Claim claim, string field, string value)
{
//out vars for tryparses
decimal outDec;
int outInt;
bool outBool;
DateTime outDT;
//our return value
bool FieldWasSaved = true;
//World Greatest Switch - God help us all.
switch (field)
{
case "Loan.FhaCaseNumber":
GetLoan(claim).FhaCaseNumber = value;
break;
case "Loan.FhaInsurance":
if (bool.TryParse(value, out outBool))
{
GetLoan(claim).FhaInsurance = outBool;
FieldWasSaved = true;
}
break;
case "Loan.UnpaidPrincipalBalance":
if (decimal.TryParse(value, out outDec))
{
GetLoan(claim).UnpaidPrincipalBalance = outDec;
FieldWasSaved = true;
}
break;
case "Loan.Mortgagor_MortgagorID":
if(Int32.TryParse(value, out outInt)){
GetLoan(claim).Mortgagor_MortgagorID = outInt;
FieldWasSaved = true;
}
break;
case "Loan.SystemDefaultDate":
if (DateTime.TryParse(value, out outDT))
{
GetLoan(claim).SystemDefaultDate = outDT;
FieldWasSaved = true;
}
break;
//And so on for 5 billion more cases
}
db.SaveChanges();
return FieldWasSaved;
}
无论如何以通用方式执行此操作还是实际需要此超级开关？
A BIT MORE CONTEXT 我并没有声称理解其他开发人员所需的所有魔法，但基本上是字符串＆＃34; Loan.FieldName＆＃34;来自标记为HTML输入标记的一些元数据。这在此开关中用于将特定字段链接到实体框架数据表/属性组合。虽然这是来自一个强烈的类型视图，但由于人类之外的原因，这种映射已成为整个事物的粘合剂。
答案 0 :(得分：4)
通常当我重构时，它会以某种方式降低代码的复杂性，或者使其更容易理解。在你发布的代码中，我不得不说它看起来并不那么复杂（尽管可能有很多行，它看起来非常重复和直接）。所以除了代码美学之外，我不确定你通过重构一个开关会获得多少收益。
话虽如此，我可能想要创建一个字典，其密钥是field，值是一个委托，其中包含每个案例的代码（每个方法可能会返回一个具有FieldWasSaved值的bool，并且对于其他4个值将具有一些out-params）。然后你的方法只使用字段从字典中查找委托，然后调用它。
当然，我可能只是按原样保留代码。对于其他开发人员而言，字典方法可能并不那么明显，并且可能使代码不那么明显。
更新：我也同意守夜人认为最好的重构可能会涉及未显示的代码 - 也许这些代码很多都属于其他类（可能会有一个贷款类，封装所有贷款字段，或类似的......）。
答案 1 :(得分：2)
如果case语句中的名称与类中的属性匹配，我会将其全部更改为使用反射。
例如，这里是我们基本业务记录核心的精简版本，我们使用它来将数据移入和移出数据库，表单，Web服务等。
public static void SetFieldValue(object oRecord, string sName, object oValue)
{
PropertyInfo theProperty = null;
FieldInfo theField = null;
System.Type oType = null;
try
{
oType = oRecord.GetType();
// See if the column is a property in the record
theProperty = oType.GetProperty(sName, BindingFlags.Instance | BindingFlags.IgnoreCase | BindingFlags.Public, null, null, new Type[0], null);
if (theProperty == null)
{
theField = oType.GetField(sName, BindingFlags.Instance | BindingFlags.IgnoreCase | BindingFlags.Public);
if (theField != null)
{
theField.SetValue(oRecord, Global.ValueFromDB(oValue, theField.FieldType.Name));
}
}
else
{
if (theProperty.CanWrite)
{
theProperty.SetValue(oRecord, Global.ValueFromDB(oValue, theProperty.PropertyType.Name), null);
}
}
}
catch (Exception theException)
{
// Do something useful here
}
}
在上面，Global.ValueFromDB是一个很大的switch语句，可以安全地将值转换为指定的类型。以下是其中的部分版本：
public static object ValueFromDB(object oValue, string sTypeName)
{
switch (sTypeName.ToLower())
{
case "string":
case "system.string":
return StrFromDB(oValue);
case "boolean":
case "system.boolean":
return BoolFromDB(oValue);
case "int16":
case "system.int16":
return IntFromDB(oValue);
case "int32":
case "system.int32":
return IntFromDB(oValue);
特定于FromDB的数据类型如下所示：
public static string StrFromDB(object theValue)
{
return StrFromDB(theValue, "");
}
public static string StrFromDB(object theValue, string sDefaultValue)
{
if ((theValue != DBNull.Value) && (theValue != null))
{
return theValue.ToString();
}
else
{
return sDefaultValue;
}
}
public static bool BoolFromDB(object theValue)
{
return BoolFromDB(theValue, false);
}
public static bool BoolFromDB(object theValue, bool fDefaultValue)
{
if (!(string.IsNullOrEmpty(StrFromDB(theValue))))
{
return Convert.ToBoolean(theValue);
}
else
{
return fDefaultValue;
}
}
public static int IntFromDB(object theValue)
{
return IntFromDB(theValue, 0);
}
public static int IntFromDB(object theValue, int wDefaultValue)
{
if ((theValue != DBNull.Value) && (theValue != null) && IsNumeric(theValue))
{
return Convert.ToInt32(theValue);
}
else
{
return wDefaultValue;
}
}
在短期内，您可能看起来不会节省太多代码，但一旦实施（我们当然有），您会发现许多用途。
答案 2 :(得分：2)
我知道回答你自己的问题是天哪，但这就是我的老板用反射和字典解决这个问题的方法。具有讽刺意味的是，他在我们完成了“所有开关之母”之后几分钟就完成了他的解决方案。没有人愿意看到下午的打字变得毫无意义，但这个解决方案更加灵活。
public JsonResult SaveField(int claimId, string field, string value)
{
try
{
var claim = db.Claims.Where(c => c.ClaimID == claimId).SingleOrDefault();
if (claim != null)
{
if(FieldSave(claim, field, value))
return Json(new DataProcessingResult { Success = true, Message = "" });
else
return Json(new DataProcessingResult { Success = false, Message = "Save Failed - Could not parse " + field });
}
else
return Json(new DataProcessingResult { Success = false, Message = "Claim not found" });
}
catch (Exception e)
{
//TODO Make this better
return Json(new DataProcessingResult { Success = false, Message = "Save Failed" });
}
}
bool FieldSave(Claim claim, string field, string value)
{
//our return value
bool FieldWasSaved = true;
string[] path = field.Split('.');
var subObject = GetMethods[path[0]](this, claim);
var secondParams = path[1];
PropertyInfo propertyInfo = subObject.GetType().GetProperty(secondParams);
if (propertyInfo.PropertyType.IsGenericType && propertyInfo.PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>))
{
FieldWasSaved = SetValue[Nullable.GetUnderlyingType(propertyInfo.PropertyType)](propertyInfo, subObject, value);
}
else
{
FieldWasSaved = SetValue[propertyInfo.PropertyType](propertyInfo, subObject, value);
}
db.SaveChanges();
return FieldWasSaved;
}
// these are used for dynamically setting the value of the field passed in to save field
// Add the object look up function here.
static Dictionary<string, Func<dynamic, dynamic, dynamic>> GetMethods = new Dictionary<string, Func<dynamic, dynamic, dynamic>>()
{
{ "Loan", new Func<dynamic, dynamic, dynamic>((x, z)=> x.GetLoan(z)) },
// and so on for the 15 or 20 model classes we have
};
// This converts the string value comming to the correct data type and
// saves the value in the object
public delegate bool ConvertString(PropertyInfo prop, dynamic dynObj, string val);
static Dictionary<Type, ConvertString> SetValue = new Dictionary<Type, ConvertString>()
{
{ typeof(String), delegate(PropertyInfo prop, dynamic dynObj, string val)
{
if(prop.PropertyType == typeof(string))
{
prop.SetValue(dynObj, val, null);
return true;
}
return false;
}
},
{ typeof(Boolean), delegate(PropertyInfo prop, dynamic dynObj, string val)
{
bool outBool = false;
if (Boolean.TryParse(val, out outBool))
{
prop.SetValue(dynObj, outBool, null);
return outBool;
}
return false;
}
},
{ typeof(decimal), delegate(PropertyInfo prop, dynamic dynObj, string val)
{
decimal outVal;
if (decimal.TryParse(val, out outVal))
{
prop.SetValue(dynObj, outVal, null);
return true;
}
return false;
}
},
{ typeof(DateTime), delegate(PropertyInfo prop, dynamic dynObj, string val)
{
DateTime outVal;
if (DateTime.TryParse(val, out outVal))
{
prop.SetValue(dynObj, outVal, null);
return true;
}
return false;
}
},
};
答案 3 :(得分：1)
一种可能性是创建一个Dictionary，其中字段名称为键，委托作为值。类似的东西：
delegate bool FieldSaveDelegate(Claim claim, string value);
然后，您可以为每个字段编写单独的方法：
bool SystemDefaultDateHandler(Claim cliaim, string value)
{
// do stuff here
}
并初始化它：
FieldSaveDispatchTable = new Dictionary<string, FieldSaveDelegate>()
{
{ "Loan.SystemDefaultDate", SystemDefaultDateHandler },
// etc, for five billion more fields
}
调度员，然后：
FieldSaveDelegate dlgt;
if (!FieldSaveDispatchTable.TryGetValue(fieldName, out dlgt))
{
// ERROR: no entry for that field
}
dlgt(claim, value);
这可能比switch语句更易于维护，但它仍然不是特别漂亮。好消息是填充字典的代码可以自动生成。
如前所述，您可以使用反射来查找字段名称以确保其有效，并检查类型（也使用反射）。这样可以减少您写入的处理程序方法的数量：每种类型一个。
即使您没有使用反射，也可以减少在字典中保存类型而不是委托所需的方法数。然后你会有一个查找来获取字段的类型，以及类型上的一个小的switch语句。
当然，假设您不进行任何特殊的每场处理。如果您必须对某些字段进行特殊验证或其他处理，那么您将需要每个字段使用一种方法，或者您需要一些额外的每字段信息。
答案 4 :(得分：1)
根据您的应用程序，您可以将 Claim 重新定义为动态对象：
class Claim : DynamicObject
{
... // Current definition
public override bool TrySetMember(SetMemberBinder binder, object value)
{
try
{
var property = typeof(Loan).GetProperty(binder.Name);
object param = null;
// Find some way to parse the string into a value of appropriate type:
// (This will of course need to be improved to handle more types)
if (property.PropertyType == typeof(Int32) )
{
param = Int32.Parse(value.ToString());
}
// Set property in the corresponding Loan object
property.SetValue(GetLoan(this), param, null);
db.Save();
}
catch
{
return base.TrySetMember(binder, value);
}
return true;
}
}
如果可以，您应该能够使用以下语法通过 Claim 对象间接使用相应的 Loan 对象：
dynamic claim = new Claim();
// Set GetLoan(claim).Mortgagor_MortgagorID to 1723 and call db.Save():
claim.Mortgagor_MortgagorID = "1723";
对于失败的情况，当无法解析输入字符串时，遗憾的是会得到一个RuntimeBinderException而不是一个很好的函数返回值，所以你需要考虑这是否适合你的情况。