Question

我正在构建一个应用程序，我的很多视图只显示一次。所以我这样做：

+(listNewController *) singleton
{
    return _singleton;
}

- (void)viewDidLoad
{
    [super viewDidLoad];
    _singleton = self;

中的某个地方

- (void)viewDidUnload
{
    _singleton = nil;

现在，不仅我对单个ViewController有了很好的引用，我还可以做一些代码保护，以确保只有在_singleton == nil时调用viewDidLoad。

但是大多数人在应用程序委托上引用了他们的ViewController而不是单例。

为什么？

无论如何，有什么加分和减号？

Answer 1

首先，我不确定大多数人都会在应用程序委托中添加引用。大多数初学者肯定会这样做，因为当您创建项目时，app委托就在那里，而且这是唯一可以从代码中的任何位置访问的对象，而无需执行任何其他操作。

缺点主要在于，只是因为方便而将所有东西放在那里并不是最好的做法。 App Delegate就是这样一个委托对象，它执行与应用程序生命周期相关的操作，而不是全局变量的容器。因此，它违反了封装的概念，只是在委托中存储与该委托的角色无关的东西。

在您的情况下，您正在使用单例来返回视图控制器的单个实例。我不确定这是最好的方法。在多个视图控制器的情况下，在特定场景中运行良好的功能是不可重用的。由于这种类要多次实例化，如果有意义的话，将它定义为单例感觉不合适。

在我看来，如果你创建一个单独的单例类（比如MyViewControllersSingleton）会更好，你可以在其中引用不同的唯一控制器作为属性。单例对象可以从任何地方以相同的方式调用：

[MyViewControllersSingleton sharedInstance].listNewController;

对于大多数应用程序，我通常拥有大部分全局变量和指向一个单独的独特视图控制器的指针，我称之为AppSingleton。但是如果你想要更好地分离关注点，你可以想象创建多个单身人士。

Answer 2

我不确定提问者试图解决的问题，但只是发布了我用来制作单身人士的两种方法：

方法1，使用+load：

@class MyClass

static MyClass * __instance = nil ;

+(void)load
{
    @autoreleasepool {
        __instance = [ [ self alloc ] init ] ;  // (use your designated initializer)
    }
}

+(MyClass*)sharedInstance
{
    return __instance ;
}

@end

方法2，延迟初始化：

@implementation MyClass

+(MyClass*)sharedInstance
{
    @synchronized( self )
    {
        if ( !__instance )
        {
            __instance = [ [ self alloc ] init ] ;  // (use your designated initializer)
        }

        return __instance ;
    }
}

@end

对于视图控制器案例，请尝试：

@implementation MyViewController 

static MyViewController * __instance = nil ;

- (id)initWithNibName:(NSString *)nibName bundle:(NSBundle *)nibBundle
{
    @synchronized( [ self class ] )
    {
        self = __instance ;
        if ( !self )
        {
            self = [ super initWithNibName:nibName bundle:nibBundle ] ;
            __instance = self ;
        }
    }

    // ...finish init as normal here

    return self ;
}

@end

在UIViewController类上没有单例的优点是什么

2 个答案: