Comment vérifier si une vue contrôleur peut effectuer un segue

Cela peut être une question très simple, mais ne donnent aucun résultat lors de la recherche pour elle si elle est ici...

Je suis en train de travailler sur un moyen de vérifier si un certain point de vue contrôleur peut effectuer une transition avec l'identifiant XYZ avant l'appel de la performSegueWithIdentifier: méthode.

Quelque chose le long des lignes de:

if ([self canPerformSegueWithIdentifier:@"SegueID"])
    [self performSegueWithIdentifier:@"SegueID"];

Possible?

Exactement la question que je suis à la recherche de la réponse à l'heure...
Hey Dan, j'ai fini par utiliser @try @catch @finally. Il fonctionne très bien.
Je l'ai fait aussi, j'avais vraiment l'espoir il est en fait un moyen de vérifier cela. En règle générale, j'essaie d'éviter les situations où une exception PEUT être levée au cours normal d'exécution situations.
Curieux de savoir pourquoi vous ne savez pas à l'avance si un viewController pourrait gérer un segue. Est-il un code de problème de conception, etc.
Dans mon cas, je voudrais pour une configuration automatique. Si une chose est associé à un segue, je peux configurer son INTERFACE utilisateur pour montrer que (plus précisément, c'est UITableViewCell instances, et de vouloir configurer leurs accessoires). Il ya beaucoup d'autres façons d'atteindre le même objectif (j'utilise), mais à la façon que je peux penser de conduire à la répétition, qui je tiens à éviter.

InformationsquelleAutor Rog | 2012-03-08

6

Comme indiqué dans la documentation:

Apps normalement n'ont pas besoin de déclencher enchaîne directement.
Au lieu de cela, vous configurez un objet dans Interface Builder associé avec
le point de vue du contrôleur, tel qu'un contrôle incorporé dans son point de vue de la hiérarchie,
pour déclencher la séquence. Cependant, vous pouvez appeler cette méthode pour déclencher une
segue par programme, peut-être en réponse à une action qui ne peut pas
être spécifié dans la table de montage séquentiel fichier de ressources. Par exemple, vous pourriez
appeler à partir d'une action personnalisée gestionnaire utilisé pour traiter secouer ou
accéléromètre événements.

La-vue-contrôleur qui reçoit ce message doit avoir été chargé
à partir d'un storyboard. Si le point de vue du contrôleur n'est pas associée à
storyboard, peut-être parce que vous avez alloué et initialisé vous-même,
cette méthode lève une exception.

Cela étant dit, lorsque vous déclenchez le segue, normalement, c'est parce qu'il est supposé que les UIViewController sera en mesure de répondre à l'aide d'un segue's identificateur. Je suis également d'accord avec Dan, F, vous devriez essayer d'éviter les situations où une exception peut être levée. La raison pour vous de ne pas être en mesure de faire quelque chose comme ceci:
```
if ([self canPerformSegueWithIdentifier:@"SegueID"])
    [self performSegueWithIdentifier:@"SegueID"];
```
Je devine que:
1. respondsToSelector: vérifie seulement si vous êtes capable de gérer ce message lors de l'exécution. Dans ce cas, vous pouvez, parce que la classe UIViewController est en mesure de répondre à performSegueWithIdentifier:sender:. Pour vérifier si une méthode est capable de gérer un message avec certains paramètres, je suppose qu'il serait impossible, parce que, pour déterminer s'il est possible, il a fait exécuter, et quand faire le NSInvalidArgumentException à la hausse.
2. Pour créer ce que vous avez suggéré, il serait utile de recevoir une liste de segue l'id de la UIViewController est associée. À partir de la UIViewController la documentation, je n'étais pas capable de trouver quelque chose qui ressemble à ça
Que pour l'instant, je devine votre meilleur pari, c'est de continuer avec la @try @catch @finally.

InformationsquelleAutor Rui Peres
24

Pour vérifier si la séquence a existé ou pas, j'ai simplement entouré l'appel avec un try-et-bloc catch. Consultez l'exemple de code ci-dessous:
```
@try {
    [self performSegueWithIdentifier:[dictionary valueForKey:@"segue"] sender:self];
}
@catch (NSException *exception) {
    NSLog(@"Segue not found: %@", exception);
}
```
Espère que cette aide.
- Cette solution fonctionne très bien. Notez que si vous avez une exception point d'arrêt, il va encore se casser. Vous pouvez cependant continuer sans s'écraser.
- Vous pouvez obtenir des fuites de mémoire, en vertu de l'ARC, car il ne nettoyez pas exception à la règle.
- Ne pas utiliser ce. Comme Andy a dit il y a une fuite à la vue du contrôleur de l'envoi de la performSegueWithIdentifier:sender: message, et tous ses enfants-vue-contrôleur (parce que UIKit conserver la vue du contrôleur, mais n'obtient jamais la chance de le libérer en raison de l'exception).
- ce n'est pas de travailler plus
InformationsquelleAutor Michael Miscampbell
14
```
- (BOOL)canPerformSegueWithIdentifier:(NSString *)identifier
{
    NSArray *segueTemplates = [self valueForKey:@"storyboardSegueTemplates"];
    NSArray *filteredArray = [segueTemplates filteredArrayUsingPredicate:[NSPredicate predicateWithFormat:@"identifier = %@", identifier]];
    return filteredArray.count>0;
}
```
- Merci c'est bon à savoir (même si elle est sans-papiers, comportement).
- Je regrette que je n'ai qu'un upvote pour donner. Grande utilisation de prédicats, Evgeny.
- NB en fonction de la réponse à stackoverflow.com/a/35060917/305913 , l'utilisation de ce sans-papiers, le comportement est susceptible de causer à votre application d'être rejeté à partir de l'app store.
- grande, et btw, vous pouvez également vérifier pour segueClassName si ses personnalisé segue classe.
InformationsquelleAutor Evgeny Mikhaylov

