Haverá IQueryable-como adições ao IObservable? (.NET Rx)

Question

Os novos quadros IObservable / IObserver na biblioteca System.Reactive próximos em .NET 4.0 são muito emocionante (veja este e este link ).

Pode ser muito cedo para especular, mas vai haver também uma (por falta de um termo melhor) IQueryable-like quadro construído para essas novas interfaces bem?

Um caso de uso particular seria para ajudar em eventos de pré-processamento na fonte, em vez de na cadeia das chamadas receptores. Por exemplo, se você tem uma interface evento muito 'falador', usando o Subscribe().Where(...) receberá todos os eventos através do gasoduto eo cliente faz a filtragem.

O que eu estou querendo saber é se haverá algo semelhante a IQueryableObservable, em que esses métodos LINQ será 'compilado' em alguma aplicação 'inteligente' Subscribe em uma fonte. Eu posso imaginar algumas arquiteturas de servidores de rede que poderia usar framework tal. Ou como sobre um add-on para o SQL Server (ou qualquer RDBMS para que o assunto), que permitiria código .NET para receber novas notificações de dados (gatilhos no código) e precisaria essas notificações do lado do servidor filtrada.

Answer 1

Bem, você conseguiu na última versão do Rx, na forma de uma interface chamada IQbservable (pronunciado como IQueryableObservable). Fique ligado para um vídeo Channel 9 sobre o assunto, chegando no início da próxima semana.

Para situar esse recurso um pouco, deve-se perceber que são conceitualmente três eixos ortogonais ao enigma Rx / IX:

• O o modelo de dados é que você está alvejando. Aqui encontramos contra modelos baseados em empurrar baseada em puxar. Seu relacionamento é baseado em dualidade . existem transformações entre estes mundos (por exemplo ToEnumerable).
• Onde você executar operações que orientam suas consultas (lato sensu). Alguns operadores precisam de simultaneidade. Este é o lugar onde programação e da IScheduler interface entrar. Existe Operadores de saltar entre os domínios de concorrência (por exemplo ObserveOn).
• Como as necessidades de uma expressão de consulta para executar. Tanto de forma idêntica (IL) ou traduzíveis (árvores de expressão). Seu relacionamento é baseado em homoiconicity . Conversões existir entre as duas representações (por exemplo AsQueryable).

Toda a interface de IQbservable (que é a dupla para IQueryable ea representação árvore de expressão de uma consulta IObservable) permite que é o último ponto. Às vezes as pessoas confundem o ato de tradução de consulta (o "como" para executar) com aspectos de comunicação remota (o "onde" para executar). Embora normalmente você traduzir consultas em alguma língua-alvo (como WQL, PowerShell, DSQLs para serviços de nuvem de notificação, etc.) e remoto -los em algum sistema de destino, ambas as preocupações pode ser dissociado. Por exemplo, você poderia usar a representação árvore de expressão para fazer Local consulta otimização.

Com relação a possíveis problemas de segurança, isso não é diferente das capacidades IQueryable. Tipicamente um só irá remota a linguagem de expressão e não quaisquer operadores "verdadeiramente efetuando-side" (o que isso significa para fins que não os funcionais fundamentalistas idiomas). Em particular, o Assine e operações Run ficar local e levá-lo para fora do queryable mônada (tradução, portanto, desencadeando, assim como GetEnumerator faz no mundo da IQueryable). Como você remoto o ato de inscrição é algo que eu vou deixar para a imaginação do leitor.

Comece a jogar com a bits mais recentes hoje e deixe-nos saber o que você pensa. Também fique atento para o próximo canal 9 vídeo sobre este novo recurso, incluindo uma discussão de algumas das sua filosofia de design.

Answer 2

Enquanto isso soa como uma possibilidade interessante, eu teria várias reservas sobre como implementar esta.

1) Assim como você não pode serialize expressões lambda não triviais usado por IQueryable, serialização estes para Rx seria igualmente difícil. Você provavelmente quer ser capaz de serializar multi-linha e lambdas de instrução como parte deste quadro. Para fazer isso, você provavelmente precisará implementar algo como outros projetos de estimação de Erik Meijer -. Dryad e Volta

2) Mesmo se você poderia serializar estas expressões lambda, eu estaria preocupado com a possibilidade de execução de código arbitrário no servidor enviados a partir do cliente. Isto poderia facilmente uma preocupação em termos de segurança muito maior do cross-site scripting. Duvido que o potencial benefício de permitir que o cliente para enviar expressões para o servidor para executar supera as implicações vulnerabilidade de segurança.

Answer 3

8 (agora 10) anos no futuro: tropecei Qactive (ex-Rxx), um Rx.Net baseado queryable provedor de servidor tcp reativa É a resposta para a "pergunta em questão"

Servidor

Observable
    .Interval(TimeSpan.FromSeconds(1))
    .ServeQbservableTcp(new IPEndPoint(IPAddress.Loopback, 3205));

Cliente

var datasourceAddress = new IPEndPoint(IPAddress.Loopback, 3205);
var datasource = new TcpQbservableClient<long>(datasourceAddress);

(
     from value in datasource.Query()
     //The code below is actually executed on the server
     where value <= 5 || value >= 8
     select value
)
.Subscribe(Console.WriteLine);

mente Notícias Agenda soprando sobre isso é que os clientes podem dizer o que e com que freqüência eles querem que os dados que recebem e o servidor ainda pode limite e controle quando, como frequente e a quantidade de dados que retorna.

Para obter mais informações sobre este https://github.com/RxDave/Qactive

Outra blog.sample

https://sachabarbs.wordpress.com/ 2016/12/23 / rx-sobre-o-arame /

Answer 4

Um problema que eu gostaria de ver resolvido com o Quadro Reactive, se é possível, está possibilitando a emissão e subcription para notificações de alteração de dados em cache de serviços da Web e outros serviços somente-pull.

Answer 5

Parece, com base em um novo Channel9 entrevista , que haverá suporte LINQ para IObserver / IObservable na BCL do .NET 4.

No entanto, será essencialmente LINQ-to-Objects consultas de estilo, por isso neste estágio, ele não se parece com um 'inteligente subscribe' como você colocá-lo. Isso é tanto quanto as implementações básicas ir em .NET 4. (No meu entendimento da entrevista acima)

Dito isto , a estrutura reativa (Rx) pode ter implementações mais detalhada de IObserver / IObservable, ou você pode ser capaz de escrever o seu próprio falecimento em Expression<Func...> para os paramaters Subscribe e, em seguida, usando o expressão Árvore da Func para inscrever-se de forma mais inteligente que se adequa ao canal de evento que você está assinando.