12 files changed, 1501 insertions, 0 deletions
diff --git a/FireBase/Offline/ConcurrentOfflineDatabase.cs b/FireBase/Offline/ConcurrentOfflineDatabase.cs
new file mode 100644
index 0000000..226892d
--- /dev/null
+++ b/FireBase/Offline/ConcurrentOfflineDatabase.cs
@@ -0,0 +1,207 @@
+namespace Firebase.Database.Offline
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Concurrent;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Linq;
+
+    using LiteDB;
+
+    /// <summary>
+    /// The offline database.
+    /// </summary>
+    public class ConcurrentOfflineDatabase : IDictionary<string, OfflineEntry>
+    {
+        private readonly LiteRepository db;
+        private readonly ConcurrentDictionary<string, OfflineEntry> ccache;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="OfflineDatabase"/> class.
+        /// </summary>
+        /// <param name="itemType"> The item type which is used to determine the database file name.  </param>
+        /// <param name="filenameModifier"> Custom string which will get appended to the file name. </param>
+        public ConcurrentOfflineDatabase(Type itemType, string filenameModifier)
+        {
+            var fullName = this.GetFileName(itemType.ToString());
+            if(fullName.Length > 100)
+            {
+                fullName = fullName.Substring(0, 100);
+            }
+
+            BsonMapper mapper = BsonMapper.Global;
+            mapper.Entity<OfflineEntry>().Id(o => o.Key);
+
+            string root = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+            string filename = fullName + filenameModifier + ".db";
+            var path = Path.Combine(root, filename);
+            this.db = new LiteRepository(new LiteDatabase(path, mapper));
+
+            var cache = db.Database
+                .GetCollection<OfflineEntry>()
+                .FindAll()
+                .ToDictionary(o => o.Key, o => o);
+
+            this.ccache = new ConcurrentDictionary<string, OfflineEntry>(cache);
+            
+        }
+
+        /// <summary>
+        /// Gets the number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1"/>.
+        /// </summary>
+        /// <returns> The number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1"/>. </returns>
+        public int Count => this.ccache.Count;
+
+        /// <summary>
+        /// Gets a value indicating whether this is a read-only collection.
+        /// </summary>
+        public bool IsReadOnly => false;
+
+        /// <summary>
+        /// Gets an <see cref="T:System.Collections.Generic.ICollection`1"/> containing the keys of the <see cref="T:System.Collections.Generic.IDictionary`2"/>.
+        /// </summary>
+        /// <returns> An <see cref="T:System.Collections.Generic.ICollection`1"/> containing the keys of the object that implements <see cref="T:System.Collections.Generic.IDictionary`2"/>. </returns>
+        public ICollection<string> Keys => this.ccache.Keys;
+
+        /// <summary>
+        /// Gets an <see cref="T:System.Collections.Generic.ICollection`1"/> containing the values in the <see cref="T:System.Collections.Generic.IDictionary`2"/>.
+        /// </summary>
+        /// <returns> An <see cref="T:System.Collections.Generic.ICollection`1"/> containing the values in the object that implements <see cref="T:System.Collections.Generic.IDictionary`2"/>. </returns>
+        public ICollection<OfflineEntry> Values => this.ccache.Values;
+
+        /// <summary>
+        /// Gets or sets the element with the specified key.
+        /// </summary>
+        /// <param name="key">The key of the element to get or set.</param>
+        /// <returns> The element with the specified key. </returns>   
+        public OfflineEntry this[string key]
+        {
+            get
+            {
+                return this.ccache[key];
+            }
+
+            set
+            {
+                this.ccache.AddOrUpdate(key, value, (k, existing) => value);
+                this.db.Upsert(value);
+            }
+        }
+
+        /// <summary>
+        /// Returns an enumerator that iterates through the collection.
+        /// </summary>
+        /// <returns> An enumerator that can be used to iterate through the collection. </returns>
+        public IEnumerator<KeyValuePair<string, OfflineEntry>> GetEnumerator()
+        {
+            return this.ccache.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return this.GetEnumerator();
+        }
+
+        /// <summary>
+        /// Adds an item to the <see cref="T:System.Collections.Generic.ICollection`1"/>.
+        /// </summary>
+        /// <param name="item">The object to add to the <see cref="T:System.Collections.Generic.ICollection`1"/>.</param>
+        public void Add(KeyValuePair<string, OfflineEntry> item)
+        {
+            this.Add(item.Key, item.Value);
+        }
+
+        /// <summary>
+        /// Removes all items from the <see cref="T:System.Collections.Generic.ICollection`1"/>.
+        /// </summary> 
+        public void Clear()
+        {
+            this.ccache.Clear();
+            this.db.Delete<OfflineEntry>(Query.All());
+        }
+
+        /// <summary>
+        /// Determines whether the <see cref="T:System.Collections.Generic.ICollection`1"/> contains a specific value.
+        /// </summary>
+        /// <param name="item">The object to locate in the <see cref="T:System.Collections.Generic.ICollection`1"/>.</param> 
+        /// <returns> True if <paramref name="item"/> is found in the <see cref="T:System.Collections.Generic.ICollection`1"/>; otherwise, false. </returns>
+        public bool Contains(KeyValuePair<string, OfflineEntry> item)
+        {
+            return this.ContainsKey(item.Key);
+        }
+
+        /// <summary>
+        /// Copies the elements of the <see cref="T:System.Collections.Generic.ICollection`1"/> to an <see cref="T:System.Array"/>, starting at a particular <see cref="T:System.Array"/> index.
+        /// </summary>
+        /// <param name="array">The one-dimensional <see cref="T:System.Array"/> that is the destination of the elements copied from <see cref="T:System.Collections.Generic.ICollection`1"/>. The <see cref="T:System.Array"/> must have zero-based indexing.</param>
+        /// <param name="arrayIndex">The zero-based index in <paramref name="array"/> at which copying begins.</param>
+        public void CopyTo(KeyValuePair<string, OfflineEntry>[] array, int arrayIndex)
+        {
+            this.ccache.ToList().CopyTo(array, arrayIndex);
+        }
+
+        /// <summary>
+        /// Removes the first occurrence of a specific object from the <see cref="T:System.Collections.Generic.ICollection`1"/>.
+        /// </summary>
+        /// <param name="item">The object to remove from the <see cref="T:System.Collections.Generic.ICollection`1"/>.</param>
+        /// <returns> True if <paramref name="item"/> was successfully removed from the <see cref="T:System.Collections.Generic.ICollection`1"/>; otherwise, false. This method also returns false if <paramref name="item"/> is not found in the original <see cref="T:System.Collections.Generic.ICollection`1"/>. </returns>
+        public bool Remove(KeyValuePair<string, OfflineEntry> item)
+        {
+            return this.Remove(item.Key);
+        }
+
+        /// <summary>
+        /// Determines whether the <see cref="T:System.Collections.Generic.IDictionary`2"/> contains an element with the specified key.
+        /// </summary>
+        /// <param name="key">The key to locate in the <see cref="T:System.Collections.Generic.IDictionary`2"/>.</param>
+        /// <returns> True if the <see cref="T:System.Collections.Generic.IDictionary`2"/> contains an element with the key; otherwise, false. </returns>
+        public bool ContainsKey(string key)
+        {
+            return this.ccache.ContainsKey(key);
+        }
+
+        /// <summary>
+        /// Adds an element with the provided key and value to the <see cref="T:System.Collections.Generic.IDictionary`2"/>.
+        /// </summary>
+        /// <param name="key">The object to use as the key of the element to add.</param>
+        /// <param name="value">The object to use as the value of the element to add.</param>
+        public void Add(string key, OfflineEntry value)
+        {
+            this.ccache.AddOrUpdate(key, value, (k, existing) => value);
+            this.db.Upsert(value);
+        }
+
+        /// <summary>
+        /// Removes the element with the specified key from the <see cref="T:System.Collections.Generic.IDictionary`2"/>.
+        /// </summary>
+        /// <param name="key">The key of the element to remove.</param>
+        /// <returns> True if the element is successfully removed; otherwise, false.  This method also returns false if <paramref name="key"/> was not found in the original <see cref="T:System.Collections.Generic.IDictionary`2"/>. </returns>
+        public bool Remove(string key)
+        {
+            this.ccache.TryRemove(key, out OfflineEntry _);
+            return this.db.Delete<OfflineEntry>(key);
+        }
+
+        /// <summary>
+        /// Gets the value associated with the specified key.
+        /// </summary> 
+        /// <param name="key">The key whose value to get.</param><param name="value">When this method returns, the value associated with the specified key, if the key is found; otherwise, the default value for the type of the <paramref name="value"/> parameter. This parameter is passed uninitialized.</param>
+        /// <returns> True if the object that implements <see cref="T:System.Collections.Generic.IDictionary`2"/> contains an element with the specified key; otherwise, false. </returns>
+        public bool TryGetValue(string key, out OfflineEntry value)
+        {
+            return this.ccache.TryGetValue(key, out value);
+        }
+
+        private string GetFileName(string fileName)
+        {
+            var invalidChars = new[] { '`', '[', ',', '=' };
+            foreach(char c in invalidChars.Concat(System.IO.Path.GetInvalidFileNameChars()).Distinct())
+            {
+                fileName = fileName.Replace(c, '_');
+            }
+
+            return fileName;
+        }
+    }
+}
diff --git a/FireBase/Offline/DatabaseExtensions.cs b/FireBase/Offline/DatabaseExtensions.cs
new file mode 100644
index 0000000..4b04314
--- /dev/null
+++ b/FireBase/Offline/DatabaseExtensions.cs
@@ -0,0 +1,195 @@
+namespace Firebase.Database.Offline
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Linq.Expressions;
+    using System.Reflection;
+    using Firebase.Database.Query;
+
+    public static class DatabaseExtensions
+    {
+        /// <summary>
+        /// Create new instances of the <see cref="RealtimeDatabase{T}"/>.
+        /// </summary>
+        /// <typeparam name="T"> Type of elements. </typeparam>
+        /// <param name="filenameModifier"> Custom string which will get appended to the file name. </param>
+        /// <param name="elementRoot"> Optional custom root element of received json items. </param>
+        /// <param name="streamingOptions"> Realtime streaming options. </param> 
+        /// <param name="initialPullStrategy"> Specifies what strategy should be used for initial pulling of server data. </param>
+        /// <param name="pushChanges"> Specifies whether changed items should actually be pushed to the server. It this is false, then Put / Post / Delete will not affect server data. </param>
+        /// <returns> The <see cref="RealtimeDatabase{T}"/>. </returns>
+        public static RealtimeDatabase<T> AsRealtimeDatabase<T>(this ChildQuery query, string filenameModifier = "", string elementRoot = "", StreamingOptions streamingOptions = StreamingOptions.LatestOnly, InitialPullStrategy initialPullStrategy = InitialPullStrategy.MissingOnly, bool pushChanges = true)
+            where T : class
+        {
+            return new RealtimeDatabase<T>(query, elementRoot, query.Client.Options.OfflineDatabaseFactory, filenameModifier, streamingOptions, initialPullStrategy, pushChanges);
+        }
+
+        /// <summary>
+        /// Create new instances of the <see cref="RealtimeDatabase{T}"/>.
+        /// </summary>
+        /// <typeparam name="T"> Type of elements. </typeparam>
+        /// <typeparam name="TSetHandler"> Type of the custom <see cref="ISetHandler{T}"/> to use. </typeparam>
+        /// <param name="filenameModifier"> Custom string which will get appended to the file name. </param>
+        /// <param name="elementRoot"> Optional custom root element of received json items. </param>
+        /// <param name="streamingOptions"> Realtime streaming options. </param> 
+        /// <param name="initialPullStrategy"> Specifies what strategy should be used for initial pulling of server data. </param>
+        /// <param name="pushChanges"> Specifies whether changed items should actually be pushed to the server. It this is false, then Put / Post / Delete will not affect server data. </param>
+        /// <returns> The <see cref="RealtimeDatabase{T}"/>. </returns>
+        public static RealtimeDatabase<T> AsRealtimeDatabase<T, TSetHandler>(this ChildQuery query, string filenameModifier = "", string elementRoot = "", StreamingOptions streamingOptions = StreamingOptions.LatestOnly, InitialPullStrategy initialPullStrategy = InitialPullStrategy.MissingOnly, bool pushChanges = true)
+            where T : class
+            where TSetHandler : ISetHandler<T>, new()
+        {
+            return new RealtimeDatabase<T>(query, elementRoot, query.Client.Options.OfflineDatabaseFactory, filenameModifier, streamingOptions, initialPullStrategy, pushChanges, Activator.CreateInstance<TSetHandler>());
+        }
+
+        /// <summary>
+        /// Overwrites existing object with given key leaving any missing properties intact in firebase.
+        /// </summary>
+        /// <param name="key"> The key. </param>
+        /// <param name="obj"> The object to set. </param>
+        /// <param name="syncOnline"> Indicates whether the item should be synced online. </param>
+        /// <param name="priority"> The priority. Objects with higher priority will be synced first. Higher number indicates higher priority. </param>
+        public static void Patch<T>(this RealtimeDatabase<T> db, string key, T obj, bool syncOnline = true, int priority = 1)
+            where T: class
+        {
+            db.Set(key, obj, syncOnline ? SyncOptions.Patch : SyncOptions.None, priority);
+        }
+
+        /// <summary>
+        /// Overwrites existing object with given key.
+        /// </summary>
+        /// <param name="key"> The key. </param>
+        /// <param name="obj"> The object to set. </param>
+        /// <param name="syncOnline"> Indicates whether the item should be synced online. </param>
+        /// <param name="priority"> The priority. Objects with higher priority will be synced first. Higher number indicates higher priority. </param>
+        public static void Put<T>(this RealtimeDatabase<T> db, string key, T obj, bool syncOnline = true, int priority = 1)
+            where T: class
+        {
+            db.Set(key, obj, syncOnline ? SyncOptions.Put : SyncOptions.None, priority);
+        }
+
+        /// <summary>
+        /// Adds a new entity to the Database.
+        /// </summary>
+        /// <param name="obj"> The object to add.  </param>
+        /// <param name="syncOnline"> Indicates whether the item should be synced online. </param>
+        /// <param name="priority"> The priority. Objects with higher priority will be synced first. Higher number indicates higher priority. </param>
+        /// <returns> The generated key for this object. </returns>
+        public static string Post<T>(this RealtimeDatabase<T> db, T obj, bool syncOnline = true, int priority = 1)
+            where T: class
+        {
+            var key = FirebaseKeyGenerator.Next();
+
+            db.Set(key, obj, syncOnline ? SyncOptions.Put : SyncOptions.None, priority);
+
+            return key;
+        }
+
+        /// <summary>
+        /// Deletes the entity with the given key.
+        /// </summary>
+        /// <param name="key"> The key. </param>
+        /// <param name="syncOnline"> Indicates whether the item should be synced online. </param>
+        /// <param name="priority"> The priority. Objects with higher priority will be synced first. Higher number indicates higher priority. </param> 
+        public static void Delete<T>(this RealtimeDatabase<T> db, string key, bool syncOnline = true, int priority = 1)
+            where T: class
+        {
+            db.Set(key, null, syncOnline ? SyncOptions.Put : SyncOptions.None, priority);
+        }
+
+        /// <summary>
+        /// Do a Put for a nested property specified by <paramref name="propertyExpression"/> of an object with key <paramref name="key"/>.
+        /// </summary>
+        /// <typeparam name="T"> Type of the root elements. </typeparam>
+        /// <typeparam name="TProperty"> Type of the property being modified</typeparam>
+        /// <param name="db"> Database instance. </param>
+        /// <param name="key"> Key of the root element to modify. </param>
+        /// <param name="propertyExpression"> Expression on the root element leading to target value to modify. </param>
+        /// <param name="value"> Value to put. </param>
+        /// <param name="syncOnline"> Indicates whether the item should be synced online. </param>
+        /// <param name="priority"> The priority. Objects with higher priority will be synced first. Higher number indicates higher priority. </param> 
+        public static void Put<T, TProperty>(this RealtimeDatabase<T> db, string key, Expression<Func<T, TProperty>> propertyExpression, TProperty value, bool syncOnline = true, int priority = 1)
+            where T: class
+        {
+            db.Set(key, propertyExpression, value, syncOnline ? SyncOptions.Put : SyncOptions.None, priority);
+        }
+
+        /// <summary>
+        /// Do a Patch for a nested property specified by <paramref name="propertyExpression"/> of an object with key <paramref name="key"/>.
+        /// </summary>
+        /// <typeparam name="T"> Type of the root elements. </typeparam>
+        /// <typeparam name="TProperty"> Type of the property being modified</typeparam>
+        /// <param name="db"> Database instance. </param>
+        /// <param name="key"> Key of the root element to modify. </param>
+        /// <param name="propertyExpression"> Expression on the root element leading to target value to modify. </param>
+        /// <param name="value"> Value to patch. </param>
+        /// <param name="syncOnline"> Indicates whether the item should be synced online. </param>
+        /// <param name="priority"> The priority. Objects with higher priority will be synced first. Higher number indicates higher priority. </param> 
+        public static void Patch<T, TProperty>(this RealtimeDatabase<T> db, string key, Expression<Func<T, TProperty>> propertyExpression, TProperty value, bool syncOnline = true, int priority = 1)
+            where T: class
+        {
+            db.Set(key, propertyExpression, value, syncOnline ? SyncOptions.Patch : SyncOptions.None, priority);
+        }
+
+        /// <summary>
+        /// Delete a nested property specified by <paramref name="propertyExpression"/> of an object with key <paramref name="key"/>. This basically does a Put with null value.
+        /// </summary>
+        /// <typeparam name="T"> Type of the root elements. </typeparam>
+        /// <typeparam name="TProperty"> Type of the property being modified</typeparam>
+        /// <param name="db"> Database instance. </param>
+        /// <param name="key"> Key of the root element to modify. </param>
+        /// <param name="propertyExpression"> Expression on the root element leading to target value to modify. </param>
+        /// <param name="value"> Value to put. </param>
+        /// <param name="syncOnline"> Indicates whether the item should be synced online. </param>
+        /// <param name="priority"> The priority. Objects with higher priority will be synced first. Higher number indicates higher priority. </param> 
+        public static void Delete<T, TProperty>(this RealtimeDatabase<T> db, string key, Expression<Func<T, TProperty>> propertyExpression, bool syncOnline = true, int priority = 1)
+            where T: class
+            where TProperty: class
+        {
+            db.Set(key, propertyExpression, null, syncOnline ? SyncOptions.Put : SyncOptions.None, priority);
+        }
+
+        /// <summary>
+        /// Post a new entity into the nested dictionary specified by <paramref name="propertyExpression"/> of an object with key <paramref name="key"/>. 
+        /// The key of the new entity is automatically generated.
+        /// </summary>
+        /// <typeparam name="T"> Type of the root elements. </typeparam>
+        /// <typeparam name="TSelector"> Type of the dictionary being modified</typeparam>
+        /// <typeparam name="TProperty"> Type of the value within the dictionary being modified</typeparam>
+        /// <param name="db"> Database instance. </param>
+        /// <param name="key"> Key of the root element to modify. </param>
+        /// <param name="propertyExpression"> Expression on the root element leading to target value to modify. </param>
+        /// <param name="value"> Value to put. </param>
+        /// <param name="syncOnline"> Indicates whether the item should be synced online. </param>
+        /// <param name="priority"> The priority. Objects with higher priority will be synced first. Higher number indicates higher priority. </param> 
+        public static void Post<T, TSelector, TProperty>(this RealtimeDatabase<T> db, string key, Expression<Func<T, TSelector>> propertyExpression, TProperty value, bool syncOnline = true, int priority = 1)
+            where T: class
+            where TSelector: IDictionary<string, TProperty>
+        {
+            var nextKey = FirebaseKeyGenerator.Next();
+            var expression = Expression.Lambda<Func<T, TProperty>>(Expression.Call(propertyExpression.Body, typeof(TSelector).GetRuntimeMethod("get_Item", new[] { typeof(string) }), Expression.Constant(nextKey)), propertyExpression.Parameters);
+            db.Set(key, expression, value, syncOnline ? SyncOptions.Put : SyncOptions.None, priority);
+        }
+
+        /// <summary>
+        /// Delete an entity with key <paramref name="dictionaryKey"/> in the nested dictionary specified by <paramref name="propertyExpression"/> of an object with key <paramref name="key"/>. 
+        /// The key of the new entity is automatically generated.
+        /// </summary>
+        /// <typeparam name="T"> Type of the root elements. </typeparam>
+        /// <typeparam name="TSelector"> Type of the dictionary being modified</typeparam>
+        /// <typeparam name="TProperty"> Type of the value within the dictionary being modified</typeparam>
+        /// <param name="db"> Database instance. </param>
+        /// <param name="key"> Key of the root element to modify. </param>
+        /// <param name="propertyExpression"> Expression on the root element leading to target value to modify. </param>
+        /// <param name="dictionaryKey"> Key within the nested dictionary to delete. </param>
+        /// <param name="syncOnline"> Indicates whether the item should be synced online. </param>
+        /// <param name="priority"> The priority. Objects with higher priority will be synced first. Higher number indicates higher priority. </param> 
+        public static void Delete<T, TProperty>(this RealtimeDatabase<T> db, string key, Expression<Func<T, IDictionary<string, TProperty>>> propertyExpression, string dictionaryKey, bool syncOnline = true, int priority = 1)
+            where T: class
+        {
+            var expression = Expression.Lambda<Func<T, TProperty>>(Expression.Call(propertyExpression.Body, typeof(IDictionary<string, TProperty>).GetRuntimeMethod("get_Item", new[] { typeof(string) }), Expression.Constant(dictionaryKey)), propertyExpression.Parameters);
+            db.Set(key, expression, null, syncOnline ? SyncOptions.Put : SyncOptions.None, priority);
+        }
+    }
+}
diff --git a/FireBase/Offline/ISetHandler.cs b/FireBase/Offline/ISetHandler.cs
new file mode 100644
index 0000000..477c36b
--- /dev/null
+++ b/FireBase/Offline/ISetHandler.cs
@@ -0,0 +1,11 @@
+namespace Firebase.Database.Offline
+{
+    using Firebase.Database.Query;
+
+    using System.Threading.Tasks;
+
+    public interface ISetHandler<in T>
+    {
+        Task SetAsync(ChildQuery query, string key, OfflineEntry entry);
+    }
+}
diff --git a/FireBase/Offline/InitialPullStrategy.cs b/FireBase/Offline/InitialPullStrategy.cs
new file mode 100644
index 0000000..70f6b8c
--- /dev/null
+++ b/FireBase/Offline/InitialPullStrategy.cs
@@ -0,0 +1,23 @@
+namespace Firebase.Database.Offline
+{
+    /// <summary>
+    /// Specifies the strategy for initial pull of server data.
+    /// </summary>
+    public enum InitialPullStrategy
+    {
+        /// <summary>
+        /// Don't pull anything.
+        /// </summary>
+        None, 
+
+        /// <summary>
+        /// Pull only what isn't already stored offline.
+        /// </summary>
+        MissingOnly,
+
+        /// <summary>
+        /// Pull everything that exists on the server.
+        /// </summary>
+        Everything,
+    }
+}
diff --git a/FireBase/Offline/Internals/MemberAccessVisitor.cs b/FireBase/Offline/Internals/MemberAccessVisitor.cs
new file mode 100644
index 0000000..1f7cb11
--- /dev/null
+++ b/FireBase/Offline/Internals/MemberAccessVisitor.cs
@@ -0,0 +1,51 @@
+namespace Firebase.Database.Offline.Internals
+{
+    using System.Collections.Generic;
+    using System.Linq.Expressions;
+    using System.Reflection;
+
+    using Newtonsoft.Json;
+
+    public class MemberAccessVisitor : ExpressionVisitor
+    {
+        private readonly IList<string> propertyNames = new List<string>();
+
+        private bool wasDictionaryAccess;
+
+        public IEnumerable<string> PropertyNames => this.propertyNames;
+
+        public MemberAccessVisitor()
+        {
+        }
+
+        public override Expression Visit(Expression expr)
+        {
+            if (expr?.NodeType == ExpressionType.MemberAccess)
+            {
+                if (this.wasDictionaryAccess)
+                {
+                    this.wasDictionaryAccess = false;
+                }
+                else
+                {
+                    var memberExpr = (MemberExpression)expr;
+                    var jsonAttr = memberExpr.Member.GetCustomAttribute<JsonPropertyAttribute>();
+
+                    this.propertyNames.Add(jsonAttr?.PropertyName ?? memberExpr.Member.Name);
+                }
+            }
+            else if (expr?.NodeType == ExpressionType.Call)
+            {
+                var callExpr = (MethodCallExpression)expr;
+                if (callExpr.Method.Name == "get_Item" && callExpr.Arguments.Count == 1)
+                {
+                    var e = Expression.Lambda(callExpr.Arguments[0]).Compile();
+                    this.propertyNames.Add(e.DynamicInvoke().ToString());
+                    this.wasDictionaryAccess = callExpr.Arguments[0].NodeType == ExpressionType.MemberAccess;
+                }
+            }
+
+            return base.Visit(expr);
+        }
+    }
+}
diff --git a/FireBase/Offline/OfflineCacheAdapter.cs b/FireBase/Offline/OfflineCacheAdapter.cs
new file mode 100644
index 0000000..a3761a0
--- /dev/null
+++ b/FireBase/Offline/OfflineCacheAdapter.cs
@@ -0,0 +1,165 @@
+namespace Firebase.Database.Offline
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Linq;
+
+    internal class OfflineCacheAdapter<TKey, T> : IDictionary<string, T>, IDictionary 
+    {
+        private readonly IDictionary<string, OfflineEntry> database;
+
+        public OfflineCacheAdapter(IDictionary<string, OfflineEntry> database)
+        {
+            this.database = database;
+        }
+
+        public void CopyTo(Array array, int index)
+        {
+            throw new NotImplementedException();
+        }
+
+        public int Count => this.database.Count;
+
+        public bool IsSynchronized { get; }
+
+        public object SyncRoot { get; }
+
+        public bool IsReadOnly => this.database.IsReadOnly;
+
+        object IDictionary.this[object key]
+        {
+            get
+            {
+                return this.database[key.ToString()].Deserialize<T>();
+            }
+
+            set
+            {
+                var keyString = key.ToString();
+                if (this.database.ContainsKey(keyString))
+                {
+                    this.database[keyString] = new OfflineEntry(keyString, value, this.database[keyString].Priority, this.database[keyString].SyncOptions);
+                }
+                else
+                {
+                    this.database[keyString] = new OfflineEntry(keyString, value, 1, SyncOptions.None);
+                }
+            }
+        }
+
+        public ICollection<string> Keys => this.database.Keys;
+
+        ICollection IDictionary.Values { get; }
+
+        ICollection IDictionary.Keys { get; }
+
+        public ICollection<T> Values => this.database.Values.Select(o => o.Deserialize<T>()).ToList();
+
+        public T this[string key]
+        {
+            get
+            {
+                return this.database[key].Deserialize<T>();
+            }
+
+            set
+            {
+                if (this.database.ContainsKey(key))
+                {
+                    this.database[key] = new OfflineEntry(key, value, this.database[key].Priority, this.database[key].SyncOptions);
+                }
+                else
+                {
+                    this.database[key] = new OfflineEntry(key, value, 1, SyncOptions.None);
+                }
+            }
+        }
+
+        public bool Contains(object key)
+        {
+            return this.ContainsKey(key.ToString());
+        }
+
+        IDictionaryEnumerator IDictionary.GetEnumerator()
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Remove(object key)
+        {
+            this.Remove(key.ToString());
+        }
+
+        public bool IsFixedSize => false;
+
+        public IEnumerator<KeyValuePair<string, T>> GetEnumerator()
+        {
+            return this.database.Select(d => new KeyValuePair<string, T>(d.Key, d.Value.Deserialize<T>())).GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return this.GetEnumerator();
+        }
+
+        public void Add(KeyValuePair<string, T> item)
+        {
+            this.Add(item.Key, item.Value);
+        }
+
+        public void Add(object key, object value)
+        {
+            this.Add(key.ToString(), (T)value);
+        }
+
+        public void Clear()
+        {
+            this.database.Clear();
+        }
+
+        public bool Contains(KeyValuePair<string, T> item)
+        {
+            return this.ContainsKey(item.Key);
+        }
+
+        public void CopyTo(KeyValuePair<string, T>[] array, int arrayIndex)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool Remove(KeyValuePair<string, T> item)
+        {
+            return this.database.Remove(item.Key);
+        }
+
+        public void Add(string key, T value)
+        {
+            this.database.Add(key, new OfflineEntry(key, value, 1, SyncOptions.None));
+        }
+
+        public bool ContainsKey(string key)
+        {
+            return this.database.ContainsKey(key);
+        }
+
+        public bool Remove(string key)
+        {
+            return this.database.Remove(key);
+        }
+
+        public bool TryGetValue(string key, out T value)
+        {
+            OfflineEntry val;
+
+            if (this.database.TryGetValue(key, out val))
+            {
+                value = val.Deserialize<T>();
+                return true;
+            }
+
+            value = default(T);
+            return false;
+        }
+    }
+}
diff --git a/FireBase/Offline/OfflineDatabase.cs b/FireBase/Offline/OfflineDatabase.cs
new file mode 100644
index 0000000..9cebf9c
--- /dev/null
+++ b/FireBase/Offline/OfflineDatabase.cs
@@ -0,0 +1,201 @@
+namespace Firebase.Database.Offline
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Linq;
+
+    using LiteDB;
+
+    /// <summary>
+    /// The offline database.
+    /// </summary>
+    public class OfflineDatabase : IDictionary<string, OfflineEntry>
+    {
+        private readonly LiteRepository db;
+        private readonly IDictionary<string, OfflineEntry> cache;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="OfflineDatabase"/> class.
+        /// </summary>
+        /// <param name="itemType"> The item type which is used to determine the database file name.  </param>
+        /// <param name="filenameModifier"> Custom string which will get appended to the file name. </param>
+        public OfflineDatabase(Type itemType, string filenameModifier)
+        {
+            var fullName = this.GetFileName(itemType.ToString());
+            if(fullName.Length > 100)
+            {
+                fullName = fullName.Substring(0, 100);
+            }
+
+            BsonMapper mapper = BsonMapper.Global;
+            mapper.Entity<OfflineEntry>().Id(o => o.Key);
+
+            string root = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+            string filename = fullName + filenameModifier + ".db";
+            var path = Path.Combine(root, filename);
+            this.db = new LiteRepository(new LiteDatabase(path, mapper));
+
+            this.cache = db.Database.GetCollection<OfflineEntry>().FindAll()
+                .ToDictionary(o => o.Key, o => o);
+        }
+
+        /// <summary>
+        /// Gets the number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1"/>.
+        /// </summary>
+        /// <returns> The number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1"/>. </returns>
+        public int Count => this.cache.Count;
+
+        /// <summary>
+        /// Gets a value indicating whether this is a read-only collection.
+        /// </summary>
+        public bool IsReadOnly => this.cache.IsReadOnly;
+
+        /// <summary>
+        /// Gets an <see cref="T:System.Collections.Generic.ICollection`1"/> containing the keys of the <see cref="T:System.Collections.Generic.IDictionary`2"/>.
+        /// </summary>
+        /// <returns> An <see cref="T:System.Collections.Generic.ICollection`1"/> containing the keys of the object that implements <see cref="T:System.Collections.Generic.IDictionary`2"/>. </returns>
+        public ICollection<string> Keys => this.cache.Keys;
+
+        /// <summary>
+        /// Gets an <see cref="T:System.Collections.Generic.ICollection`1"/> containing the values in the <see cref="T:System.Collections.Generic.IDictionary`2"/>.
+        /// </summary>
+        /// <returns> An <see cref="T:System.Collections.Generic.ICollection`1"/> containing the values in the object that implements <see cref="T:System.Collections.Generic.IDictionary`2"/>. </returns>
+        public ICollection<OfflineEntry> Values => this.cache.Values;
+
+        /// <summary>
+        /// Gets or sets the element with the specified key.
+        /// </summary>
+        /// <param name="key">The key of the element to get or set.</param>
+        /// <returns> The element with the specified key. </returns>   
+        public OfflineEntry this[string key]
+        {
+            get
+            {
+                return this.cache[key];
+            }
+
+            set
+            {
+                this.cache[key] = value;
+                this.db.Upsert(value);
+            }
+        }
+
+        /// <summary>
+        /// Returns an enumerator that iterates through the collection.
+        /// </summary>
+        /// <returns> An enumerator that can be used to iterate through the collection. </returns>
+        public IEnumerator<KeyValuePair<string, OfflineEntry>> GetEnumerator()
+        {
+            return this.cache.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return this.GetEnumerator();
+        }
+
+        /// <summary>
+        /// Adds an item to the <see cref="T:System.Collections.Generic.ICollection`1"/>.
+        /// </summary>
+        /// <param name="item">The object to add to the <see cref="T:System.Collections.Generic.ICollection`1"/>.</param>
+        public void Add(KeyValuePair<string, OfflineEntry> item)
+        {
+            this.Add(item.Key, item.Value);
+        }
+
+        /// <summary>
+        /// Removes all items from the <see cref="T:System.Collections.Generic.ICollection`1"/>.
+        /// </summary> 
+        public void Clear()
+        {
+            this.cache.Clear();
+            this.db.Delete<OfflineEntry>(Query.All());
+        }
+
+        /// <summary>
+        /// Determines whether the <see cref="T:System.Collections.Generic.ICollection`1"/> contains a specific value.
+        /// </summary>
+        /// <param name="item">The object to locate in the <see cref="T:System.Collections.Generic.ICollection`1"/>.</param> 
+        /// <returns> True if <paramref name="item"/> is found in the <see cref="T:System.Collections.Generic.ICollection`1"/>; otherwise, false. </returns>
+        public bool Contains(KeyValuePair<string, OfflineEntry> item)
+        {
+            return this.ContainsKey(item.Key);
+        }
+
+        /// <summary>
+        /// Copies the elements of the <see cref="T:System.Collections.Generic.ICollection`1"/> to an <see cref="T:System.Array"/>, starting at a particular <see cref="T:System.Array"/> index.
+        /// </summary>
+        /// <param name="array">The one-dimensional <see cref="T:System.Array"/> that is the destination of the elements copied from <see cref="T:System.Collections.Generic.ICollection`1"/>. The <see cref="T:System.Array"/> must have zero-based indexing.</param>
+        /// <param name="arrayIndex">The zero-based index in <paramref name="array"/> at which copying begins.</param>
+        public void CopyTo(KeyValuePair<string, OfflineEntry>[] array, int arrayIndex)
+        {
+            this.cache.CopyTo(array, arrayIndex);
+        }
+
+        /// <summary>
+        /// Removes the first occurrence of a specific object from the <see cref="T:System.Collections.Generic.ICollection`1"/>.
+        /// </summary>
+        /// <param name="item">The object to remove from the <see cref="T:System.Collections.Generic.ICollection`1"/>.</param>
+        /// <returns> True if <paramref name="item"/> was successfully removed from the <see cref="T:System.Collections.Generic.ICollection`1"/>; otherwise, false. This method also returns false if <paramref name="item"/> is not found in the original <see cref="T:System.Collections.Generic.ICollection`1"/>. </returns>
+        public bool Remove(KeyValuePair<string, OfflineEntry> item)
+        {
+            return this.Remove(item.Key);
+        }
+
+        /// <summary>
+        /// Determines whether the <see cref="T:System.Collections.Generic.IDictionary`2"/> contains an element with the specified key.
+        /// </summary>
+        /// <param name="key">The key to locate in the <see cref="T:System.Collections.Generic.IDictionary`2"/>.</param>
+        /// <returns> True if the <see cref="T:System.Collections.Generic.IDictionary`2"/> contains an element with the key; otherwise, false. </returns>
+        public bool ContainsKey(string key)
+        {
+            return this.cache.ContainsKey(key);
+        }
+
+        /// <summary>
+        /// Adds an element with the provided key and value to the <see cref="T:System.Collections.Generic.IDictionary`2"/>.
+        /// </summary>
+        /// <param name="key">The object to use as the key of the element to add.</param>
+        /// <param name="value">The object to use as the value of the element to add.</param>
+        public void Add(string key, OfflineEntry value)
+        {
+            this.cache.Add(key, value);
+            this.db.Insert(value);
+        }
+
+        /// <summary>
+        /// Removes the element with the specified key from the <see cref="T:System.Collections.Generic.IDictionary`2"/>.
+        /// </summary>
+        /// <param name="key">The key of the element to remove.</param>
+        /// <returns> True if the element is successfully removed; otherwise, false.  This method also returns false if <paramref name="key"/> was not found in the original <see cref="T:System.Collections.Generic.IDictionary`2"/>. </returns>
+        public bool Remove(string key)
+        {
+            this.cache.Remove(key);
+            return this.db.Delete<OfflineEntry>(key);
+        }
+
+        /// <summary>
+        /// Gets the value associated with the specified key.
+        /// </summary> 
+        /// <param name="key">The key whose value to get.</param><param name="value">When this method returns, the value associated with the specified key, if the key is found; otherwise, the default value for the type of the <paramref name="value"/> parameter. This parameter is passed uninitialized.</param>
+        /// <returns> True if the object that implements <see cref="T:System.Collections.Generic.IDictionary`2"/> contains an element with the specified key; otherwise, false. </returns>
+        public bool TryGetValue(string key, out OfflineEntry value)
+        {
+            return this.cache.TryGetValue(key, out value);
+        }
+
+        private string GetFileName(string fileName)
+        {
+            var invalidChars = new[] { '`', '[', ',', '=' };
+            foreach(char c in invalidChars.Concat(System.IO.Path.GetInvalidFileNameChars()).Distinct())
+            {
+                fileName = fileName.Replace(c, '_');
+            }
+
+            return fileName;
+        }
+    }
+}
diff --git a/FireBase/Offline/OfflineEntry.cs b/FireBase/Offline/OfflineEntry.cs
new file mode 100644
index 0000000..3b862cb
--- /dev/null
+++ b/FireBase/Offline/OfflineEntry.cs
@@ -0,0 +1,116 @@
+namespace Firebase.Database.Offline
+{
+    using System;
+
+    using Newtonsoft.Json;
+
+    /// <summary>
+    /// Represents an object stored in offline storage.
+    /// </summary>
+    public class OfflineEntry
+    {
+        private object dataInstance;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="OfflineEntry"/> class with an already serialized object.
+        /// </summary>
+        /// <param name="key"> The key. </param>
+        /// <param name="obj"> The object. </param>
+        /// <param name="priority"> The priority. Objects with higher priority will be synced first. Higher number indicates higher priority. </param>  
+        /// <param name="syncOptions"> The sync options. </param>
+        public OfflineEntry(string key, object obj, string data, int priority, SyncOptions syncOptions, bool isPartial = false)
+        {
+            this.Key = key;
+            this.Priority = priority;
+            this.Data = data;
+            this.Timestamp = DateTime.UtcNow;
+            this.SyncOptions = syncOptions;
+            this.IsPartial = isPartial;
+
+            this.dataInstance = obj;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="OfflineEntry"/> class.
+        /// </summary>
+        /// <param name="key"> The key. </param>
+        /// <param name="obj"> The object. </param>
+        /// <param name="priority"> The priority. Objects with higher priority will be synced first. Higher number indicates higher priority. </param>  
+        /// <param name="syncOptions"> The sync options. </param>
+        public OfflineEntry(string key, object obj, int priority, SyncOptions syncOptions, bool isPartial = false)
+            : this(key, obj, JsonConvert.SerializeObject(obj), priority, syncOptions, isPartial)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="OfflineEntry"/> class.
+        /// </summary>
+        public OfflineEntry() 
+        {
+        }
+
+        /// <summary>
+        /// Gets or sets the key of this entry.
+        /// </summary>
+        public string Key
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Gets or sets the priority. Objects with higher priority will be synced first. Higher number indicates higher priority. 
+        /// </summary>
+        public int Priority 
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Gets or sets the timestamp when this entry was last touched.
+        /// </summary>
+        public DateTime Timestamp
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Gets or sets the <see cref="SyncOptions"/> which define what sync state this entry is in.
+        /// </summary>
+        public SyncOptions SyncOptions
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Gets or sets serialized JSON data. 
+        /// </summary>
+        public string Data
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Specifies whether this is only a partial object.
+        /// </summary>
+        public bool IsPartial
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Deserializes <see cref="Data"/> into <typeparamref name="T"/>. The result is cached.
+        /// </summary>
+        /// <typeparam name="T"> Type of object to deserialize into. </typeparam>
+        /// <returns> Instance of <typeparamref name="T"/>. </returns>
+        public T Deserialize<T>()
+        {
+            return (T)(this.dataInstance ?? (this.dataInstance = JsonConvert.DeserializeObject<T>(this.Data)));
+        }
+    }
+}
diff --git a/FireBase/Offline/RealtimeDatabase.cs b/FireBase/Offline/RealtimeDatabase.cs
new file mode 100644
index 0000000..61a7010
--- /dev/null
+++ b/FireBase/Offline/RealtimeDatabase.cs
@@ -0,0 +1,459 @@
+namespace Firebase.Database.Offline
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Reactive.Linq;
+    using System.Reactive.Subjects;
+    using System.Threading;
+    using System.Threading.Tasks;
+
+    using Firebase.Database.Extensions;
+    using Firebase.Database.Query;
+    using Firebase.Database.Streaming;
+    using System.Reactive.Threading.Tasks;
+    using System.Linq.Expressions;
+    using Internals;
+    using Newtonsoft.Json;
+    using System.Reflection;
+    using System.Reactive.Disposables;
+
+    /// <summary>
+    /// The real-time Database which synchronizes online and offline data. 
+    /// </summary>
+    /// <typeparam name="T"> Type of entities. </typeparam>
+    public partial class RealtimeDatabase<T> : IDisposable where T : class
+    {
+        private readonly ChildQuery childQuery;
+        private readonly string elementRoot;
+        private readonly StreamingOptions streamingOptions;
+        private readonly Subject<FirebaseEvent<T>> subject;
+        private readonly InitialPullStrategy initialPullStrategy;
+        private readonly bool pushChanges;
+        private readonly FirebaseCache<T> firebaseCache;
+
+        private bool isSyncRunning;
+        private IObservable<FirebaseEvent<T>> observable;
+        private FirebaseSubscription<T> firebaseSubscription;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RealtimeDatabase{T}"/> class.
+        /// </summary>
+        /// <param name="childQuery"> The child query.  </param>
+        /// <param name="elementRoot"> The element Root. </param>
+        /// <param name="offlineDatabaseFactory"> The offline database factory.  </param>
+        /// <param name="filenameModifier"> Custom string which will get appended to the file name.  </param>
+        /// <param name="streamChanges"> Specifies whether changes should be streamed from the server.  </param>
+        /// <param name="pullEverythingOnStart"> Specifies if everything should be pull from the online storage on start. It only makes sense when <see cref="streamChanges"/> is set to true. </param>
+        /// <param name="pushChanges"> Specifies whether changed items should actually be pushed to the server. If this is false, then Put / Post / Delete will not affect server data. </param>
+        public RealtimeDatabase(ChildQuery childQuery, string elementRoot, Func<Type, string, IDictionary<string, OfflineEntry>> offlineDatabaseFactory, string filenameModifier, StreamingOptions streamingOptions, InitialPullStrategy initialPullStrategy, bool pushChanges, ISetHandler<T> setHandler = null)
+        {
+            this.childQuery = childQuery;
+            this.elementRoot = elementRoot;
+            this.streamingOptions = streamingOptions;
+            this.initialPullStrategy = initialPullStrategy;
+            this.pushChanges = pushChanges;
+            this.Database = offlineDatabaseFactory(typeof(T), filenameModifier);
+            this.firebaseCache = new FirebaseCache<T>(new OfflineCacheAdapter<string, T>(this.Database));
+            this.subject = new Subject<FirebaseEvent<T>>();
+
+            this.PutHandler = setHandler ?? new SetHandler<T>();
+
+            this.isSyncRunning = true;
+            Task.Factory.StartNew(this.SynchronizeThread, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default);
+        }
+
+        /// <summary>
+        /// Event raised whenever an exception is thrown in the synchronization thread. Exception thrown in there are swallowed, so this event is the only way to get to them. 
+        /// </summary>
+        public event EventHandler<ExceptionEventArgs> SyncExceptionThrown;
+
+        /// <summary>
+        /// Gets the backing Database.
+        /// </summary>
+        public IDictionary<string, OfflineEntry> Database
+        {
+            get;
+            private set;
+        }
+
+        public ISetHandler<T> PutHandler
+        {
+            private get;
+            set;
+        }
+
+        /// <summary>
+        /// Overwrites existing object with given key.
+        /// </summary>
+        /// <param name="key"> The key. </param>
+        /// <param name="obj"> The object to set. </param>
+        /// <param name="syncOnline"> Indicates whether the item should be synced online. </param>
+        /// <param name="priority"> The priority. Objects with higher priority will be synced first. Higher number indicates higher priority. </param>
+        public void Set(string key, T obj, SyncOptions syncOptions, int priority = 1)
+        {
+            this.SetAndRaise(key, new OfflineEntry(key, obj, priority, syncOptions));
+        }
+
+        public void Set<TProperty>(string key, Expression<Func<T, TProperty>> propertyExpression, object value, SyncOptions syncOptions, int priority = 1)
+        {
+            var fullKey = this.GenerateFullKey(key, propertyExpression, syncOptions);
+            var serializedObject = JsonConvert.SerializeObject(value).Trim('"', '\\');
+
+            if (fullKey.Item3)
+            {
+                if (typeof(TProperty) != typeof(string) || value == null)
+                {
+                    // don't escape non-string primitives and null;
+                    serializedObject = $"{{ \"{fullKey.Item2}\" : {serializedObject} }}";
+                }
+                else
+                {
+                    serializedObject = $"{{ \"{fullKey.Item2}\" : \"{serializedObject}\" }}";
+                }
+            }
+
+            var setObject = this.firebaseCache.PushData("/" + fullKey.Item1, serializedObject).First();
+
+            if (!this.Database.ContainsKey(key) || this.Database[key].SyncOptions != SyncOptions.Patch && this.Database[key].SyncOptions != SyncOptions.Put)
+            {
+                this.Database[fullKey.Item1] = new OfflineEntry(fullKey.Item1, value, serializedObject, priority, syncOptions, true);
+            }
+
+            this.subject.OnNext(new FirebaseEvent<T>(key, setObject.Object, setObject == null ? FirebaseEventType.Delete : FirebaseEventType.InsertOrUpdate, FirebaseEventSource.Offline));
+        }
+
+        /// <summary>
+        /// Fetches an object with the given key and adds it to the Database.
+        /// </summary>
+        /// <param name="key"> The key. </param>
+        /// <param name="priority"> The priority. Objects with higher priority will be synced first. Higher number indicates higher priority. </param>
+        public void Pull(string key, int priority = 1)
+        {
+            if (!this.Database.ContainsKey(key))
+            {
+                this.Database[key] = new OfflineEntry(key, null, priority, SyncOptions.Pull);
+            }
+            else if (this.Database[key].SyncOptions == SyncOptions.None)
+            {
+                // pull only if push isn't pending
+                this.Database[key].SyncOptions = SyncOptions.Pull;
+            }
+        }
+
+        /// <summary>
+        /// Fetches everything from the remote database.
+        /// </summary>
+        public async Task PullAsync()
+        {
+            var existingEntries = await this.childQuery
+                .OnceAsync<T>()
+                .ToObservable()
+                .RetryAfterDelay<IReadOnlyCollection<FirebaseObject<T>>, FirebaseException>(
+                    this.childQuery.Client.Options.SyncPeriod,
+                    ex => ex.StatusCode == System.Net.HttpStatusCode.OK) // OK implies the request couldn't complete due to network error. 
+                .Select(e => this.ResetDatabaseFromInitial(e, false))
+                .SelectMany(e => e)
+                .Do(e => 
+                {
+                    this.Database[e.Key] = new OfflineEntry(e.Key, e.Object, 1, SyncOptions.None);
+                    this.subject.OnNext(new FirebaseEvent<T>(e.Key, e.Object, FirebaseEventType.InsertOrUpdate, FirebaseEventSource.OnlinePull));
+                })
+                .ToList();
+
+            // Remove items not stored online
+            foreach (var item in this.Database.Keys.Except(existingEntries.Select(f => f.Key)).ToList())
+            {
+                this.Database.Remove(item);
+                this.subject.OnNext(new FirebaseEvent<T>(item, null, FirebaseEventType.Delete, FirebaseEventSource.OnlinePull));
+            }
+        }
+
+        /// <summary>
+        /// Retrieves all offline items currently stored in local database.
+        /// </summary>
+        public IEnumerable<FirebaseObject<T>> Once()
+        {
+            return this.Database
+                .Where(kvp => !string.IsNullOrEmpty(kvp.Value.Data) && kvp.Value.Data != "null" && !kvp.Value.IsPartial)
+                .Select(kvp => new FirebaseObject<T>(kvp.Key, kvp.Value.Deserialize<T>()))
+                .ToList();
+        }
+
+        /// <summary> 
+        /// Starts observing the real-time Database. Events will be fired both when change is done locally and remotely.
+        /// </summary> 
+        /// <returns> Stream of <see cref="FirebaseEvent{T}"/>. </returns>
+        public IObservable<FirebaseEvent<T>> AsObservable()
+        {
+            if (!this.isSyncRunning)
+            {
+                this.isSyncRunning = true;
+                Task.Factory.StartNew(this.SynchronizeThread, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default);
+            }
+
+            if (this.observable == null)
+            {
+                var initialData = Observable.Return(FirebaseEvent<T>.Empty(FirebaseEventSource.Offline));
+                if(this.Database.TryGetValue(this.elementRoot, out OfflineEntry oe))
+                {
+                    initialData = Observable.Return(oe)
+                        .Where(offlineEntry => !string.IsNullOrEmpty(offlineEntry.Data) && offlineEntry.Data != "null" && !offlineEntry.IsPartial)
+                        .Select(offlineEntry => new FirebaseEvent<T>(offlineEntry.Key, offlineEntry.Deserialize<T>(), FirebaseEventType.InsertOrUpdate, FirebaseEventSource.Offline));
+                }
+                else if(this.Database.Count > 0)
+                {
+                    initialData = this.Database
+                        .Where(kvp => !string.IsNullOrEmpty(kvp.Value.Data) && kvp.Value.Data != "null" && !kvp.Value.IsPartial)
+                        .Select(kvp => new FirebaseEvent<T>(kvp.Key, kvp.Value.Deserialize<T>(), FirebaseEventType.InsertOrUpdate, FirebaseEventSource.Offline))
+                        .ToList()
+                        .ToObservable();
+                }
+
+                this.observable = initialData
+                    .Merge(this.subject)
+                    .Merge(this.GetInitialPullObservable()
+                            .RetryAfterDelay<IReadOnlyCollection<FirebaseObject<T>>, FirebaseException>(
+                                this.childQuery.Client.Options.SyncPeriod, 
+                                ex => ex.StatusCode == System.Net.HttpStatusCode.OK) // OK implies the request couldn't complete due to network error. 
+                            .Select(e => this.ResetDatabaseFromInitial(e))
+                            .SelectMany(e => e)
+                            .Do(this.SetObjectFromInitialPull)
+                            .Select(e => new FirebaseEvent<T>(e.Key, e.Object, e.Object == null ? FirebaseEventType.Delete : FirebaseEventType.InsertOrUpdate, FirebaseEventSource.OnlineInitial))
+                            .Concat(Observable.Create<FirebaseEvent<T>>(observer => this.InitializeStreamingSubscription(observer))))
+                            .Do(next => { }, e => this.observable = null, () => this.observable = null)
+                    .Replay()
+                    .RefCount();
+            }
+
+            return this.observable;
+        }
+
+        public void Dispose()
+        {
+            this.subject.OnCompleted();
+            this.firebaseSubscription?.Dispose();
+        }
+
+        private IReadOnlyCollection<FirebaseObject<T>> ResetDatabaseFromInitial(IReadOnlyCollection<FirebaseObject<T>> collection, bool onlyWhenInitialEverything = true)
+        {
+            if (onlyWhenInitialEverything && this.initialPullStrategy != InitialPullStrategy.Everything)
+            {
+                return collection;
+            }
+
+            // items which are in local db, but not in the online collection
+            var extra = this.Once()
+                            .Select(f => f.Key)
+                            .Except(collection.Select(c => c.Key))
+                            .Select(k => new FirebaseObject<T>(k, null));
+
+            return collection.Concat(extra).ToList();
+        }
+
+        private void SetObjectFromInitialPull(FirebaseObject<T> e)
+        {
+            // set object with no sync only if it doesn't exist yet 
+            // and the InitialPullStrategy != Everything
+            // this attempts to deal with scenario when you are offline, have local changes and go online
+            // in this case having the InitialPullStrategy set to everything would basically purge all local changes
+            if (!this.Database.ContainsKey(e.Key) || this.Database[e.Key].SyncOptions == SyncOptions.None || this.Database[e.Key].SyncOptions == SyncOptions.Pull || this.initialPullStrategy != InitialPullStrategy.Everything)
+            {
+                this.Database[e.Key] = new OfflineEntry(e.Key, e.Object, 1, SyncOptions.None);
+            }
+        }
+
+        private IObservable<IReadOnlyCollection<FirebaseObject<T>>> GetInitialPullObservable()
+        {
+            FirebaseQuery query;
+            switch (this.initialPullStrategy)
+            {
+                case InitialPullStrategy.MissingOnly:
+                    query = this.childQuery.OrderByKey().StartAt(() => this.GetLatestKey());
+                    break;
+                case InitialPullStrategy.Everything:
+                    query = this.childQuery;
+                    break;
+                case InitialPullStrategy.None:
+                default:
+                    return Observable.Empty<IReadOnlyCollection<FirebaseEvent<T>>>();
+            }
+
+            if (string.IsNullOrWhiteSpace(this.elementRoot))
+            {
+                return Observable.Defer(() => query.OnceAsync<T>().ToObservable());
+            }
+            
+            // there is an element root, which indicates the target location is not a collection but a single element
+            return Observable.Defer(async () => Observable.Return(await query.OnceSingleAsync<T>()).Select(e => new[] { new FirebaseObject<T>(this.elementRoot, e) }));
+        }
+
+        private IDisposable InitializeStreamingSubscription(IObserver<FirebaseEvent<T>> observer)
+        {
+            var completeDisposable = Disposable.Create(() => this.isSyncRunning = false);
+
+            switch (this.streamingOptions)
+            {
+                case StreamingOptions.LatestOnly:
+                    // stream since the latest key
+                    var queryLatest = this.childQuery.OrderByKey().StartAt(() => this.GetLatestKey());
+                    this.firebaseSubscription = new FirebaseSubscription<T>(observer, queryLatest, this.elementRoot, this.firebaseCache);
+                    this.firebaseSubscription.ExceptionThrown += this.StreamingExceptionThrown;
+
+                    return new CompositeDisposable(this.firebaseSubscription.Run(), completeDisposable);
+                case StreamingOptions.Everything:
+                    // stream everything
+                    var queryAll = this.childQuery;
+                    this.firebaseSubscription = new FirebaseSubscription<T>(observer, queryAll, this.elementRoot, this.firebaseCache);
+                    this.firebaseSubscription.ExceptionThrown += this.StreamingExceptionThrown;
+
+                    return new CompositeDisposable(this.firebaseSubscription.Run(), completeDisposable);
+                default:
+                    break;
+            }
+
+            return completeDisposable;
+        }
+
+        private void SetAndRaise(string key, OfflineEntry obj, FirebaseEventSource eventSource = FirebaseEventSource.Offline)
+        {
+            this.Database[key] = obj;
+            this.subject.OnNext(new FirebaseEvent<T>(key, obj?.Deserialize<T>(), string.IsNullOrEmpty(obj?.Data) || obj?.Data == "null" ? FirebaseEventType.Delete : FirebaseEventType.InsertOrUpdate, eventSource));
+        }
+
+        private async void SynchronizeThread()
+        {
+            while (this.isSyncRunning)
+            {
+                try
+                {
+                    var validEntries = this.Database.Where(e => e.Value != null);
+                    await this.PullEntriesAsync(validEntries.Where(kvp => kvp.Value.SyncOptions == SyncOptions.Pull));
+
+                    if (this.pushChanges)
+                    {
+                        await this.PushEntriesAsync(validEntries.Where(kvp => kvp.Value.SyncOptions == SyncOptions.Put || kvp.Value.SyncOptions == SyncOptions.Patch));
+                    }
+                }
+                catch (Exception ex)
+                {
+                    this.SyncExceptionThrown?.Invoke(this, new ExceptionEventArgs(ex));
+                }
+
+                await Task.Delay(this.childQuery.Client.Options.SyncPeriod);
+            }
+        }
+
+        private string GetLatestKey()
+        {
+            var key = this.Database.OrderBy(o => o.Key, StringComparer.Ordinal).LastOrDefault().Key ?? string.Empty;
+
+            if (!string.IsNullOrWhiteSpace(key))
+            {
+                key = key.Substring(0, key.Length - 1) + (char)(key[key.Length - 1] + 1);
+            }
+
+            return key;
+        }
+
+        private async Task PushEntriesAsync(IEnumerable<KeyValuePair<string, OfflineEntry>> pushEntries)
+        {
+            var groups = pushEntries.GroupBy(pair => pair.Value.Priority).OrderByDescending(kvp => kvp.Key).ToList();
+
+            foreach (var group in groups)
+            {
+                var tasks = group.OrderBy(kvp => kvp.Value.IsPartial).Select(kvp => 
+                    kvp.Value.IsPartial ?
+                    this.ResetSyncAfterPush(this.PutHandler.SetAsync(this.childQuery, kvp.Key, kvp.Value), kvp.Key) :
+                    this.ResetSyncAfterPush(this.PutHandler.SetAsync(this.childQuery, kvp.Key, kvp.Value), kvp.Key, kvp.Value.Deserialize<T>()));
+
+                try
+                {
+                    await Task.WhenAll(tasks).WithAggregateException();
+                }
+                catch (Exception ex)
+                {
+                    this.SyncExceptionThrown?.Invoke(this, new ExceptionEventArgs(ex));
+                }
+            }
+        }
+
+        private async Task PullEntriesAsync(IEnumerable<KeyValuePair<string, OfflineEntry>> pullEntries)
+        {
+            var taskGroups = pullEntries.GroupBy(pair => pair.Value.Priority).OrderByDescending(kvp => kvp.Key);
+
+            foreach (var group in taskGroups)
+            {
+                var tasks = group.Select(pair => this.ResetAfterPull(this.childQuery.Child(pair.Key == this.elementRoot ? string.Empty : pair.Key).OnceSingleAsync<T>(), pair.Key, pair.Value));
+
+                try
+                { 
+                    await Task.WhenAll(tasks).WithAggregateException();
+                }
+                catch (Exception ex)
+                {
+                    this.SyncExceptionThrown?.Invoke(this, new ExceptionEventArgs(ex));
+                }
+            }
+        }
+
+        private async Task ResetAfterPull(Task<T> task, string key, OfflineEntry entry)
+        {
+            await task;
+            this.SetAndRaise(key, new OfflineEntry(key, task.Result, entry.Priority, SyncOptions.None), FirebaseEventSource.OnlinePull);
+        }
+
+        private async Task ResetSyncAfterPush(Task task, string key, T obj)
+        {
+            await this.ResetSyncAfterPush(task, key);
+
+            if (this.streamingOptions == StreamingOptions.None)
+            {
+                this.subject.OnNext(new FirebaseEvent<T>(key, obj, obj == null ? FirebaseEventType.Delete : FirebaseEventType.InsertOrUpdate, FirebaseEventSource.OnlinePush));
+            }
+        }
+
+        private async Task ResetSyncAfterPush(Task task, string key)
+        {
+            await task;
+            this.ResetSyncOptions(key);
+        }
+
+        private void ResetSyncOptions(string key)
+        {
+            var item = this.Database[key];
+
+            if (item.IsPartial)
+            {
+                this.Database.Remove(key);
+            }
+            else
+            {
+                item.SyncOptions = SyncOptions.None;
+                this.Database[key] = item;
+            }
+        }
+
+        private void StreamingExceptionThrown(object sender, ExceptionEventArgs<FirebaseException> e)
+        {
+            this.SyncExceptionThrown?.Invoke(this, new ExceptionEventArgs(e.Exception));
+        }
+
+        private Tuple<string, string, bool> GenerateFullKey<TProperty>(string key, Expression<Func<T, TProperty>> propertyGetter, SyncOptions syncOptions)
+        {
+            var visitor = new MemberAccessVisitor();
+            visitor.Visit(propertyGetter);
+            var propertyType = typeof(TProperty).GetTypeInfo();
+            var prefix = key == string.Empty ? string.Empty : key + "/";
+
+            // primitive types
+            if (syncOptions == SyncOptions.Patch && (propertyType.IsPrimitive || Nullable.GetUnderlyingType(typeof(TProperty)) != null || typeof(TProperty) == typeof(string)))
+            {
+                return Tuple.Create(prefix + string.Join("/", visitor.PropertyNames.Skip(1).Reverse()), visitor.PropertyNames.First(), true);
+            }
+
+            return Tuple.Create(prefix + string.Join("/", visitor.PropertyNames.Reverse()), visitor.PropertyNames.First(), false);
+        }
+
+    }
+}
diff --git a/FireBase/Offline/SetHandler.cs b/FireBase/Offline/SetHandler.cs
new file mode 100644
index 0000000..1efa7b6
--- /dev/null
+++ b/FireBase/Offline/SetHandler.cs
@@ -0,0 +1,24 @@
+namespace Firebase.Database.Offline
+{
+    using Firebase.Database.Query;
+
+    using System.Threading.Tasks;
+
+    public class SetHandler<T> : ISetHandler<T>
+    {
+        public virtual async Task SetAsync(ChildQuery query, string key, OfflineEntry entry)
+        {
+            using (var child = query.Child(key))
+            {
+                if (entry.SyncOptions == SyncOptions.Put)
+                {
+                    await child.PutAsync(entry.Data);
+                }
+                else
+                {
+                    await child.PatchAsync(entry.Data);
+                }
+            }
+        }
+    }
+}
diff --git a/FireBase/Offline/StreamingOptions.cs b/FireBase/Offline/StreamingOptions.cs
new file mode 100644
index 0000000..9ed4e54
--- /dev/null
+++ b/FireBase/Offline/StreamingOptions.cs
@@ -0,0 +1,21 @@
+namespace Firebase.Database.Offline
+{
+    public enum StreamingOptions
+    {
+        /// <summary>
+        /// No realtime streaming.
+        /// </summary>
+        None,
+
+        /// <summary>
+        /// Streaming of only new items - not the existing ones.
+        /// </summary>
+        LatestOnly,
+
+        /// <summary>
+        /// Streaming of all items. This will also pull all existing items on start, so be mindful about the number of items in your DB. 
+        /// When used, consider not setting the <see cref="InitialPullStrategy"/> to <see cref="InitialPullStrategy.Everything"/> because you would pointlessly pull everything twice.
+        /// </summary>
+        Everything
+    }
+}
diff --git a/FireBase/Offline/SyncOptions.cs b/FireBase/Offline/SyncOptions.cs
new file mode 100644
index 0000000..b2f382a
--- /dev/null
+++ b/FireBase/Offline/SyncOptions.cs
@@ -0,0 +1,28 @@
+namespace Firebase.Database.Offline
+{
+    /// <summary>
+    /// Specifies type of sync requested for given data.
+    /// </summary>
+    public enum SyncOptions
+    {
+        /// <summary>
+        /// No sync needed for given data. 
+        /// </summary>
+        None,
+
+        /// <summary>
+        /// Data should be pulled from firebase.
+        /// </summary>
+        Pull,
+
+        /// <summary>
+        /// Data should be put to firebase.
+        /// </summary>
+        Put,
+
+        /// <summary>
+        /// Data should be patched in firebase.
+        /// </summary>
+        Patch
+    }
+}