参数和列表哪个更好

我当前的代码如下，它是作为代理暴露给客户端的WCF服务方法：

public UnifiedDTO GetAllCardTitle(string trainSymbolOrCarLocation, 
                                  DateTime startDate, 
                                  DateTime endDate, 
                                  string procedureName = CardTitle.procedureNameTrainRuns)

该方法采用过程名称（作为最后一个参数），其余参数是绑定输入参数，但问题是我们在参数数量和类型发生变化的情况下没有灵活性。该项目正处于初始阶段，因此肯定会做出改变。

我所拥有的选项是转换方法，如下所示：

public UnifiedDTO GetAllCardTitle(params object [] parameters)

我们可以自由地传递参数和过程细节，并可以进行相应的绑定。但是，由于装箱和拆箱，可能会出现性能问题。它将要求客户端应用程序传递具有正确顺序和值的参数以进行绑定，正如底层所期望的那样

public UnifiedDTO GetAllCardTitle(List<Filter> parameter, string procedureName)

Where Parameter类将定义为：

public class Filter
{
    public string name { set; get; }
    public string value { set; get; }
    public string dataTypeID { set; get; }

    public Filter(string _name, string _value, string _dataTypeID)
    {
        name = _name;
        value = _value;
        dataTypeID = _dataTypeID;
    }
}

在此方法中，对于给定过程，我们将每个参数与其名称值绑定，DataType，并且它需要将值类型转换为正确的数据类型，它比最后一个方法具有更大的灵活性，并且可以按任何顺序传递，因为绑定是按名称进行的。然而，它需要对申请进行更多的尽职调查。

是否还有更好的方法使用 C#.Net 中引入的新内容来处理这种情况？

None. 使用动态 http://loosexaml.wordpress.com/2011/01/01/wcf-serialization-of-dlr-dynamic-types/对象代替

要创建与 DLR 一起使用的 C# 类，最简单的方法是从 DynamicObject 派生。尝试在 WCF 服务中使用动态类型时会出现一个限制。当尝试使用 WCF 的 DataContractSerializer 进行序列化时，尝试使用 DynamicObject 派生类型将导致运行时异常。

[DataContract]
public class SerializableDynamicObject : IDynamicMetaObjectProvider
{
[DataMember]
private IDictionary<string,object> dynamicProperties = new Dictionary<string,object>();

#region IDynamicMetaObjectProvider implementation
public DynamicMetaObject GetMetaObject (Expression expression)
{
    return new SerializableDynamicMetaObject(expression, 
        BindingRestrictions.GetInstanceRestriction(expression, this), this);
}
#endregion

#region Helper methods for dynamic meta object support
internal object setValue(string name, object value) 
{
    dynamicProperties.Add(name, value);
    return value;
}

internal object getValue(string name) 
{
    object value;
    if(!dynamicProperties.TryGetValue(name, out value)) {
        value = null;
    }
    return value;
}

internal IEnumerable<string> getDynamicMemberNames() 
{
    return dynamicProperties.Keys;
}
#endregion
}


public class SerializableDynamicMetaObject : DynamicMetaObject
{
Type objType;

public SerializableDynamicMetaObject(Expression expression, BindingRestrictions restrictions, object value) 
    : base(expression, restrictions, value) 
{
    objType = value.GetType();
}

public override DynamicMetaObject BindGetMember (GetMemberBinder binder)
{
    var self = this.Expression;
    var dynObj = (SerializableDynamicObject)this.Value;
    var keyExpr = Expression.Constant(binder.Name);
    var getMethod = objType.GetMethod("getValue", BindingFlags.NonPublic | BindingFlags.Instance);
    var target = Expression.Call(Expression.Convert(self, objType),
                                 getMethod,
                                 keyExpr);
    return new DynamicMetaObject(target,
        BindingRestrictions.GetTypeRestriction(self, objType));
}

public override DynamicMetaObject BindSetMember (SetMemberBinder binder, DynamicMetaObject value)
{
    var self = this.Expression;
    var keyExpr = Expression.Constant(binder.Name); 
    var valueExpr = Expression.Convert(value.Expression, typeof(object));
    var setMethod = objType.GetMethod("setValue", BindingFlags.NonPublic | BindingFlags.Instance);
    var target = Expression.Call(Expression.Convert(self, objType),
    setMethod, 
    keyExpr, 
    valueExpr);
    return new DynamicMetaObject(target,
        BindingRestrictions.GetTypeRestriction(self, objType));
}

public override IEnumerable<string> GetDynamicMemberNames ()
{
    var dynObj = (SerializableDynamicObject)this.Value;
    return dynObj.getDynamicMemberNames();
}
}

一个警告，动态成员可以是任何东西，这意味着在运行时有人可以将方法分配给这些字段之一。如果这在您的应用程序中可行，您需要确保分配给动态类型的任何方法都不会被序列化。我把这个作为练习留给读者。

取自这里 http://loosexaml.wordpress.com/2011/01/01/wcf-serialization-of-dlr-dynamic-types/