rxx Wiki Rss Feed

Updated Wiki: Either

davedev — Tue, 30 Oct 2012 17:44:02 GMT

Either<TLeft, TRight>

.NET 4.0	Silverlight 4	Silverlight 5	Phone 7.0	Phone 7.1

Overview

Overview

See this discussion for an overview.

(TODO)

Updated Wiki: Either

davedev — Tue, 30 Oct 2012 17:43:00 GMT

Either<TLeft, TRight>

.NET 4.0	Silverlight 4	Silverlight 5	Phone 7.0	Phone 7.1
Cannot resolve image macro, invalid image name or id.	Cannot resolve image macro, invalid image name or id.	Cannot resolve image macro, invalid image name or id.	Cannot resolve image macro, invalid image name or id.	Cannot resolve image macro, invalid image name or id.

Overview

Overview

See this discussion for an overview.

(TODO)

Updated Wiki: Documentation

davedev — Tue, 30 Oct 2012 17:39:14 GMT

Rxx Documentation

Rxx Features

The following table shows all of the features that Rxx offers and the differences between the multi-targeted versions of Rxx.dll.

= Fully supported

= Partially supported

Feature	.NET 4.0	Silverlight 4/5	Phone 7.0	Phone 7.1
Parsers *Updated*
Trace extensions
WebRequest extensions
ObservableWebClient *Updated*
ObservableSocket *Updated*
ObservableHttpListener
ObservableTcpListener *New*
ObservableSmtpClient
ObservableDns
ObservablePing
ObservableNewtworkChange
ObservableSyndication
FromPropertyChangedPattern extension
FromEventBasedAsyncPattern extension
Zip and CombineLatest extensions *New*
TimeShift and related extensions
OrderBy, ThenBy and descending extensions *New*
WCF extensions *New*
UI extensions
CommandSubject and ICommand extensions
Catch, Retry and OnErrorResumeNext extensions
Cursor types and extensions
Serve extension
Introspect and Introspective extensions
Prime and StartPrimed extensions
Multicast extension
Pair and IObservable<Either> extensions
Either<TLeft, TRight>
Maybe<T> (type and extension)
Scalar<T>
I/O extensions
SqlCommand extensions *New*
User Data extensions *New*
Consume extension
ListSubject, DictionarySubject extensions *Updated*
Operational classes and extensions
ObservableDynamicObject
SerialDisposable extensions
Expression extensions
PropertyDescriptor extensions
ApplicationSettingsBase extensions
IEnumerable<T> extensions

Updated Wiki: Home

davedev — Wed, 15 Aug 2012 17:49:18 GMT

Welcome

Rxx is a library of unofficial reactive LINQ extensions supplementary to Microsoft's Reactive Extensions for .NET (Rx). Rxx is developed entirely in C# and targets the .NET Framework 4.0, Silverlight 4.0/5.0 and Windows Phone 7.0/7.1.

The Documentation tab shows the complete list of extensions and features.

Goals

The Rxx project is designed to provide LINQ extensions that we (the contributors) believe are useful in real-world applications and are not currently present in the Microsoft Reactive Extensions for .NET (Rx) libraries.
Rxx is NOT meant to supersede Rx, but to supplement it. We'd prefer for our extensions to be included in Rx and will remove any duplication from our library as they evolve.
Rxx is currently packaged as a single class library to make distribution and integration into your applications easier.
1. We offer stable and experimental releases for 3 different platforms: .NET 4.0, Silverlight 4/5 and Windows Phone 7.0/7.1.
2. You can also download Rxx on NuGet.
Community feedback and contributions will help guide the evolution of Rxx.

Getting Started

See our Release Notes and Getting Started topics.
Before experimenting with Rxx, read about our Hands-on Labs
If you're looking to contribute, then please see our Contributions topic.

New Comment on "Documentation"

davedev — Thu, 09 Aug 2012 00:23:42 GMT

Please ask questions in the Discussions area in the future. I don't get notified about new comments. To answer your question, the MSDN-style library reference documentation is available in the Downloads area. Look for "Rxx Doc" for your desired platform(s).

New Comment on "Documentation"

mattme — Wed, 30 May 2012 13:25:12 GMT

Where's the MSDN-style library reference documentation?

Updated Wiki: TCP Qbservable Provider

davedev — Sat, 05 May 2012 21:10:15 GMT

1.0 Alpha

Targets the .NET Framework 4.5 Beta.
Written entirely in C# 5 and VS 11 Beta.
Depends on Rx 2.0 Beta and Rxx 2.0 Beta, both of which are included in the download.
- (Note that Rxx 2.0 Beta is not yet officially released and will most likely change).

Overview

The TCP Qbservable Provider library enables you to easily expose IQbservable<T> services over TCP. When a client subscribes, its query is serialized to the server as an expression tree and then executed on the server.

For more in-depth information, see this series of blog posts.

Warning: This provider allows clients to execute arbitrary code on your server.

This is only an alpha release, so security hasn't been fully considered. Do not expose a Qbservable TCP service on a public server or client without taking the necessary precautions to secure them first.

Features

Simple server factory methods for hosting a Qbservable TCP service.
- Supports hosting any IObservable<T> query as a TCP service (hot or cold).
- Supports hosting any IQbservable<T> query as a TCP service.
Simple client factory methods for acquiring a Qbservable TCP service.
- You must only specify the end point address and the expected return type. The result is an IQbservable<T> that you can query and Subscribe.
- All Qbservable Rx operators are supported.
Automatically serialized Expression trees.
- Dynamic expressions and debug info expressions are not supported. All other types of expressions are supported.
Automatically serialized anonymous types.
Immediate evaluation of local members and closures (optional; default behavior)
- Compiler-generated methods are executed locally and replaced with their return values before the expression is transmitted to the server. This includes iterator blocks, which are serialized as List<T>.
- Evaluation assumes that local methods are never executed for their side-effects. Actions (void-returning methods) cause an exception. Do not depend upon the order in which members are invoked.
Full duplex communication (optional; default behavior for IObservable<T> closures)
- Must opt-in on server.
- May opt-in on client for full duplex communication of all local members; automatic for IObservable<T> closures.
- Duplex communication automatically supports iterator blocks.
Designed with extensibility in mind; e.g., supports custom Qbservable service providers, protocols and sinks.

Simple Examples

The following example creates a cold observable sequence that generates a new notification every second and exposes it as an IQbservable<long> service over TCP port 3205 on the local computer.

Server

IObservable<long> source = Observable.Interval(TimeSpan.FromSeconds(1));

var service = source.ServeQbservableTcp(new IPEndPoint(IPAddress.Loopback, 3205));

using (service.SubscribeEither(
	client => Console.WriteLine("Client shutdown."),
	ex => Console.WriteLine("Error: {0}", ex.Message),
	ex => Console.WriteLine("Fatal error: {0}", ex.Message),
	() => Console.WriteLine("This will never be printed because a service host never completes.")))
{
	Console.ReadKey();
}

The following example creates a LINQ query over the IQbservable<long> service that is created by the previous example. Subscribing to the query on the client causes the query to be serialized to the server and executed there. In other words, the where clause is actually executed on the server so that the client only receives the data that it requested without having to do any filtering itself. The client will receive the first six values, one per second. The server then filters out the next 2 values - it does not send them to the client. Finally, the remaining values are sent to the client until either the client or the server disposes of the subscription.

Client

var client = new QbservableTcpClient<long>(new IPEndPoint(IPAddress.Loopback, 3205));

IQbservable<long> query =
	from value in client.Query()
	where value <= 5 || value >= 8
	select value;

using (query.Subscribe(
	value => Console.WriteLine("Client observed: " + value),
	ex => Console.WriteLine("Error: {0}", ex.Message),
	() => Console.WriteLine("Completed")))
{
	Console.ReadKey();
}

Getting Started

Download the latest release and unzip it.
All of the assemblies that you need to build your own applications are located in the bin folder.

To run the examples:

Run QbservableServer.exe.
1. The server will start hosting example Qbservable services as soon as the console application begins.
2. Pressing a key at any time will stop the server.
Run QbservableClient.exe.
1. You can run several client console applications at the same time.
When the client console application starts, press any key to connect to the server. The client will begin running the first example.
Press any key to stop the current example and start the following example.

To build the source code:

Download the source code from the Source Code tab.
1. The solution is located under the QbservableProvider directory, but it depends upon the relative path to the Main branch. Make sure that both paths exist.
You must build the Rxx 2.0 Beta project in the Main branch in Debug mode. See How To Build the Source Code for instructions.
Open the QbservableProvider solution in VS 11 Beta.
Set the QbservableServer project as the startup project.
Build and run. The server will start as soon as the console application begins.
Set the QbservableClient project as the startup project.
Build and run. You can run several client console applications at the same time.
When the client console application starts, press any key to connect to the server.

Tip: To see the original and rewritten expression trees, run the client application with the debugger attached and look at the Output window.

Planning

