ModuleClient class

Paket:: azure-iot-device

IoT Hub-Geräteclient, der zum Verbinden eines Geräts mit einem Azure IoT-Hub verwendet wird.

Benutzer des SDK sollten eine der Factorymethoden aufrufen, fromConnectionString oder fromSharedAccessSignature, um einen IoT Hub-Geräteclient zu erstellen.

Extends: InternalClient

Methoden

close()
close(Callback<Disconnected>)	Schließt die Transportverbindung und zerstört die Clientressourcen. Hinweis: Nach dem Aufrufen dieser Methode kann das ModuleClient-Objekt nicht wiederverwendet werden.
fromAuthenticationProvider(AuthenticationProvider, any)	Erstellt einen IoT Hub-Modulclient aus der angegebenen Authentifizierungsmethode und verwendet den angegebenen Transporttyp.
fromConnectionString(string, any)	Erstellt einen IoT Hub-Geräteclient aus der angegebenen Verbindungszeichenfolge mithilfe des angegebenen Transporttyps.
fromEnvironment(any)
fromEnvironment(any, Callback<ModuleClient>)	Erstellt einen IoT Hub-Modulclient mithilfe von Konfigurationsinformationen aus der Umgebung. Wenn eine Umgebungsvariable namens `EdgeHubConnectionString` oder `IotHubConnectionString` vorhanden ist, wird dieser Wert verwendet und das Verhalten identisch mit dem Aufrufen `fromConnectionString` übergeben. Wenn diese Umgebungsvariablen nicht vorhanden sind, müssen die folgenden Variablen definiert werden: `- IOTEDGE_WORKLOADURI URI for iotedged's workload API - IOTEDGE_DEVICEID Device identifier - IOTEDGE_MODULEID Module identifier - IOTEDGE_MODULEGENERATIONID Module generation identifier - IOTEDGE_IOTHUBHOSTNAME IoT Hub host name - IOTEDGE_AUTHSCHEME Authentication scheme to use; must be "sasToken"`
fromSharedAccessSignature(string, any)	Erstellt einen IoT Hub-Modulclient aus der angegebenen Freigegebenen Zugriffssignatur mithilfe des angegebenen Transporttyps.
invokeMethod(string, MethodParams)
invokeMethod(string, MethodParams, Callback<MethodResult>)	Ruft eine Methode auf einem nachgeschalteten Gerät oder auf einem anderen Modul auf demselben IoTEdge-Gerät auf. Beachten Sie, dass dieses Feature nur funktioniert, wenn das Modul als Teil eines IoTEdge-Geräts ausgeführt wird.
invokeMethod(string, string, MethodParams)
invokeMethod(string, string, MethodParams, Callback<MethodResult>)
onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)	Registriert einen Rückruf für eine Methode mit dem Namen `methodName`.
sendOutputEvent(string, Message)
sendOutputEvent(string, Message, Callback<MessageEnqueued>)	Sendet ein Ereignis an die angegebene Modulausgabe.
sendOutputEventBatch(string, Message[])
sendOutputEventBatch(string, Message[], Callback<MessageEnqueued>)	Sendet ein Array von Ereignissen an die angegebene Modulausgabe.
setOptions(DeviceClientOptions)
setOptions(DeviceClientOptions, Callback<TransportConfigured>)	Übergibt Optionen an das `ModuleClient`-Objekt, das zum Konfigurieren des Transports verwendet werden kann.

Geerbte Methoden

