public static IObservable <PingReply> Send(IPAddress address, int timeout, byte[] buffer)
{
Contract.Requires(address != null);
Contract.Requires(timeout >= 0);
Contract.Requires(buffer != null);
Contract.Ensures(Contract.Result <IObservable <PingReply> >() != null);
return(Observable2.UsingHot(new Ping(), ping => ping.SendObservable(address, timeout, buffer)));
}
public void ctor_100_5()
{
var meter = new FrequencyMeter(200, TimeSpan.FromSeconds(5));
Observable2.Interval(TimeSpan.FromMilliseconds(30))
.Select(_ => meter.RecordLap())
.Subscribe(Console.WriteLine);
Thread.Sleep(3000);
}
public static IObservable <string> DownloadFile(
Uri address,
string fileName)
{
Contract.Requires(address != null);
Contract.Requires(fileName != null);
Contract.Ensures(Contract.Result <IObservable <string> >() != null);
return(Observable2.UsingHot(new WebClient(), client => client.DownloadFileObservable(address, fileName)));
}
public static IObservable <PingReply> Send(string hostNameOrAddress, int timeout, byte[] buffer, PingOptions options)
{
Contract.Requires(!string.IsNullOrWhiteSpace(hostNameOrAddress));
Contract.Requires(timeout >= 0);
Contract.Requires(buffer != null);
Contract.Requires(options != null);
Contract.Ensures(Contract.Result <IObservable <PingReply> >() != null);
return(Observable2.UsingHot(new Ping(), ping => ping.SendObservable(hostNameOrAddress, timeout, buffer, options)));
}
public static IObservable <Either <DownloadProgressChangedEventArgs, string> > DownloadFileWithProgress(
Uri address,
string fileName)
{
Contract.Requires(address != null);
Contract.Requires(fileName != null);
Contract.Ensures(Contract.Result <IObservable <Either <DownloadProgressChangedEventArgs, string> > >() != null);
return(Observable2.UsingHot(new WebClient(), client => client.DownloadFileWithProgress(address, fileName)));
}
public void ctor()
{
var conditioner = new FrequencyConditioner(30);
Observable2.Interval(TimeSpan.FromMilliseconds(33))
.Take(150)
.Where(_ => conditioner.CheckLap())
.Do(i => Console.WriteLine("{0}: {1}", i, conditioner.Frequency))
.Do(_ => Thread.Sleep(40))
.Wait();
}
public static IObservable <byte[]> UploadValues(
Uri address,
string method,
NameValueCollection values)
{
Contract.Requires(address != null);
Contract.Requires(values != null);
Contract.Ensures(Contract.Result <IObservable <byte[]> >() != null);
return(Observable2.UsingHot(new WebClient(), client => client.UploadValuesObservable(address, method, values)));
}
public static IObservable <Either <UploadProgressChangedEventArgs, byte[]> > UploadDataWithProgress(
Uri address,
string method,
byte[] data)
{
Contract.Requires(address != null);
Contract.Requires(data != null);
Contract.Ensures(Contract.Result <IObservable <Either <UploadProgressChangedEventArgs, byte[]> > >() != null);
return(Observable2.UsingHot(new WebClient(), client => client.UploadDataWithProgress(address, method, data)));
}
public static IObservable <byte[]> UploadData(
Uri address,
string method,
byte[] data)
{
Contract.Requires(address != null);
Contract.Requires(data != null);
Contract.Ensures(Contract.Result <IObservable <byte[]> >() != null);
return(Observable2.UsingHot(new WebClient(), client => client.UploadDataObservable(address, method, data)));
}
public void ctor_2()
{
var filter = new FrequencyFilter(25);
Observable2.Interval(TimeSpan.FromMilliseconds(20))
.Do(_ => filter.CheckLap())
.Select(_ => filter.ArrangedFrequency)
.Subscribe(Console.WriteLine);
Thread.Sleep(3000);
}
public static IObservable <Either <UploadProgressChangedEventArgs, byte[]> > UploadValuesWithProgress(
Uri address,
string method,
NameValueCollection values)
{
Contract.Requires(address != null);
Contract.Requires(values != null);
Contract.Ensures(Contract.Result <IObservable <Either <UploadProgressChangedEventArgs, byte[]> > >() != null);
return(Observable2.UsingHot(new WebClient(), client => client.UploadValuesWithProgress(address, method, values)));
}
public static IObservable <string> DownloadString(
Uri address)
{
Contract.Requires(address != null);
Contract.Ensures(Contract.Result <IObservable <string> >() != null);
#if !SILVERLIGHT
return(Observable2.UsingHot(new WebClient(), client => client.DownloadStringObservable(address)));
#else
return(new WebClient().DownloadStringObservable(address));
#endif
}
public static IObservable <Stream> OpenRead(
Uri address)
{
Contract.Requires(address != null);
Contract.Ensures(Contract.Result <IObservable <Stream> >() != null);
#if !SILVERLIGHT
return(Observable2.UsingHot(new WebClient(), client => client.OpenReadObservable(address)));
#else
return(new WebClient().OpenReadObservable(address));
#endif
}
public static IObservable <Either <DownloadProgressChangedEventArgs, Stream> > OpenReadWithProgress(
Uri address)
{
Contract.Requires(address != null);
Contract.Ensures(Contract.Result <IObservable <Either <DownloadProgressChangedEventArgs, Stream> > >() != null);
#if !SILVERLIGHT
return(Observable2.UsingHot(new WebClient(), client => client.OpenReadWithProgress(address)));
#else
return(new WebClient().OpenReadWithProgress(address));
#endif
}
public void ctor_1()
{
var filter = new FrequencyFilter(25);
var meter = new FrequencyMeter();
Observable2.Interval(TimeSpan.FromMilliseconds(20))
.Where(_ => filter.CheckLap())
.Do(_ => meter.RecordLap())
.Subscribe(Console.WriteLine);
Thread.Sleep(3000);
Assert.IsTrue(meter.Frequency > 24);
Assert.IsTrue(meter.Frequency <= 25);
}
private static IObservable <PingReply> CreatePingObservable(Ping ping, Action <object> start)
{
Contract.Requires(ping != null);
Contract.Requires(start != null);
Contract.Ensures(Contract.Result <IObservable <PingReply> >() != null);
return(Observable2.FromEventBasedAsyncPattern <PingCompletedEventHandler, PingCompletedEventArgs>(
h => h.Invoke,
h => ping.PingCompleted += h,
h => ping.PingCompleted -= h,
start,
ping.SendAsyncCancel)
.Select(e => e.EventArgs.Reply));
}
/// <summary>
/// Sends the specified e-mail message to an SMTP server for delivery.
/// </summary>
/// <param name="client">The object that sends the e-mail message.</param>
/// <param name="message">A <see cref="MailMessage"/> that contains the message to send.</param>
/// <returns>A singleton observable that contains the cached result of sending the specified <paramref name="message"/>.</returns>
public static IObservable <EventPattern <AsyncCompletedEventArgs> > SendObservable(
this SmtpClient client,
MailMessage message)
{
Contract.Requires(client != null);
Contract.Requires(message != null);
Contract.Ensures(Contract.Result <IObservable <EventPattern <AsyncCompletedEventArgs> > >() != null);
return(Observable2.FromEventBasedAsyncPattern <SendCompletedEventHandler>(
d => d.Invoke,
eh => client.SendCompleted += eh,
eh => client.SendCompleted -= eh,
token => client.SendAsync(message, token),
client.SendAsyncCancel));
}
public static IObservable <string> UploadString(
Uri address,
string method,
string data)
{
Contract.Requires(address != null);
Contract.Requires(method != null);
Contract.Ensures(Contract.Result <IObservable <string> >() != null);
#if !SILVERLIGHT
return(Observable2.UsingHot(new WebClient(), client => client.UploadStringObservable(address, method, data)));
#else
return(new WebClient().UploadStringObservable(address, method, data));
#endif
}
/// <summary>
/// Downloads the specified resource as a <see cref="Byte"/> array.
/// </summary>
/// <param name="client">The object that downloads the resource.</param>
/// <param name="address">A <see cref="Uri"/> containing the URI to download.</param>
/// <returns>An observable that caches the result of the download and replays it to observers.</returns>
public static IObservable <byte[]> DownloadDataObservable(
this WebClient client,
Uri address)
{
Contract.Requires(client != null);
Contract.Requires(address != null);
Contract.Ensures(Contract.Result <IObservable <byte[]> >() != null);
return(Observable2.FromEventBasedAsyncPattern <DownloadDataCompletedEventHandler, DownloadDataCompletedEventArgs>(
handler => handler.Invoke,
handler => client.DownloadDataCompleted += handler,
handler => client.DownloadDataCompleted -= handler,
token => client.DownloadDataAsync(address, token),
client.CancelAsync)
.Select(e => e.EventArgs.Result));
}
/// <summary>
/// Downloads the specified resource as a file.
/// </summary>
/// <param name="client">The object that downloads the resource.</param>
/// <param name="address">A <see cref="Uri"/> containing the URI to download.</param>
/// <param name="fileName">The file to create or overwrite with the resource.</param>
/// <returns>An observable that caches the result of the download and replays it to observers.</returns>
public static IObservable <string> DownloadFileObservable(
this WebClient client,
Uri address,
string fileName)
{
Contract.Requires(client != null);
Contract.Requires(address != null);
Contract.Requires(fileName != null);
Contract.Ensures(Contract.Result <IObservable <string> >() != null);
return(Observable2.FromEventBasedAsyncPattern <AsyncCompletedEventHandler, AsyncCompletedEventArgs>(
handler => handler.Invoke,
handler => client.DownloadFileCompleted += handler,
handler => client.DownloadFileCompleted -= handler,
token => client.DownloadFileAsync(address, fileName, token),
client.CancelAsync)
.Select(e => fileName));
}
protected override void Main()
{
//// Note that Rxx for Silverlight does not support DependencyProperty change notifications,
//// due to limitations in Silverlight.
var foo = new Foo();
var bar = new Bar();
IObservable <string> seeFooChange = Observable2.FromPropertyChangedPattern(foo, o => o.Value);
IObservable <string> seeBarChange = Observable2.FromPropertyChangedPattern(bar, o => o.Value);
using (seeFooChange.Subscribe(ConsoleOutput))
using (seeBarChange.Subscribe(ConsoleOutput))
{
foo.Value = UserInput(Text.PromptFormat, Instructions.EnterAValueForFoo);
bar.Value = UserInput(Text.PromptFormat, Instructions.EnterAValueForBar);
}
}
/// <summary>
/// Opens a writeable stream to the specified resource.
/// </summary>
/// <param name="client">The object that uploads to the resource.</param>
/// <param name="address">The URI of the resource to receive the stream.</param>
/// <param name="method">The HTTP method used to send data to the resource. If <see langword="null"/>, the default is POST for HTTP and STOR for FTP.</param>
/// <returns>An observable containing the writeable stream that sends data to the resource.</returns>
public static IObservable <Stream> OpenWriteObservable(
this WebClient client,
Uri address,
string method)
{
Contract.Requires(client != null);
Contract.Requires(address != null);
Contract.Requires(method != null);
Contract.Ensures(Contract.Result <IObservable <Stream> >() != null);
return(Observable2.FromEventBasedAsyncPattern <OpenWriteCompletedEventHandler, OpenWriteCompletedEventArgs>(
handler => handler.Invoke,
handler => client.OpenWriteCompleted += handler,
handler => client.OpenWriteCompleted -= handler,
token => client.OpenWriteAsync(address, method, token),
client.CancelAsync)
.Select(e => e.EventArgs.Result));
}
private void TrySubscribe(object obj)
{
var observable = Observable2.Coerce <object>(obj);
if (observable == null)
{
SetScalarValue(obj);
}
else
{
source = observable;
currentValue = null;
hasValue = false;
subscribing = Dispatcher.CurrentDispatcher.BeginInvoke((Action)Subscribe, DispatcherPriority.DataBind);
}
}
protected override void Main()
{
var foo = new Foo();
var bar = new Bar();
var baz = new Baz();
IObservable <string> seeFooChange = Observable2.FromPropertyChangedPattern(() => foo.Value);
IObservable <string> seeBarChange = Observable2.FromPropertyChangedPattern(() => bar.Value);
IObservable <string> seeBazChange = Observable2.FromPropertyChangedPattern(() => baz.Value);
using (seeFooChange.Subscribe(ConsoleOutput))
using (seeBarChange.Subscribe(ConsoleOutput))
using (seeBazChange.Subscribe(ConsoleOutput))
{
foo.Value = UserInput(Text.PromptFormat, Instructions.EnterAValueForFoo);
bar.Value = UserInput(Text.PromptFormat, Instructions.EnterAValueForBar);
baz.Value = UserInput(Text.PromptFormat, Instructions.EnterAValueForBaz);
}
}
/// <summary>
/// Uploads data to the specified resource.
/// </summary>
/// <param name="client">The object that uploads to the resource.</param>
/// <param name="address">The URI of the resource to receive the collection.</param>
/// <param name="method">The HTTP method used to send data to the resource. If <see langword="null"/>, the default is POST for HTTP and STOR for FTP.</param>
/// <param name="values">The collection of data as name/value pairs to send to the resource.</param>
/// <returns>An observable that caches the response from the server and replays it to observers.</returns>
public static IObservable <byte[]> UploadValuesObservable(
this WebClient client,
Uri address,
string method,
NameValueCollection values)
{
Contract.Requires(client != null);
Contract.Requires(address != null);
Contract.Requires(values != null);
Contract.Ensures(Contract.Result <IObservable <byte[]> >() != null);
return(Observable2.FromEventBasedAsyncPattern <UploadValuesCompletedEventHandler, UploadValuesCompletedEventArgs>(
handler => handler.Invoke,
handler => client.UploadValuesCompleted += handler,
handler => client.UploadValuesCompleted -= handler,
token => client.UploadValuesAsync(address, method, values, token),
client.CancelAsync)
.Select(e => e.EventArgs.Result));
}
/// <summary>
/// Uploads a string to the specified resource.
/// </summary>
/// <param name="client">The object that uploads to the resource.</param>
/// <param name="address">The URI of the resource to receive the string.</param>
/// <param name="method">The HTTP method used to send data to the resource. If <see langword="null"/>, the default is POST for HTTP and STOR for FTP.</param>
/// <param name="data">The string to send to the resource.</param>
/// <returns>An observable that caches the response from the server and replays it to observers.</returns>
public static IObservable <string> UploadStringObservable(
this WebClient client,
Uri address,
string method,
string data)
{
Contract.Requires(client != null);
Contract.Requires(address != null);
Contract.Requires(method != null);
Contract.Ensures(Contract.Result <IObservable <string> >() != null);
return(Observable2.FromEventBasedAsyncPattern <UploadStringCompletedEventHandler, UploadStringCompletedEventArgs>(
handler => handler.Invoke,
handler => client.UploadStringCompleted += handler,
handler => client.UploadStringCompleted -= handler,
token => client.UploadStringAsync(address, method, data, token),
client.CancelAsync)
.Select(e => e.EventArgs.Result));
}
/// <summary>
/// Sends an e-mail message to an SMTP server for delivery.
/// </summary>
/// <param name="client">The object that sends the e-mail message.</param>
/// <param name="from">Contains the address information of the message sender.</param>
/// <param name="recipients">Contains the addresses that the message is sent to.</param>
/// <param name="subject">Contains the subject line for the message.</param>
/// <param name="body">Contains the message body.</param>
/// <returns>A singleton observable that contains the cached result of sending the message.</returns>
public static IObservable <EventPattern <AsyncCompletedEventArgs> > SendObservable(
this SmtpClient client,
string from,
string recipients,
string subject,
string body)
{
Contract.Requires(client != null);
Contract.Requires(!string.IsNullOrEmpty(from));
Contract.Requires(!string.IsNullOrEmpty(recipients));
Contract.Ensures(Contract.Result <IObservable <EventPattern <AsyncCompletedEventArgs> > >() != null);
return(Observable2.FromEventBasedAsyncPattern <SendCompletedEventHandler>(
d => d.Invoke,
eh => client.SendCompleted += eh,
eh => client.SendCompleted -= eh,
token => client.SendAsync(from, recipients, subject, body, token),
client.SendAsyncCancel));
}
/// <summary>
/// Adds a command binding to the specified <paramref name="element"/> and returns an observable sequence with two notification channels,
/// with the right channel receiving notifications when the <paramref name="command"/> is executed and the left channel
/// receiving notifications when the <paramref name="command"/> is queried as to whether it can be executed.
/// </summary>
/// <param name="command">The <see cref="ICommand"/> from which notifications are received.</param>
/// <param name="element">The <see cref="UIElement"/> that queries or executes the specified <paramref name="command"/>.</param>
/// <returns>An observable sequence with two notification channels, with the right channel receiving notifications when the <paramref name="command"/> is executed and
/// the left channel receiving notifications when the <paramref name="command"/> is queried as to whether it can be executed.</returns>
public static IObservable <Either <EventPattern <CanExecuteRoutedEventArgs>, EventPattern <ExecutedRoutedEventArgs> > > AsObservable(
this ICommand command,
UIElement element)
{
Contract.Requires(command != null);
Contract.Requires(element != null);
Contract.Ensures(Contract.Result <IObservable <Either <EventPattern <CanExecuteRoutedEventArgs>, EventPattern <ExecutedRoutedEventArgs> > > >() != null);
return(Observable2.CreateEither <EventPattern <CanExecuteRoutedEventArgs>, EventPattern <ExecutedRoutedEventArgs> >(
observer =>
{
var binding = new CommandBinding(
command,
(sender, e) => observer.OnNextRight(new EventPattern <ExecutedRoutedEventArgs>(sender, e)),
(sender, e) => observer.OnNextLeft(new EventPattern <CanExecuteRoutedEventArgs>(sender, e)));
element.CommandBindings.Add(binding);
return () => element.CommandBindings.Remove(binding);
}));
}
/// <summary>
/// Downloads the specified resource as a <see cref="Byte"/> array and includes a channel for progress notifications.
/// </summary>
/// <param name="client">The object that downloads the resource.</param>
/// <param name="address">A <see cref="Uri"/> containing the URI to download.</param>
/// <returns>An observable that contains progress notifications in the left channel and the data in the right channel.</returns>
public static IObservable <Either <DownloadProgressChangedEventArgs, byte[]> > DownloadDataWithProgress(
this WebClient client,
Uri address)
{
Contract.Requires(client != null);
Contract.Requires(address != null);
Contract.Ensures(Contract.Result <IObservable <Either <DownloadProgressChangedEventArgs, byte[]> > >() != null);
return(Observable2.FromEventBasedAsyncPattern <DownloadDataCompletedEventHandler, DownloadDataCompletedEventArgs, DownloadProgressChangedEventHandler, DownloadProgressChangedEventArgs>(
handler => handler.Invoke,
handler => client.DownloadDataCompleted += handler,
handler => client.DownloadDataCompleted -= handler,
handler => handler.Invoke,
handler => client.DownloadProgressChanged += handler,
handler => client.DownloadProgressChanged -= handler,
token => client.DownloadDataAsync(address, token),
client.CancelAsync)
.Select(
left => left.EventArgs,
right => right.EventArgs.Result));
}
private void Bind(object obj, Type targetType)
{
Contract.Requires(targetType != null);
if (!disposed && !object.Equals(obj, boundSource))
{
boundSource = obj;
CancelSubscribe();
observer = Observable2.CoerceObserver <object>(obj);
if (targetType == typeof(IEnumerable))
{
TrySubscribeEnumerable(obj);
}
else
{
TrySubscribe(obj);
}
}
}
