Pular para o conteúdo principal
Data e Schema

Esta página ainda não foi traduzida: mostrando a versão em inglês.

Records ao vivo

Assine uma consulta ou um Record, e o jogo recebe o estado atual completo e depois uma cópia nova a cada alteração. Não há polling para escrever: quando outro Player, uma Function ou um operador no Backoffice altera os dados, o seu handler Changed roda com o novo estado. Os exemplos usam o Schema do Sky Arena; os tipos C# são configurados em Leitura de Records.

using System.Collections.Generic;
using System.Linq;
using Playserv.Data;
using Playserv.DataSubscription;
using Playserv.Wrapper;

ISharedCollection<MatchResults> top = await PlayServData.Records<MatchResults>().SubscribeAsync(
    new PlayServRecordQuery<MatchResults>()
        .Where(m => m.Score >= 1000)
        .WithLimit(50));

void Show(IReadOnlyList<MatchResults> results) =>
    leaderboard.Show(results.OrderByDescending(m => m.Score).Take(10));   // sort on the client

Show(top.Items);          // the current state, already there when SubscribeAsync returns
top.Changed += Show;      // every change after that

Assinar um conjunto de Records

Records<T>().SubscribeAsync(query) retorna uma ISharedCollection<T>. Items guarda os valores dos Records que atendem à consulta: o estado atual já está lá quando SubscribeAsync retorna. A partir daí, Changed dispara com o conjunto inteiro a cada alteração. Changed não dispara para o estado inicial, então mostre Items primeiro. A cada vez, o conjunto é substituído por inteiro; não é uma lista do que mudou.

Uma consulta ao vivo suporta menos coisas do que uma consulta de leitura única:

RecursoLeitura únicaAo vivo
Where, And, IncludeSimSim
OrNãoSim, até 8 grupos
Include de uma relação de uma relaçãoNãoSim
OrderBy, Search, Hide, cursoresSimNão: ordene os Records no cliente.

Uma consulta com algo que a chamada não suporta lança PlayServQueryCapabilityException, que diz o que remover.


Assinar um único Record

record.SubscribeAsync() mantém um Record carregado atualizado e retorna uma IPlayServRecordSubscription<T>:

var pilot = await PlayServData.Records<Pilots>().LoadAsync(pilotId);
var live = await pilot.SubscribeAsync();
hud.SetLevel(pilot.Value.Level);                                   // the state you loaded
live.Changed += change => hud.SetLevel(change.Record.Value.Level); // every change after that
MembroO que informa
ChangedO Record mudou. change.Record é o Record atualizado; ChangedFields lista os campos alterados.
ConflictO Record mudou na plataforma enquanto você tinha edições não salvas nele. Você recebe as duas versões: LocalValue e RemoteValue.

Um Record com alterações não salvas não pode iniciar uma assinatura: salve-o ou recarregue-o antes. Um Record parcial é recarregado por completo antes de a assinatura começar.


O que chega

QuandoO que você recebe
A assinatura começaO estado atual, em Items (ou o Record que você assinou). Changed não dispara.
Um Record que atende à consulta é criado, alterado ou excluídoO novo estado completo do conjunto, em Changed.
Um Record ligado por Include mudaTambém o novo estado completo, com o Record ligado atualizado.

Os eventos de uma assinatura de um único Record chegam na thread principal da Unity, então você pode atualizar a UI a partir do handler.


Limites

ItemLimite
Records num conjunto ao vivo200
Campos64
Filtros16, e 16 em cada grupo Or
Grupos Or8
Níveis de Include6

Mantenha um conjunto ao vivo abaixo de 200 Records

Uma consulta ao vivo sem WithLimit que encontra mais de 200 Records termina, logo no início ou mais tarde, quando o conjunto passa de 200. Defina WithLimit como 200 ou menos, ou restrinja o filtro.


Quando uma assinatura termina

Uma assinatura termina de vez quando:

  • o Record que ela acompanha é excluído: record.IsDeleted passa a ser true;
  • o conjunto passa de 200 Records sem um limite.

Failure dispara com o motivo e, em seguida, Terminated. State passa a ser Terminated, e TerminalError guarda o motivo. O último estado recebido continua em Items ou Record. Para voltar a acompanhar os dados, assine de novo.


Encerrar uma assinatura

Chame CloseAsync() quando não precisar mais dela, ou Dispose() se não puder esperar, por exemplo em OnDestroy. State passa a ser Closed; nem Failure nem Terminated disparam.

void OnDestroy() => top?.Dispose();

Assinaturas idênticas são compartilhadas

Várias assinaturas com a mesma consulta compartilham uma única assinatura na plataforma. A compartilhada só para quando a última delas é encerrada, então encerre cada uma que abrir.


Reconexões

Se a conexão cair, State passa a ser Reconnecting, e o SDK reabre todas as assinaturas abertas assim que o jogo volta a ficar online, sem nenhum código da sua parte. A assinatura então recebe o estado atual, incluindo tudo o que mudou nesse meio-tempo. Veja Conexão e sessão.


Próximos passos

Atualizado em 21 de out. de 2026