Program the Web

IsPlatformSupported()

public void DoSomethingAsync(object token) 
{
    // Kick off something async
}
public class DoSomethingCompletedEventArgs : EventArgs 
{
    public string Result { get; set; }
    public bool Cancelled { get; set; }
    public Exception Error { get; set; }
}

public event EventHandler<DoSomethingCompletedEventArgs>
    DoSomethingCompleted;
var uri = new Uri("http://search.twitter.com/search.json?q=4sq.com");
var client = new WebClient();

client.DownloadStringCompleted += (sender, args)
{
    // TODO: Get the only one we want?
    // TODO: Check for cancel?
    // TODO: Check for exception?
    // TODO: Check for result?

    // TODO: What about more composition?
};

client.DownloadStringAsync(uri);

// TODO: How to unsubscribe
client.DownloadStringCompleted -= ???
var uri = new Uri("http://search.twitter.com/search.json?q=4sq.com");
var client = new WebClient();
var token = new object();

DownloadStringCompletedEventHandler h = (sender, args)
{
    // Check if it's ours
    if (token != args.UserState) return;

    if (args.Cancelled)
    {
        // Do something to say we stopped
    }
    else if (args.Error != null)
    {
        // Do something with that error
    }
    else
    {
        // Well, now what?
    }
};

client.DownloadStringCompleted += h;
client.DownloadStringAsync(uri, token);

// When we're ready to clean up
client.DownloadStringCompleted -= h;
var client = new WebClient();
var searchUri = new Uri("http://search.twitter.com/search.json?q=4sq.com");
var uploadUri = new Uri("http://localhost:8080/uploads");

IObservable<Unit> query =
    from result in client.DownloadStringAsObservable(searchUri, new object())
    let transformed = TransformResult(result)
    from upload in client.UploadStringAsObservable(
        uploadUri,
        "POST",
        transformed,
        new object())
    select upload;

var subscription = query.Subscribe(
    x => {}, // Nothing to do
    exn => 
    {
        // Do something with the exception
    }, 
    () => 
    {
        // Indicate we're finished
    });
public static IObservable<TSource> CreateWithDisposable<TSource>(
    Func<IObserver<TSource>, IDisposable> subscribe
)

public static IObservable<TSource> Create<TSource>(
    Func<IObserver<TSource>, Action> subscribe
)
public static IObservable<string> DownloadStringAsObservable(
    this WebClient client, 
    Uri address,
    object userToken)
{
    return Observable.Create<string>(observer =>
    {
        DownloadStringCompletedEventHandler handler = (sender, args) =>
        {
            if (args.UserState != userToken) return;

            if (args.Cancelled)
                observer.OnCompleted();
            else if(args.Error != null)
                observer.OnError(args.Error);
            else
            {
                observer.OnNext(args.Result);
                observer.OnCompleted();
            }
        };

        client.DownloadStringCompleted += handler;

        try
        {
            client.DownloadStringAsync(address, token);
        }
        catch (Exception ex)
        {
            observer.OnError(ex);
        }

        return () => client.DownloadStringCompleted -= handler;
    });
}
public static IObservable<Unit> UploadStringAsObservable(
    this WebClient client, 
    Uri address, 
    string method, 
    string data,
    object userToken)
{
    return Observable.Create<Unit>(observer =>
    {
        UploadStringCompletedEventHandler handler = (sender, args) =>
        {
            if (args.UserState != userToken) return;

            if (args.Cancelled)
                observer.OnCompleted();
            else if (args.Error != null)
                observer.OnError(args.Error);
            else
            {
                observer.OnNext(new Unit());
                observer.OnCompleted();
            }
        };

        client.UploadStringCompleted += handler;

        try
        {
            client.UploadStringAsync(address, data, method, token);
        }
        catch(Exception ex)
        {
            observer.OnError(ex);
        }

        return () => client.UploadStringCompleted -= handler;
    });          
}
public static IObservable<DownloadProgressChangedEventArgs> 
    DownloadProgressChangedAsObservable(
        this WebClient client,
        object userToken)
{
    return Observable.FromEvent<DownloadProgressChangedEventArgs>(
            client,
            "DownloadProgressChanged")
        .Where(x => x.EventArgs.UserState == userToken)
        .Select(x => x.EventArgs)
}
// count: the size of the buffer
// skip (Optional): how many values to skip
// returns: Observable<Array<T>>