Research building on top of WCF to support advanced configuration, customization, extensibility, standardization and additional transports such as WebSockets over HTTP.
Improve expression tree serialization; e.g., fix bugs and write unit tests.
Consider security.
Consider memory/performance.
Support querying from Silverlight 5 and Windows Phone 7.5 apps. (This may require WebSockets though.)
Support querying from RxJS clients.

Updated Wiki: TCP Qbservable Provider

davedev — Wed, 02 May 2012 11:42:33 GMT

TCP Qbservable Provider

Overview
Features
Simple Examples
Getting Started
- Source Code
Planning

1.0 Alpha

Targets the .NET Framework 4.5 Beta.
Written entirely in C# 5 and VS 11 Beta.
Depends on Rx 2.0 Beta and Rxx 2.0 Beta, both of which are included in the download.
- (Note that Rxx 2.0 Beta is not yet officially released and will most likely change).

Overview

Warning: This provider allows clients to execute arbitrary code on your server.

This is only an alpha release, so security hasn't been fully considered. Do not expose a Qbservable TCP service on a public server or client without taking the necessary precautions to secure them first.

Features

Simple server factory methods for hosting a Qbservable TCP service.
- Supports hosting any IObservable<T> query as a TCP service (hot or cold).
- Supports hosting any IQbservable<T> query as a TCP service.
Simple client factory methods for acquiring a Qbservable TCP service.
- You must only specify the end point address and the expected return type. The result is an IQbservable<T> that you can query and Subscribe.
- All Qbservable Rx operators are supported.
Automatically serialized Expression trees.
- Dynamic expressions and debug info expressions are not supported. All other types of expressions are supported.
Automatically serialized anonymous types.
Immediate evaluation of local members and closures (optional; default behavior)
- Compiler-generated methods are executed locally and replaced with their return values before the expression is transmitted to the server. This includes iterator blocks, which are serialized as List<T>.
- Evaluation assumes that local methods are never executed for their side-effects. Actions (void-returning methods) cause an exception. Do not depend upon the order in which members are invoked.
Full duplex communication (optional; default behavior for IObservable<T> closures)
- Must opt-in on server.
- May opt-in on client for full duplex communication of all local members; automatic for IObservable<T> closures.
- Duplex communication automatically supports iterator blocks.
Designed with extensibility in mind; e.g., supports custom Qbservable service providers, protocols and sinks.

Simple Examples

The following example creates a cold observable sequence that generates a new notification every second and exposes it as an IQbservable<long> service over TCP port 3205 on the local computer.

Server

IObservable<long> source = Observable.Interval(TimeSpan.FromSeconds(1));

var service = source.ServeQbservableTcp(new IPEndPoint(IPAddress.Loopback, 3205));

using (service.SubscribeEither(
	client => Console.WriteLine("Client shutdown."),
	ex => Console.WriteLine("Error: {0}", ex.Message),
	ex => Console.WriteLine("Fatal error: {0}", ex.Message),
	() => Console.WriteLine("This will never be printed because a service host never completes.")))
{
	Console.ReadKey();
}

Client

var client = new QbservableTcpClient<long>(new IPEndPoint(IPAddress.Loopback, 3205));

IQbservable<long> query =
	from value in client.Query()
	where value <= 5 || value >= 8
	select value;

using (query.Subscribe(
	value => Console.WriteLine("Client observed: " + value),
	ex => Console.WriteLine("Error: {0}", ex.Message),
	() => Console.WriteLine("Completed")))
{
	Console.ReadKey();
}

Getting Started

Download the latest release and unzip it.
All of the assemblies that you need to build your own applications are located in the bin folder.

To run the examples:

Run QbservableServer.exe.
1. The server will start hosting example Qbservable services as soon as the console application begins.
2. Pressing a key at any time will stop the server.
Run QbservableClient.exe.
1. You can run several client console applications at the same time.
When the client console application starts, press any key to connect to the server. The client will begin running the first example.
Press any key to stop the current example and start the following example.

To build the source code:

Download the source code from the Source Code tab.
1. The solution is located under the QbservableProvider directory, but it depends upon the relative path to the Main branch. Make sure that both paths exist.
You must build the Rxx 2.0 Beta project in the Main branch in Debug mode. See How To Build the Source Code for instructions.
Open the QbservableProvider solution in VS 11 Beta.
Set the QbservableServer project as the startup project.
Build and run. The server will start as soon as the console application begins.
Set the QbservableClient project as the startup project.
Build and run. You can run several client console applications at the same time.
When the client console application starts, press any key to connect to the server.

Tip: To see the original and rewritten expression trees, run the client application with the debugger attached and look at the Output window.

Planning

Research building on top of WCF to support advanced configuration, customization, extensibility, standardization and additional transports such as WebSockets over HTTP.
Improve expression tree serialization; e.g., fix bugs and write unit tests.
Consider security.
Consider memory/performance.
Support querying from Silverlight 5 and Windows Phone 7.5 apps. (This may require WebSockets though.)
Support querying from RxJS clients.

Updated Wiki: TCP Qbservable Provider

davedev — Wed, 25 Apr 2012 16:54:10 GMT

TCP Qbservable Provider

Overview
Features
Simple Examples
Getting Started
- Source Code
Planning

1.0 Alpha

Targets the .NET Framework 4.5 Beta.
Written entirely in C# 5 and VS 11 Beta.
Depends on Rx 2.0 Beta and Rxx 2.0 Beta, both of which are included in the download.
- (Note that Rxx 2.0 Beta is not yet officially released and will most likely change).

Overview

Warning: This provider allows clients to execute arbitrary code on your server.

This is only an alpha release, so security hasn't been fully considered. Do not expose a Qbservable TCP service on a public server or client without taking the necessary precautions to secure them first.

Features

Simple server factory methods for hosting a Qbservable TCP service.
- Supports hosting any IObservable<T> query as a TCP service (hot or cold).
- Supports hosting any IQbservable<T> query as a TCP service.
Simple client factory methods for acquiring a Qbservable TCP service.
- You must only specify the end point address and the expected return type. The result is an IQbservable<T> that you can query and Subscribe.
- All Qbservable Rx operators are supported.
Automatically serialized Expression trees.
- Dynamic expressions and debug info expressions are not supported. All other types of expressions are supported.
Automatically serialized anonymous types.
Immediate evaluation of local members and closures (optional; default behavior)
- Compiler-generated methods are executed locally and replaced with their return values before the expression is transmitted to the server. This includes iterator blocks, which are serialized as List<T>.
- Evaluation assumes that local methods are never executed for their side-effects. Actions (void-returning methods) cause an exception. Do not depend upon the order in which members are invoked.
Full duplex communication (optional; default behavior for IObservable<T> closures)
- Must opt-in on server.
- May opt-in on client for full duplex communication of all local members; automatic for IObservable<T> closures.
- Duplex communication automatically supports iterator blocks.
Designed with extensibility in mind; e.g., supports custom Qbservable service providers, protocols and sinks.

Simple Examples

The following example creates a cold observable sequence that generates a new notification every second and exposes it as an IQbservable<long> service over TCP port 3205 on the local computer.

Server

IObservable<long> source = Observable.Interval(TimeSpan.FromSeconds(1));

var service = source.ServeQbservableTcp(new IPEndPoint(IPAddress.Loopback, 3205));

using (service.SubscribeEither(
	client => Console.WriteLine("Client shutdown."),
	ex => Console.WriteLine("Error: {0}", ex.Message),
	ex => Console.WriteLine("Fatal error: {0}", ex.Message),
	() => Console.WriteLine("This will never be printed because a service host never completes.")))
{
	Console.ReadKey();
}

Client

var client = new QbservableTcpClient<long>(new IPEndPoint(IPAddress.Loopback, 3205));

IQbservable<long> query =
	from value in client.Query()
	where value <= 5 || value >= 8
	select value;

using (query.Subscribe(
	value => Console.WriteLine("Client observed: " + value),
	ex => Console.WriteLine("Error: {0}", ex.Message),
	() => Console.WriteLine("Completed")))
{
	Console.ReadKey();
}

Getting Started

Download the latest release and unzip it.
All of the assemblies that you need to build your own applications are located in the bin folder.

To run the examples:

Run QbservableServer.exe.
1. The server will start hosting example Qbservable services as soon as the console application begins.
2. Pressing a key at any time will stop the server.
Run QbservableClient.exe.
1. You can run several client console applications at the same time.
When the client console application starts, press any key to connect to the server. The client will begin running the first example.
Press any key to stop the current example and start the following example.

To build the source code:

Download the source code from the Source Code tab.
1. The solution is located under the QbservableProvider directory, but it depends upon the relative path to the Main branch. Make sure that both paths exist.
You must build the Rxx 2.0 Beta project in the Main branch in Debug mode. See How To Build the Source Code for instructions.
Open the QbservableProvider solution in VS 11 Beta.
Set the QbservableServer project as the startup project.
Build and run. The server will start as soon as the console application begins.
Set the QbservableClient project as the startup project.
Build and run. You can run several client console applications at the same time.
When the client console application starts, press any key to connect to the server.

