Lägga till registrering i en iOS/macOS-app med inbyggd autentisering - Microsoft identity platform

Gäller för: Grön cirkel med en vit bockmarkeringssymbol som anger att följande innehåll gäller för externa klienter. Externa klienter (läs mer)

Den här självstudien visar hur du registrerar en användare i din iOS/macOS-app med hjälp av inbyggd autentisering, antingen med en engångslösenkod via e-post eller med användarnamn (e-post) och lösenord. Du får också lära dig hur du samlar in användarattribut under registreringen, inklusive ett användarnamn (alias) och hanterar fel.

I den här handledningen kommer du att:

Registrera en användare med ett engångslösenord via e-post eller ett användarnamn (e-post) och lösenord.
Samla in användarattribut under registreringen, inklusive ett användarnamn (alias).
Hantera anmälningsfel.

Förutsättningar

Slutför stegen i Självstudie: Förbered din iOS/macOS-app för intern autentisering.
Om du vill samla in användarattribut under registreringen konfigurerar du användarattributen när du skapar ditt användarflöde för registrering och inloggning.
Om du vill samla in ett användarnamn (alias) under registreringen aktiverar du det inbyggda användarattributet Username i din klientorganisations användarflöde för registrering.

Om du vill registrera en användare med e-postlösenord eller användarnamn (e-post) och lösenord samlar du in ett e-postmeddelande från användaren och skickar sedan ett e-postmeddelande med ett engångslösenord till användaren. Användaren anger ett giltigt engångslösenord för e-post för att verifiera sitt användarnamn.

Om du vill registrera en användare måste du:

Skapa ett användargränssnitt (UI) för att:
- Samla in ett e-postmeddelande från användaren. Lägg till validering i dina indata för att se till att användaren anger en giltig e-postadress.
- Samla in ett lösenord om du registrerar dig med användarnamn (e-post) och lösenord.
- Samla in ett användarnamn (alias) om din app stöder aliasbaserad inloggning.
- Samla in ett engångslösenord för e-post från användaren.
- Samla in användarattribut om det behövs.
- Skicka om engångslösenordet om användaren inte tar emot det.
- Starta registreringsflödet.
I din app lägger du till en knapp vars select-händelse utlöser följande kodfragment:
```
@IBAction func signUpPressed(_: Any) {
    guard let email = emailTextField.text else {
        resultTextView.text = "Email or password not set"
        return
    }

    let parameters = MSALNativeAuthSignUpParameters(username: email)
    nativeAuth.signUp(parameters: parameters, delegate: self)
}
```
- Om du vill registrera en användare med e-post engångslösenord använder du bibliotekets signUp(parameters:delegate) metod, som svarar asynkront genom att anropa någon av metoderna för det skickade ombudsobjektet, som måste implementera SignUpStartDelegate protokollet. Följande kodrad initierar registreringsprocessen för användare:
```
nativeAuth.signUp(parameters: parameters, delegate: self)
```
  signUp(parameters:delegate) I metoden skickar du en MSALNativeAuthSignUpParameters instans som innehåller användarens e-postadress från överföringsformuläret tillsammans med ombudet (en klass som implementerar SignUpStartDelegate protokollet).
- Om du vill registrera en användare med e-post med lösenord använder du följande kodfragment:
```
@IBAction func signUpPressed(_: Any) {
    guard let email = emailTextField.text, let password = passwordTextField.text else {
       resultTextView.text = "Email or password not set"
       return
    }

    let parameters = MSALNativeAuthSignUpParameters(username: email)
    parameters.password = password
    nativeAuth.signUp(parameters: parameters, delegate: self)
}
```
  Bibliotekets signUp(parameters:delegate) metod svarar asynkront genom att anropa en av metoderna för det skickade ombudsobjektet, som måste implementera protokollet SignUpStartDelegate . Följande kodrad initierar registreringsprocessen för användare:
```
nativeAuth.signUp(parameters: parameters, delegate: self)
```
  signUp(parameters:delegate) I metoden skickar du en MSALNativeAuthSignUpParameters instans som innehåller användarens e-postadress och deras lösenord tillsammans med ombudet (en klass som implementerar SignUpStartDelegate protokollet).
