Powiązania wyjściowe usługi Azure Notification Hubs dla usługi Azure Functions

W tym artykule wyjaśniono, jak wysyłać powiadomienia wypychane przy użyciu powiązań usługi Azure Notification Hubs w usłudze Azure Functions. Usługa Azure Functions obsługuje powiązania wyjściowe dla usługi Notification Hubs.

Musisz skonfigurować usługę Notification Hubs dla usługi Powiadomień platformy (PNS), której chcesz użyć. Aby uzyskać więcej informacji na temat pobierania powiadomień wypychanych w aplikacji klienckiej z usługi Notification Hubs, zobacz Szybki start: konfigurowanie powiadomień wypychanych w centrum powiadomień.

Pakiety: Functions 1.x

Powiązania usługi Notification Hubs są dostępne w pakiecie NuGet Microsoft.Azure.WebJobs.Extensions.NotificationHubs w wersji 1.x. Kod źródłowy pakietu znajduje się w repozytorium GitHub azure-webjobs-sdk-extensions .

W poniższej tabeli przedstawiono sposób dodawania obsługi powiązań wyjściowych w każdym środowisku projektowym.

Pakiety: Funkcje 2.x i nowsze

Powiązanie wyjściowe nie jest dostępne w usłudze Functions 2.x i nowszych.

Przykładowy szablon:

Wysyłane powiadomienia mogą być powiadomieniami natywnymi lub powiadomieniami szablonu. Natywne powiadomienie jest przeznaczone dla określonej platformy klienta, zgodnie z konfiguracją platform we właściwości powiązania wyjściowego. Powiadomienie szablonu może służyć do określania celu na wielu platformach.

Przykłady szablonów dla każdego języka:

• Skrypt języka C#: parametr wyjściowy
• Skrypt języka C#: asynchroniczny
• Skrypt języka C#: JSON
• Skrypt języka C#: typy bibliotek
• F#
• JavaScript

Przykładowy szablon skryptu języka C#: parametr out

W tym przykładzie jest wysyłane powiadomienie dotyczące rejestracji szablonu zawierającego message symbol zastępczy w szablonie:

using System;
using System.Threading.Tasks;
using System.Collections.Generic;

public static void Run(string myQueueItem,  out IDictionary<string, string> notification, TraceWriter log)
{
    log.Info($"C# Queue trigger function processed: {myQueueItem}");
    notification = GetTemplateProperties(myQueueItem);
}

private static IDictionary<string, string> GetTemplateProperties(string message)
{
    Dictionary<string, string> templateProperties = new Dictionary<string, string>();
    templateProperties["message"] = message;
    return templateProperties;
}

Przykładowy szablon skryptu języka C#: asynchroniczny

Jeśli używasz kodu asynchronicznego, parametry out nie są dozwolone. W takim przypadku użyj polecenia IAsyncCollector , aby zwrócić powiadomienie o szablonie. Poniższy kod jest asynchronicznym przykładem poprzedniego przykładu:

using System;
using System.Threading.Tasks;
using System.Collections.Generic;

public static async Task Run(string myQueueItem, IAsyncCollector<IDictionary<string,string>> notification, TraceWriter log)
{
    log.Info($"C# Queue trigger function processed: {myQueueItem}");

    log.Info($"Sending Template Notification to Notification Hub");
    await notification.AddAsync(GetTemplateProperties(myQueueItem));    
}

private static IDictionary<string, string> GetTemplateProperties(string message)
{
    Dictionary<string, string> templateProperties = new Dictionary<string, string>();
    templateProperties["user"] = "A new user wants to be added : " + message;
    return templateProperties;
}

Przykład szablonu skryptu języka C#: JSON

W tym przykładzie jest wysyłane powiadomienie o rejestracji szablonu zawierającego message symbol zastępczy w szablonie przy użyciu prawidłowego ciągu JSON:

using System;

public static void Run(string myQueueItem,  out string notification, TraceWriter log)
{
    log.Info($"C# Queue trigger function processed: {myQueueItem}");
    notification = "{\"message\":\"Hello from C#. Processed a queue item!\"}";
}

Przykład szablonu skryptu języka C#: typy bibliotek

W tym przykładzie pokazano, jak używać typów zdefiniowanych w bibliotece usługi Microsoft Azure Notification Hubs:

#r "Microsoft.Azure.NotificationHubs"

using System;
using System.Threading.Tasks;
using Microsoft.Azure.NotificationHubs;

public static void Run(string myQueueItem,  out Notification notification, TraceWriter log)
{
   log.Info($"C# Queue trigger function processed: {myQueueItem}");
   notification = GetTemplateNotification(myQueueItem);
}

private static TemplateNotification GetTemplateNotification(string message)
{
    Dictionary<string, string> templateProperties = new Dictionary<string, string>();
    templateProperties["message"] = message;
    return new TemplateNotification(templateProperties);
}

Przykład szablonu języka F#

W tym przykładzie jest wysyłane powiadomienie dotyczące rejestracji szablonu zawierającego location element i message:

let Run(myTimer: TimerInfo, notification: byref<IDictionary<string, string>>) =
    notification = dict [("location", "Redmond"); ("message", "Hello from F#!")]

Przykład szablonu języka JavaScript

W tym przykładzie jest wysyłane powiadomienie dotyczące rejestracji szablonu zawierającego location element i message:

module.exports = async function (context, myTimer) {
    var timeStamp = new Date().toISOString();

    if (myTimer.IsPastDue)
    {
        context.log('Node.js is running late!');
    }
    context.log('Node.js timer trigger function ran!', timeStamp);  
    context.bindings.notification = {
        location: "Redmond",
        message: "Hello from Node!"
    };
};

Przykład: natywne dla usługi APNS

W tym przykładzie skryptu w języku C# pokazano, jak wysłać natywne powiadomienie usługi Apple Push Notification Service (APNS):

#r "Microsoft.Azure.NotificationHubs"
#r "Newtonsoft.Json"

using System;
using Microsoft.Azure.NotificationHubs;
using Newtonsoft.Json;

public static async Task Run(string myQueueItem, IAsyncCollector<Notification> notification, TraceWriter log)
{
    log.Info($"C# Queue trigger function processed: {myQueueItem}");

    // In this example, the queue item is a new user to be processed in the form of a JSON string with 
    // a "name" value.
    //
    // The JSON format for a native Apple Push Notification Service (APNS) notification is:
    // { "aps": { "alert": "notification message" }}  

    log.LogInformation($"Sending APNS notification of a new user");    
    dynamic user = JsonConvert.DeserializeObject(myQueueItem);    
    string apnsNotificationPayload = "{\"aps\": {\"alert\": \"A new user wants to be added (" + 
                                        user.name + ")\" }}";
    log.LogInformation($"{apnsNotificationPayload}");
    await notification.AddAsync(new AppleNotification(apnsNotificationPayload));        
}

Przykład: natywna usługa WNS

W tym przykładzie skryptu języka C# pokazano, jak używać typów zdefiniowanych w bibliotece usługi Microsoft Azure Notification Hubs w celu wysyłania natywnej usługi powiadomień wypychanych systemu Windows (WNS) wyskakujące powiadomienie:

#r "Microsoft.Azure.NotificationHubs"
#r "Newtonsoft.Json"

using System;
using Microsoft.Azure.NotificationHubs;
using Newtonsoft.Json;

public static async Task Run(string myQueueItem, IAsyncCollector<Notification> notification, TraceWriter log)
{
    log.Info($"C# Queue trigger function processed: {myQueueItem}");

    // In this example, the queue item is a new user to be processed in the form of a JSON string with 
    // a "name" value.
    //
    // The XML format for a native WNS toast notification is ...
    // <?xml version="1.0" encoding="utf-8"?>
    // <toast>
    //      <visual>
    //     <binding template="ToastText01">
    //       <text id="1">notification message</text>
    //     </binding>
    //   </visual>
    // </toast>

    log.Info($"Sending WNS toast notification of a new user");    
    dynamic user = JsonConvert.DeserializeObject(myQueueItem);    
    string wnsNotificationPayload = "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
                                    "<toast><visual><binding template=\"ToastText01\">" +
                                        "<text id=\"1\">" + 
                                            "A new user wants to be added (" + user.name + ")" + 
                                        "</text>" +
                                    "</binding></visual></toast>";

    log.Info($"{wnsNotificationPayload}");
    await notification.AddAsync(new WindowsNotification(wnsNotificationPayload));        
}

Atrybuty

W bibliotekach klas języka C# użyj atrybutu NotificationHub .

Parametry i właściwości konstruktora atrybutu są opisane w sekcji Konfiguracja .

Konfigurowanie

W poniższej tabeli wymieniono właściwości konfiguracji powiązania ustawione w pliku function.json i atrybut:NotificationHub

Podczas tworzenia aplikacji lokalnie dodaj ustawienia aplikacji w pliku local.settings.json w kolekcji Values .

przykładowy plik function.json

Oto przykład powiązania usługi Notification Hubs w pliku function.json :

{
  "bindings": [
    {
      "type": "notificationHub",
      "direction": "out",
      "name": "notification",
      "tagExpression": "",
      "hubName": "my-notification-hub",
      "connection": "MyHubConnectionString",
      "platform": "apns"
    }
  ],
  "disabled": false
}

Konfiguracja parametrów połączenia

Aby użyć powiązania wyjściowego centrum powiadomień, należy skonfigurować parametry połączenia dla centrum. Możesz wybrać istniejące centrum powiadomień lub utworzyć nowe na karcie Integracja w witrynie Azure Portal. Można również skonfigurować parametry połączenia ręcznie.

Aby skonfigurować parametry połączenia do istniejącego centrum powiadomień:

1. Przejdź do centrum powiadomień w witrynie Azure Portal, wybierz pozycję Zasady dostępu i wybierz przycisk kopiowania obok zasad DefaultFullSharedAccessSignature .

   Parametry połączenia dla zasad DefaultFullSharedAccessSignature jest kopiowany do centrum powiadomień. Ta parametry połączenia umożliwia funkcji wysyłanie komunikatów powiadomień do centrum.

2. Przejdź do aplikacji funkcji w witrynie Azure Portal, rozwiń węzeł Ustawienia, a następnie wybierz pozycję Zmienne środowiskowe.

3. Na karcie Ustawienie aplikacji wybierz pozycję + Dodaj, aby dodać klucz, taki jak MyHubConnectionString. Nazwa tego ustawienia aplikacji to ustawienie połączenia powiązania wyjściowego w function.json lub atrybut .NET. Aby uzyskać więcej informacji, zobacz Konfiguracja.

4. Dla wartości wklej skopiowaną wartość DefaultFullSharedAccessSignature parametry połączenia z centrum powiadomień, a następnie wybierz pozycję Zastosuj.

Podczas tworzenia aplikacji lokalnie dodaj ustawienia aplikacji w pliku local.settings.json w kolekcji Values .

Wyjątki i kody powrotne

Powiązana zawartość

• Pojęcia powiązań i wyzwalaczy usługi Azure Functions