Tip: To see the original and rewritten expression trees, run the client application with the debugger attached and look at the Output window.

Planning

Research building on top of WCF to support advanced configuration, customization, extensibility, standardization and additional transports such as WebSockets over HTTP.
Improve expression tree serialization; e.g., fix bugs and write unit tests.
Consider security.
Consider memory/performance.
Support querying from Silverlight 5 and Windows Phone 7.5 apps. (This may require WebSockets though.)
Support querying from RxJS clients.

Updated Wiki: TCP Qbservable Provider

davedev — Wed, 25 Apr 2012 16:53:09 GMT

TCP Qbservable Provider

Overview
Features
Simple Examples
Getting Started
- Source Code
Planning

1.0 Alpha

Targets the .NET Framework 4.5 Beta.
Written entirely in C# 5 and VS 11 Beta.
Depends on Rx 2.0 Beta and Rxx 2.0 Beta, both of which are included in the download.
- (Note that Rxx 2.0 Beta is not yet officially released and will most likely change).

Overview

Warning: This provider allows clients to execute arbitrary code on your server.

This is only an alpha release, so security hasn't been fully considered. Do not expose a Qbservable TCP service on a public server or client without taking the necessary precautions to secure them first.

For more in-depth information, see this blog post.

Features

Simple server factory methods for hosting a Qbservable TCP service.
- Supports hosting any IObservable<T> query as a TCP service (hot or cold).
- Supports hosting any IQbservable<T> query as a TCP service.
Simple client factory methods for acquiring a Qbservable TCP service.
- You must only specify the end point address and the expected return type. The result is an IQbservable<T> that you can query and Subscribe.
- All Qbservable Rx operators are supported.
Automatically serialized Expression trees.
- Dynamic expressions and debug info expressions are not supported. All other types of expressions are supported.
Automatically serialized anonymous types.
Immediate evaluation of local members and closures (optional; default behavior)
- Compiler-generated methods are executed locally and replaced with their return values before the expression is transmitted to the server. This includes iterator blocks, which are serialized as List<T>.
- Evaluation assumes that local methods are never executed for their side-effects. Actions (void-returning methods) cause an exception. Do not depend upon the order in which members are invoked.
Full duplex communication (optional; default behavior for IObservable<T> closures)
- Must opt-in on server.
- May opt-in on client for full duplex communication of all local members; automatic for IObservable<T> closures.
- Duplex communication automatically supports iterator blocks.
Designed with extensibility in mind; e.g., supports custom Qbservable service providers, protocols and sinks.

Simple Examples

The following example creates a cold observable sequence that generates a new notification every second and exposes it as an IQbservable<long> service over TCP port 3205 on the local computer.

Server

IObservable<long> source = Observable.Interval(TimeSpan.FromSeconds(1));

var service = source.ServeQbservableTcp(new IPEndPoint(IPAddress.Loopback, 3205));

using (service.SubscribeEither(
	client => Console.WriteLine("Client shutdown."),
	ex => Console.WriteLine("Error: {0}", ex.Message),
	ex => Console.WriteLine("Fatal error: {0}", ex.Message),
	() => Console.WriteLine("This will never be printed because a service host never completes.")))
{
	Console.ReadKey();
}

Client

var client = new QbservableTcpClient<long>(new IPEndPoint(IPAddress.Loopback, 3205));

IQbservable<long> query =
	from value in client.Query()
	where value <= 5 || value >= 8
	select value;

using (query.Subscribe(
	value => Console.WriteLine("Client observed: " + value),
	ex => Console.WriteLine("Error: {0}", ex.Message),
	() => Console.WriteLine("Completed")))
{
	Console.ReadKey();
}

Getting Started

Download the latest release and unzip it.
All of the assemblies that you need to build your own applications are located in the bin folder.

To run the examples:

Run QbservableServer.exe.
1. The server will start hosting example Qbservable services as soon as the console application begins.
2. Pressing a key at any time will stop the server.
Run QbservableClient.exe.
1. You can run several client console applications at the same time.
When the client console application starts, press any key to connect to the server. The client will begin running the first example.
Press any key to stop the current example and start the following example.

To build the source code:

Download the source code from the Source Code tab.
1. The solution is located under the QbservableProvider directory, but it depends upon the relative path to the Main branch. Make sure that both paths exist.
You must build the Rxx 2.0 Beta project in the Main branch in Debug mode. See How To Build the Source Code for instructions.
Open the QbservableProvider solution in VS 11 Beta.
Set the QbservableServer project as the startup project.
Build and run. The server will start as soon as the console application begins.
Set the QbservableClient project as the startup project.
Build and run. You can run several client console applications at the same time.
When the client console application starts, press any key to connect to the server.

Tip: To see the original and rewritten expression trees, run the client application with the debugger attached and look at the Output window.

Planning

Research building on top of WCF to support advanced configuration, customization, extensibility, standardization and additional transports such as WebSockets over HTTP.
Improve expression tree serialization; e.g., fix bugs and write unit tests.
Consider security.
Consider memory/performance.
Support querying from Silverlight 5 and Windows Phone 7.5 apps. (This may require WebSockets though.)
Support querying from RxJS clients.

Updated Wiki: Documentation

davedev — Tue, 24 Apr 2012 18:54:39 GMT

Rxx Documentation

Rxx Features

The following table shows all of the features that Rxx offers and the differences between the multi-targeted versions of Rxx.dll.

= Fully supported

= Partially supported

Feature	.NET 4.0	Silverlight 4/5	Phone 7.0	Phone 7.1
Parsers *Updated*
Trace extensions
WebRequest extensions
ObservableWebClient *Updated*
ObservableSocket *Updated*
ObservableHttpListener
ObservableTcpListener *New*
ObservableSmtpClient
ObservableDns
ObservablePing
ObservableNewtworkChange
ObservableSyndication
FromPropertyChangedPattern extension
FromEventBasedAsyncPattern extension
Zip and CombineLatest extensions *New*
TimeShift and related extensions
OrderBy, ThenBy and descending extensions *New*
WCF extensions *New*
UI extensions
CommandSubject and ICommand extensions
Catch, Retry and OnErrorResumeNext extensions
Cursor types and extensions
Serve extension
Introspect and Introspective extensions
Prime and StartPrimed extensions
Multicast extension
Pair and IObservable<Either> extensions
Either<TLeft, TRight>
Maybe<T> (type and extension)
Scalar<T>
I/O extensions
SqlCommand extensions *New*
User Data extensions *New*
Consume extension
ListSubject, DictionarySubject extensions *Updated*
Operational classes and extensions
ObservableDynamicObject
SerialDisposable extensions
Expression extensions
PropertyDescriptor extensions
ApplicationSettingsBase extensions
IEnumerable<T> extensions

Updated Wiki: TCP Qbservable Provider

davedev — Tue, 24 Apr 2012 18:48:47 GMT

TCP Qbservable Provider

Overview
Features
Simple Examples
Getting Started
- Source Code
Planning

1.0 Alpha

Targets the .NET Framework 4.5 Beta.
Written entirely in C# 5 and VS 11 Beta.
Depends on Rx 2.0 Beta and Rxx 2.0 Beta, both of which are included in the download.
- (Note that Rxx 2.0 Beta is not yet officially released and will most likely change).

Overview

Warning: This provider allows clients to execute arbitrary code on your server.

This is only an alpha release, so security hasn't been fully considered. Do not expose a Qbservable TCP service on a public server or client without taking the necessary precautions to secure them first.

Features

Simple server factory methods for hosting a Qbservable TCP service.
- Supports hosting any IObservable<T> query as a TCP service (hot or cold).
- Supports hosting any IQbservable<T> query as a TCP service.
Simple client factory methods for acquiring a Qbservable TCP service.
- You must only specify the end point address and the expected return type. The result is an IQbservable<T> that you can query and Subscribe.
- All Qbservable Rx operators are supported.
Automatically serialized Expression trees.
- Dynamic expressions and debug info expressions are not supported. All other types of expressions are supported.
Automatically serialized anonymous types.
Immediate evaluation of local members and closures (optional; default behavior)
- Compiler-generated methods are executed locally and replaced with their return values before the expression is transmitted to the server. This includes iterator blocks, which are serialized as List<T>.
- Evaluation assumes that local methods are never executed for their side-effects. Actions (void-returning methods) cause an exception. Do not depend upon the order in which members are invoked.
Full duplex communication (optional; default behavior for IObservable<T> closures)
- Must opt-in on server.
- May opt-in on client for full duplex communication of all local members; automatic for IObservable<T> closures.
- Duplex communication automatically supports iterator blocks.
Designed with extensibility in mind; e.g., supports custom Qbservable service providers, protocols and sinks.

Simple Examples

The following example creates a cold observable sequence that generates a new notification every second and exposes it as an IQbservable<long> service over TCP port 3205 on the local computer.