- Om du vill implementera protokollet SignUpStartDelegate som ett tillägg till din klass använder du:
```
extension ViewController: SignUpStartDelegate {
    func onSignUpStartError(error: MSAL.SignUpStartError) {
        resultTextView.text = "Error signing up: \(error.errorDescription ?? "no description")"
    }

    func onSignUpCodeRequired(
        newState: MSAL.SignUpCodeRequiredState,
        sentTo: String,
        channelTargetType: MSAL.MSALNativeAuthChannelType,
        codeLength: Int
    ) {
        resultTextView.text = "Verification code sent to \(sentTo)"
    }
}
```
  Anropet till signUp(parameters:delegate) resulterar i ett anrop till antingen onSignUpCodeRequired() eller onSignUpStartError() delegatmetoder. onSignUpCodeRequired(newState:sentTo:channelTargetType:codeLength) anropas för att ange att en kod har skickats för att verifiera användarens e-postadress. Tillsammans med viss information om var koden har skickats och hur många siffror den innehåller har den här ombudsmetoden också en newState parameter av typen SignUpCodeRequiredState, vilket ger dig åtkomst till två nya metoder:
  - submitCode(code:delegate)
  - resendCode(delegate)
  Om du vill skicka koden som användaren angav använder du:
```
newState.submitCode(code: userSuppliedCode, delegate: self)
```
  - Om du vill implementera protokollet SignUpVerifyCodeDelegate som ett tillägg till din klass använder du:
```
extension ViewController: SignUpVerifyCodeDelegate {
    func onSignUpVerifyCodeError(error: MSAL.VerifyCodeError, newState: MSAL.SignUpCodeRequiredState?) {
        resultTextView.text = "Error verifying code: \(error.errorDescription ?? "no description")"
    }

    func onSignUpCompleted(newState: SignInAfterSignUpState) {
        resultTextView.text = "Signed up successfully!"
    }
}
```
    Accepterar submitCode(code:delegate) en delegatparameter och du måste implementera de metoder som krävs i SignUpVerifyCodeDelegate protokollet. I det vanligaste scenariot får du ett anrop till onSignUpCompleted(newState) som anger att användaren har registrerats och att flödet är klart.

Oavsett om du registrerar en användare med e-postlösenord eller användarnamn (e-post) och lösenord kan du samla in användarattribut innan ett användarkonto skapas. Metoden signUp(parameters:delegate) kan anropas med hjälp av en MSALNativeAuthSignUpParameters som har en attributegenskap.

Om du vill samla in användarattribut använder du följande kodfragment:
```
let attributes = [
    "country": "United States",
    "city": "Redmond"
]

let parameters = MSALNativeAuthSignUpParameters(username: email)
parameters.password = password
parameters.attributes = attributes
nativeAuth.signUp(parameters: parameters, delegate: self)
```
signUp(parameters:delegate)resulterar i ett anrop till antingen onSignUpCodeRequired() eller onSignUpStartError() delegeringsmetoder, eller till onSignUpAttributesInvalid(attributeNames: [String]) om det har implementerats i delegeringen.
Om du vill implementera SignUpStartDelegate protokollet som ett tillägg till klassen använder du följande kodfragment:
```
extension ViewController: SignUpStartDelegate {
    func onSignUpStartError(error: MSAL.SignUpStartError) {
        resultTextView.text = "Error signing up: \(error.errorDescription ?? "no description")"
    }

    func onSignUpCodeRequired(
        newState: MSAL.SignUpCodeRequiredState,
        sentTo: String,
        channelTargetType: MSAL.MSALNativeAuthChannelType,
        codeLength: Int
    ) {
        resultTextView.text = "Verification code sent to \(sentTo)"
    }

    func onSignUpAttributesInvalid(attributeNames: [String]) {
       resultTextView.text = "Invalid attributes  \(attributeNames)"
    }
}
```
Om attributen är ogiltiga anropas metoden onSignUpAttributesInvalid(attributeNames: [String]). I det här fallet visar du listan över ogiltiga attribut för användaren. Annars anropas onSignUpCodeRequired(newState:sentTo:channelTargetType:codeLength) för att ange att en kod har skickats för att verifiera användarens e-postadress. Förutom information som mottagaren av koden och antalet siffror i koden har den här ombudsmetoden en newState parameter av typen SignUpCodeRequiredState, som ger dig åtkomst till två nya metoder:
- submitCode(code:delegate)
- resendCode(delegate)

