DBService.GetSchedules

DBService.cs

// ORIGINAL

public static void GetSchedules(Action<IDictionary<BaseChannel, ICollection<BaseProgram>>> callback,
    IEnumerable<BaseChannel> channels, bool refresh = false)
{
    // Fetch the data from the online service if it's the first-load, or a force-refresh.
    if (DBServiceCache.IsScheduleCached == false || refresh == true)
    {
        lock (DBServiceCache.Schedules)
        {
            DBServiceCache.Schedules.Clear();
        }

        DBServiceCache.IsScheduleCached = true;

        // Split the channels up in chunks of five (service limit)
        foreach (var chunk in channels.Chunks(5))
        {
            // Create a schedule request for each set of 5 channels.
            var input = new GetSchedulesRequest(DBService.requestId++)
            {
                Channels = chunk,
                Parameters = new GetSchedulesParams
                {
                    ChannelList = chunk.Where(channel => channel != null)
                                       .Select(channel => channel.SourceUrl)
                                       .ToArray(),
                    BroadcastDate = GetBroadcastDate()
                }
            };

            // Fetch the program schedule for the schedule request.
            GetDataAsync<BasePrograms, GetSchedulesRequest>(input, (schedules, request) =>
            {
                int i = 0;

                var newSchedules = new Dictionary<BaseChannel, ICollection<BaseProgram>>();

                // Adds the channels to a channel => schedule dictionary.
                foreach (var channel in request.Channels.Where(c => c != null))
                {
                    var schedule = schedules.Programs.Programs[i++];
                    if (schedule != null)
                    {
                        newSchedules.Add(channel, schedule);
                    }
                }

                // Cache the schedules.
                lock (DBServiceCache.Schedules)
                {
                    foreach (var pair in newSchedules)
                    {
                        if (DBServiceCache.Schedules.ContainsKey(pair.Key) == false)
                        {
                            DBServiceCache.Schedules.Add(pair);
                        }
                    }
                }

                // Flatten the schedules dictionary, selecting all the channels.
                var flattenSchedules = newSchedules.Values.SelectMany(self => self);

                lock (DBServiceCache.Programs)
                {
                    // Create a source_url => program dictionary cache.
                    foreach (var pair in flattenSchedules.ToDictionary(program => program.SourceUrl))
                    {
                        if (DBServiceCache.Programs.ContainsKey(pair.Key) == false)
                        {
                            DBServiceCache.Programs.Add(pair);
                        }
                    }
                }

                callback(newSchedules);
            });
        }
    }
    else
    {
        callback(DBServiceCache.Schedules);
    }
}

// REWRITTEN USING REACTIVE EXTENSIONS

public static IObservable<Dictionary<BaseChannel, ICollection<BaseProgram>>> GetSchedules(
    IEnumerable<BaseChannel> channels, bool refresh = false)
{
    // Fetch the data from the online service if it's the first-load, or a force-refresh.
    if (DBServiceCache.IsScheduleCached == false || refresh == true)
    {
        lock (DBServiceCache.Schedules)
        {
            DBServiceCache.Schedules.Clear();
        }

        DBServiceCache.IsScheduleCached = true;

        return Observable.For(channels.Chunks(5), chunk =>
        {
            var request = new GetSchedulesRequest(DBService.requestId++)
            {
                Channels = chunk,
                Parameters = new GetSchedulesParams
                {
                    ChannelList = chunk.Where(channel => channel != null)
                                       .Select(channel => channel.SourceUrl)
                                       .ToArray(),
                    BroadcastDate = GetBroadcastDate()
                }
            };

            return GetDataAsync<BasePrograms, GetSchedulesRequest>(request)
                        .Select(schedules =>
                        {
                            var newSchedules = new Dictionary<BaseChannel, ICollection<BaseProgram>>();

                            int i = 0;
                            foreach (var channel in request.Channels.Where(c => c != null))
                            {
                                var schedule = schedules.Programs.Programs[i++];
                                if (schedule != null)
                                {
                                    newSchedules.Add(channel, schedule);
                                }
                            }

                            lock (DBServiceCache.Schedules)
                            {
                                foreach (var pair in newSchedules)
                                {
                                    if (DBServiceCache.Schedules.ContainsKey(pair.Key) == false)
                                    {
                                        DBServiceCache.Schedules.Add(pair.Key, pair.Value);
                                    }
                                }
                            }

                            var flattenSchedules = newSchedules.Values.SelectMany(self => self);

                            lock (DBServiceCache.Programs)
                            {
                                foreach (var pair in flattenSchedules.ToDictionary(program => program.SourceUrl))
                                {
                                    if (DBServiceCache.Programs.ContainsKey(pair.Key) == false)
                                    {
                                        DBServiceCache.Programs.Add(pair.Key, pair.Value);
                                    }
                                }
                            }

                            return newSchedules;
                        });
        });
    }
    else
    {
        return Observable.Return(DBServiceCache.Schedules);
    }
}