Server

IObservable<long> source = Observable.Interval(TimeSpan.FromSeconds(1));

var service = source.ServeQbservableTcp(new IPEndPoint(IPAddress.Loopback, 3205));

using (service.SubscribeEither(
	client => Console.WriteLine("Client shutdown."),
	ex => Console.WriteLine("Error: {0}", ex.Message),
	ex => Console.WriteLine("Fatal error: {0}", ex.Message),
	() => Console.WriteLine("This will never be printed because a service host never completes.")))
{
	Console.ReadKey();
}

Client

var client = new QbservableTcpClient<long>(new IPEndPoint(IPAddress.Loopback, 3205));

IQbservable<long> query =
	from value in client.Query()
	where value <= 5 || value >= 8
	select value;

using (query.Subscribe(
	value => Console.WriteLine("Client observed: " + value),
	ex => Console.WriteLine("Error: {0}", ex.Message),
	() => Console.WriteLine("Completed")))
{
	Console.ReadKey();
}

Getting Started

Download the latest release and unzip it.
All of the assemblies that you need to build your own applications are located in the bin folder.

To run the examples:

Run QbservableServer.exe.
1. The server will start hosting example Qbservable services as soon as the console application begins.
2. Pressing a key at any time will stop the server.
Run QbservableClient.exe.
1. You can run several client console applications at the same time.
When the client console application starts, press any key to connect to the server. The client will begin running the first example.
Press any key to stop the current example and start the following example.

To build the source code:

Download the source code from the Source Code tab.
1. The solution is located under the QbservableProvider directory, but it depends upon the relative path to the Main branch. Make sure that both paths exist.
You must build the Rxx 2.0 Beta project in the Main branch in Debug mode. See How To Build the Source Code for instructions.
Open the QbservableProvider solution in VS 11 Beta.
Set the QbservableServer project as the startup project.
Build and run. The server will start as soon as the console application begins.
Set the QbservableClient project as the startup project.
Build and run. You can run several client console applications at the same time.
When the client console application starts, press any key to connect to the server.

Tip: To see the original and rewritten expression trees, run the client application with the debugger attached and look at the Output window.

Planning

Research building on top of WCF to support advanced configuration, customization, extensibility, standardization and additional transports such as WebSockets over HTTP.
Improve expression tree serialization; e.g., fix bugs and write unit tests.
Consider security.
Consider memory/performance.
Support querying from Silverlight 5 and Windows Phone 7.5 apps. (This may require WebSockets though.)
Support querying from RxJS clients.

Updated Wiki: TCP Qbservable Provider

davedev — Tue, 24 Apr 2012 18:45:53 GMT

TCP Qbservable Provider

Overview
Features
Simple Examples
Getting Started
- Source Code
Planning

1.0 Alpha

Targets the .NET Framework 4.5 Beta.
Written entirely in C# 5 and VS 11 Beta.
Depends on Rx 2.0 Beta and Rxx 2.0 Beta, both of which are included in the download.
- (Note that Rxx 2.0 Beta is not yet officially released and will most likely change).

Overview

Warning: This provider allows clients to execute arbitrary code on your server.

This is only an alpha release, so security hasn't been fully considered. Do not expose a Qbservable TCP service on a public server or client without taking the necessary precautions to secure them first.

Features

Simple server factory methods for hosting a Qbservable TCP service.
- Supports hosting any IObservable<T> query as a TCP service (hot or cold).
- Supports hosting any IQbservable<T> query as a TCP service.
Simple client factory methods for acquiring a Qbservable TCP service.
- You must only specify the end point address and the expected return type. The result is an IQbservable<T> that you can query and Subscribe.
- All Qbservable Rx operators are supported.
Automatically serialized Expression trees.
- Dynamic expressions and debug info expressions are not supported. All other types of expressions are supported.
Automatically serialized anonymous types.
Immediate evaluation of local members and closures (optional; default behavior)
- Compiler-generated methods are executed locally and replaced with their return values before the expression is transmitted to the server. This includes iterator blocks, which are serialized as List<T>.
- Evaluation assumes that local methods are never executed for their side-effects. Actions (void-returning methods) cause an exception. Do not depend upon the order in which members are invoked.
Full duplex communication (optional; default behavior for IObservable<T> closures)
- Must opt-in on server.
- May opt-in on client for full duplex communication of all local members; automatic for IObservable<T> closures.
- Duplex communication automatically supports iterator blocks.
Designed with extensibility in mind; e.g., supports custom Qbservable service providers, protocols and sinks.

Simple Examples

The following example creates a cold observable sequence that generates a new notification every second and exposes it as an IQbservable<long> service over TCP port 3205 on the local computer.

Server

IObservable<long> source = Observable.Interval(TimeSpan.FromSeconds(1));

var service = source.ServeQbservableTcp(new IPEndPoint(IPAddress.Loopback, 3205));

using (service.SubscribeEither(
	client => Console.WriteLine("Client shutdown."),
	ex => Console.WriteLine("Error: {0}", ex.Message),
	ex => Console.WriteLine("Fatal error: {0}", ex.Message),
	() => Console.WriteLine("This will never be printed because a service host never completes.")))
{
	Console.ReadKey();
}

Client

var client = new QbservableTcpClient<long>(new IPEndPoint(IPAddress.Loopback, 3205));

IQbservable<long> query =
	from value in client.Query()
	where value <= 5 || value >= 8
	select value;

using (query.Subscribe(
	value => Console.WriteLine("Client observed: " + value),
	ex => Console.WriteLine("Error: {0}", ex.Message),
	() => Console.WriteLine("Completed")))
{
	Console.ReadKey();
}

Getting Started

Download the latest release and unzip it.
All of the assemblies that you need to build your own applications are located in the bin folder.

To run the examples:

Run QbservableServer.exe.
1. The server will start hosting example Qbservable services as soon as the console application begins.
2. Pressing a key at any time will stop the server.
Run QbservableClient.exe.
1. You can run several client console applications at the same time.
When the client console application starts, press any key to connect to the server. The client will begin running the first example.
Press any key to stop the current example and start the following example.

To build the source code:

Download the source code from the Source Code tab.
1. The solution is located under the QbservableProvider directory, but it depends upon the relative path to the Main branch. Make sure that both paths exist.
You must build the Rxx 2.0 Beta project in the Main branch in Debug mode. See How To Build the Source Code for instructions.
Open the QbservableProvider solution in VS 11 Beta.

3. Set the QbservableServer project as the startup project.
4. Build and run. The server will start as soon as the console application begins.
5. Set the QbservableClient project as the startup project.
6. Build and run. You can run several client console applications at the same time.
7. When the client console application starts, press any key to connect to the server.

Tip: To see the original and rewritten expression trees, run the client application with the debugger attached and look at the Output window.

Planning

Research building on top of WCF to support advanced configuration, customization, extensibility, standardization and additional transports such as WebSockets over HTTP.
Improve expression tree serialization; e.g., fix bugs and write unit tests.
Consider security.
Consider memory/performance.
Support querying from Silverlight 5 and Windows Phone 7.5 apps. (This may require WebSockets though.)
Support querying from RxJS clients.

Updated Wiki: TCP Qbservable Provider

davedev — Tue, 24 Apr 2012 18:44:32 GMT

TCP Qbservable Provider

Overview
Features
Simple Examples
Getting Started
- Source Code
Planning

1.0 Alpha

Targets the .NET Framework 4.5 Beta.
Written entirely in C# 5 and VS 11 Beta.
Depends on Rx 2.0 Beta and Rxx 2.0 Beta, both of which are included in the download.
- (Note that Rxx 2.0 Beta is not yet officially released and will most likely change).

Overview

Warning: This provider allows clients to execute arbitrary code on your server.

This is only an alpha release, so security hasn't been fully considered. Do not expose a Qbservable TCP service on a public server or client without taking the necessary precautions to secure them first.

Features

Simple server factory methods for hosting a Qbservable TCP service.
- Supports hosting any IObservable<T> query as a TCP service (hot or cold).
- Supports hosting any IQbservable<T> query as a TCP service.
Simple client factory methods for acquiring a Qbservable TCP service.
- You must only specify the end point address and the expected return type. The result is an IQbservable<T> that you can query and Subscribe.
- All Qbservable Rx operators are supported.
Automatically serialized Expression trees.
- Dynamic expressions and debug info expressions are not supported. All other types of expressions are supported.
Automatically serialized anonymous types.
Immediate evaluation of local members and closures (optional; default behavior)
- Compiler-generated methods are executed locally and replaced with their return values before the expression is transmitted to the server. This includes iterator blocks, which are serialized as List<T>.
- Evaluation assumes that local methods are never executed for their side-effects. Actions (void-returning methods) cause an exception. Do not depend upon the order in which members are invoked.
Full duplex communication (optional; default behavior for IObservable<T> closures)
- Must opt-in on server.
- May opt-in on client for full duplex communication of all local members; automatic for IObservable<T> closures.
- Duplex communication automatically supports iterator blocks.
Designed with extensibility in mind; e.g., supports custom Qbservable service providers, protocols and sinks.