abandon(Message)
abandon(Message, Callback<MessageAbandoned>)
addListener<E>(string \| symbol, (args: any[]) => void)	Alias für `emitter.on(eventName, listener)`.
complete(Message)
complete(Message, Callback<MessageCompleted>)
emit<E>(string \| symbol, any[])	Ruft die einzelnen Listener synchron auf, die für das Ereignis mit dem Namen `eventName`registriert wurden, in der Reihenfolge, in der sie registriert wurden, und übergibt die angegebenen Argumente an jedes Ereignis. Gibt `true` zurück, wenn das Ereignis Listener hatte, `false` andernfalls. import { EventEmitter } from 'node:events'; const myEmitter = new EventEmitter(); // First listener myEmitter.on('event', function firstListener() { console.log('Helloooo! first listener'); }); // Second listener myEmitter.on('event', function secondListener(arg1, arg2) { console.log(`event with parameters ${arg1}, ${arg2} in second listener`); }); // Third listener myEmitter.on('event', function thirdListener(...args) { const parameters = args.join(', '); console.log(`event with parameters ${parameters} in third listener`); }); console.log(myEmitter.listeners('event')); myEmitter.emit('event', 1, 2, 3, 4, 5); // Prints: // [ // [Function: firstListener], // [Function: secondListener], // [Function: thirdListener] // ] // Helloooo! first listener // event with parameters 1, 2 in second listener // event with parameters 1, 2, 3, 4, 5 in third listener
eventNames()	Gibt ein Array zurück, das die Ereignisse auflistet, für die der Emitter Listener registriert hat. `import { EventEmitter } from 'node:events'; const myEE = new EventEmitter(); myEE.on('foo', () => {}); myEE.on('bar', () => {}); const sym = Symbol('symbol'); myEE.on(sym, () => {}); console.log(myEE.eventNames()); // Prints: [ 'foo', 'bar', Symbol(symbol) ]`
getMaxListeners()	Gibt den aktuellen Maximallistenerwert für die `EventEmitter` zurück, die entweder durch `emitter.setMaxListeners(n)` oder standardmäßig auf `events.defaultMaxListeners`festgelegt ist.
getTwin()
getTwin(Callback<Twin>)
listenerCount<E>(string \| symbol, (args: any[]) => void)	Gibt die Anzahl der Listener zurück, die auf das Ereignis mit dem Namen `eventName`lauschen. Wenn `listener` angegeben wird, wird zurückgegeben, wie oft der Listener in der Liste der Listener des Ereignisses gefunden wird.
listeners<E>(string \| symbol)	Gibt eine Kopie des Arrays von Listenern für das Ereignis mit dem Namen `eventName`zurück. `server.on('connection', (stream) => { console.log('someone connected!'); }); console.log(util.inspect(server.listeners('connection'))); // Prints: [ [Function] ]`
off<E>(string \| symbol, (args: any[]) => void)	Alias für `emitter.removeListener()`.
on<E>(string \| symbol, (args: any[]) => void)	Fügt die `listener`-Funktion am Ende des Listenerarrays für das Ereignis mit dem Namen `eventName`hinzu. Es werden keine Überprüfungen vorgenommen, um festzustellen, ob die `listener` bereits hinzugefügt wurde. Mehrere Aufrufe, die dieselbe Kombination aus `eventName` übergeben, und `listener` führen dazu, dass die `listener` mehrmals hinzugefügt und aufgerufen wird. `server.on('connection', (stream) => { console.log('someone connected!'); });` Gibt einen Verweis auf die `EventEmitter`zurück, sodass Aufrufe verkettet werden können. Standardmäßig werden Ereignislistener in der Reihenfolge aufgerufen, in der sie hinzugefügt werden. Die `emitter.prependListener()`-Methode kann als Alternative zum Hinzufügen des Ereignislisteners zum Anfang des Listenersarrays verwendet werden. `import { EventEmitter } from 'node:events'; const myEE = new EventEmitter(); myEE.on('foo', () => console.log('a')); myEE.prependListener('foo', () => console.log('b')); myEE.emit('foo'); // Prints: // b // a`
once<E>(string \| symbol, (args: any[]) => void)	Fügt eine einmalige`listener`-Funktion für das Ereignis mit dem Namen `eventName`hinzu. Wenn `eventName` das nächste Mal ausgelöst wird, wird dieser Listener entfernt und dann aufgerufen. `server.once('connection', (stream) => { console.log('Ah, we have our first user!'); });` Gibt einen Verweis auf die `EventEmitter`zurück, sodass Aufrufe verkettet werden können. Standardmäßig werden Ereignislistener in der Reihenfolge aufgerufen, in der sie hinzugefügt werden. Die `emitter.prependOnceListener()`-Methode kann als Alternative zum Hinzufügen des Ereignislisteners zum Anfang des Listenersarrays verwendet werden. `import { EventEmitter } from 'node:events'; const myEE = new EventEmitter(); myEE.once('foo', () => console.log('a')); myEE.prependOnceListener('foo', () => console.log('b')); myEE.emit('foo'); // Prints: // b // a`
open()
open(Callback<Connected>)
prependListener<E>(string \| symbol, (args: any[]) => void)	Fügt die `listener`-Funktion dem beginnenden des Listenersarrays für das Ereignis mit dem Namen `eventName`hinzu. Es werden keine Überprüfungen vorgenommen, um festzustellen, ob die `listener` bereits hinzugefügt wurde. Mehrere Aufrufe, die dieselbe Kombination aus `eventName` übergeben, und `listener` führen dazu, dass die `listener` mehrmals hinzugefügt und aufgerufen wird. `server.prependListener('connection', (stream) => { console.log('someone connected!'); });` Gibt einen Verweis auf die `EventEmitter`zurück, sodass Aufrufe verkettet werden können.
prependOnceListener<E>(string \| symbol, (args: any[]) => void)	Fügt dem beginnenden des Listenersarrays eine `listenereventName` Funktion für das Ereignis hinzu, das genannt wird. Wenn `eventName` das nächste Mal ausgelöst wird, wird dieser Listener entfernt und dann aufgerufen. `server.prependOnceListener('connection', (stream) => { console.log('Ah, we have our first user!'); });` Gibt einen Verweis auf die `EventEmitter`zurück, sodass Aufrufe verkettet werden können.
rawListeners<E>(string \| symbol)	Gibt eine Kopie des Arrays von Listenern für das Ereignis mit dem Namen `eventName`zurück, einschließlich aller Wrapper (z. B. von `.once()`erstellt). import { EventEmitter } from 'node:events'; const emitter = new EventEmitter(); emitter.once('log', () => console.log('log once')); // Returns a new Array with a function `onceWrapper` which has a property // `listener` which contains the original listener bound above const listeners = emitter.rawListeners('log'); const logFnWrapper = listeners[0]; // Logs "log once" to the console and does not unbind the `once` event logFnWrapper.listener(); // Logs "log once" to the console and removes the listener logFnWrapper(); emitter.on('log', () => console.log('log persistently')); // Will return a new Array with a single function bound by `.on()` above const newListeners = emitter.rawListeners('log'); // Logs "log persistently" twice newListeners[0](); emitter.emit('log');
reject(Message)
reject(Message, Callback<MessageRejected>)
removeAllListeners<E>(string \| symbol)	Entfernt alle Listener oder die der angegebenen `eventName`. Es empfiehlt sich, Listener zu entfernen, die an anderer Stelle im Code hinzugefügt wurden, insbesondere, wenn die `EventEmitter` Instanz von einer anderen Komponente oder einem anderen Modul (z. B. Sockets oder Dateistreams) erstellt wurde. Gibt einen Verweis auf die `EventEmitter`zurück, sodass Aufrufe verkettet werden können.
removeListener<E>(string \| symbol, (args: any[]) => void)	Entfernt die angegebene `listener` aus dem Listenerarray für das Ereignis mit dem Namen `eventName`. `const callback = (stream) => { console.log('someone connected!'); }; server.on('connection', callback); // ... server.removeListener('connection', callback);` `removeListener()` entfernt höchstens eine Instanz eines Listeners aus dem Listenerarray. Wenn ein einzelner Listener mehrmals zum Listenerarray für die angegebene `eventName`hinzugefügt wurde, muss `removeListener()` mehrmals aufgerufen werden, um jede Instanz zu entfernen. Sobald ein Ereignis ausgegeben wird, werden alle listener, die zum Zeitpunkt der Ausstrahlung an sie angefügt sind, in der Reihenfolge aufgerufen. Das bedeutet, dass alle oder `removeAllListeners()` Aufrufe `removeListener()`nach der Ausstrahlung und bevor der letzte Hörer die Ausführung beendet hat, sie nicht aus `emit()` dem laufenden Ablauf entfernen. Nachfolgende Ereignisse verhalten sich wie erwartet. import { EventEmitter } from 'node:events'; class MyEmitter extends EventEmitter {} const myEmitter = new MyEmitter(); const callbackA = () => { console.log('A'); myEmitter.removeListener('event', callbackB); }; const callbackB = () => { console.log('B'); }; myEmitter.on('event', callbackA); myEmitter.on('event', callbackB); // callbackA removes listener callbackB but it will still be called. // Internal listener array at time of emit [callbackA, callbackB] myEmitter.emit('event'); // Prints: // A // B // callbackB is now removed. // Internal listener array [callbackA] myEmitter.emit('event'); // Prints: // A Da Hörer über ein internes Array verwaltet werden, ändert das Aufrufen dieses Hörers die Positionsindizes jedes nach der Entfernung registrierten Listeners. Dies wirkt sich nicht auf die Reihenfolge aus, in der Listener aufgerufen werden. Dies bedeutet jedoch, dass alle Kopien des Listenerarrays, wie sie von der `emitter.listeners()`-Methode zurückgegeben werden, neu erstellt werden müssen. Wenn eine einzelne Funktion mehrmals als Handler für ein einzelnes Ereignis (wie im folgenden Beispiel) hinzugefügt wurde, entfernt `removeListener()` die zuletzt hinzugefügte Instanz. Im Beispiel wird der `once('ping')` Listener entfernt: `import { EventEmitter } from 'node:events'; const ee = new EventEmitter(); function pong() { console.log('pong'); } ee.on('ping', pong); ee.once('ping', pong); ee.removeListener('ping', pong); ee.emit('ping'); ee.emit('ping');` Gibt einen Verweis auf die `EventEmitter`zurück, sodass Aufrufe verkettet werden können.
sendEvent(Message)
sendEvent(Message, Callback<MessageEnqueued>)
sendEventBatch(Message[])
sendEventBatch(Message[], Callback<MessageEnqueued>)
setMaxListeners(number)	Standardmäßig druckt `EventEmitter`s eine Warnung, wenn für ein bestimmtes Ereignis mehr als `10` Listener hinzugefügt werden. Dies ist ein nützlicher Standardwert, der hilft, Speicherverluste zu finden. Mit der `emitter.setMaxListeners()`-Methode kann der Grenzwert für diese spezifische `EventEmitter` Instanz geändert werden. Der Wert kann auf `Infinity` (oder `0`) festgelegt werden, um eine unbegrenzte Anzahl von Listenern anzugeben. Gibt einen Verweis auf die `EventEmitter`zurück, sodass Aufrufe verkettet werden können.
setRetryPolicy(RetryPolicy)	Legt die Vom Client verwendete Wiederholungsrichtlinie für alle Vorgänge fest. Der Standardwert ist ExponentialBackoffWithJitter.
setTransportOptions(any)
setTransportOptions(any, Callback<TransportConfigured>)
updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)
[captureRejectionSymbol](Error, string \| symbol, any[])	Die Methode `Symbol.for('nodejs.rejection')` wird aufgerufen, wenn eine Versprechensablehnung beim Aussenden eines Ereignisses auftritt und `captureRejections` auf dem Emitter aktiviert ist. Es ist möglich, anstelle von `Symbol.for('nodejs.rejection')`zu verwenden`events.captureRejectionSymbol`. `import { EventEmitter, captureRejectionSymbol } from 'node:events'; class MyClass extends EventEmitter { constructor() { super({ captureRejections: true }); } [captureRejectionSymbol](err, event, ...args) { console.log('rejection happened for', event, 'with', err, ...args); this.destroy(err); } destroy(err) { // Tear the resource down here. } }`

Details zur Methode

close()

function close(): Promise<Disconnected>

Gibt zurück

Promise<Disconnected>

close(Callback<Disconnected>)

Schließt die Transportverbindung und zerstört die Clientressourcen.

Hinweis: Nach dem Aufrufen dieser Methode kann das ModuleClient-Objekt nicht wiederverwendet werden.

function close(closeCallback?: Callback<Disconnected>)

Parameter

closeCallback: Callback<Disconnected>

Optionale Funktion, die aufgerufen werden soll, sobald der Transport getrennt und der Client geschlossen wurde.

fromAuthenticationProvider(AuthenticationProvider, any)

Erstellt einen IoT Hub-Modulclient aus der angegebenen Authentifizierungsmethode und verwendet den angegebenen Transporttyp.

static function fromAuthenticationProvider(authenticationProvider: AuthenticationProvider, transportCtor: any): ModuleClient

Parameter

authenticationProvider: AuthenticationProvider

Objekt, das zum Abrufen der Authentifizierungsparameter für den IoT-Hub verwendet wird.

transportCtor: any

Transportprotokoll, das zum Herstellen einer Verbindung mit dem IoT-Hub verwendet wird.

Gibt zurück

ModuleClient

fromConnectionString(string, any)

Erstellt einen IoT Hub-Geräteclient aus der angegebenen Verbindungszeichenfolge mithilfe des angegebenen Transporttyps.