Användarattribut på en eller flera sidor

Om du vill sprida attributen på en eller flera sidor anger du de attribut som du tänker samla in på olika sidor som obligatoriska i klientkonfigurationen för kundidentitets- och åtkomsthantering (CIAM).

Anropa signUp(parameters:delegate) utan att skicka några attribut i instansen MSALNativeAuthSignUpParameters . Nästa steg är att anropa newState.submitCode(code: userSuppliedCode, delegate: self) för att verifiera användarens e-post.

SignUpVerifyCodeDelegate Implementera protokollet som ett tillägg till klassen som tidigare, men den här gången måste du implementera den valfria metoden onSignUpAttributesRequired(attributes:newState) utöver de metoder som krävs:

extension ViewController: SignUpVerifyCodeDelegate {
    func onSignUpAttributesRequired(newState: SignUpAttributesRequiredState) {
        resultTextView.text = "Attributes required"
    }

    func onSignUpVerifyCodeError(error: MSAL.VerifyCodeError, newState: MSAL.SignUpCodeRequiredState?) {
        resultTextView.text = "Error verifying code: \(error.errorDescription ?? "no description")"
    }

    func onSignUpCompleted(newState: SignInAfterSignUpState) {
        resultTextView.text = "Signed up successfully!"
    }
}

Den här ombudsmetoden har en newState parameter av typen SignUpAttributesRequiredState, som ger dig åtkomst till en ny metod:

submitAttributes(attributes:delegate)

Om du vill skicka de attribut som användaren angav använder du följande kodfragment:

let attributes = [
    "country": "United States",
    "city": "Redmond"
]

newState.submitAttributes(attributes: attributes, delegate: self)

Implementera även protokollet SignUpAttributesRequiredDelegate som ett tillägg till din klass:

extension ViewController: SignUpAttributesRequiredDelegate {
    func onSignUpAttributesRequiredError(error: AttributesRequiredError) {
        resultTextView.text = "Error submitting attributes: \(error.errorDescription ?? "no description")"
    }

    func onSignUpAttributesRequired(attributes: [MSALNativeAuthRequiredAttribute], newState: SignUpAttributesRequiredState) {
        resultTextView.text = "Attributes required"
    }

    func onSignUpAttributesInvalid(attributeNames: [String], newState: SignUpAttributesRequiredState) {
        resultTextView.text = "Attributes invalid"
    }

    func onSignUpCompleted(newState: SignInAfterSignUpState) {
        resultTextView.text = "Signed up successfully!"
    }
}

När användaren inte anger alla obligatoriska attribut, eller om attributen är ogiltiga, anropas dessa ombudsmetoder:

onSignUpAttributesInvalid: anger att ett eller flera attribut som skickades misslyckades med validering av indata. Det här felet innehåller parametern attributeNames, som är en lista över alla attribut som skickades av utvecklaren som inte kunde validera indata.
onSignUpAttributesRequired: anger att servern kräver att ett eller flera attribut skickas innan användarkontot kan skapas. Detta inträffar när ett eller flera attribut anges som obligatoriska i klientkonfigurationen. Det här resultatet innehåller attributparametern, som är en lista över MSALNativeAuthRequiredAttribute objekt, som beskriver information om de användarattribut som API:et kräver.

Båda delegeringsmetoderna innehåller en ny tillståndsreferens. Använd parametern newState för att anropa submitAttributes(attributes:delegate) igen med de nya attributen.