Simple Examples

The following example creates a cold observable sequence that generates a new notification every second and exposes it as an IQbservable<long> service over TCP port 3205 on the local computer.

IObservable<long> source = Observable.Interval(TimeSpan.FromSeconds(1));

var service = source.ServeQbservableTcp(new IPEndPoint(IPAddress.Loopback, 3205));

using (service.SubscribeEither(
	client => Console.WriteLine("Client shutdown."),
	ex => Console.WriteLine("Error: {0}", ex.Message),
	ex => Console.WriteLine("Fatal error: {0}", ex.Message),
	() => Console.WriteLine("This will never be printed because a service host never completes.")))
{
	Console.ReadKey();
}

var client = new QbservableTcpClient<long>(new IPEndPoint(IPAddress.Loopback, 3205));

IQbservable<long> query =
	from value in client.Query()
	where value <= 5 || value >= 8
	select value;

using (query.Subscribe(
	value => Console.WriteLine("Client observed: " + value),
	ex => Console.WriteLine("Error: {0}", ex.Message),
	() => Console.WriteLine("Completed")))
{
	Console.ReadKey();
}

Getting Started

Download the latest release and unzip it.
All of the assemblies that you need to build your own applications are located in the bin folder.

To run the examples:

Run QbservableServer.exe.
1. The server will start hosting example Qbservable services as soon as the console application begins.
2. Pressing a key at any time will stop the server.
Run QbservableClient.exe.
1. You can run several client console applications at the same time.
When the client console application starts, press any key to connect to the server. The client will begin running the first example.
Press any key to stop the current example and start the following example.

To build the source code:

Download the source code from the Source Code tab.
1. The solution is located under the QbservableProvider directory, but it depends upon the relative path to the Main branch. Make sure that both paths exist.
You must build the Rxx 2.0 Beta project in the Main branch in Debug mode. See How To Build the Source Code for instructions.
Open the QbservableProvider solution in VS 11 Beta.

Tip: To see the original and rewritten expression trees, run the client application with the debugger attached and look at the Output window.

Planning

Research building on top of WCF to support advanced configuration, customization, extensibility, standardization and additional transports such as WebSockets over HTTP.
Improve expression tree serialization; e.g., fix bugs and write unit tests.
Consider security.
Consider memory/performance.
Support querying from Silverlight 5 and Windows Phone 7.5 apps. (This may require WebSockets though.)
Support querying from RxJS clients.

Updated Wiki: TCP Qbservable Provider

davedev — Tue, 24 Apr 2012 18:44:13 GMT

TCP Qbservable Provider

Overview
Features
Examples|Simple Examples
Getting Started
- Source Code
Planning

1.0 Alpha

Targets the .NET Framework 4.5 Beta.
Written entirely in C# 5 and VS 11 Beta.
Depends on Rx 2.0 Beta and Rxx 2.0 Beta, both of which are included in the download.
- (Note that Rxx 2.0 Beta is not yet officially released and will most likely change).

Overview

Warning: This provider allows clients to execute arbitrary code on your server.

This is only an alpha release, so security hasn't been fully considered. Do not expose a Qbservable TCP service on a public server or client without taking the necessary precautions to secure them first.

Features

Simple server factory methods for hosting a Qbservable TCP service.
- Supports hosting any IObservable<T> query as a TCP service (hot or cold).
- Supports hosting any IQbservable<T> query as a TCP service.
Simple client factory methods for acquiring a Qbservable TCP service.
- You must only specify the end point address and the expected return type. The result is an IQbservable<T> that you can query and Subscribe.
- All Qbservable Rx operators are supported.
Automatically serialized Expression trees.
- Dynamic expressions and debug info expressions are not supported. All other types of expressions are supported.
Automatically serialized anonymous types.
Immediate evaluation of local members and closures (optional; default behavior)
- Compiler-generated methods are executed locally and replaced with their return values before the expression is transmitted to the server. This includes iterator blocks, which are serialized as List<T>.
- Evaluation assumes that local methods are never executed for their side-effects. Actions (void-returning methods) cause an exception. Do not depend upon the order in which members are invoked.
Full duplex communication (optional; default behavior for IObservable<T> closures)
- Must opt-in on server.
- May opt-in on client for full duplex communication of all local members; automatic for IObservable<T> closures.
- Duplex communication automatically supports iterator blocks.
Designed with extensibility in mind; e.g., supports custom Qbservable service providers, protocols and sinks.

Simple Examples

The following example creates a cold observable sequence that generates a new notification every second and exposes it as an IQbservable<long> service over TCP port 3205 on the local computer.

IObservable<long> source = Observable.Interval(TimeSpan.FromSeconds(1));

var service = source.ServeQbservableTcp(new IPEndPoint(IPAddress.Loopback, 3205));

using (service.SubscribeEither(
	client => Console.WriteLine("Client shutdown."),
	ex => Console.WriteLine("Error: {0}", ex.Message),
	ex => Console.WriteLine("Fatal error: {0}", ex.Message),
	() => Console.WriteLine("This will never be printed because a service host never completes.")))
{
	Console.ReadKey();
}

var client = new QbservableTcpClient<long>(new IPEndPoint(IPAddress.Loopback, 3205));

IQbservable<long> query =
	from value in client.Query()
	where value <= 5 || value >= 8
	select value;

using (query.Subscribe(
	value => Console.WriteLine("Client observed: " + value),
	ex => Console.WriteLine("Error: {0}", ex.Message),
	() => Console.WriteLine("Completed")))
{
	Console.ReadKey();
}

Getting Started

Download the latest release and unzip it.
All of the assemblies that you need to build your own applications are located in the bin folder.

To run the examples:

Run QbservableServer.exe.
1. The server will start hosting example Qbservable services as soon as the console application begins.
2. Pressing a key at any time will stop the server.
Run QbservableClient.exe.
1. You can run several client console applications at the same time.
When the client console application starts, press any key to connect to the server. The client will begin running the first example.
Press any key to stop the current example and start the following example.

To build the source code:

Download the source code from the Source Code tab.
1. The solution is located under the QbservableProvider directory, but it depends upon the relative path to the Main branch. Make sure that both paths exist.
You must build the Rxx 2.0 Beta project in the Main branch in Debug mode. See How To Build the Source Code for instructions.
Open the QbservableProvider solution in VS 11 Beta.

Tip: To see the original and rewritten expression trees, run the client application with the debugger attached and look at the Output window.

Planning

Research building on top of WCF to support advanced configuration, customization, extensibility, standardization and additional transports such as WebSockets over HTTP.
Improve expression tree serialization; e.g., fix bugs and write unit tests.
Consider security.
Consider memory/performance.
Support querying from Silverlight 5 and Windows Phone 7.5 apps. (This may require WebSockets though.)
Support querying from RxJS clients.

Updated Wiki: TCP Qbservable Provider

davedev — Tue, 24 Apr 2012 18:23:18 GMT

TCP Qbservable Provider

Overview
Features
Getting Started
- Source Code
Planning

1.0 Alpha

Targets the .NET Framework 4.5 Beta.
Written entirely in C# 5 and VS 11 Beta.
Depends on Rx 2.0 Beta and Rxx 2.0 Beta, both of which are included in the download.
- (Note that Rxx 2.0 Beta is not yet officially released and will most likely change).

Overview

Warning: This provider allows clients to execute arbitrary code on your server.

This is only an alpha release, so security hasn't been fully considered. Do not expose a Qbservable TCP service on a public server or client without taking the necessary precautions to secure them first.

Features

Simple server factory methods for hosting a Qbservable TCP service.
- Supports hosting any IObservable<T> query as a TCP service (hot or cold).
- Supports hosting any IQbservable<T> query as a TCP service.
Simple client factory methods for acquiring a Qbservable TCP service.
- You must only specify the end point address and the expected return type. The result is an IQbservable<T> that you can query and Subscribe.
- All Qbservable Rx operators are supported.
Automatically serialized Expression trees.
- Dynamic expressions and debug info expressions are not supported. All other types of expressions are supported.
Automatically serialized anonymous types.
Immediate evaluation of local members and closures (optional; default behavior)
- Compiler-generated methods are executed locally and replaced with their return values before the expression is transmitted to the server. This includes iterator blocks, which are serialized as List<T>.
- Evaluation assumes that local methods are never executed for their side-effects. Actions (void-returning methods) cause an exception. Do not depend upon the order in which members are invoked.
Full duplex communication (optional; default behavior for IObservable<T> closures)
- Must opt-in on server.
- May opt-in on client for full duplex communication of all local members; automatic for IObservable<T> closures.
- Duplex communication automatically supports iterator blocks.
Designed with extensibility in mind; e.g., supports custom Qbservable service providers, protocols and sinks.

Getting Started