Rx.Observable.prototype.BufferWithCount =  function(
    count, 
    skip);
Rx.Observable.FromArray([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    .BufferWithCount(2)
    .Subscribe(
        function (next) {
            $.each(next, function (index, value) {
                $("<p/>").html("Buffered: " + index + "-" + value)
                    .appendTo(results);
            });
        });
Buffered: 0-1
Buffered: 1-2 // one
Buffered: 0-3
Buffered: 1-4 // two
Buffered: 0-5
Buffered: 1-6 // three
Buffered: 0-7
Buffered: 1-8 // four
Buffered: 0-9
Buffered: 1-10 // five
Rx.Observable.FromArray([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    .BufferWithCount(2, 4)
    .Subscribe(
        function (next) {
            $.each(next, function (index, value) {
                $("<p/>").html("Buffered: " + index + "-" + value)
                    .appendTo(results);
            });
        });
Buffered: 0-1
Buffered: 1-2 // one
Buffered: 0-5
Buffered: 1-6 // two
Buffered: 0-9
Buffered: 1-10 // three
// timeSpan: time span in milliseconds to buffer
// timeShift (Optional): time to skip listening in milliseconds
// scheduler (Optional): a custom scheduler
// returns: Observable<Array<T>>

Rx.Observable.prototype.BufferWithTime = function(
    timeSpan, 
    timeShift, 
    scheduler);
var delayedScheduler = Rx.DelayedScheduler = function (delay) {

    return new Rx.Scheduler(
        function (action) {
            var id = window.setTimeout(action, delay);
            return Rx.Disposable.Create(function () {
                window.clearTimeout(id);
            });
        },
        function (action, dueTime) {
            var id = window.setTimeout(action, dueTime);
            return Rx.Disposable.Create(function () {
                window.clearTimeout(id);
            });
        },
        function () {
            return new Date().getTime();
        });
};
Rx.Observable.FromArray(
        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 
        new Rx.DelayedScheduler(100))
    .BufferWithTime(300)
    .Subscribe(
        function (next) {
            $.each(next, function (index, value) {
                $("<p/>").html("Buffered: " + index + "-" + value)
                    .appendTo(results);
            });
        });
Buffered: 0-1
Buffered: 1-2 // one
Buffered: 0-3
Buffered: 1-4 
Buffered: 2-5 // two
Buffered: 0-6
Buffered: 1-7
Buffered: 2-8 // three
Buffered: 0-9
Buffered: 1-10 // four
Rx.Observable.FromArray(
        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 
        new Rx.DelayedScheduler(100))
    .BufferWithTime(300, 400)
    .Subscribe(
        function (next) {
            $.each(next, function (index, value) {
                $("<p/>").html("Buffered: " + index + "-" + value)
                    .appendTo(results);
            });
        });
Buffered: 0-1
Buffered: 1-2 // one
Buffered: 0-4
Buffered: 1-5
Buffered: 2-6 // two
Buffered: 0-8
Buffered: 1-9
Buffered: 2-10 // three
// timeSpan: time used to determine buffer size
// count: count used to determine buffer size
// scheduler (Optional): optional scheduler
// returns: Observable<Array<T>>

Rx.Observable.prototype.BufferWithTimeOrCount = function(
    timeSpan, 
    count, 
    scheduler);

var randomScheduler = Rx.RandomScheduler = function (delay) {

    return new Rx.Scheduler(
    function (action) {
        var randomnumber = Math.random() * (delay + 1) << 0;
        var id = window.setTimeout(action, randomnumber);
        return Rx.Disposable.Create(function () {
            window.clearTimeout(id);
        });
    },
    function (action, dueTime) {
        var id = window.setTimeout(action, dueTime);
        return Rx.Disposable.Create(function () {
            window.clearTimeout(id);
        });
    },
    function () {
        return new Date().getTime();
    });
};
Rx.Observable.FromArray(
        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
        new Rx.RandomScheduler(100))
    .BufferWithTimeOrCount(200, 4)
    .Subscribe(
        function (next) {
            $.each(next, function (index, value) {
                $("<p/>").html("Buffered: " + index + "-" + value)
                    .appendTo(results);
            });
        });
Buffered: 0-1
Buffered: 1-2 // timeout
Buffered: 0-3
Buffered: 1-4 // timeout
Buffered: 2-5
Buffered: 3-6 // count
Buffered: 0-7
Buffered: 1-8 // timeout
Buffered: 0-9
Buffered: 1-10 // timeout
function someDeferredFunction() {
    var deferred = new dojo.Deferred();
    setTimeout(
        function() {
            deferred.callback(42); 
        }, 1000);
    return deferred;    
}
var deferred1 = someDeferredFunction();
deferred1.then(
    // Success
    function(value) {
        alert(value);
    },
    // Failure
    function(error) {
        alert(error);
    });
var deferred2 = someDeferredFunction();
deferred2.asObservable()
    .Select(function(value) { return value * value; })
    .Subscribe(
        function(value) {
            alert(value);
        });
dojo.Deferred.prototype.asObservable = function () {
    var subject = new Rx.AsyncSubject();

    this.then(
        // Success
        function (value) {
            subject.OnNext(value);
            subject.OnCompleted();
        },
        // Failure
        function (error) {
            subject.OnError(error);
        });

    return subject;
};
function someAsyncSubjectFunction() {
    var subject = new Rx.AsyncSubject();

    setTimeout(
        function() {
            subject.OnNext(42);
            subject.OnCompleted();
        },
        1000);

    return subject;
}
var subject = someAsyncSubjectFunction();
subject
    .AsDeferred()
    .then(
        function (value) {
            alert(value);
        },
        function (error) {
            alert(error);
        });
Rx.AsyncSubject.prototype.AsDeferred = function () {
   var deferred = new dojo.Deferred();

    this.Subscribe(
        function (value) {
            deferred.callback(value);
        },
        function (error) {
            deferred.errback(error);
        });

    return deferred;
}
    public interface IObjectConverter
    {
        // Given a string and a .Net type, read this string
        // and give me back a corresponding instance of that
        // type
        object FromString(string stringValue, Type type);
        T FromString<T>(string stringValue);

        bool CanBeParsed(Type type);
    }
        public void RegisterConverter<T>(Func<string, T> finder)
        {
            _froms[typeof(T)] = x => finder(x);
        }
    public class Contact
    {
        public string FirstName { get; set; } 
        public string LastName { get; set; }
    }
        [Test]
        public void register_and_retrieve_a_new_type_of_complex_object()
        {
            var finder = new ObjectConverter();
            finder.RegisterConverter<Contact>(text =>
            {
                var parts = text.Split(' ');
                return new Contact(){
                    FirstName = parts[0],
                    LastName = parts[1]
                };
            });

            var c = finder.FromString<Contact>("Jeremy Miller");

            c.FirstName.ShouldEqual("Jeremy");
            c.LastName.ShouldEqual("Miller");
        }
        [Test]
        public void how_about_getting_an_array_of_those_complex_objects()
        {
            // Same converter as before
            var finder = new ObjectConverter();
            finder.RegisterConverter<Contact>(text =>
            {
                var parts = text.Split(' ');
                return new Contact()
                {
                    FirstName = parts[0],
                    LastName = parts[1]
                };
            });

            // Now, let's pull an array of Contact's
            var contacts = 
                finder.FromString<Contact[]>("Jeremy Miller, Rod Paddock, Chad Myers");

            contacts.Select(x => x.LastName)
                .ShouldHaveTheSameElementsAs("Miller", "Paddock", "Myers");
        }
        // 'User' and 'Site' are both Entity types
        // in our system
        [FormatAs("User {user} is at Site {site}")]
        public void UserIsAtSite(User user, Site site)
        {
            user.Site = site;
            _system.Save(user);
        }
    public interface IObjectConverterFamily
    {
        // ObjectConverter calls this method on unknown types
        // to ask an IObjectConverterFamily if it "knows" how
        // to convert a string into the given type
        bool Matches(Type type, IObjectConverter converter);

        // If Matches() returns true for a given type, 
        // ObjectConverter asks this IObjectConverterFamily
        // for a converter Lambda and calls its 
        // RegisterFinder() method behind the scenes to cache
        // the Lambda for later usage
        Func<string, object> CreateConverter(Type type, Cache<Type, Func<string, object>> converters);
    }
    public class DomainEntityConverterFamily : IObjectConverterFamily
    {
        private readonly IRepository _repository;

        public DomainEntityConverterFamily(IRepository repository)
        {
            _repository = repository;
        }

        // Matches any type deriving from DomainEntity
        // CanBeCastTo<> is an extension method in FubuCore as well
        public bool Matches(Type type, IObjectConverter converter)
        {
            return type.CanBeCastTo<DomainEntity>();
        }

        // In this case we find the correct object by looking it up by Id
        // from our repository
        public Func<string, object> CreateConverter(Type type, Cache<Type, Func<string, object>> converters)
        {
            return text =>
            {
                var guid = new Guid(text);
                return _repository.Find(type, guid);
            };
        }
    }
load_assembly 'System.CoreEx'
load_assembly 'System.Interactive'
load_assembly 'System.Reactive'
load_assembly 'WindowsBase'
load_assembly 'PresentationCore'
load_assembly 'PresentationFramework'
load_assembly 'System.Xaml'
load_assembly 'System.CoreEx'
load_assembly 'System.Reactive'
require 'System.Core'
require 'wpf'
require 'rxnet'
include System
include System::Linq
include System::Windows
include System::Windows::Controls

using_clr_extensions System
using_clr_extensions System::Linq
class RubyWindow < Window

    def initialize
        self.Title = 'Hello Ruby!'

        stackpanel = StackPanel.new
        @textbox = TextBox.new
        @listbox = ListBox.new
        stackpanel.children.add(@textbox)
        stackpanel.children.add(@listbox)
        self.content = stackpanel

        initialize_handlers
    end

end
def initialize_handlers

    @textbox_changed = Observable.
        method(:from_event).
        of(TextChangedEventArgs).
        call(@textbox, 'TextChanged')

end
some_object.
    method(:some_method).
    of(SomeType).
    call(some_args)
def initialize_handlers

    @textbox_changed = Observable.
        method(:from_event).
        of(TextChangedEventArgs).
        call(@textbox, 'TextChanged').
        select(lambda { |event| event.sender.text })        

end
var textChanged = 
    Observable.FromEvent<TextChangedEventArgs>(textbox, "TextChanged")
        .Select(ev => ((TextBox)sender).Text);
def initialize_handlers

    @textbox_changed = Observable.
        method(:from_event).
        of(TextChangedEventArgs).
        call(@textbox, 'TextChanged').
        select(lambda { |event| event.sender.text })        

    @textbox_changed.
        subscribe(lambda {|text| @listbox.items.add(text))

end
def initialize_handlers

    @textbox_changed = Observable.
        method(:from_event).
        of(TextChangedEventArgs).
        call(@textbox, 'TextChanged').
        select(lambda { |event| event.sender.text })        

    @textbox_changed.
        throttle(TimeSpan.from_milliseconds(500))
        subscribe(lambda {|text| @listbox.items.add(text))

end
def initialize_handlers

    @textbox_changed = Observable.
        method(:from_event).
        of(TextChangedEventArgs).
        call(@textbox, 'TextChanged').
        select(lambda { |event| event.sender.text })        

    @textbox_changed.
        throttle(TimeSpan.from_milliseconds(500)).
        observe_on_dispatcher.
        subscribe(lambda {|text| @listbox.items.add(text))

end
def initialize_handlers

    @textbox_changed = Observable.
        method(:from_event).
        of(TextChangedEventArgs).
        call(@textbox, 'TextChanged').
        select(lambda { |event| event.sender.text })        

    @textbox_changed.
        throttle(TimeSpan.from_milliseconds(500)).
        observe_on_dispatcher.
        distinct_until_changed.
        subscribe(lambda {|text| @listbox.items.add(text))

end
load_assembly 'System.Core'
using_clr_extensions System::Linq
class Object  
    def to_seq(type = Object)    
        System::Linq::Enumerable.method(:of_type).of(type).call(self.to_a)  
    end
end
load_assembly 'System.Core'
using_clr_extensions System::Linq

class Object  
    def to_seq(type = Object)    
        System::Linq::Enumerable.method(:of_type).of(type).call(self.to_a)  
    end
end

(1..10).to_seq.
    select(lambda { |x| x * x }).
    where(lambda { |x| x % 3 == 0 }).
    each { |x| puts x }
load_assembly 'System.Core'
load_assembly 'System.CoreEx'
load_assembly 'System.Reactive'

include System
include System::Linq

using_clr_extensions System
using_clr_extensions System::Linq
class Object  
    def to_seq(type = Object)    
        System::Linq::Enumerable.method(:of_type).of(type).call(self.to_a)  
    end

    def to_observable(type = Object)
        System::Linq::Observable.method(:to_observable).of(type).call(self.to_a)
    end
end
observable = (1..10).to_observable.
    select(lambda { |x| x * x }).
    where(lambda { |x| x % 3 == 0 })
observable.subscribe(
    lambda do |next_value|
        puts next_value
    end,
    lambda do |error|
        puts '#{error.message}'
    end,
    lambda do 
        puts 'done!'
    end)
9
36
81
done!
// items : Observable[]
// scheduler : optional custom scheduler
// returns : Observable

Rx.Observable.prototype.OnErrorResumeNext(
    items,
    scheduler);

// items : Observable[]
// returns : Observable
Rx.Observable.OnErrorResumeNext(
    items);
Rx.Observable.OnErrorResumeNext([
    Rx.Observable.FromArray([1, 2]),
    Rx.Observable.FromArray([3, 4, 5]),
    Rx.Observable.FromArray([6, 7]).Concat(Rx.Observable.Throw("woops!")),
    Rx.Observable.FromArray([8, 9])])
    .Subscribe(
        function (next) {
            $("<p/>").html(next).appendTo("#results");
        });
// resourceSelector : () -> Disposable,
// resourceUsage : Disposable -> Observable
// returns : Observable

Rx.Observable.Using = function(
    resourceSelector, 
    resourceUsage);
DataDisposable = function (element, key) {

    this.data = function (value) {
        return element.data(key, value);
    };

    // Dispose method
    this.Dispose = function () {
        element.removeData(key);
    };
};
Rx.Observable.Using(

    // resourceSelector
    function () {
        return new DataDisposable($("#content"), "key1");
    },

    // resourceUsage
    function (disposable) {
        disposable.data(123);

        return Rx.Observable.Return(456 * disposable.data());
    })
    .Subscribe(
        function (next) {
            $("<p/>").html(next).appendTo("#content");
        });
Rx.Observable.Using(

    // resourceSelector
    function () {
        return new DataDisposable($("#content"), "key1");
    },

    // resourceUsage
    function (disposable) {
        disposable.data(123);

        return Rx.Observable.Return(456 * disposable.data())
            .Concat(Rx.Observable.Throw("woops"));
    })
    .Catch(Rx.Observable.Return(789))
    .Subscribe(
        function (next) {
            $("<p/>").html(next).appendTo("#content");
        });
// returns : Observable

Rx.Observable.prototype.Retry();

// count : int
// scheduler : optional scheduler
// returns : Observable

Rx.Observable.prototype.Retry(
    count,
    scheduler);
Rx.Observable.FromArray([1, 2, 3])
    .Retry()
    .Subscribe(
        function (next) {
            $("<p/>").html(next).appendTo("#results");
        });
Rx.Observable.FromArray([1, 2, 3])
    .Concat(Rx.Observable.Throw("woah nellie!"))
    .Retry()
    .Subscribe(
        function (next) {
            $("<p/>").html(next).appendTo("#results");
        });
var count = 0;

Rx.Observable.Return(4)
    .Concat(
        Rx.Observable.If(
            function() { return count == 0; },
            Rx.Observable.Throw("nope!"),
            Rx.Observable.Return(5)))
    .Concat(
        Rx.Observable.If(
            function () { return count == 1; },
            Rx.Observable.Throw("nope!"),
            Rx.Observable.Return(6)))
    .Finally(function() { count++; })
    .Retry()
    .Subscribe(
        function (next) {
            $("<p/>").html(next).appendTo("#results");
        });
4 // Hits exception
4
5 // Hits exception
4
5
6

Why Do We Need It?

How Do We Get There?

Conclusion

A small Windows Mobile rant

Wrapping up iOS

Building an iPhone app in C#

Apple support

Taking the bait

Buffering Output

…With Count?

…With Time?

…With Both?

Conclusion

AgileZen

Likes

Wish List

Wrap-up

Code Diff from within Code Source

Code Diff from within Solution Exlorer or Solution Navigator

Code Change Review through Global Code Diff

Defining the Baseline for Comparison

StoryTeller

StructureMap

Dojo Deferred

From Deferred to Observable

From Observable to Deferred

Conclusion

Putting ObjectConverter to Work

“Finding” Objects

Family of Types in One Swath

What Does the Future Hold?

Taming User Input

Removing the Boilerplate

Starting the Solution

Conclusion

Conclusion

OnErrorResumeNext VB Style

Cleaning Up With Using

If At First You Fail, Retry

Conclusion