Powiązanie wyjściowe usługi SignalR Service dla usługi Azure Functions

Użyj powiązania danych wyjściowych usługi SignalR , aby wysłać co najmniej jeden komunikat przy użyciu usługi Azure SignalR Service. Możesz rozgłasić komunikat do:

• Wszyscy połączeni klienci
• Klienci połączeni w określonej grupie
• Klienci połączeni uwierzytelnieni dla określonego użytkownika

Powiązanie wyjściowe umożliwia również zarządzanie grupami, takimi jak dodawanie klienta lub użytkownika do grupy, usuwanie klienta lub użytkownika z grupy.

Aby uzyskać informacje na temat konfiguracji i konfiguracji, zobacz omówienie.

Przykład

Emisja do wszystkich klientów

Funkcję języka C# można utworzyć przy użyciu jednego z następujących trybów języka C#:

• Model izolowanego procesu roboczego: skompilowana funkcja języka C#, która jest uruchamiana w procesie roboczym izolowanym od środowiska uruchomieniowego. Proces izolowanego procesu roboczego jest wymagany do obsługi funkcji języka C# działających w długoterminowych wersjach pomocy technicznej (LTS) i innych niż LTS dla platformy .NET i programu .NET Framework.
• Model przetwarzania: skompilowana funkcja języka C#, która działa w tym samym procesie co środowisko uruchomieniowe usługi Azure Functions.
• Skrypt języka C#: używany głównie podczas tworzenia funkcji języka C# w witrynie Azure Portal.

Ważne

Wsparcie zostanie zakończone dla modelu procesu 10 listopada 2026 r. Zdecydowanie zalecamy przeprowadzenie migracji aplikacji do izolowanego modelu procesu roboczego w celu uzyskania pełnej obsługi.

Model izolowanego procesu roboczego

W poniższym przykładzie pokazano funkcję, która wysyła komunikat przy użyciu powiązania wyjściowego do wszystkich połączonych klientów. NewMessage to nazwa metody, która ma być wywoływana na każdym kliencie.

