c#参数性能

Question

所以我有一个非常经常地调用方法作为模式的一部分.它看起来像这样:

DoWork(new TimeSpan(0, 0, 2, 0));

或者在代码的另一部分:

DoWork(new TimeSpan(0, 0, 6, 50));

在每种情况下,参数都不会改变,我最近醒来并找出了为每次调用创建参数的性能问题.我的解决方案是:

// instance field
TimeSpan _cachedValue = new TimeSpan(0, 0, 2, 0);
// and when called, 
DoWork(this._cachedValue)

这一点都非常明显,我遇到的问题是将参数值存储在一个字段中...它的凌乱 - 在一个已经膨胀的类中(例如我在一个类中调用10个左右的do work方法)每个变种数千次 - 所以这十个额外的领域).

如果我可以做这样的事情,那会很酷:

DoWork([DoesNotChange()]new TimeSpan(0, 0, 2, 0));

参数的这个理论属性表明,对于该特定调用,该值只需要计算一次,然后重复传递给方法.

这样的事情可能吗？或者我刚刚离开我的坚果？

干杯

编辑:

哇你们大家工作快,谢谢.至于我的问题,我上次应该学会不要过度简化 - 对不起.为了清楚起见,我将发布一个实际的代码段.此类用于Silverlight应用程序中的数据绑定.我正在使用PropertyChanged事件的强类型来实现可维护性:

internal class BasicDataClass : INotifyPropertyChanged
{
    private readonly Expression<Func<double>> _propertySelector;
    private double _someFieldA;
    private double _someFieldB;
    private double _someFieldC;

    public BasicDataClass()
    {
        _propertySelector = () => SomeFieldC;
    }

    /// <summary>
    /// This is fastest
    /// </summary>
    public double SomeFieldA
    {
        get { return _someFieldA; }
        set
        {
            if (!_someFieldA.Equals(value))
            {
                _someFieldA = value;
                PropertyChanged.Raise(this, "SomeFieldA");
            }
        }
    }

    /// <summary>
    /// This is many times slower
    /// </summary>
    public double SomeFieldB
    {
        get { return _someFieldB; }
        set
        {
            if (!_someFieldB.Equals(value))
            {
                _someFieldB = value;
                PropertyChanged.Raise(() => SomeFieldB);
            }
        }
    }

    /// <summary>
    /// This is only, very slightly slower than A
    /// but requires an extra field
    /// </summary>
    public double SomeFieldC
    {
        get { return _someFieldC; }
        set
        {
            if (!_someFieldC.Equals(value))
            {
                _someFieldC = value;
                PropertyChanged.Raise(_propertySelector);
            }
        }
    }

    #region INotifyPropertyChanged Members

    /// <summary>
    /// The property changed.
    /// </summary>
    public event PropertyChangedEventHandler PropertyChanged;

    #endregion
}

作为参考,Raise扩展方法:

    public static void Raise<TValue>(
        this PropertyChangedEventHandler handler, Expression<Func<TValue>> propertySelector)
    {
        if (handler != null)
        {
            var memberExpression = propertySelector.Body as MemberExpression;
            if (memberExpression != null)
            {
                object sender = ((ConstantExpression)memberExpression.Expression).Value;
                handler(sender, new PropertyChangedEventArgs(memberExpression.Member.Name));
            }
        }
    }

    public static void Raise(this PropertyChangedEventHandler handler, object sender, string propertyName)
    {
        if (handler != null)
        {
                handler(sender, new PropertyChangedEventArgs(propertyName));
        }
    }

再次,抱歉没有具体.

Answer 1

这些基本上都是常数,对吧？那么为什么不用它们填充静态字段:

private static readonly TimeSpan RpcTimeOut = TimeSpan.FromSeconds(2);

...
DoWork(RpcTimeOut);

我认为这比尝试归因参数更清晰.

通过将这些作为静态字段,您不会真正膨胀任何对象 - 每个AppDomain只有一个字段值.