Download the latest release and unzip it.
Run QbservableServer.exe.
1. The server will start hosting example Qbservable services as soon as the console application begins.
2. Pressing a key at any time will stop the server.
Run QbservableClient.exe.
1. You can run several client console applications at the same time.
When the client console application starts, press any key to connect to the server. The client will begin running the first example.
Press any key to stop the current example and start the following example.

Source Code

Download the source code from the Source Code tab.
1. The solution is located under the QbservableProvider directory, but it depends upon the relative path to the Main branch. Make sure that both paths exist.
You must build the Rxx 2.0 Beta project in the Main branch in Debug mode. See How To Build the Source Code for instructions.
Open the QbservableProvider solution in VS 11 Beta.

Tip: To see the original and rewritten expression trees, run the client application with the debugger attached and look at the Output window.

Planning

Research building on top of WCF to support advanced configuration, customization, extensibility, standardization and additional transports such as WebSockets over HTTP.
Improve expression tree serialization; e.g., fix bugs and write unit tests.
Consider security.
Consider memory/performance.
Support querying from Silverlight 5 and Windows Phone 7.5 apps. (This may require WebSockets though.)
Support querying from RxJS clients.

Updated Wiki: TCP Qbservable Provider

davedev — Tue, 24 Apr 2012 18:15:28 GMT

TCP Qbservable Provider

1.0 Alpha

Targets the .NET Framework 4.5 Beta.
Written entirely in C# 5 and VS 11 Beta.
Depends on Rx 2.0 Beta and Rxx 2.0 Beta, both of which are included in the download.
- (Note that Rxx 2.0 Beta is not yet officially released and will most likely change).

Overview

Warning: This provider allows clients to execute arbitrary code on your server.

This is only an alpha release, so security hasn't been fully considered. Do not expose a Qbservable TCP service on a public server or client without taking the necessary precautions to secure them first.

Features

Simple server factory methods for hosting a Qbservable TCP service.
- Supports hosting any IObservable<T> query as a TCP service (hot or cold).
- Supports hosting any IQbservable<T> query as a TCP service.
Simple client factory methods for acquiring a Qbservable TCP service.
- You must only specify the end point address and the expected return type. The result is an IQbservable<T> that you can query and Subscribe.
- All Qbservable Rx operators are supported.
Automatically serialized Expression trees.
- Dynamic expressions and debug info expressions are not supported. All other types of expressions are supported.
Automatically serialized anonymous types.
Immediate evaluation of local members and closures (optional; default behavior)
- Compiler-generated methods are executed locally and replaced with their return values before the expression is transmitted to the server. This includes iterator blocks, which are serialized as List<T>.
- Evaluation assumes that local methods are never executed for their side-effects. Actions (void-returning methods) cause an exception. Do not depend upon the order in which members are invoked.
Full duplex communication (optional; default behavior for IObservable<T> closures)
- Must opt-in on server.
- May opt-in on client for full duplex communication of all local members; automatic for IObservable<T> closures.
- Duplex communication automatically supports iterator blocks.
Designed with extensibility in mind; e.g., supports custom Qbservable service providers, protocols and sinks

Getting Started

Download the latest release and unzip it.
Run QbservableServer.exe.
1. The server will start hosting example Qbservable services as soon as the console application begins.
2. Pressing a key at any time will stop the server.
Run QbservableClient.exe.
1. You can run several client console applications at the same time.
When the client console application starts, press any key to connect to the server. The client will begin running the first example.
Press any key to stop the current example and start the following example.

Source Code

Download the source code from the Source Code tab.
1. The solution is located under the QbservableProvider directory, but it depends upon the relative path to the Main branch. Make sure that both paths exist.
You must build the Rxx 2.0 Beta project in the Main branch in Debug mode. See Building for instructions.
Open the QbservableProvider solution in VS 11 Beta.

Tip: To see the original and rewritten expression trees, run the client application with the debugger attached and look at the Output window.

Planning

Research building on top of WCF to support advanced configuration, customization, extensibility, standardization and additional transports such as WebSockets over HTTP.
Improve expression tree serialization; e.g., fix bugs and write unit tests.
Consider security.
Consider memory/performance.
Support querying from Silverlight 5 and Windows Phone 7.5 apps. (This may require WebSockets though.)
Support querying from RxJS clients.

Updated Wiki: TCP Qbservable Provider

davedev — Tue, 24 Apr 2012 18:06:02 GMT

TCP Qbservable Provider

1.0 Alpha

Targets the .NET Framework 4.5 Beta.
Written entirely in C# 5 and VS 11 Beta.
Depends on Rx 2.0 Beta and Rxx 2.0 Beta, both of which are included in the download.
- (Note that Rxx 2.0 Beta is not yet officially released and will most likely change).

Overview

Warning: This provider allows clients to execute arbitrary code on your server.

This is only an alpha release, so security hasn't been fully considered. Do not expose a Qbservable TCP service on a public server or client without taking the necessary precautions to secure them first.

Features

Simple server factory methods for hosting a Qbservable TCP service.
- Supports hosting any IObservable<T> query as a TCP service (hot or cold).
- Supports hosting any IQbservable<T> query as a TCP service.
Simple client factory methods for acquiring a Qbservable TCP service.
- You must only specify the end point address and the expected return type. The result is an IQbservable<T> that you can query and Subscribe.
- All qbservable Rx operators are supported.
Automatically serialized Expression trees.
- Dynamic expressions and debug info expressions are not supported. All other types of expressions are supported.
Automatically serialized anonymous types.
Immediate evaluation of local members and closures (optional; default behavior)
- Compiler-generated methods are executed locally and replaced with their return values before the expression is transmitted to the server. This includes iterator blocks, which are serialized as List<T>.
- Evaluation assumes that local methods are never executed for their side-effects. Actions (void-returning methods) cause an exception. Do not depend upon the order in which members are invoked.
Full duplex communication (optional; default behavior for IObservable<T> closures)
- Must opt-in on server.
- May opt-in on client for full duplex communication of all local members; automatic for IObservable<T> closures.
- Duplex communication automatically supports iterator blocks.
Designed with extensibility in mind; e.g., supports custom Qbservable service providers, protocols and sinks

Getting Started

Download the latest release and unzip it.
Run QbservableServer.exe.
1. The server will start hosting example Qbservable services as soon as the console application begins.
2. Pressing a key will stop the server at any time.

You can run several client console applications, if you'd like.

When the client console application starts, follow the on-screen instructions.

Tip: To see the original and rewritten expression trees, run the client application with the debugger attached and look at the Output window.

Planning

Research building on top of WCF to support advanced configuration, customization, extensibility, standardization and additional transports such as WebSockets over HTTP.
Improve expression tree serialization; e.g., fix bugs and write unit tests.
Consider security.
Consider memory/performance.
Support querying from Silverlight 5 and Windows Phone 7.5 apps. (This may require WebSockets though.)
Support querying from RxJS clients.

Updated Wiki: TCP Qbservable Provider

davedev — Tue, 24 Apr 2012 18:03:10 GMT

TCP Qbservable Provider

1.0 Alpha

Targets the .NET Framework 4.5 Beta.
Written entirely in C# 5 and VS 11 Beta.
Depends on Rx 2.0 Beta and Rxx 2.0 Beta, both of which are included in the download.
- (Note that Rxx 2.0 Beta is not yet officially released and will most likely change).

Overview

Warning: This provider allows clients to execute arbitrary code on your server.

This is only an alpha release, so security hasn't been fully considered. Do not expose a Qbservable TCP service on a public server or client without taking the necessary precautions to secure them first.

Features

Simple server factory methods for hosting a Qbservable TCP service.

Simple client factory methods for acquiring a Qbservable TCP service.

Automatically serialized Expression trees.
- Dynamic expressions and debug info expressions are not supported. All other types of expressions are supported.
Automatically serialized anonymous types.
Immediate evaluation of local members and closures (optional; default behavior)
- Compiler-generated methods are executed locally and replaced with their return values before the expression is transmitted to the server. This includes iterator blocks, which are serialized as List<T>.
- Evaluation assumes that local methods are never executed for their side-effects. Actions (void-returning methods) cause an exception. Do not depend upon the order in which members are invoked.
Full duplex communication (optional; default behavior for IObservable<T> closures)
- Must opt-in on server.
- May opt-in on client for full duplex communication of all local members; automatic for IObservable<T> closures.
- Duplex communication automatically supports iterator blocks.
Designed with extensibility in mind; e.g., supports custom Qbservable service providers, protocols and sinks

Getting Started

Download the latest release and unzip it.
Run QbservableServer.exe.
1. The server will start hosting example Qbservable services as soon as the console application begins.
2. Pressing a key will stop the server at any time.

You can run several client console applications, if you'd like.

When the client console application starts, follow the on-screen instructions.

Tip: To see the original and rewritten expression trees, run the client application with the debugger attached and look at the Output window.

Planning

Research building on top of WCF to support advanced configuration, customization, extensibility, standardization and additional transports such as WebSockets over HTTP.
Improve expression tree serialization; e.g., fix bugs and write unit tests.
Consider security.
Consider memory/performance.
Support querying from Silverlight 5 and Windows Phone 7.5 apps. (This may require WebSockets though.)
Support querying from RxJS clients.

Updated Wiki: Release Notes

davedev — Mon, 12 Mar 2012 17:09:24 GMT

Release Notes

See also: Getting Started and Contributions

Rxx 1.3

Dependencies

Reactive Extensions (Rx) version 1.0.11226.2 (Official stable version, SP1)
- This is only required when using the stable Rxx build.
- Rxx does not redistribute Rx, so you must download and install it yourself. If you've installed Rxx via NuGet, then Rx is automatically downloaded for you.
Reactive Extensions (Rx) version 1.1.11111.0 (Experimental)
- This is only required when using the experimental Rxx build. These downloads are clearly marked with an Experimental suffix.
- Rxx does not redistribute Rx, so you must download and install it yourself. If you've installed Rxx_Experimental via NuGet, then Rx_Experimental is automatically downloaded for you.
System.Windows.Interactivity.dll for Silverlight 4
- Rxx for Silverlight 4 requires that you add a reference to System.Windows.Interactivity.dll in your Silverlight application when using the EventSubscription class. If you're not using that class, then you don't need to add a reference to this assembly.
- This assembly is included in the download package on CodePlex and NuGet; however, the NuGet package does not automatically add a reference in your project. You must add a reference manually by navigating to the packages folder.
Microsoft.Contracts.dll for Windows Phone
- Rxx for Windows Phone requires that you add a reference to Microsoft.Contracts.dll in your Windows Phone application.
- This assembly is included in the download package on CodePlex and NuGet; however, the NuGet package does not automatically add a reference in your project. You must add a reference manually by navigating to the packages folder.

Known Issues

There are currently no known issues. To check for the latest known issues, use the Issue Tracker.

What's New?

Rxx 1.3 contains bug fixes and several new features. See the Documentation tab for a complete list of the features in Rxx.

Upgraded to the latest Rx stable and experimental releases.
Added support for Silverlight 5 and Windows Phone 7.1, including labs.
Fixed a bug in ObservableWebClient that caused web exceptions to be unhandled.
Fixed a thread-safety bug in the Introspect (pairwise) operator that caused potentially concurrent notifications.
Major performance improvements for cursors and parsers, especially the SelectMany, And, All and Exactly operators.
Fixed various parser operators to avoid stack overflows; e.g., And, All and Exactly.
Renamed ParserExtensions class to Parser and ObservableParserExtensions class to ObservableParser (a naming convention similar to System.Linq.Enumerable and System.Reactive.Linq.Observable).
Renamed the ParserExtensions.Parse and ObservableParserExtensions.Parse static factory methods to Create.
Fixed Exactly(0) so it doesn't behave like None and instead returns success with length=0.
Fixed a bug in Ix parsers that prevented the source sequence's enumerators from being disposed.
Fixed reactive parsers so they propagate look-ahead notifications for NonGreedy quantifiers.
Fixed the reactive OnFailure parser operator so that it calls OnError and OnCompleted.
Refactored the IParserCursor interface and modified the ParserTraceExecutionContext class slightly to support one of the aforementioned optimizations.
Added support for disabling cursor buffer truncations while the cursor has branches. (This feature supports one of the aforementioned optimizations for parsers.)
Added BinaryParser and BinaryObservableParser classes, related types, a ParseBinary extension method (Ix and Rx) and related labs.
Added an AtEndOfSequence parser operator (Ix and Rx).
Added Stream.ToEnumerable extension methods.
Added TcpClientExtensions, TcpListenerExtensions and ObservableTcpListener, including a corresponding lab.
Renamed RxxLab to BaseConsoleLab and RxxUILab to BaseLab for parity with the Labs Framework templates.
Excluded Zip and CombineLatest extensions (N-ary IE<IO<>> and Tuple-returning) from experimental builds since they are defined in Rx Experimental. They may be removed entirely in a subsequent release.
Added socket extensions for Windows Phone 7.1. Also added a corresponding socket lab for WP7.1, Silverlight 4 and 5.
Added ObservableDns for WP7.1 and a corresponding lab.
Added ObservableNetworkChange.NetworkAddress for WP7.1 and improved ObservableNetworkChange.NetworkAvailability.
Added ObservableUserData, ContactsExtensions and AppointmentsExtensions classes for WP 7.1, with a corresponding lab.
Added Socket extensions for EBAP and refactored some existing extensions to use EBAP internally, where appropriate.
Added SqlCommand extensions.
Implemented Either.ToString.
Deleted IPairedObservable and related types (though all IObservable<Either<>> extensions are still available).
Deleted PairedObservable class and merged extensions into Observable2. Renamed Create methods to CreateEither. Renamed ForEachPair to ForEach.
Renamed PairedObservableExtensions class to ObservableExtensions2. Renamed SubscribePair methods to SubscribeEither.
Renamed PairedObserver class to Observer2. Renamed Create methods to CreateEither.
Added value-based and time-based OrderBy, OrderByDescending, ThenBy and ThenByDescending extensions for IObservable<T>. Includes a lab and unit tests.
Added ObservableServiceAttribute and ObservableOperationAttribute, which support defining WCF service operations that return IObservable<T>. Includes a corresponding lab.
Added ICommunicationObject extensions.
Added INotifyCollectionChanged extensions for converting to CollectionNotification<T> and CollectionModification<T>.
Renamed ToNotification and ToModification extensions to ToNotifications and ToModifications, respectively. They now return lists.
Changed the Value property to Values on CollectionModification<T> so that the Add and Remove kinds can model AddRange and RemoveRange. This is an optimization.
Added an ExistingValues property that is used instead of the Value property on CollectionNotification objects of the "Exists" kind. This is an optimization.
Changed the behavior of the IListSubject.Subscribe and IDictionarySubject.Subscribe methods to include an initial "Exists" notification containing a snapshot of the entire collection.
Added "Changes" method to IListSubject and IDictionarySubject. This method returns an observable that does not include any "Exists" notifications but otherwise behaves just like Subscribe.
Deleted the IListSubject.View and IDictionarySubject.View methods.
Changed the Accept methods on CollectionNotification<T> so that the exists parameter takes a list as input and the onReplaced parameter takes two inputs (old value and new value).
Changed the Accept methods on CollectionModification<T> so that the add and remove parameters take lists as input.
Added RaiseCanExecuteChanged method and a new constructor to AnonymousCommand, which does not require an anonymous event to be specified and instead uses an auto-generated event.
Added the Scalar<T> type and a corresponding Scalar class with static factory methods.
Added SampleIntrospective operator with a unit test and a lab.
Improved lab applications.

Rxx 1.2

Dependencies

Reactive Extensions (Rx) version 1.0.10621 (Official stable version, SP1)
- This is only required when using the stable Rxx build.
- Rxx does not redistribute Rx, so you must download and install it yourself. If you've installed Rxx via NuGet, then Rx is automatically downloaded for you.
Reactive Extensions (Rx) version 1.1.10621 (Experimental)
- This is only required when using the experimental Rxx build. These downloads are clearly marked with an Experimental suffix.
- Rxx does not redistribute Rx, so you must download and install it yourself. If you've installed Rxx via NuGet, then Rx is automatically downloaded for you.
System.Windows.Interactivity.dll for Silverlight
- Rxx for Silverlight requires that you add a reference to System.Windows.Interactivity.dll in your Silverlight application when using the EventSubscription class. If you're not using that class, then you don't need to add a reference to this assembly.
- This assembly is included in the ZIP file that is available for download as of Feb. 12, 2012; however, it isn't included in the NuGet package. This will be corrected in Rxx 1.3.
Microsoft.Contracts.dll for Windows Phone
- Rxx for Windows Phone requires that you add a reference to Microsoft.Contracts.dll in your Windows Phone application.
- This assembly is included in the ZIP file that is available for download as of Feb. 12, 2012; however, it isn't included in the NuGet package. This will be corrected in Rxx 1.3.

Known Issues

System.Net.ObservableWebClient causes unhandled exceptions.

Do not use any of the System.Net.ObservableWebClient methods if it's possible that any kind of exception might be thrown by your web request. All exceptions will result in an exception on a pooled thread that cannot be handled, ultimately crashing your application.

Workaround

Use the System.Net.WebClientExtensions methods instead. The only difference is that these extensions require you to construct and dispose of a WebClient object yourself.

Related work items

ObservableWebClient.DownloadData doesnt handle 404

What's New?

Rxx 1.2 contains bug fixes and several new features. See the Documentation tab for a complete list of the features in Rxx.