[Function(nameof(BroadcastToAll))]
[SignalROutput(HubName = "chat", ConnectionStringSetting = "SignalRConnection")]
public static SignalRMessageAction BroadcastToAll([HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequestData req)
{
    using var bodyReader = new StreamReader(req.Body);
    return new SignalRMessageAction("newMessage")
    {
        // broadcast to all the connected clients without specifying any connection, user or group.
        Arguments = new[] { bodyReader.ReadToEnd() },
    };
}

Model w procesie

W poniższym przykładzie pokazano funkcję, która wysyła komunikat przy użyciu powiązania wyjściowego do wszystkich połączonych klientów. Elementem docelowym jest nazwa metody, która ma być wywoływana na każdym kliencie. Właściwość Arguments jest tablicą obiektów zero lub więcej, które mają być przekazywane do metody klienta.

[FunctionName("SendMessage")]
public static Task SendMessage(
    [HttpTrigger(AuthorizationLevel.Anonymous, "post")]object message,
    [SignalR(HubName = "hubName1")]IAsyncCollector<SignalRMessage> signalROutput)
{
    return signalROutput.AddAsync(
        new SignalRMessage
        {
            Target = "newMessage",
            Arguments = new [] { message }
        });
}

Oto dane powiązania w pliku function.json :

Przykład function.json:

{
  "type": "signalR",
  "name": "signalROutput",
  "hubName": "hubName1",
  "connectionStringSetting": "<name of setting containing SignalR Service connection string>",
  "direction": "out"
}

Model w wersji 4

const { app, output } = require('@azure/functions');

const signalR = output.generic({
    type: 'signalR',
    name: 'signalR',
    hubName: 'hub',
    connectionStringSetting: 'AzureSignalRConnectionString',
});

// You can use any other trigger type instead.
app.http('broadcast', {
    methods: ['GET'],
    authLevel: 'anonymous',
    extraOutputs: [signalR],
    handler: (request, context) => {
        context.extraOutputs.set(signalR, {
            "target": "newMessage",
            "arguments": [request.body]
        });
    }
});

Model w wersji 3

Oto dane powiązania w pliku function.json :

Przykład function.json:

{
  "type": "signalR",
  "name": "signalROutput",
  "hubName": "hubName1",
  "connectionStringSetting": "<name of setting containing SignalR Service connection string>",
  "direction": "out"
}

Oto kod JavaScript:

module.exports = async function (context, req) {
    context.bindings.signalROutput = [{
        "target": "newMessage",
        "arguments": [ req.body ]
    }];
};

Kompletne przykłady programu PowerShell są oczekujące.

Oto kod języka Python:

def main(req: func.HttpRequest, signalROutput: func.Out[str]) -> func.HttpResponse:
    message = req.get_json()
    signalROutput.set(json.dumps({
        'target': 'newMessage',
        'arguments': [ message ]
    }))

@FunctionName("sendMessage")
@SignalROutput(name = "$return", HubName = "hubName1")
public SignalRMessage sendMessage(
        @HttpTrigger(
            name = "req",
            methods = { HttpMethod.POST },
            authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Object> req) {

    SignalRMessage message = new SignalRMessage();
    message.target = "newMessage";
    message.arguments.add(req.getBody());
    return message;
}

Wyślij do użytkownika

Komunikat można wysłać tylko do połączeń, które zostały uwierzytelnione dla użytkownika, ustawiając identyfikator użytkownika w komunikacie usługi SignalR.

Model izolowanego procesu roboczego

[Function(nameof(SendToUser))]
[SignalROutput(HubName = "chat", ConnectionStringSetting = "SignalRConnection")]
public static SignalRMessageAction SendToUser([HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequestData req)
{
    using var bodyReader = new StreamReader(req.Body);
    return new SignalRMessageAction("newMessage")
    {
        Arguments = new[] { bodyReader.ReadToEnd() },
        UserId = "userToSend",
    };
}

Model w procesie

[FunctionName("SendMessage")]
public static Task SendMessage(
    [HttpTrigger(AuthorizationLevel.Anonymous, "post")]object message,
    [SignalR(HubName = "hubName1")]IAsyncCollector<SignalRMessage> signalROutput)
{
    return signalROutput.AddAsync(
        new SignalRMessage
        {
            // the message will only be sent to this user ID
            UserId = "userId1",
            Target = "newMessage",
            Arguments = new [] { message }
        });
}

Oto dane powiązania w pliku function.json :

Przykład function.json:

{
  "type": "signalR",
  "name": "signalROutput",
  "hubName": "hubName1",
  "connectionStringSetting": "<name of setting containing SignalR Service connection string>",
  "direction": "out"
}

Kompletne przykłady programu PowerShell są oczekujące.

Oto kod języka Python:

def main(req: func.HttpRequest, signalROutput: func.Out[str]) -> func.HttpResponse:
    message = req.get_json()
    signalROutput.set(json.dumps({
        #message will only be sent to this user ID
        'userId': 'userId1',
        'target': 'newMessage',
        'arguments': [ message ]
    }))

@FunctionName("sendMessage")
@SignalROutput(name = "$return", HubName = "hubName1")
public SignalRMessage sendMessage(
        @HttpTrigger(
            name = "req",
            methods = { HttpMethod.POST },
            authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Object> req) {

    SignalRMessage message = new SignalRMessage();
    message.userId = "userId1";
    message.target = "newMessage";
    message.arguments.add(req.getBody());
    return message;
}

Model w wersji 4

const { app, output } = require('@azure/functions');

const signalR = output.generic({
    type: 'signalR',
    name: 'signalR',
    hubName: 'hub',
    connectionStringSetting: 'AzureSignalRConnectionString',
});

app.http('sendToUser', {
    methods: ['GET'],
    authLevel: 'anonymous',
    extraOutputs: [signalR],
    handler: (request, context) => {
        context.extraOutputs.set(signalR, {
            "target": "newMessage",
            "arguments": [request.body],
            "userId": "userId1",
        });
    }
});

Model w wersji 3

Oto dane powiązania w pliku function.json :

Przykład function.json:

{
  "type": "signalR",
  "name": "signalROutput",
  "hubName": "hubName1",
  "connectionStringSetting": "<name of setting containing SignalR Service connection string>",
  "direction": "out"
}

Oto kod JavaScript:

module.exports = async function (context, req) {
    context.bindings.signalROutput = [{
        "target": "newMessage",
        "arguments": [ req.body ],
        "userId": "userId1",
    }];
};

Wysyłanie do grupy

Komunikat można wysłać tylko do połączeń, które zostały dodane do grupy, ustawiając nazwę grupy w komunikacie usługi SignalR.

Model izolowanego procesu roboczego

[Function(nameof(SendToGroup))]
[SignalROutput(HubName = "chat", ConnectionStringSetting = "SignalRConnection")]
public static SignalRMessageAction SendToGroup([HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequestData req)
{
    using var bodyReader = new StreamReader(req.Body);
    return new SignalRMessageAction("newMessage")
    {
        Arguments = new[] { bodyReader.ReadToEnd() },
        GroupName = "groupToSend"
    };
}

Model w procesie

[FunctionName("SendMessage")]
public static Task SendMessage(
    [HttpTrigger(AuthorizationLevel.Anonymous, "post")]object message,
    [SignalR(HubName = "hubName1")]IAsyncCollector<SignalRMessage> signalROutput)
{
    return signalROutput.AddAsync(
        new SignalRMessage
        {
            // the message will be sent to the group with this name
            GroupName = "myGroup",
            Target = "newMessage",
            Arguments = new [] { message }
        });
}

Oto dane powiązania w pliku function.json :

Przykład function.json:

{
  "type": "signalR",
  "name": "signalROutput",
  "hubName": "hubName1",
  "connectionStringSetting": "<name of setting containing SignalR Service connection string>",
  "direction": "out"
}

Model w wersji 4

const { app, output } = require('@azure/functions');

const signalR = output.generic({
    type: 'signalR',
    name: 'signalR',
    hubName: 'hub',
    connectionStringSetting: 'AzureSignalRConnectionString',
});

app.http('sendToGroup', {
    methods: ['GET'],
    authLevel: 'anonymous',
    extraOutputs: [signalR],
    handler: (request, context) => {
        context.extraOutputs.set(signalR, {
            "target": "newMessage",
            "arguments": [request.body],
            "groupName": "myGroup",
        });
    }
});

Model w wersji 3

Oto dane powiązania w pliku function.json :

Przykład function.json:

{
  "type": "signalR",
  "name": "signalROutput",
  "hubName": "hubName1",
  "connectionStringSetting": "<name of setting containing SignalR Service connection string>",
  "direction": "out"
}

Oto kod JavaScript:

module.exports = async function (context, req) {
    context.bindings.signalROutput = [{
        "target": "newMessage",
        "arguments": [ req.body ],
        "groupName": "myGroup",
    }];
};

Kompletne przykłady programu PowerShell są oczekujące.

Oto kod języka Python:

def main(req: func.HttpRequest, signalROutput: func.Out[str]) -> func.HttpResponse:
    message = req.get_json()
    signalROutput.set(json.dumps({
        #message will only be sent to this group
        'groupName': 'myGroup',
        'target': 'newMessage',
        'arguments': [ message ]
    }))

@FunctionName("sendMessage")
@SignalROutput(name = "$return", HubName = "hubName1")
public SignalRMessage sendMessage(
        @HttpTrigger(
            name = "req",
            methods = { HttpMethod.POST },
            authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Object> req) {

    SignalRMessage message = new SignalRMessage();
    message.groupName = "myGroup";
    message.target = "newMessage";
    message.arguments.add(req.getBody());
    return message;
}

Zarządzanie grupami

Usługa SignalR Service umożliwia dodawanie użytkowników lub połączeń do grup. Komunikaty można następnie wysyłać do grupy. Do zarządzania grupami można użyć powiązania wyjściowego SignalR .

Model izolowanego procesu roboczego

Określ SignalRGroupActionType , aby dodać lub usunąć członka. Poniższy przykład usuwa użytkownika z grupy.

[Function(nameof(RemoveFromGroup))]
[SignalROutput(HubName = "chat", ConnectionStringSetting = "SignalRConnection")]
public static SignalRGroupAction RemoveFromGroup([HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequestData req)
{
    return new SignalRGroupAction(SignalRGroupActionType.Remove)
    {
        GroupName = "group1",
        UserId = "user1"
    };
}

Model w procesie

Określ GroupAction , aby dodać lub usunąć członka. Poniższy przykład dodaje użytkownika do grupy.

[FunctionName("addToGroup")]
public static Task AddToGroup(
    [HttpTrigger(AuthorizationLevel.Anonymous, "post")]HttpRequest req,
    ClaimsPrincipal claimsPrincipal,
    [SignalR(HubName = "hubName1")]
        IAsyncCollector<SignalRGroupAction> signalRGroupActions)
{
    var userIdClaim = claimsPrincipal.FindFirst(ClaimTypes.NameIdentifier);
    return signalRGroupActions.AddAsync(
        new SignalRGroupAction
        {
            UserId = userIdClaim.Value,
            GroupName = "myGroup",
            Action = GroupAction.Add
        });
}

Uwaga

Aby uzyskać ClaimsPrincipal poprawne powiązanie, musisz skonfigurować ustawienia uwierzytelniania w usłudze Azure Functions.

Oto dane powiązania w pliku function.json :

Przykład function.json:

{
  "type": "signalR",
  "name": "signalROutput",
  "hubName": "hubName1",
  "connectionStringSetting": "<name of setting containing SignalR Service connection string>",
  "direction": "out"
}

Model w wersji 4

const { app, output } = require('@azure/functions');

const signalR = output.generic({
    type: 'signalR',
    name: 'signalR',
    hubName: 'hub',
    connectionStringSetting: 'AzureSignalRConnectionString',
});

// The following function adds a user to a group
app.http('addUserToGroup', {
    methods: ['POST'],
    authLevel: 'anonymous',
    extraOutputs: [signalR],
    handler: (request, context) => {
        context.extraOutputs.set(signalR, {
            "userId": req.query.userId,
            "groupName": "myGroup",
            "action": "add"
        });
    }
});

// The following function removes a user from a group
app.http('removeUserFromGroup', {
    methods: ['POST'],
    authLevel: 'anonymous',
    extraOutputs: [signalR],
    handler: (request, context) => {
        context.extraOutputs.set(signalR, {
            "userId": req.query.userId,
            "groupName": "myGroup",
            "action": "remove"
        });
    }
});

Model w wersji 3

Oto dane powiązania w pliku function.json :

Przykład function.json:

{
  "type": "signalR",
  "name": "signalROutput",
  "hubName": "hubName1",
  "connectionStringSetting": "<name of setting containing SignalR Service connection string>",
  "direction": "out"
}

Oto kod JavaScript:

Poniższy przykład dodaje użytkownika do grupy.

module.exports = async function (context, req) {
  context.bindings.signalROutput = [{
    "userId": req.query.userId,
    "groupName": "myGroup",
    "action": "add"
  }];
};

Poniższy przykład usuwa użytkownika z grupy.

module.exports = async function (context, req) {
  context.bindings.signalROutput = [{
    "userId": req.query.userId,
    "groupName": "myGroup",
    "action": "remove"
  }];
};

Kompletne przykłady programu PowerShell są oczekujące.

Poniższy przykład dodaje użytkownika do grupy.

def main(req: func.HttpRequest, signalROutput: func.Out[str]) -> func.HttpResponse:
    signalROutput.set(json.dumps({
        'userId': 'userId1',
        'groupName': 'myGroup',
        'action': 'add'
    }))

Poniższy przykład usuwa użytkownika z grupy.

def main(req: func.HttpRequest, signalROutput: func.Out[str]) -> func.HttpResponse:
    signalROutput.set(json.dumps({
        'userId': 'userId1',
        'groupName': 'myGroup',
        'action': 'remove'
    }))

Poniższy przykład dodaje użytkownika do grupy.

@FunctionName("addToGroup")
@SignalROutput(name = "$return", HubName = "hubName1")
public SignalRGroupAction addToGroup(
        @HttpTrigger(
            name = "req",
            methods = { HttpMethod.POST },
            authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Object> req,
        @BindingName("userId") String userId) {

    SignalRGroupAction groupAction = new SignalRGroupAction();
    groupAction.action = "add";
    groupAction.userId = userId;
    groupAction.groupName = "myGroup";
    return action;
}

Poniższy przykład usuwa użytkownika z grupy.

@FunctionName("removeFromGroup")
@SignalROutput(name = "$return", HubName = "hubName1")
public SignalRGroupAction removeFromGroup(
        @HttpTrigger(
            name = "req",
            methods = { HttpMethod.POST },
            authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Object> req,
        @BindingName("userId") String userId) {

    SignalRGroupAction groupAction = new SignalRGroupAction();
    groupAction.action = "remove";
    groupAction.userId = userId;
    groupAction.groupName = "myGroup";
    return action;
}

Atrybuty

Zarówno w procesie przetwarzania, jak i izolowanym procesie roboczym biblioteki języka C# używają atrybutu do zdefiniowania funkcji. Zamiast tego skrypt języka C# używa pliku konfiguracji function.json.

Model izolowanego procesu roboczego

W poniższej tabeli opisano właściwości atrybutu SignalROutput .

Właściwość atrybutu	opis
Nazwa centrum	Ta wartość musi być ustawiona na nazwę centrum SignalR, dla którego są generowane informacje o połączeniu.
ConnectionStringSetting	Nazwa kolekcji ustawień lub ustawień aplikacji, która zawiera parametry połączenia usługi SignalR Service, która jest domyślnie ustawiona na AzureSignalRConnectionString.

Model w procesie

W poniższej tabeli opisano właściwości atrybutu wyjściowego SignalR .

Właściwość atrybutu	opis
Nazwa centrum	Ta wartość musi być ustawiona na nazwę centrum SignalR, dla którego są generowane informacje o połączeniu.
ConnectionStringSetting	Nazwa kolekcji ustawień lub ustawień aplikacji, która zawiera parametry połączenia usługi SignalR Service, która jest domyślnie ustawiona na AzureSignalRConnectionString.

Adnotacje

W poniższej tabeli opisano obsługiwane ustawienia adnotacji SignalROutput .

Ustawienie	opis
nazwa	Nazwa zmiennej używana w kodzie funkcji dla obiektu informacji o połączeniu.
hubName	Ta wartość musi być ustawiona na nazwę centrum SignalR, dla którego są generowane informacje o połączeniu.
connectionStringSetting	Nazwa kolekcji ustawień lub ustawień aplikacji, która zawiera parametry połączenia usługi SignalR Service, która jest domyślnie ustawiona na AzureSignalRConnectionString.

Konfigurowanie

W poniższej tabeli opisano właściwości konfiguracji powiązania ustawione w pliku function.json .

właściwość function.json	opis
typ	Musi być ustawiona wartość signalR.
kierunek	Musi być ustawiona wartość out.
nazwa	Nazwa zmiennej używana w kodzie funkcji dla obiektu informacji o połączeniu.
hubName	Ta wartość musi być ustawiona na nazwę centrum SignalR, dla którego są generowane informacje o połączeniu.
connectionStringSetting	Nazwa kolekcji ustawień lub ustawień aplikacji, która zawiera parametry połączenia usługi SignalR Service, która jest domyślnie ustawiona na AzureSignalRConnectionString.

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

Użycie

Aby zapewnić optymalne zabezpieczenia, aplikacja funkcji powinna używać tożsamości zarządzanych podczas nawiązywania połączenia z usługą Azure SignalR, zamiast używać parametrów połączenia, które zawierają wspólny klucz tajny. Aby uzyskać więcej informacji, zobacz Autoryzowanie żądań do zasobów usługi Azure SignalR Service za pomocą tożsamości zarządzanych firmy Microsoft Entra.

Następne kroki

• Obsługa komunikatów z usługi SignalR Service (powiązanie wyzwalacza)
• Zwracanie adresu URL punktu końcowego usługi i tokenu dostępu (powiązanie danych wejściowych)