C# 静态参数化类的实例会发生什么？

假设我有这个班：

public class DispatcherService<T>
{
    private static Action<T> Dispatcher;

    public static void SetDispatcher(Action<T> action)
    {
        Dispatcher = action;
    }

    public static void Dispatch(T obj)
    {
        Dispatcher.Invoke(obj);
    }
}

公共类DispatcherService
{
专用静态动作调度器；
公共静态无效SetDispatcher（操作）
{
调度器=动作；
}
公共静态无效调度（T obj）
{
Dispatcher.Invoke（obj）；
}
}

让我直说吧。。。对于每种类型，我只有一个

DispatcherService

实例，并且只有在我调用它时才有。对吧?

---

只要询问内存问题。

您可以拥有任意多个

DispatcherService

实例，因为该类可以自由实例化。另一个问题是，这没有意义，因为它没有实例方法。您可以将其更改为

publicstaticclassdispatcherservice

，如果它不是要实例化的，如本例所示

---

对于每种类型，您最多还有一个

DispatcherService.Dispatcher

实例，这可能是您想要知道的。如果您不为特定的

t

访问

DispatcherService

，则不会为该

t

分配任何资源，因为可以自由实例化该类，因此您可以拥有任意多个

DispatcherService

实例。另一个问题是，这没有意义，因为它没有实例方法。您可以将其更改为

publicstaticclassdispatcherservice

，如果它不是要实例化的，如本例所示

对于每种类型，您最多还有一个

DispatcherService.Dispatcher

实例，这可能是您想要知道的。如果您没有为特定的

t

访问

DispatcherService

，则不会为该

t

分配任何资源

我只有一个例子 每种类型的DispatcherService

对

只有当我叫它的时候。对吧?

对

CLR在需要使用该代码时会发出该代码

---

注 如果我知道你在哪里，我会把它改成单件

public class DispatcherService<T>
{

    private static readonly DispatcherService<T> _dispatcher = new DispatcherService<T>();
    private Action<T> _action;

    private DispatcherService() {}

    public static DispatcherService<T> Dispatcher
    {
        get {return _dispatcher ;}
    }

    public void SetDispatcher(Action<T> action)
    {
        Dispatcher = action;
    }

    public void Dispatch(T obj)
    {
        Dispatcher.Invoke(obj);
    }
}

公共类DispatcherService
{
私有静态只读DispatcherService_dispatcher=new DispatcherService（）；
私人行动；
私有DispatcherService（）{}
公共静态调度器服务调度器
{
获取{return\u dispatcher；}
}
公共无效SetDispatcher（操作）
{
调度器=动作；
}
公共无效调度（T obj）
{
Dispatcher.Invoke（obj）；
}
}

我只有一个例子 每种类型的DispatcherService

对

只有当我叫它的时候。对吧?

对

CLR在需要使用该代码时会发出该代码

---

注 如果我知道你在哪里，我会把它改成单件

public class DispatcherService<T>
{

    private static readonly DispatcherService<T> _dispatcher = new DispatcherService<T>();
    private Action<T> _action;

    private DispatcherService() {}

    public static DispatcherService<T> Dispatcher
    {
        get {return _dispatcher ;}
    }

    public void SetDispatcher(Action<T> action)
    {
        Dispatcher = action;
    }

    public void Dispatch(T obj)
    {
        Dispatcher.Invoke(obj);
    }
}

公共类DispatcherService
{
私有静态只读DispatcherService_dispatcher=new DispatcherService（）；
私人行动；
私有DispatcherService（）{}
公共静态调度器服务调度器
{
获取{return\u dispatcher；}
}
公共无效SetDispatcher（操作）
{
调度器=动作；
}
公共无效调度（T obj）
{
Dispatcher.Invoke（obj）；
}
}

（如果您希望显示尖括号，则涉及尖括号的代码需要“格式化为代码”）@AakashM噢，谢谢，我忘了。（如果您希望显示尖括号，则涉及尖括号的代码需要“格式化为代码”）@AakashM噢，谢谢，我忘了。单身的额外好处是什么？我也很好奇，会有什么不同？因为你把它当作单身来使用。它不仅仅是一个包含helper方法的静态类，它还获得了类型信息。这是设计中的最佳实践。单例的额外好处是什么？我也很好奇，会有什么不同？因为你把它作为单例使用。它不仅仅是一个包含helper方法的静态类，它还获得了类型信息。这是设计中的最佳实践。