Qual é o uso adequado de um evento?
li perguntas como Access EventEmitter Service dentro da CustomHttp onde o usuário usa o EventEmitter em seu serviço, mas ele foi sugerido neste Comentário não usá-lo e usar observáveis diretamente em seus serviços.
Também li isto. pergunta onde a solução sugere passar o evento Emissor para a criança e assiná-lo.a minha pergunta é : devo ou não subscrever manualmente uma Evento? Como devo usá-lo?
2 answers
EventEmitter é uma abstração angular2 e seu único propósito é emitir eventos em componentes. Citando um comentário de Rob Wormald
Isto é muito claro no caso do emissor. documentacao.[...] EventEmitter is really an Angular abstraction, and should be used pretty much only for emitting custom Events in components. Caso contrário, basta usar Rx como se fosse qualquer outra biblioteca.
O que há de errado em usá-lo? O Angular2 nunca nos garante que o evento Continue a ser observável. Isso significa refactorar o nosso código se ele mudar. A única API a que devemos aceder é o seu métodoUtilização por directivas e Componentes para emitir eventos personalizados.
emit(). Nunca devemos subscrever manualmente um evento.
Tudo o que foi dito acima é mais claro neste Comentário de Ward Bell {[[28]} (recomendado para leia o artigo e a resposta a esse comentário. Citar a Referência
O comentário dele está de acordo com o comentário do Rob há muito tempo. Então, como usá-lo correctamente?Não conte com que o EventEmitter continue a ser um observável!
Não conte com a presença dos operadores observáveis no futuro!Estes serão depreciados em breve e provavelmente removidos antes da libertação.
Utilize o evento apenas para a ligação entre um filho e o componente pai. Não subscreva. Não chame nenhum desses métodos. Apenas chamada
eve.emit()
Basta usá-lo para emitir eventos a partir do seu componente. Veja um exemplo a seguir.
@Component({
selector : 'child',
template : `
<button (click)="sendNotification()">Notify my parent!</button>
`
})
class Child {
@Output() notifyParent: EventEmitter<any> = new EventEmitter();
sendNotification() {
this.notifyParent.emit('Some value to send to the parent');
}
}
@Component({
selector : 'parent',
template : `
<child (notifyParent)="getNotification($event)"></child>
`
})
class Parent {
getNotification(evt) {
// Do something with the notification (evt) sent by the child!
}
}
class MyService {
@Output() myServiceEvent : EventEmitter<any> = new EventEmitter();
}
Espero que estes dois exemplos simples esclareçam o uso adequado do evento.
Resposta:
Não, Não assines manualmente para eles, não os use em serviços. Use - os como é mostrado na documentação apenas para emitir eventos em componentes. Não derrotes a abstração angular.
EventEmitter is a public, documented type in the final Angular Core API. Se é ou não baseado em Observable é irrelevante; se os seus métodos documentados emit e subscribe se adequam ao que você precisa, então vá em frente e use-o.
Tal como indicado nos documentos:
Então eles queriam um objeto semelhante que se comportasse de certa forma, implementaram-no e tornaram-no público. Se fosse apenas uma abstração Angular interna que não deveria ser usada, não a teriam tornado pública. Há muitas vezes em que é útil ter um emissor que envia eventos de um tipo específico. Se esse é o teu caso de uso, força. If / when a reference implementation of the spec they link para estar disponível, deve ser uma substituição drop-in, assim como qualquer outro polifill.Usa Rx.Observable but provides an adapter to make it work as specified here: https://github.com/jhusain/observable-spec
Uma vez uma referência a implementação da especificação está disponível, mude para ela.
Certifica-te apenas que o gerador que passas para a função subscribe() segue a especificação ligada. O objeto devolvido tem a garantia de ter um método unsubscribe que deve ser chamado para liberar quaisquer referências ao gerador (este é atualmente um objeto RxJS Subscription}, mas esse é de fato um detalhe de implementação que não deve ser dependente).
export class MyServiceEvent {
message: string;
eventId: number;
}
export class MyService {
public onChange: EventEmitter<MyServiceEvent> = new EventEmitter<MyServiceEvent>();
public doSomething(message: string) {
// do something, then...
this.onChange.emit({message: message, eventId: 42});
}
}
export class MyConsumer {
private _serviceSubscription;
constructor(private service: MyService) {
this._serviceSubscription = this.service.onChange.subscribe({
next: (event: MyServiceEvent) => {
console.log(`Received message #${event.eventId}: ${event.message}`);
}
})
}
public consume() {
// do some stuff, then later...
this.cleanup();
}
private cleanup() {
this._serviceSubscription.unsubscribe();
}
}
Toda a dura condenação e condenação previsões sombrias parecem derivar de um único comentário de fluxo de pilha de um único desenvolvedor em uma versão pré-lançamento do Angular 2.