static function fromConnectionString(connStr: string, transportCtor: any): ModuleClient

Parameter

connStr: string

Eine Verbindungszeichenfolge, die Berechtigungen für "Geräteverbindung" auf einem IoT-Hub kapselt.

transportCtor: any

Ein Transportkonstruktor.

Gibt zurück

ModuleClient

fromEnvironment(any)

static function fromEnvironment(transportCtor: any): Promise<ModuleClient>

Parameter

transportCtor: any

Gibt zurück

Promise<ModuleClient>

fromEnvironment(any, Callback<ModuleClient>)

Erstellt einen IoT Hub-Modulclient mithilfe von Konfigurationsinformationen aus der Umgebung.

Wenn eine Umgebungsvariable namens EdgeHubConnectionString oder IotHubConnectionString vorhanden ist, wird dieser Wert verwendet und das Verhalten identisch mit dem Aufrufen fromConnectionString übergeben. Wenn diese Umgebungsvariablen nicht vorhanden sind, müssen die folgenden Variablen definiert werden:

- IOTEDGE_WORKLOADURI          URI for iotedged's workload API
- IOTEDGE_DEVICEID             Device identifier
- IOTEDGE_MODULEID             Module identifier
- IOTEDGE_MODULEGENERATIONID   Module generation identifier
- IOTEDGE_IOTHUBHOSTNAME       IoT Hub host name
- IOTEDGE_AUTHSCHEME           Authentication scheme to use; must be "sasToken"

static function fromEnvironment(transportCtor: any, callback?: Callback<ModuleClient>)

Parameter

transportCtor: any

Transportprotokoll, das zum Herstellen einer Verbindung mit dem IoT-Hub verwendet wird.

callback: Callback<ModuleClient>

Optionaler Rückruf, der aufgerufen werden soll, wenn der ModuleClient erstellt wurde oder wenn beim Erstellen des Clients ein Fehler auftritt.

fromSharedAccessSignature(string, any)

Erstellt einen IoT Hub-Modulclient aus der angegebenen Freigegebenen Zugriffssignatur mithilfe des angegebenen Transporttyps.

static function fromSharedAccessSignature(sharedAccessSignature: string, transportCtor: any): ModuleClient

Parameter

sharedAccessSignature: string

Eine Freigegebene Zugriffssignatur, die Berechtigungen "Geräteverbindung" auf einem IoT-Hub kapselt.

transportCtor: any

Gibt zurück

ModuleClient

invokeMethod(string, MethodParams)

function invokeMethod(deviceId: string, methodParams: MethodParams): Promise<MethodResult>

Parameter

deviceId: string

methodParams: MethodParams

Gibt zurück

Promise<MethodResult>

invokeMethod(string, MethodParams, Callback<MethodResult>)

Ruft eine Methode auf einem nachgeschalteten Gerät oder auf einem anderen Modul auf demselben IoTEdge-Gerät auf. Beachten Sie, dass dieses Feature nur funktioniert, wenn das Modul als Teil eines IoTEdge-Geräts ausgeführt wird.

function invokeMethod(deviceId: string, methodParams: MethodParams, callback?: Callback<MethodResult>)

Parameter

deviceId: string

Zielgerätebezeichner

methodParams: MethodParams

Parameter des direkten Methodenaufrufs

callback: Callback<MethodResult>

optionaler Rückruf, der entweder mit einem Error-Objekt oder dem Ergebnis des Methodenaufrufs aufgerufen wird.

invokeMethod(string, string, MethodParams)

function invokeMethod(deviceId: string, moduleId: string, methodParams: MethodParams): Promise<MethodResult>

Parameter

deviceId: string

moduleId: string

methodParams: MethodParams

Gibt zurück

Promise<MethodResult>

invokeMethod(string, string, MethodParams, Callback<MethodResult>)

function invokeMethod(deviceId: string, moduleId: string, methodParams: MethodParams, callback: Callback<MethodResult>)

Parameter

deviceId: string

moduleId: string

methodParams: MethodParams

callback: Callback<MethodResult>

onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

Registriert einen Rückruf für eine Methode mit dem Namen methodName.

function onMethod(methodName: string, callback: DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

Parameter

methodName: string

Name der Methode, die vom Rückruf behandelt wird

callback: DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>

Funktion, die aufgerufen werden soll, wenn eine Methodenanforderung für die Methode aufgerufen wird, die aufgerufen wird, methodName empfangen wird.

sendOutputEvent(string, Message)

function sendOutputEvent(outputName: string, message: Message): Promise<MessageEnqueued>

Parameter

outputName: string

message: Message

Gibt zurück

Promise<MessageEnqueued>

sendOutputEvent(string, Message, Callback<MessageEnqueued>)

Sendet ein Ereignis an die angegebene Modulausgabe.

function sendOutputEvent(outputName: string, message: Message, callback?: Callback<MessageEnqueued>)

Parameter

outputName: string

Name der Ausgabe, an die das Ereignis gesendet werden soll

message: Message

Nachricht, die an die angegebene Ausgabe gesendet werden soll

callback: Callback<MessageEnqueued>

Optionale Funktion, die aufgerufen werden soll, wenn der Vorgang in die Warteschlange gestellt wurde.

sendOutputEventBatch(string, Message[])

function sendOutputEventBatch(outputName: string, messages: Message[]): Promise<MessageEnqueued>

Parameter

outputName: string

messages: Message[]

Gibt zurück

Promise<MessageEnqueued>

sendOutputEventBatch(string, Message[], Callback<MessageEnqueued>)

Sendet ein Array von Ereignissen an die angegebene Modulausgabe.

function sendOutputEventBatch(outputName: string, messages: Message[], callback?: Callback<MessageEnqueued>)

Parameter

outputName: string

Name der Ausgabe, an die die Ereignisse gesendet werden sollen

messages: Message[]

callback: Callback<MessageEnqueued>

Funktion, die aufgerufen werden soll, wenn die Vorgänge in die Warteschlange gestellt wurden.

setOptions(DeviceClientOptions)

function setOptions(options: DeviceClientOptions): Promise<TransportConfigured>

Parameter

options: DeviceClientOptions

Gibt zurück

Promise<TransportConfigured>

setOptions(DeviceClientOptions, Callback<TransportConfigured>)

Übergibt Optionen an das ModuleClient-Objekt, das zum Konfigurieren des Transports verwendet werden kann.

function setOptions(options: DeviceClientOptions, done?: Callback<TransportConfigured>)

Parameter

options: DeviceClientOptions

Ein DeviceClientOptions--Objekt.

done: Callback<TransportConfigured>

Optionaler Rückruf zum Aufrufen, nachdem die Optionen festgelegt wurden.

Details zur geerbten Methode

abandon(Message)

function abandon(message: Message): Promise<MessageAbandoned>

Parameter

message: Message

Gibt zurück

Promise<MessageAbandoned>

Geerbt von InternalClient.abandon

abandon(Message, Callback<MessageAbandoned>)

function abandon(message: Message, abandonCallback: Callback<MessageAbandoned>)

Parameter

message: Message

abandonCallback: Callback<MessageAbandoned>

Geerbt von InternalClient.abandon

addListener<E>(string | symbol, (args: any[]) => void)

Alias für emitter.on(eventName, listener).

function addListener<E>(eventName: string | symbol, listener: (args: any[]) => void): ModuleClient

Parameter

eventName: string | symbol

listener: (args: any[]) => void

Gibt zurück

ModuleClient

Geerbt von InternalClient.addListener

complete(Message)

function complete(message: Message): Promise<MessageCompleted>

Parameter

message: Message

Gibt zurück

Promise<MessageCompleted>

Geerbt von InternalClient.complete

complete(Message, Callback<MessageCompleted>)

function complete(message: Message, completeCallback: Callback<MessageCompleted>)

Parameter

message: Message

completeCallback: Callback<MessageCompleted>

Geerbt von InternalClient.complete

emit<E>(string | symbol, any[])

Ruft die einzelnen Listener synchron auf, die für das Ereignis mit dem Namen eventNameregistriert wurden, in der Reihenfolge, in der sie registriert wurden, und übergibt die angegebenen Argumente an jedes Ereignis.

Gibt true zurück, wenn das Ereignis Listener hatte, false andernfalls.

import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();

// First listener
myEmitter.on('event', function firstListener() {
  console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
  console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
  const parameters = args.join(', ');
  console.log(`event with parameters ${parameters} in third listener`);
});

console.log(myEmitter.listeners('event'));

myEmitter.emit('event', 1, 2, 3, 4, 5);

// Prints:
// [
//   [Function: firstListener],
//   [Function: secondListener],
//   [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener

function emit<E>(eventName: string | symbol, args: any[]): boolean

Parameter

eventName: string | symbol

args: any[]

Gibt zurück

boolean

von InternalClient.emit geerbt

eventNames()

Gibt ein Array zurück, das die Ereignisse auflistet, für die der Emitter Listener registriert hat.

import { EventEmitter } from 'node:events';

const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});

const sym = Symbol('symbol');
myEE.on(sym, () => {});

console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]

function eventNames(): (string | symbol)[]

Gibt zurück

(string | symbol)[]

Geerbt von InternalClient.eventNames

getMaxListeners()

Gibt den aktuellen Maximallistenerwert für die EventEmitter zurück, die entweder durch emitter.setMaxListeners(n) oder standardmäßig auf events.defaultMaxListenersfestgelegt ist.

function getMaxListeners(): number

Gibt zurück

number

Geerbt von InternalClient.getMaxListeners

getTwin()

function getTwin(): Promise<Twin>

Gibt zurück

