Question

我注意到在我们用于很多网页的自定义基类中，我们有一些静态方法。由于该类被用作网页的基类，因此将方法设置为静态会带来什么好处呢？我在想但没有想要验证。

同样在自定义基类中，我们具有在另一个类库中调用我们的manager类中的其他静态方法的属性，并返回DataTable或HashTable。我可以看到哪里作为开发人员编写代码的便利因素，但除此之外，他们还有任何理由让这些方法在那里保持静态？

所以现有代码看起来像这样：

public class CustomBaseClass
    protected Hashtable displayText
        {
            get{
                if(_displayText == null)
                    displayText = MyManager.GetCustomersList(sCustID);

因为GetCustomersList是静态的，所以此方法中的每个方法也必须是静态的。一直到我们的数据访问层。我觉得用这种方式编码似乎很奇怪，但对你们所想的都感到好奇。

我们编写应用程序的旧开发人员已经不见了，他们在整个地方使用它们。他们的任何否定或注意使用静态方法，尤其是在asp.net应用程序中？

如果我创建单例不会更有意义，那么我不必将所有方法调用直到我们的DAL静态？洛尔

提前致谢。

Answer 1

使方法静态的主要原因通常是它不依赖于类的任何实例成员。避免必须创建类的新实例来调用该方法，然后需要在以后对其进行垃圾回收。

静态和实例方法显然都有它们的位置。通常，我为实用程序方法创建静态方法，这些方法从静态成员（尽管你必须同步）或参数获取所有状态，或者为类的所有实例设置类范围属性。

你可以使用单身人士（虽然有些人讨厌他们），或者你可以让你的DAO对象在最高级别的课程中创建，然后进一步向下注入。

使用静态方法的主要问题是虽然单元测试静态方法非常容易，但是通过调用静态DAO类来模拟结果可能会更加困难。如果它是一个注入的实例，那么模拟它会容易得多。

Answer 2

在Web应用程序（和此问题）的上下文中标记static的唯一原因是它在所有请求线程中共享并保留在内存中。这意味着如果两个请求都处理并且每个请求都尝试设置静态数据，那么您就会遇到竞争条件（并且可能存在线程问题）。

在您的特定情况下，您的老开发人员似乎只是懒惰;没有理由说它必须是静态的（基于提供的代码示例）。

Answer 3

比单身或静态类更好的选择是使用Monostate Pattern。

基本上，在Monostate模式中，通过将所有静态成员标记为私有并提供公共实例包装，为静态类或单例提供普通类的语义。这是隐藏实现细节的一种方式，因此类被实例化和使用，就像在堆上分配单个实例一样。

Monostate带来两大好处：

一致的语义。消费者像使用任何其他类一样使用monostate。
实现隐藏。隐藏实现 - 事实上类是静态的还是单例 - 如果在线下，类实现需要更改，则更改有限只是实现该类的源文件。班上的消费者并不知道这种变化。

如果没有monostate，当类实现发生更改时，类的每个使用者，对类的每个引用或要更改的成员都必须同时更改，可能会有大量源文件分散在许多项目中。

这是一个静态类作为Monostate

的简单示例

public class MyMonostateClass
{
  #region internal, static implementation

  private static string dataItem;

  private static int someMethod( int foo )
  {
    return 0 ; // do something useful return the appropriate value
  }

  #endregion internal, static implementation

  #region public instance implementation wrappers

  public string DataItem
  {
    get { return dataItem; }
    set { dataItem = value; }
  }

  public int SomeMethod( int foo )
  {
    return MyMonostateClass.someMethod(foo);
  }

  #endregion public instance implementation wrappers

  public MyMonostateClass()
  {
    return ;
  }

}

和Monostate单身之一：

public class MyMonostateSingletonList : IList<int>
{
  private static readonly IList<int> instance = new List<int>() ;

  public MyMonostateSingletonList()
  {
    return ;
  }
  public int IndexOf( int item )
  {
    return instance.IndexOf(item) ;
  }
  public void Insert( int index , int item )
  {
    instance.Insert( index , item ) ;
  }
  public void RemoveAt( int index )
  {
    instance.RemoveAt( index ) ;
  }
  public int this[int index]
  {
    get
    {
      return instance[index] ;
    }
    set
    {
      instance[index] = value ;
    }
  }
  public void Add( int item )
  {
    instance.Add(item) ;
  }
  public void Clear()
  {
    instance.Clear() ;
  }
  public bool Contains( int item )
  {
    return instance.Contains(item) ;
  }
  public void CopyTo( int[] array , int arrayIndex )
  {
    instance.CopyTo( array , arrayIndex ) ;
  }
  public int Count
  {
    get { return instance.Count ; }
  }
  public bool IsReadOnly
  {
    get { return instance.IsReadOnly ; }
  }
  public bool Remove( int item )
  {
    return instance.Remove(item);
  }
  public IEnumerator<int> GetEnumerator()
  {
    return instance.GetEnumerator() ;
  }
  System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
  {
    return instance.GetEnumerator() ;
  }
}

Answer 4

我想说没有优点或缺点但是这取决于你是否应该选择静态方法的要求。想想以下情景：

您不应使用静态类/成员/方法：在一般情况下，例如 - 如果您需要存储和获取用户访问信息。
您应该使用静态方法：如果您需要实现一些实用程序方法，如发送电子邮件，记录错误，从web.config获取值，获取客户端的IP地址。

无论何时编写函数或声明变量，在创建类的对象之前，它都不会在内存中创建实例。但是如果使用static修饰符声明任何函数或变量，它会直接在内存中创建实例并全局操作。 static修饰符不引用任何对象。

我希望这会有所帮助..

在Web应用程序中使用静态方法的好处

4 个答案: