MemoryStoreQueue

Afficher les obsolètes

*Ce contenu est traduit en utilisant l'IA (Beta) et peut contenir des erreurs. Pour consulter cette page en anglais, clique ici.

Création impossible
Non répliqué

Fournit l'accès à une file d'attente dans MemoryStore.Une file d'attente est une structure de données qui fournit un stockage temporaire pour des éléments arbitraires (jusqu'à la taille maximale de l'élément -- voir limites de la mémoire de stockage).Chaque élément de file d'attente a une priorité numérique : MemoryStore récupère d'abord les éléments ayant une priorité plus élevée dans la file d'attente, puis récupère les éléments ayant la même priorité dans l'ordre d'ajout.

Les éléments dans la file d'attente peuvent être optionnellement définis pour expirer après un certain temps.Les articles expirés disparaissent simplement de la file d'attente comme s'ils n'avaient jamais été ajoutés.

Résumé

Méthodes

Afficher tous les hérités de Instance
Afficher tous les hérités de Object

Propriétés

Afficher tous les hérités de Instance
Afficher tous les hérités de Object

Méthodes

AddAsync

()
Rendement

Ajoute un élément à la file d'attente.

Paramètres

value: Variant

La valeur de l'élément à ajouter à la file d'attente.

Valeur par défaut : ""
expiration: number

Temps d'expiration de l'élément, en secondes, après lequel l'élément sera automatiquement supprimé de la file d'attente.

Valeur par défaut : ""
priority: number

Priorité de l'élément. Les éléments avec une priorité plus élevée sont récupérés dans la file d'attente avant les éléments avec une priorité inférieure.

Valeur par défaut : 0

Retours

()

GetSizeAsync

number
Rendement

Obtient la taille de la file d'attente.

Paramètres

excludeInvisible: boolean

Détermine si exclure les éléments invisibles du compteur de taille.

Valeur par défaut : false

Retours

number

ReadAsync

Tuple
Rendement

Lit un ou plusieurs éléments de la file d'attente comme une seule opération atomique.

Cette méthode ne supprime pas automatiquement les éléments retournés de la file d'attente, mais les rend invisibles aux autres appels ReadAsync pour la période de l'expiration du délai d'invisibilité.Les articles doivent être explicitement retirés de la file d'attente avec MemoryStoreQueue:RemoveAsync() avant l'expiration du délai d'invisibilité.La limite de temps d'invisibilité par défaut est de 30 secondes à moins qu'une valeur différente n'ait été fournie dans MemoryStoreService:GetQueue() .

Paramètres

count: number

Nombre d'éléments à lire. La valeur maximale autorisée de ce paramètre est de 100.

Valeur par défaut : ""
allOrNothing: boolean

Contrôle le comportement de la méthode dans le cas où la file d'attente a moins de count éléments : si elle est définie sur false, la méthode retourne tous les éléments disponibles ; si elle est définie sur true, elle ne retourne aucun élément.La valeur par défaut est false.

Valeur par défaut : false
waitTimeout: number

La durée, en secondes, pendant laquelle la méthode attendra si le nombre d'objets requis n'est pas immédiatement disponible dans la file d'attente.Les lectures sont tentées toutes les deux secondes pendant cette période.Ce paramètre peut être réglé à zéro pour indiquer aucune attente.Si ce paramètre n'est pas fourni ou défini sur -1, la méthode attendra indéfiniment.

Valeur par défaut : -1

Retours

Tuple

Une tuple de deux éléments.Le premier élément est un tableau de valeurs d'élément lu de la file d'attente.Le deuxième élément est un identifiant de chaîne qui doit être passé à MemoryStoreQueue:RemoveAsync() pour supprimer définitivement ces éléments de la file d'attente.

Échantillons de code

The following code sample demonstrates using MemoryStoreQueue:ReadAsync() and MemoryStoreQueue:RemoveAsync() to reliably read, process, and remove items from a queue. Though this process can be as complicated as necessary, this example simply sets a flag in the corresponding data store item, which guarantees that every item will eventually be processed even if some of the calls encounter errors or the server crashes:

Depending on where the failure happens, it's possible that an item will be processed more than once. You should account for that like the following code sample, in which the end result is the same even if DataStoreService:UpdateAsync() is invoked multiple times.

Using a MemoryStoreQueue
local MemoryStoreService = game:GetService("MemoryStoreService")

local DataStoreService = game:GetService("DataStoreService")



local queue = MemoryStoreService:GetQueue("PlayerQueue")

local dataStore = DataStoreService:GetDataStore("PlayerStore")



while true do

	pcall(function()

		-- wait for an item to process

		local items, id = queue:ReadAsync(1, false, 30)



		-- check if an item was retrieved

		if #items > 0 then

			-- mark the item as processed

			dataStore:UpdateAsync(items[0], function(data)

				data = data or {}

				data.processed = 1

				return data

			end)



			-- remove the item from the queue

			queue:RemoveAsync(id)

		end

	end)

end

RemoveAsync

()
Rendement

Supprime un article ou des articles précédemment lus de la file d'attente.Cette méthode utilise l'identifiant retourné par MemoryStoreQueue:ReadAsync() pour identifier les éléments à supprimer.Si l'appel est effectué après l'expiration du délai d'invisibilité, l'appel n'a aucun effet.

Paramètres

id: string

Identifie les éléments à supprimer. Utilisez la valeur renvoyée par MemoryStoreQueue:ReadAsync().

Valeur par défaut : ""

Retours

()

Échantillons de code

The following code sample demonstrates using MemoryStoreQueue:ReadAsync() and MemoryStoreQueue:RemoveAsync() to reliably read, process, and remove items from a queue. Though this process can be as complicated as necessary, this example simply sets a flag in the corresponding data store item, which guarantees that every item will eventually be processed even if some of the calls encounter errors or the server crashes:

Depending on where the failure happens, it's possible that an item will be processed more than once. You should account for that like the following code sample, in which the end result is the same even if DataStoreService:UpdateAsync() is invoked multiple times.

Using a MemoryStoreQueue
local MemoryStoreService = game:GetService("MemoryStoreService")

local DataStoreService = game:GetService("DataStoreService")



local queue = MemoryStoreService:GetQueue("PlayerQueue")

local dataStore = DataStoreService:GetDataStore("PlayerStore")



while true do

	pcall(function()

		-- wait for an item to process

		local items, id = queue:ReadAsync(1, false, 30)



		-- check if an item was retrieved

		if #items > 0 then

			-- mark the item as processed

			dataStore:UpdateAsync(items[0], function(data)

				data = data or {}

				data.processed = 1

				return data

			end)



			-- remove the item from the queue

			queue:RemoveAsync(id)

		end

	end)

end
Afficher tous les hérités de Instance
Afficher tous les hérités de Object

Évènements

Afficher tous les hérités de Instance
Afficher tous les hérités de Object