Användarnamnet (aliaset) är ett särskilt användarattribut. Precis som andra attribut, till exempel stad eller land, samlar du in dem under registreringen. Till skillnad från dessa attribut kan användaren senare använda aliaset för att logga in. Aliaset (till exempel "johndoe") ger användarna ett kortare, vänligare sätt att logga in än sin e-postadress.

Användarnamnet (aliaset) ersätter inte användarnamnet (e-postmeddelandet). Under registreringen måste appen alltid samla in användarnamnet (e-postmeddelandet) som primär identifierare och samlar in aliaset som ett attribut tillsammans med e-postmeddelandet. Vid inloggningen kan användaren sedan välja att logga in med antingen användarnamnet (e-postmeddelandet) eller användarnamnet (aliaset).

När det inbyggda användarattributet Användarnamn är aktiverat i ditt registreringsanvändarflöde accepterar SDK:t det via samma attributordlista som används för andra attribut som flatusername nyckeln. Du kan skicka användarnamnet (aliaset) direkt i anropet signUp så att användaren inte behöver gå igenom ett separat steg som krävs för attribut.

Om du vill samla in ett användarnamn (alias) lägger du till ett indatafält för användarnamnet i ditt registreringsgränssnitt tillsammans med e-postfältet och skickar sedan aliaset som ett attribut i registreringsanropet:

guard let email = emailTextField.text, !email.isEmpty,
      let password = passwordTextField.text, !password.isEmpty,
      let username = usernameTextField.text, !username.isEmpty else {
    showResultText("Please fill in all fields")
    return
}

let attributes: [String: Any] = [
    "flatusername": username
]

let parameters = MSALNativeAuthSignUpParameters(username: email)
parameters.password = password
parameters.attributes = attributes
nativeAuth.signUp(parameters: parameters, delegate: self)

För engångslösenordsflöden för e-post (utan lösenord) skickar du attributen utan att ange något lösenord:

let parameters = MSALNativeAuthSignUpParameters(username: email)
parameters.attributes = attributes
nativeAuth.signUp(parameters: parameters, delegate: self)

När du hanterar fel vid registrering av användarnamn (alias) error.isUserAlreadyExists omfattar egenskapen även ett duplicerat alias och error.isInvalidAttributes visar ett ogiltigt aliasvärde.

Under registreringen lyckas inte alla åtgärder. Användaren kan till exempel försöka registrera sig med en e-postadress som redan används eller skicka en ogiltig kod.

I den tidigare implementeringen av SignUpStartDelegate protokollet visades felet helt enkelt när delegatfunktionen hanterades onSignUpStartError(error) .

Om du vill förbättra användarupplevelsen genom att hantera den specifika feltypen använder du följande kodfragment:

func onSignUpStartError(error: MSAL.SignUpStartError) {
    if error.isUserAlreadyExists {
        resultTextView.text = "Unable to sign up: User already exists"
    } else if error.isInvalidPassword {
        resultTextView.text = "Unable to sign up: The password is invalid"
    } else if error.isInvalidUsername {
        resultTextView.text = "Unable to sign up: The username is invalid"
    } else {
        resultTextView.text = "Unexpected error signing up: \(error.errorDescription ?? "no description")"
    }
}

Efter ett lyckat registreringsflöde kan du logga in en användare utan att initiera ett inloggningsflöde. Om användaren har registrerat sig med ett användarnamn (alias) kan de logga in med antingen sin e-postadress eller sitt alias. Läs mer i artikeln Självstudie: Logga in användare automatiskt efter registrering i en iOS/macOS-app .

Nästa steg

Självstudie: Lägga till inloggning och utloggning i iOS/macOS-appen med inbyggd autentisering

Feedback

Var den här sidan till hjälp?

Last updated on 2026-06-24

Självstudie: Lägga till registrering i en iOS/macOS-app med inbyggd autentisering

Förutsättningar

Registrera en användare

Samla in användarattribut under registreringen

Användarattribut på en eller flera sidor

Samla in ett användarnamn (alias) under registreringen

Hantera registreringsfel

Valfritt: Logga in efter ett registreringsflöde

Nästa steg

Feedback

Ytterligare resurser