Promise<Twin>

Von InternalClient.getTwin geerbt

getTwin(Callback<Twin>)

function getTwin(done: Callback<Twin>)

Parameter

done: Callback<Twin>

Von InternalClient.getTwin geerbt

listenerCount<E>(string | symbol, (args: any[]) => void)

Gibt die Anzahl der Listener zurück, die auf das Ereignis mit dem Namen eventNamelauschen. Wenn listener angegeben wird, wird zurückgegeben, wie oft der Listener in der Liste der Listener des Ereignisses gefunden wird.

function listenerCount<E>(eventName: string | symbol, listener?: (args: any[]) => void): number

Parameter

eventName: string | symbol

Der Name des Ereignisses, auf das gewartet wird

listener: (args: any[]) => void

Die Ereignishandlerfunktion

Gibt zurück

number

geerbt von InternalClient.listenerCount

listeners<E>(string | symbol)

Gibt eine Kopie des Arrays von Listenern für das Ereignis mit dem Namen eventNamezurück.

server.on('connection', (stream) => {
  console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]

function listeners<E>(eventName: string | symbol): (args: any[]) => void[]

Parameter

eventName: string | symbol

Gibt zurück

(args: any[]) => void[]

von InternalClient.listeners geerbt

off<E>(string | symbol, (args: any[]) => void)

Alias für emitter.removeListener().

function off<E>(eventName: string | symbol, listener: (args: any[]) => void): ModuleClient

Parameter

eventName: string | symbol

listener: (args: any[]) => void

Gibt zurück

ModuleClient

von InternalClient.off geerbt

on<E>(string | symbol, (args: any[]) => void)

Fügt die listener-Funktion am Ende des Listenerarrays für das Ereignis mit dem Namen eventNamehinzu. Es werden keine Überprüfungen vorgenommen, um festzustellen, ob die listener bereits hinzugefügt wurde. Mehrere Aufrufe, die dieselbe Kombination aus eventName übergeben, und listener führen dazu, dass die listener mehrmals hinzugefügt und aufgerufen wird.

server.on('connection', (stream) => {
  console.log('someone connected!');
});

Gibt einen Verweis auf die EventEmitterzurück, sodass Aufrufe verkettet werden können.

Standardmäßig werden Ereignislistener in der Reihenfolge aufgerufen, in der sie hinzugefügt werden. Die emitter.prependListener()-Methode kann als Alternative zum Hinzufügen des Ereignislisteners zum Anfang des Listenersarrays verwendet werden.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

function on<E>(eventName: string | symbol, listener: (args: any[]) => void): ModuleClient

Parameter

eventName: string | symbol

Der Name des Ereignisses.

listener: (args: any[]) => void

Die Rückruffunktion

Gibt zurück

ModuleClient

von InternalClient.on geerbt

once<E>(string | symbol, (args: any[]) => void)

Fügt eine einmaligelistener-Funktion für das Ereignis mit dem Namen eventNamehinzu. Wenn eventName das nächste Mal ausgelöst wird, wird dieser Listener entfernt und dann aufgerufen.

server.once('connection', (stream) => {
  console.log('Ah, we have our first user!');
});

Gibt einen Verweis auf die EventEmitterzurück, sodass Aufrufe verkettet werden können.

Standardmäßig werden Ereignislistener in der Reihenfolge aufgerufen, in der sie hinzugefügt werden. Die emitter.prependOnceListener()-Methode kann als Alternative zum Hinzufügen des Ereignislisteners zum Anfang des Listenersarrays verwendet werden.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

function once<E>(eventName: string | symbol, listener: (args: any[]) => void): ModuleClient

Parameter

eventName: string | symbol

Der Name des Ereignisses.

listener: (args: any[]) => void

Die Rückruffunktion

Gibt zurück

ModuleClient

von InternalClient.once geerbt

open()

function open(): Promise<Connected>

Gibt zurück

Promise<Connected>

Von InternalClient.open geerbt

open(Callback<Connected>)

function open(openCallback: Callback<Connected>)

Parameter

openCallback: Callback<Connected>

Von InternalClient.open geerbt

prependListener<E>(string | symbol, (args: any[]) => void)

Fügt die listener-Funktion dem beginnenden des Listenersarrays für das Ereignis mit dem Namen eventNamehinzu. Es werden keine Überprüfungen vorgenommen, um festzustellen, ob die listener bereits hinzugefügt wurde. Mehrere Aufrufe, die dieselbe Kombination aus eventName übergeben, und listener führen dazu, dass die listener mehrmals hinzugefügt und aufgerufen wird.

server.prependListener('connection', (stream) => {
  console.log('someone connected!');
});

Gibt einen Verweis auf die EventEmitterzurück, sodass Aufrufe verkettet werden können.

function prependListener<E>(eventName: string | symbol, listener: (args: any[]) => void): ModuleClient

Parameter

eventName: string | symbol

Der Name des Ereignisses.

listener: (args: any[]) => void

Die Rückruffunktion

Gibt zurück

ModuleClient

geerbt von InternalClient.prependListener

prependOnceListener<E>(string | symbol, (args: any[]) => void)

Fügt dem beginnenden des Listenersarrays eine listenereventName Funktion für das Ereignis hinzu, das genannt wird. Wenn eventName das nächste Mal ausgelöst wird, wird dieser Listener entfernt und dann aufgerufen.

server.prependOnceListener('connection', (stream) => {
  console.log('Ah, we have our first user!');
});

Gibt einen Verweis auf die EventEmitterzurück, sodass Aufrufe verkettet werden können.

function prependOnceListener<E>(eventName: string | symbol, listener: (args: any[]) => void): ModuleClient

Parameter

eventName: string | symbol

Der Name des Ereignisses.

listener: (args: any[]) => void

Die Rückruffunktion

Gibt zurück

ModuleClient

geerbt von InternalClient.prependOnceListener

rawListeners<E>(string | symbol)

Gibt eine Kopie des Arrays von Listenern für das Ereignis mit dem Namen eventNamezurück, einschließlich aller Wrapper (z. B. von .once()erstellt).

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));

// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];

// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();

// Logs "log once" to the console and removes the listener
logFnWrapper();

emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');

// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');

function rawListeners<E>(eventName: string | symbol): (args: any[]) => void[]

Parameter

eventName: string | symbol

Gibt zurück

(args: any[]) => void[]

von InternalClient.rawListeners geerbt

reject(Message)

function reject(message: Message): Promise<MessageRejected>

Parameter

message: Message

Gibt zurück

Promise<MessageRejected>

von InternalClient.reject geerbt

reject(Message, Callback<MessageRejected>)

function reject(message: Message, rejectCallback: Callback<MessageRejected>)

Parameter

message: Message

rejectCallback: Callback<MessageRejected>

von InternalClient.reject geerbt

removeAllListeners<E>(string | symbol)

Entfernt alle Listener oder die der angegebenen eventName.

Es empfiehlt sich, Listener zu entfernen, die an anderer Stelle im Code hinzugefügt wurden, insbesondere, wenn die EventEmitter Instanz von einer anderen Komponente oder einem anderen Modul (z. B. Sockets oder Dateistreams) erstellt wurde.

Gibt einen Verweis auf die EventEmitterzurück, sodass Aufrufe verkettet werden können.

function removeAllListeners<E>(eventName?: string | symbol): ModuleClient

Parameter

eventName: string | symbol

Gibt zurück

ModuleClient

geerbt von InternalClient.removeAllListeners

removeListener<E>(string | symbol, (args: any[]) => void)

Entfernt die angegebene listener aus dem Listenerarray für das Ereignis mit dem Namen eventName.

const callback = (stream) => {
  console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);

removeListener() entfernt höchstens eine Instanz eines Listeners aus dem Listenerarray. Wenn ein einzelner Listener mehrmals zum Listenerarray für die angegebene eventNamehinzugefügt wurde, muss removeListener() mehrmals aufgerufen werden, um jede Instanz zu entfernen.

Sobald ein Ereignis ausgegeben wird, werden alle listener, die zum Zeitpunkt der Ausstrahlung an sie angefügt sind, in der Reihenfolge aufgerufen. Das bedeutet, dass alle oder removeAllListeners() Aufrufe removeListener()nach der Ausstrahlung und bevor der letzte Hörer die Ausführung beendet hat, sie nicht aus emit() dem laufenden Ablauf entfernen. Nachfolgende Ereignisse verhalten sich wie erwartet.

import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();

const callbackA = () => {
  console.log('A');
  myEmitter.removeListener('event', callbackB);
};

const callbackB = () => {
  console.log('B');
};

myEmitter.on('event', callbackA);

myEmitter.on('event', callbackB);

// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
//   A
//   B

// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
//   A

Da Hörer über ein internes Array verwaltet werden, ändert das Aufrufen dieses Hörers die Positionsindizes jedes nach der Entfernung registrierten Listeners. Dies wirkt sich nicht auf die Reihenfolge aus, in der Listener aufgerufen werden. Dies bedeutet jedoch, dass alle Kopien des Listenerarrays, wie sie von der emitter.listeners()-Methode zurückgegeben werden, neu erstellt werden müssen.

Wenn eine einzelne Funktion mehrmals als Handler für ein einzelnes Ereignis (wie im folgenden Beispiel) hinzugefügt wurde, entfernt removeListener() die zuletzt hinzugefügte Instanz. Im Beispiel wird der once('ping') Listener entfernt:

import { EventEmitter } from 'node:events';
const ee = new EventEmitter();

function pong() {
  console.log('pong');
}

ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);

ee.emit('ping');
ee.emit('ping');

Gibt einen Verweis auf die EventEmitterzurück, sodass Aufrufe verkettet werden können.

function removeListener<E>(eventName: string | symbol, listener: (args: any[]) => void): ModuleClient

Parameter

eventName: string | symbol

listener: (args: any[]) => void

Gibt zurück

ModuleClient

Geerbt von InternalClient.removeListener

sendEvent(Message)

function sendEvent(message: Message): Promise<MessageEnqueued>

Parameter

message: Message

Gibt zurück

Promise<MessageEnqueued>

geerbt von InternalClient.sendEvent

sendEvent(Message, Callback<MessageEnqueued>)

function sendEvent(message: Message, sendEventCallback: Callback<MessageEnqueued>)

Parameter

message: Message

sendEventCallback: Callback<MessageEnqueued>

geerbt von InternalClient.sendEvent

sendEventBatch(Message[])

function sendEventBatch(messages: Message[]): Promise<MessageEnqueued>

Parameter

messages: Message[]

Gibt zurück

Promise<MessageEnqueued>

von InternalClient.sendEventBatch geerbt

sendEventBatch(Message[], Callback<MessageEnqueued>)

function sendEventBatch(messages: Message[], sendEventBatchCallback: Callback<MessageEnqueued>)

Parameter

messages: Message[]

sendEventBatchCallback: Callback<MessageEnqueued>

von InternalClient.sendEventBatch geerbt

setMaxListeners(number)

Standardmäßig druckt EventEmitters eine Warnung, wenn für ein bestimmtes Ereignis mehr als 10 Listener hinzugefügt werden. Dies ist ein nützlicher Standardwert, der hilft, Speicherverluste zu finden. Mit der emitter.setMaxListeners()-Methode kann der Grenzwert für diese spezifische EventEmitter Instanz geändert werden. Der Wert kann auf Infinity (oder 0) festgelegt werden, um eine unbegrenzte Anzahl von Listenern anzugeben.

Gibt einen Verweis auf die EventEmitterzurück, sodass Aufrufe verkettet werden können.

function setMaxListeners(n: number): ModuleClient

Parameter

n: number

Gibt zurück

ModuleClient

Geerbt von InternalClient.setMaxListeners

setRetryPolicy(RetryPolicy)

Legt die Vom Client verwendete Wiederholungsrichtlinie für alle Vorgänge fest. Der Standardwert ist ExponentialBackoffWithJitter.

function setRetryPolicy(policy: RetryPolicy)

Parameter

policy: RetryPolicy

{RetryPolicy} Die Wiederholungsrichtlinie, die für alle zukünftigen Vorgänge verwendet werden soll.

Geerbt von InternalClient.setRetryPolicy

setTransportOptions(any)

function setTransportOptions(options: any): Promise<TransportConfigured>

Parameter

options: any

Gibt zurück

Promise<TransportConfigured>

Geerbt von InternalClient.setTransportOptions

setTransportOptions(any, Callback<TransportConfigured>)

function setTransportOptions(options: any, done: Callback<TransportConfigured>)

Parameter

options: any

done: Callback<TransportConfigured>

Geerbt von InternalClient.setTransportOptions

updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)

function updateSharedAccessSignature(sharedAccessSignature: string, updateSasCallback?: Callback<SharedAccessSignatureUpdated>)

Parameter

sharedAccessSignature: string

updateSasCallback: Callback<SharedAccessSignatureUpdated>

Geerbt von InternalClient.updateSharedAccessSignature

[captureRejectionSymbol](Error, string | symbol, any[])

Die Methode Symbol.for('nodejs.rejection') wird aufgerufen, wenn eine Versprechensablehnung beim Aussenden eines Ereignisses auftritt und captureRejections auf dem Emitter aktiviert ist. Es ist möglich, anstelle von Symbol.for('nodejs.rejection')zu verwendenevents.captureRejectionSymbol.

import { EventEmitter, captureRejectionSymbol } from 'node:events';

class MyClass extends EventEmitter {
  constructor() {
    super({ captureRejections: true });
  }

  [captureRejectionSymbol](err, event, ...args) {
    console.log('rejection happened for', event, 'with', err, ...args);
    this.destroy(err);
  }

  destroy(err) {
    // Tear the resource down here.
  }
}

function [captureRejectionSymbol](error: Error, event: string | symbol, args: any[])

Parameter

error: Error

event: string | symbol

args: any[]

Geerbt von InternalClient.__@captureRejectionSymbol@127

Freigeben über

ModuleClient class

Methoden

Geerbte Methoden

Details zur Methode

close()

Gibt zurück

close(Callback<Disconnected>)

Parameter

fromAuthenticationProvider(AuthenticationProvider, any)

Parameter

Gibt zurück

fromConnectionString(string, any)

Parameter

Gibt zurück

fromEnvironment(any)

Parameter

Gibt zurück

fromEnvironment(any, Callback<ModuleClient>)

Parameter

fromSharedAccessSignature(string, any)

Parameter

Gibt zurück

invokeMethod(string, MethodParams)

Parameter

Gibt zurück

invokeMethod(string, MethodParams, Callback<MethodResult>)

Parameter

invokeMethod(string, string, MethodParams)

Parameter

Gibt zurück

invokeMethod(string, string, MethodParams, Callback<MethodResult>)

Parameter

onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

Parameter

sendOutputEvent(string, Message)

Parameter

Gibt zurück

sendOutputEvent(string, Message, Callback<MessageEnqueued>)

Parameter

sendOutputEventBatch(string, Message[])

Parameter

Gibt zurück

sendOutputEventBatch(string, Message[], Callback<MessageEnqueued>)

Parameter

setOptions(DeviceClientOptions)

Parameter

Gibt zurück

setOptions(DeviceClientOptions, Callback<TransportConfigured>)

Parameter

Details zur geerbten Methode

abandon(Message)

Parameter

Gibt zurück

abandon(Message, Callback<MessageAbandoned>)

Parameter

addListener<E>(string | symbol, (args: any[]) => void)

Parameter

Gibt zurück

complete(Message)

Parameter

Gibt zurück

complete(Message, Callback<MessageCompleted>)

Parameter

emit<E>(string | symbol, any[])

Parameter

Gibt zurück

eventNames()

Gibt zurück

getMaxListeners()

Gibt zurück

getTwin()

Gibt zurück

getTwin(Callback<Twin>)

Parameter

listenerCount<E>(string | symbol, (args: any[]) => void)

Parameter

Gibt zurück

listeners<E>(string | symbol)

Parameter