Internalized or removed all interactive extensions that were unnecessary or that shadowed Microsoft's Ix Experimental library.
Added DependencyObjectExtensions.DependencyPropertyChanged and UIElementExtensions.RoutedEventRaised extension methods and a corresponding lab.
Added CollectionNotification, CollectionModification, IListSubject, IDictionarySubject and concrete types.
Added Collect extension methods to Observable2, ObservableDirectory, DirectoryInfoExtensions and FileSystemWatcherExtensions.
Added ObservableDirectory lab.
Moved various extension methods into new classes: SmtpClientExtensions, PingExtensions, HttpListenerExtensions, WebClientExtensions, WebRequestExtensions and SocketExtensions.
Adjusted trace identity format. Also adjusted the default text for Ix tracing.
Added ObservableSyndication for RSS 2.0 and Atom 1.0, with a corresponding UI lab that also uses DictionarySubject and the Collect extension method.
Added ApplicationSettingsBase extensions for observing setting changes.
Added ICommand extensions, CommandSubject, AnonymousCommand and a corresponding lab.
Added the Subscription XAML markup extension for WPF, which is similar to Binding and supports observable data sources. Includes a corresponding lab.
Added EventSubscription trigger, which supports event handler bindings from FrameworkElement to IObserver, delegate or ICommand properties. Includes a corresponding lab.
Major performance and memory improvements for parsers; now avoids stack overflows due to recursion in quantifiers.
Added ICursor<T> and IObservableCursor<T> types with concrete implementations, including CursorSubject<T> and ToCursor extension methods.
Added full support for reactive XML parsers in WP7. Now there's complete parser parity across all platforms.
Added view model support for all platforms, with corresponding UI labs. Includes optional IViewModel interface and optional Rxx.ViewModel base class.
Added Exactly parser operator.
Added non-greedy variants to some of the quantifying parser operators.
Added an overload to the AtLeast parser operator that accepts a maximum parameter, with behavior similar to the {n,m} regex pattern.
Added AndUnordered and AllUnordered parser operators, fixed the XML parsers so that attributes are matched in any order and reversed the order of the attributes in the XML schema labs.
Added Consume extensions that generalize the producer/consumer pattern over observables.
Added Stream, FileStream and TextReader extensions.
Added ObservableFile class with a corresponding lab.
Added n-ary Zip and CombineLatest combinators.
Improved lab applications.

Rxx 1.1

Dependencies

Rxx has the following dependencies. Note that Rxx does not redistribute these, so you must download and install them yourself.

Reactive Extensions (Rx) version 1.0.10621 (Official stable version)
- This is only required when using the stable Rxx build.
Reactive Extensions (Rx) version 1.1.10621 (Experimental)
- This is only required when using the experimental Rxx build. These downloads are clearly marked with an Experimental suffix.

What's New?

The latest Rxx release is based on the official Rx 1.0 stable release. Rxx now supports builds for .NET 4.0, Silverlight 4 and Windows Phone 7. In addition, Rxx 1.1 is also built against each of the Rx experimental releases for all of the aforementioned platforms. A number of new features have also been included since the previous Rxx release. See the Documentation tab for a complete list of the features in Rxx.

Added Parsers, labs and tests from http://archive.msdn.microsoft.com/RxParsers. (Includes all updates from the Rx Parsers vNext release.)
Added IEnumerable<T> StartWith and Scan extensions.
Renamed the lab project's IEnumerable Run extension method to ForEach.
Some lab improvements. Also upgraded to DaveSexton.Labs.dll version 1.3.
Enabled most documentation rules in StyleCop.
Fixed all StyleCop documentation warnings for code that was missed previously.
LeftValue and RightValue types are now internal. Use the new Either.Left and Either.Right static factory methods instead.
Marked Either (LeftValue and RightValue) and Maybe with SerializableAttribute.
Deleted Observable2.Run extensions because they already exist in Rx 1.1.10425 as Observable.ForEach.
Renamed Enumerable2.Run extensions to ForEach.
Renamed PairedObservableExtensions.Subscribe to SubscribePair and also renamed ForEach extensions to ForEachPair.
Added Multicast overload that accepts a subject factory allowing clearing of state if observable goes cold.
Added ObservableDns class with a corresponding lab.
Added new overloads to FromEventBasedAsyncPattern that exclude the TEventAgs type argument.
Added ObservableSmtpClient class with System.Net.Mail.SmtpClient extensions.
Added ObservableSocket class with System.Net.Sockets.Socket extensions.
Added ObservableWebRequest class with extensions for System.Net.WebRequest and derived types.
Added Maybe class with static factory methods Return<T> and Empty<T>, and internalized the Maybe<T> constructor and Empty field.
Integrated Sandcastle into the build process to generate reference documentation (Rxx.chm) in Release mode.
Added overloads to Zip & CombineLatest that automatically use Tuple.Create as the selector function.
Added ObservableNewtworkChange class with System.Net.NetworkInformation.NetworkChange extensions.
Added ObservablePing class with System.Net.NetworkInformation.Ping extensions.
Rxx for Silverlight 4, including corresponding Silverlight labs and documentation.
Rxx for Windows Phone 7, including corresponding WP7 labs and documentation.
Rxx for Rx Experimental.

Rxx 1.0 (Compatible: Rx 1.0.10425)

Dependencies

Rxx has the following dependencies. Note that Rxx does not redistribute them so you must download and install them yourself.

Reactive Extensions (Rx) for the .NET Framework 4.0 version 1.0.10425

Important Notes

Rxx with Labs (Console Application) now has all of its dependencies included so that it works out-of-the-box.
RxxLabs.exe requires administrator privileges for the Reactive WebClient lab to register a local HTTP port.
- To start RxxLabs.exe, right-mouse click and select Run as Administrator; otherwise, do not run the Reactive WebClient lab because it will crash the program.

What's New?

This release is based on the previous 1.0 release, refactored to support Rx version 1.0.10425. In addition, some small modifications have been made.

Moved types and extensions into the appropriate namespaces for consistency with Rx.
Added IEnumerable<T> Do, Run, Concat, Repeat, Throw and Catch extensions.
Added IObservable<T> Run extensions.
Removed DefaultIfEmpty extension because it's included in Rx 1.0.10425.
Improved the Priming and WebClient labs.

Rxx 1.0

Dependencies

Rxx has the following dependencies. Note that Rxx does not redistribute them so you must download and install them yourself.

Reactive Extensions (Rx) for the .NET Framework 4.0 version 1.0.2856.0

The latest version of Rx is available here; however, Rxx is not compatible yet. We are working on a compatible version that will be released ASAP.

What's New?

This is the first release of Rxx. The following extensions are included:

Trace extensions (Rx and Ix).
FromEventBasedAsyncPattern extension.
FromPropertyChangedPattern extension.
Generalization of out-of-band binary observables; a.k.a., “Pairing”. Useful for things like progress and out-of-band exception channels. Includes several extensions.
Catch, Retry and OnErrorResumeNext extensions that filter by Exception type, pair the observable with an error channel and support back-off algorithms.
Generalization of time-shifting into a TimeShift operator. Also included some common patterns: AsTimer, AsInterval and Pulse.
Serve extension. Useful in hosting scenarios such as receiving sockets with a maximum concurrency, without blocking during receives.
DefaultIfEmpty extension.
Maybe extension.
Prime and StartPrimed extensions.
PropertyDescriptor extensions for observable property changes and events.
FileSystemWatcher extensions.
Introspect, WindowIntrospective and BufferIntrospective extensions.
HttpListener extensions (ObservableHttpListener).
WebClient extensions (ObservableWebClient).
OperationalObservable and OperationalEnumerable – a generalization of unary and binary operator overloads in C# being used as combinators; e.g., var os = xs + ys - zs;
ObservableDynamicObject.

rxx Wiki Rss Feed

Updated Wiki: Either

Either<TLeft, TRight>

Overview

Updated Wiki: Either

Either<TLeft, TRight>

Overview

Updated Wiki: Documentation

Rxx Documentation

Rxx Features

Updated Wiki: Home

Welcome

Goals

Getting Started

See Also

New Comment on "Documentation"

New Comment on "Documentation"

Updated Wiki: TCP Qbservable Provider

TCP Qbservable Provider

1.0 Alpha

Overview

Features

Simple Examples

Server

Client

Getting Started

To run the examples:

To build the source code:

Planning

Updated Wiki: TCP Qbservable Provider

TCP Qbservable Provider

1.0 Alpha

Overview

Features

Simple Examples

Server

Client

Getting Started

To run the examples:

To build the source code:

Planning

Updated Wiki: TCP Qbservable Provider

TCP Qbservable Provider

1.0 Alpha

Overview

Features

Simple Examples

Server

Client

Getting Started

To run the examples:

To build the source code:

Planning

Updated Wiki: TCP Qbservable Provider

TCP Qbservable Provider

1.0 Alpha

Overview

Features

Simple Examples

Server

Client

Getting Started

To run the examples:

To build the source code:

Planning

Updated Wiki: Documentation

Rxx Documentation

Rxx Features

Updated Wiki: TCP Qbservable Provider

TCP Qbservable Provider

1.0 Alpha

Overview

Features

Simple Examples

Server

Client

Getting Started

To run the examples:

To build the source code:

Planning