_{Ce post a été mis à jour pour Swift 4.}

Ici est un plus correct moyen rapide de vérifier si un segue existe:

extension UIViewController {
func canPerformSegue(withIdentifier id: String) -> Bool {
        guard let segues = self.value(forKey: "storyboardSegueTemplates") as? [NSObject] else { return false }
        return segues.first { $0.value(forKey: "identifier") as? String == id } != nil
    }

    ///Performs segue with passed identifier, if self can perform it.
    func performSegueIfPossible(id: String?, sender: AnyObject? = nil) {
        guard let id = id, canPerformSegue(withIdentifier: id) else { return }
        self.performSegue(withIdentifier: id, sender: sender)
    }
}

//1
if canPerformSegue("test") {
    performSegueIfPossible(id: "test") //or with sender: , sender: ...)
}

//2
performSegueIfPossible(id: "test") //or with sender: , sender: ...)

Super réponse, je m'inquiète que moi.valueForKey("storyboardSegueTemplates"), "storyboardSegueTemplates" serait une propriété privée, il n'est pas exposé/documenté n'importe où. Est-ce code transmis par le biais de l'app store de validation? Quiconque utilisé dans les applications de production?

InformationsquelleAutor Arbitur

Vous pouvez remplacer l' -(BOOL)shouldPerformSegueWithIdentifier:expéditeur: méthode et de faire de votre logique.

- (BOOL) shouldPerformSegueWithIdentifier:(NSString *)identifier sender:(id)sender {
    if ([identifier isEqualToString:@"someSegue"]) {
        if (!canIPerformSegue) {
            return NO;
        }
    }
    return YES;    
}

Espère que cette aide.

InformationsquelleAutor ffxfiend

Référence CanPerformSegue.swift

import UIKit

extension UIViewController{
    func canPerformSegue(identifier: String) -> Bool {
        guard let identifiers = value(forKey: "storyboardSegueTemplates") as? [NSObject] else {
            return false
        }
        let canPerform = identifiers.contains { (object) -> Bool in
            if let id = object.value(forKey: "_identifier") as? String {
                return id == identifier
            }else{
                return false
            }
        }
        return canPerform
    }
}

InformationsquelleAutor yuelong qin

Swift version de Evgeny Mikhaylov de réponse, ce qui a fonctionné pour moi:

- Je réutiliser un contrôleur pour les deux points de vue. Cela me permet de réutiliser le code.

if(canPerformSegueWithIdentifier("segueFoo")) {
  self.performSegueWithIdentifier("segueFoo", sender: nil)
}
else {
  self.performSegueWithIdentifier("segueBar", sender: nil)
}


func canPerformSegueWithIdentifier(identifier: NSString) -> Bool {
    let templates:NSArray = self.valueForKey("storyboardSegueTemplates") as! NSArray
    let predicate:NSPredicate = NSPredicate(format: "identifier=%@", identifier)

    let filteredtemplates = templates.filteredArrayUsingPredicate(predicate)
    return (filteredtemplates.count>0)
}

Je crois que cette méthode est le nom est réservé à iOS, car je suis en train de vivre un comportement inattendu à l'aide de cette approche. Il est préférable de le renommer, par exemple, à canRunSegueWithIdentifier

InformationsquelleAutor JoeGalind

-1

Il n'y a aucun moyen de vérifier cela en utilisant les fonctions standard, ce que vous pouvez faire est de la sous-classe UIStoryboardSegue et stocker les informations dans la source - vue-contrôleur (qui est transmis au constructeur). Dans interface builder, sélectionnez "Custom" comme la séquence de type de type de la classe nom de votre segue, votre constructeur sera appelé à chaque segue instancié et vous pouvez interroger les données stockées, si elle existe.

Vous devez également remplacer les perform méthode à appeler [source presentModalViewController:destination animated:YES] ou [source pushViewController:destination animated:YES] en fonction de ce type de transition que vous voulez.
- L'appel de présenter, push et pop par programme est très dangereux parce que la séquence peut être modifiée à tout moment à partir d'un modèle à une poussée de la scène. Lorsque vous sautez un modal il va se planter. Il est préférable d'être sûr que le nommé segue existe ou utiliser try/catch qui, je pense, est encore assez bâclée, car il n'est pas vraiment exceptionnel. Il devrait y avoir une méthode pour vérifier si un segue identificateur est défini. Cela semble être absent sur le but.
InformationsquelleAutor Hampus Nilsson

Vous devez vous connecter pour publier un commentaire.