diff --git a/MongoDB.FSharp.Tests/AcceptanceTests.fs b/MongoDB.FSharp.Tests/AcceptanceTests.fs
index 23f7475..f3ad802 100644
--- a/MongoDB.FSharp.Tests/AcceptanceTests.fs
+++ b/MongoDB.FSharp.Tests/AcceptanceTests.fs
@@ -7,14 +7,14 @@ open MongoDB.Bson
 open MongoDB.Driver
 open MongoDB.Driver.Linq
 
-open MongoDB.FSharp
+open MongoDB.Driver.FSharp
 open System.Linq
 open Microsoft.FSharp.Linq
 
 open TestUtils
 
 type ObjectWithList() =
-    member val Id : BsonObjectId = BsonObjectId.GenerateNewId() with get, set
+    member val Id : BsonObjectId = BsonObjectId(ObjectId.GenerateNewId()) with get, set
     member val List : string list = [] with get, set
 
 type RecordType = {
@@ -41,91 +41,98 @@ type DimmerSwitch =
     | On
 
 type ObjectWithOptions() =
-    member val Id : BsonObjectId = BsonObjectId.GenerateNewId() with get, set
+    member val Id : BsonObjectId = BsonObjectId(ObjectId.GenerateNewId()) with get, set
     member val Age : int option = None with get, set
 
 type ObjectWithDimmer() =
-    member val Id : BsonObjectId = BsonObjectId.GenerateNewId() with get, set
+    member val Id : BsonObjectId = BsonObjectId(ObjectId.GenerateNewId()) with get, set
     member val Switch : DimmerSwitch = Off with get, set
 
 type ObjectWithDimmers() =
-    member val Id : BsonObjectId = BsonObjectId.GenerateNewId() with get, set
+    member val Id : BsonObjectId = BsonObjectId(ObjectId.GenerateNewId()) with get, set
     member val Kitchen : DimmerSwitch = Off with get, set
     member val Bedroom1 : DimmerSwitch = Off with get, set
     member val Bedroom2 : DimmerSwitch = Off with get, set
 
 type ``When serializing lists``() = 
-    let db = MongoDatabase.Create "mongodb://localhost/test"
+    let conn = new MongoClient("mongodb://localhost")
+    let db = conn.GetDatabase("test")
     do
         Serializers.Register()
 
     interface System.IDisposable with
         member this.Dispose() = 
-            db.DropCollection "objects" |> ignore
-            db.DropCollection "persons" |> ignore
+            ()
+            db.DropCollectionAsync "objects" |> AwaitVoidTask |> ignore
+            db.DropCollectionAsync "persons" |> AwaitVoidTask |> ignore
 
     /// Seems to be fixed in version 1.5 of the C# driver
     [<Fact>]
     member this.``It can serialize an object with a list``() =
-        let collection = db.GetCollection<ObjectWithList> "objects"
-        let obj = ObjectWithList()
-        obj.List <- [ "hello"; "world" ]
-        collection.Save obj |> ignore
-
-        let genCollection = db.GetCollection "objects"
-        let fromDb = genCollection.FindOne(new QueryDocument("_id", obj.Id))
-        let array = fromDb.["List"].AsBsonArray
-        Assert.Equal(2, array.Count)
+            let collection = db.GetCollection<ObjectWithList> "objects"
+            let obj = ObjectWithList()
+            obj.List <- [ "hello"; "world" ]
+            collection.InsertOneAsync obj |> AwaitVoidTask |> Async.RunSynchronously
+
+            let genCollection = db.GetCollection<ObjectWithList> "objects"
+            let fromDb = genCollection.Find(fun x -> x.Id = obj.Id).FirstAsync() 
+                            |> Async.AwaitTask |> Async.RunSynchronously
+            let array = fromDb.List
+            Assert.Equal(2, array.Length)
         
     [<Fact>]
-    member this.``It can deserialze lists``() =
-        let list = BsonArray([ "hello"; "world" ])
-        let id = BsonObjectId.GenerateNewId()
-        let document = BsonDocument([ BsonElement("_id", id); BsonElement("List", list) ])
-        let collection = db.GetCollection "objects"
-        collection.Save document |> ignore
-
-        let collection = db.GetCollection<ObjectWithList> "objects"
-        let fromDb = collection.FindOne(new QueryDocument("_id", id))
-        let array = fromDb.List
-        Assert.Equal(2, array.Length)
+    member this.``It can deserialze lists``() =        
+            let list = BsonArray([ "hello"; "world" ])
+            let id = BsonObjectId(ObjectId.GenerateNewId())
+            let document = BsonDocument([ BsonElement("_id", id); BsonElement("List", list) ])
+            let collection = db.GetCollection "objects"
+            collection.InsertOneAsync document |> AwaitVoidTask |> Async.RunSynchronously
+
+            let collection = db.GetCollection<ObjectWithList> "objects"
+            let fromDb = collection.Find(fun x -> x.Id = id).FirstAsync() 
+                            |> Async.AwaitTask |> Async.RunSynchronously
+            let array = fromDb.List
+            Assert.Equal(2, array.Length)
 
     [<Fact>]
     member this.``It can serialize records``() =
-        let collection = db.GetCollection<RecordType> "objects"
-        let obj = { Id = BsonObjectId.GenerateNewId(); Name = "test"  }
-        collection.Save obj |> ignore
+            let collection = db.GetCollection<RecordType> "objects"
+            let obj = { Id = BsonObjectId(ObjectId.GenerateNewId()); Name = "test"  }
+            collection.InsertOneAsync obj |> AwaitVoidTask |> ignore
 
-        let genCollection = db.GetCollection "objects"
-        let fromDb = genCollection.FindOne(new QueryDocument("_id", obj.Id))
-        let test = fromDb.["Name"].AsString
-        Assert.Equal<string>("test", test)
+            let fromDb = collection.Find(fun x -> x.Id = obj.Id).FirstAsync() 
+                                    |> Async.AwaitTask 
+                                    |> Async.RunSynchronously
+            Assert.Equal<string>("test", fromDb.Name)
 
     [<Fact>]
     member this.``It can deserialize records``() =
-        let id = BsonObjectId.GenerateNewId()
+        let id = BsonObjectId(ObjectId.GenerateNewId())
         let document = BsonDocument([BsonElement("_id", id); BsonElement("Name", BsonString("value"))])
         let collection = db.GetCollection "objects"
-        collection.Save(document) |> ignore
+        collection.InsertOneAsync(document) |> AwaitVoidTask |> Async.RunSynchronously
 
         let collection = db.GetCollection<RecordType>("objects")
-        let fromDb = collection.FindOneById(id)
+        let fromDb = collection.Find(fun x -> x.Id = id).FirstAsync() 
+                                    |> Async.AwaitTask 
+                                    |> Async.RunSynchronously
         Assert.NotNull(fromDb)
         Assert.Equal<string>("value", fromDb.Name)
 
     [<Fact>]
     member this.``It can serialize and deserialize nested records``() =
         let collection = db.GetCollection<Person> "persons"
-        let obj = { Id = BsonObjectId.GenerateNewId(); PersonName = "test"; Age = 33; Childs = [{ChildName = "Adrian"; Age = 3}] }
-        collection.Save obj |> ignore
+        let obj = { Id = BsonObjectId(ObjectId.GenerateNewId()); 
+                    PersonName = "test"; 
+                    Age = 33; 
+                    Childs = [{ChildName = "Adrian";
+                    Age = 3}] }
+        collection.InsertOneAsync obj |> AwaitVoidTask |> Async.RunSynchronously
 
         let genCollection = db.GetCollection<Person> "persons"
-        let person = query { 
-            for p in genCollection.AsQueryable() do 
-            where (p.Id = obj.Id) 
-            select p
-            headOrDefault
-        }
+        let person = genCollection.Find(fun x -> x.Id = obj.Id).FirstAsync()  
+                        |> Async.AwaitTask
+                        |> Async.RunSynchronously
 
         Assert.NotNull person
         Assert.Equal<string>("test",person.PersonName)
@@ -135,7 +142,7 @@ type ``When serializing lists``() =
         let child = person.Childs |> Seq.head
 
         Assert.Equal<string>("Adrian", child.ChildName)
-        Assert.Equal<int>(3, child.Age)
+        Assert.Equal<int>(3, child.Age) 
 
 
     [<Fact>]
@@ -143,13 +150,19 @@ type ``When serializing lists``() =
         let collection = db.GetCollection<ObjectWithOptions> "objects"
         let obj = ObjectWithOptions()
         obj.Age <- Some 42
-        collection.Save obj |> ignore
+        collection.InsertOneAsync obj 
+            |> AwaitVoidTask
+            |> Async.RunSynchronously
 
         let collection = db.GetCollection "objects"
-        let fromDb = collection.FindOneById(obj.Id)
+        let filter = new BsonDocumentFilterDefinition<_>(new BsonDocument() 
+                                                            |> (fun d -> d.Add("_id",obj.Id)))
+        let fromDb = collection.Find<BsonDocument>(filter).FirstAsync() 
+                                                    |> Async.AwaitTask
+                                                    |> Async.RunSynchronously
         let age = fromDb.GetElement("Age")
         Assert.NotNull(age);
-        Assert.Equal<string>("Some", age.Value.AsBsonDocument.GetElement("_t").Value.AsString)
+        Assert.Equal<string>("Some", age.Value.ToBsonDocument().GetElement("_t").Value.AsString)
         let value = age.Value.AsBsonDocument.GetElement("_v").Value
         Assert.True(value.IsBsonArray)
         let array = value.AsBsonArray
@@ -158,13 +171,19 @@ type ``When serializing lists``() =
 
     [<Fact>]
     member this.``It can serialize DimmerSwitch types``() =
-        let collection = db.GetCollection<ObjectWithOptions> "objects"
         let obj = ObjectWithDimmer()
-        obj.Switch <- DimMarquee(42, "loser")
-        collection.Save obj |> ignore
-
-        let collection = db.GetCollection "objects"
-        let fromDb = collection.FindOneById(obj.Id)
+        obj.Switch <- DimMarquee(42, "loser") 
+        db.GetCollection<ObjectWithDimmer>("objects").InsertOneAsync (obj)
+                |> AwaitVoidTask
+                |> Async.RunSynchronously
+
+        let collection = db.GetCollection<BsonDocument> "objects"
+            
+        let filter = new BsonDocumentFilterDefinition<_>(new BsonDocument() 
+                                                            |> (fun d -> d.Add("_id",obj.Id)))
+        let fromDb = collection.Find(filter).FirstAsync()
+                                                    |> Async.AwaitTask
+                                                    |> Async.RunSynchronously
         let switch = fromDb.GetElement("Switch")
         Assert.NotNull(switch);
         Assert.Equal<string>("DimMarquee", switch.Value.AsBsonDocument.GetElement("_t").Value.AsString)
@@ -177,37 +196,45 @@ type ``When serializing lists``() =
 
     [<Fact>]
     member this.``It can deserialize option types``() =
-        let id = BsonObjectId.GenerateNewId()
-        let arrayPart = BsonArray([ BsonInt32(42) ])
-        let structure = BsonDocument(BsonElement("_t", BsonString("Some")), BsonElement("_v", arrayPart))
-        let document = BsonDocument(BsonElement("_id", id), BsonElement("Age", structure))
-        let collection = db.GetCollection "objects"
-        collection.Save(document) |> ignore
-
-        let collection = db.GetCollection<ObjectWithOptions> "objects"
-        let fromDb = collection.FindOneById id
-        match fromDb.Age with
-        | Some 42 -> ()
-        | _ -> fail "expected Some 42 but got something else"
+            let id = BsonObjectId(ObjectId.GenerateNewId())
+            let arrayPart = BsonArray([ BsonInt32(42) ])       
+            let structure = BsonDocument([| BsonElement("_t", BsonString("Some")); BsonElement("_v", arrayPart) |].AsEnumerable())
+            let document = BsonDocument([|BsonElement("_id", id); BsonElement("Age", structure)|].AsEnumerable())
+            let collection = db.GetCollection "objects"
+            collection.InsertOneAsync(document) 
+                |> AwaitVoidTask
+                |> ignore
+
+            let collection = db.GetCollection<ObjectWithOptions> "objects"
+            let fromDb = collection.Find(fun x -> x.Id = id).FirstAsync() 
+                                                        |> Async.AwaitTask
+                                                        |> Async.RunSynchronously
+            match fromDb.Age with
+            | Some 42 -> ()
+            | _ -> fail "expected Some 42 but got something else"
 
     [<Fact>]
     member this.``We can integrate serialize & deserialize on DimmerSwitches``() =
-        let collection = db.GetCollection<ObjectWithDimmers> "objects"
-        let obj = ObjectWithDimmers()
-        obj.Kitchen <- Off
-        obj.Bedroom1 <- Dim 42
-        obj.Bedroom2 <- DimMarquee(12, "when I was little...")
-        collection.Save obj |> ignore
-
-        let fromDb = collection.FindOneById obj.Id
-        match fromDb.Kitchen with
-        | Off -> ()
-        | _ -> fail "Kitchen light wasn't off"
-
-        match fromDb.Bedroom1 with
-        | Dim 42 -> ()
-        | _ -> fail "Bedroom1 light wasn't dim enough"
-
-        match fromDb.Bedroom2 with
-        | DimMarquee(12, "when I was little...") -> ()
-        | _ -> fail "Bedroom2 doesn't have the party we thought"
\ No newline at end of file
+            let collection = db.GetCollection<ObjectWithDimmers> "objects"
+            let obj = ObjectWithDimmers()
+            obj.Kitchen <- Off
+            obj.Bedroom1 <- Dim 42
+            obj.Bedroom2 <- DimMarquee(12, "when I was little...")
+            collection.InsertOneAsync obj 
+                |> AwaitVoidTask
+                |> ignore
+
+            let fromDb = collection.Find(fun x -> x.Id = obj.Id).FirstAsync() 
+                        |> Async.AwaitTask
+                        |> Async.RunSynchronously
+            match fromDb.Kitchen with
+            | Off -> ()
+            | _ -> fail "Kitchen light wasn't off"
+
+            match fromDb.Bedroom1 with
+            | Dim 42 -> ()
+            | _ -> fail "Bedroom1 light wasn't dim enough"
+
+            match fromDb.Bedroom2 with
+            | DimMarquee(12, "when I was little...") -> ()
+            | _ -> fail "Bedroom2 doesn't have the party we thought"
\ No newline at end of file
diff --git a/MongoDB.FSharp.Tests/MongoDB.FSharp.Tests.fsproj b/MongoDB.FSharp.Tests/MongoDB.FSharp.Tests.fsproj
index a23ad59..a7e56b9 100644
--- a/MongoDB.FSharp.Tests/MongoDB.FSharp.Tests.fsproj
+++ b/MongoDB.FSharp.Tests/MongoDB.FSharp.Tests.fsproj
@@ -14,6 +14,7 @@
     <TargetFrameworkProfile />
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
     <RestorePackages>true</RestorePackages>
+    <TargetFSharpCoreVersion>4.3.1.0</TargetFSharpCoreVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -34,16 +35,45 @@
     <WarningLevel>3</WarningLevel>
     <DocumentationFile>bin\Release\MongoDB.FSharp.Tests.XML</DocumentationFile>
   </PropertyGroup>
+  <PropertyGroup>
+    <MinimumVisualStudioVersion Condition="'$(MinimumVisualStudioVersion)' == ''">11</MinimumVisualStudioVersion>
+  </PropertyGroup>
+  <Choose>
+    <When Condition="'$(VisualStudioVersion)' == '11.0'">
+      <PropertyGroup>
+        <FSharpTargetsPath>$(MSBuildExtensionsPath32)\..\Microsoft SDKs\F#\3.0\Framework\v4.0\Microsoft.FSharp.Targets</FSharpTargetsPath>
+      </PropertyGroup>
+    </When>
+    <Otherwise>
+      <PropertyGroup>
+        <FSharpTargetsPath>$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\FSharp\Microsoft.FSharp.Targets</FSharpTargetsPath>
+      </PropertyGroup>
+    </Otherwise>
+  </Choose>
+  <Import Project="$(FSharpTargetsPath)" Condition="Exists('$(FSharpTargetsPath)')" />
+  <Import Project="$(SolutionDir)\.nuget\nuget.targets" />
   <ItemGroup>
-    <Reference Include="FSharp.Core, Version=4.3.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+    <Compile Include="TestUtils.fs" />
+    <Compile Include="AcceptanceTests.fs" />
+    <Compile Include="SerializersTests.fs" />
+    <None Include="packages.config" />
+    <Content Include="app.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <Reference Include="FSharp.Core">
+      <HintPath>..\packages\FSharp.Core.3.1.2.1\lib\net40\FSharp.Core.dll</HintPath>
       <Private>True</Private>
     </Reference>
     <Reference Include="MongoDB.Bson">
-      <HintPath>..\packages\mongocsharpdriver.1.8.1\lib\net35\MongoDB.Bson.dll</HintPath>
+      <HintPath>..\packages\MongoDB.Bson.2.0.1\lib\net45\MongoDB.Bson.dll</HintPath>
       <Private>True</Private>
     </Reference>
     <Reference Include="MongoDB.Driver">
-      <HintPath>..\packages\mongocsharpdriver.1.8.1\lib\net35\MongoDB.Driver.dll</HintPath>
+      <HintPath>..\packages\MongoDB.Driver.2.0.1\lib\net45\MongoDB.Driver.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="MongoDB.Driver.Core">
+      <HintPath>..\packages\MongoDB.Driver.Core.2.0.1\lib\net45\MongoDB.Driver.Core.dll</HintPath>
       <Private>True</Private>
     </Reference>
     <Reference Include="mscorlib" />
@@ -59,23 +89,12 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="TestUtils.fs" />
-    <Compile Include="AcceptanceTests.fs" />
-    <Compile Include="SerializersTests.fs" />
-    <None Include="packages.config" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\MongoDB.FSharp\MongoDB.FSharp.fsproj">
-      <Name>MongoDB.FSharp</Name>
+    <ProjectReference Include="..\MongoDB.FSharp\MongoDB.Driver.FSharp.fsproj">
+      <Name>MongoDB.Driver.FSharp</Name>
       <Project>{7cbeb93a-1590-42db-9e40-61630e79304a}</Project>
       <Private>True</Private>
     </ProjectReference>
   </ItemGroup>
-  <PropertyGroup>
-    <MinimumVisualStudioVersion Condition="'$(MinimumVisualStudioVersion)' == ''">11</MinimumVisualStudioVersion>
-  </PropertyGroup>
-  <Import Project="$(MSBuildExtensionsPath32)\..\Microsoft SDKs\F#\3.0\Framework\v4.0\Microsoft.FSharp.Targets" Condition=" Exists('$(MSBuildExtensionsPath32)\..\Microsoft SDKs\F#\3.0\Framework\v4.0\Microsoft.FSharp.Targets')" />
-  <Import Project="$(SolutionDir)\.nuget\nuget.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">
diff --git a/MongoDB.FSharp.Tests/SerializersTests.fs b/MongoDB.FSharp.Tests/SerializersTests.fs
index 1a12b2e..4071cdd 100644
--- a/MongoDB.FSharp.Tests/SerializersTests.fs
+++ b/MongoDB.FSharp.Tests/SerializersTests.fs
@@ -2,7 +2,7 @@
 
 open Xunit
 
-open MongoDB.FSharp.Serializers
+open MongoDB.Driver.FSharp.Serializers
 open TestUtils
 
 
diff --git a/MongoDB.FSharp.Tests/TestUtils.fs b/MongoDB.FSharp.Tests/TestUtils.fs
index faab238..7bc7c71 100644
--- a/MongoDB.FSharp.Tests/TestUtils.fs
+++ b/MongoDB.FSharp.Tests/TestUtils.fs
@@ -1,6 +1,15 @@
 module TestUtils
 
 open Xunit
+open System.Threading.Tasks
+open System
 
 let fail msg =
-    Assert.True(false, msg)
\ No newline at end of file
+    Assert.True(false, msg)
+
+let AwaitVoidTask (task : Task) : Async<unit> =
+    Async.FromContinuations(fun (cont, econt, ccont) ->
+        task.ContinueWith(fun task ->
+            if task.IsFaulted then econt task.Exception
+            elif task.IsCanceled then ccont (OperationCanceledException())
+            else cont ()) |> ignore)
\ No newline at end of file
diff --git a/MongoDB.FSharp.Tests/app.config b/MongoDB.FSharp.Tests/app.config
new file mode 100644
index 0000000..bb9b825
--- /dev/null
+++ b/MongoDB.FSharp.Tests/app.config
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <runtime>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="FSharp.Core" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.3.1.0" newVersion="4.3.1.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+  </runtime>
+</configuration>
\ No newline at end of file
diff --git a/MongoDB.FSharp.Tests/packages.config b/MongoDB.FSharp.Tests/packages.config
index 9ae09f6..59a5501 100644
--- a/MongoDB.FSharp.Tests/packages.config
+++ b/MongoDB.FSharp.Tests/packages.config
@@ -1,6 +1,10 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
+  <package id="FSharp.Core" version="3.1.2.1" targetFramework="net45" />
   <package id="mongocsharpdriver" version="1.8.1" targetFramework="net45" />
+  <package id="MongoDB.Bson" version="2.0.1" targetFramework="net45" />
+  <package id="MongoDB.Driver" version="2.0.1" targetFramework="net45" />
+  <package id="MongoDB.Driver.Core" version="2.0.1" targetFramework="net45" />
   <package id="Unquote" version="2.2.2" targetFramework="net45" />
   <package id="xunit" version="1.9.1" targetFramework="net45" />
 </packages>
diff --git a/MongoDB.FSharp.nuspec b/MongoDB.FSharp.nuspec
index 63dd4ac..1c4a7a5 100644
--- a/MongoDB.FSharp.nuspec
+++ b/MongoDB.FSharp.nuspec
@@ -1,18 +1,20 @@
 <?xml version="1.0"?>
 <package >
   <metadata>
-    <id>MongoDB.FSharp</id>
-    <version>0.1.0</version>
-    <title>MongoDB.FSharp</title>
-    <authors>Tim Kellogg</authors>
+    <id>MongoDB.Driver.FSharp</id>
+    <version>0.2.0</version>
+    <title>MongoDB.Driver.FSharp</title>
+    <authors>Sebastian Faltoni, Tim Kellogg</authors>
     <owners>Tim Kellogg</owners>
-    <licenseUrl>https://github.com/tkellogg/MongoDB.FSharp/blob/master/License.txt</licenseUrl>
-    <projectUrl>https://github.com/tkellogg/MongoDB.FSharp</projectUrl>
-    <!--<iconUrl>http://ICON_URL_HERE_OR_DELETE_THIS_LINE</iconUrl>-->
+    <licenseUrl>https://github.com/nukedbit/MongoDB.FSharp/blob/master/License.txt</licenseUrl>
+    <projectUrl>https://github.com/nukedbit/MongoDB.FSharp</projectUrl>
     <requireLicenseAcceptance>false</requireLicenseAcceptance>
     <description>Silent utilities to make the official MongoDB driver feel natural to work with in F#</description>
     <releaseNotes>Initial release, should work but not recommended for production</releaseNotes>
-    <copyright>Copyright 2013</copyright>
+    <copyright>Copyright 2015</copyright>
+    <dependencies>
+      <dependency id="MongoDB.Driver" version="2.0.1" />
+    </dependencies>
     <tags>f# fsharp mongodB nosql utility</tags>
   </metadata>
 </package>
diff --git a/MongoDB.FSharp.sln b/MongoDB.FSharp.sln
index 384c927..f8645fa 100644
--- a/MongoDB.FSharp.sln
+++ b/MongoDB.FSharp.sln
@@ -1,10 +1,8 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 2012
-Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "MongoDB.FSharp", "MongoDB.FSharp\MongoDB.FSharp.fsproj", "{7CBEB93A-1590-42DB-9E40-61630E79304A}"
-EndProject
-Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "MongoDB.FSharp.Tests", "MongoDB.FSharp.Tests\MongoDB.FSharp.Tests.fsproj", "{DE725DAC-C637-4DA7-A30D-69061D33D1B2}"
-EndProject
+# Visual Studio 2013
+VisualStudioVersion = 12.0.31101.0
+MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".nuget", ".nuget", "{1207C2F4-D695-48D4-A0D1-9258EC678E22}"
 	ProjectSection(SolutionItems) = preProject
 		.nuget\NuGet.Config = .nuget\NuGet.Config
@@ -21,6 +19,10 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 		README.md = README.md
 	EndProjectSection
 EndProject
+Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "MongoDB.Driver.FSharp", "MongoDB.FSharp\MongoDB.Driver.FSharp.fsproj", "{7CBEB93A-1590-42DB-9E40-61630E79304A}"
+EndProject
+Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "MongoDB.FSharp.Tests", "MongoDB.FSharp.Tests\MongoDB.FSharp.Tests.fsproj", "{DE725DAC-C637-4DA7-A30D-69061D33D1B2}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
diff --git a/MongoDB.FSharp/MongoDB.FSharp.fsproj b/MongoDB.FSharp/MongoDB.Driver.FSharp.fsproj
similarity index 63%
rename from MongoDB.FSharp/MongoDB.FSharp.fsproj
rename to MongoDB.FSharp/MongoDB.Driver.FSharp.fsproj
index 5e12d40..68e5c84 100644
--- a/MongoDB.FSharp/MongoDB.FSharp.fsproj
+++ b/MongoDB.FSharp/MongoDB.Driver.FSharp.fsproj
@@ -8,12 +8,13 @@
     <ProjectGuid>7cbeb93a-1590-42db-9e40-61630e79304a</ProjectGuid>
     <OutputType>Library</OutputType>
     <RootNamespace>MongoDB.FSharp</RootNamespace>
-    <AssemblyName>MongoDB.FSharp</AssemblyName>
-    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
-    <Name>MongoDB.FSharp</Name>
+    <AssemblyName>MongoDB.Driver.FSharp</AssemblyName>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <Name>MongoDB.Driver.FSharp</Name>
     <TargetFrameworkProfile />
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
     <RestorePackages>true</RestorePackages>
+    <TargetFSharpCoreVersion>4.3.0.0</TargetFSharpCoreVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -24,6 +25,9 @@
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <WarningLevel>3</WarningLevel>
     <DocumentationFile>bin\Debug\MongoDB.FSharp.XML</DocumentationFile>
+    <StartAction>Program</StartAction>
+    <StartProgram>D:\Users\faltonis\git\catalog-monitor\CatalogMonitor.Service\bin\Debug\CatalogMonitor.Service.exe</StartProgram>
+    <EnableUnmanagedDebugging>true</EnableUnmanagedDebugging>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
@@ -34,33 +38,47 @@
     <WarningLevel>3</WarningLevel>
     <DocumentationFile>bin\Release\MongoDB.FSharp.XML</DocumentationFile>
   </PropertyGroup>
+  <PropertyGroup>
+    <MinimumVisualStudioVersion Condition="'$(MinimumVisualStudioVersion)' == ''">11</MinimumVisualStudioVersion>
+  </PropertyGroup>
+  <Choose>
+    <When Condition="'$(VisualStudioVersion)' == '11.0'">
+      <PropertyGroup>
+        <FSharpTargetsPath>$(MSBuildExtensionsPath32)\..\Microsoft SDKs\F#\3.0\Framework\v4.0\Microsoft.FSharp.Targets</FSharpTargetsPath>
+      </PropertyGroup>
+    </When>
+    <Otherwise>
+      <PropertyGroup>
+        <FSharpTargetsPath>$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\FSharp\Microsoft.FSharp.Targets</FSharpTargetsPath>
+      </PropertyGroup>
+    </Otherwise>
+  </Choose>
+  <Import Project="$(FSharpTargetsPath)" Condition="Exists('$(FSharpTargetsPath)')" />
+  <Import Project="$(SolutionDir)\.nuget\nuget.targets" />
   <ItemGroup>
-    <Reference Include="FSharp.Core, Version=4.3.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+    <Compile Include="SerializationOptions.fs" />
+    <Compile Include="Serializers.fs" />
+    <None Include="Script.fsx" />
+    <Content Include="packages.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <Reference Include="FSharp.Core">
+      <HintPath>..\packages\FSharp.Core.3.1.2.1\lib\net40\FSharp.Core.dll</HintPath>
       <Private>True</Private>
     </Reference>
     <Reference Include="MongoDB.Bson">
-      <HintPath>..\packages\mongocsharpdriver.1.8.1\lib\net35\MongoDB.Bson.dll</HintPath>
-      <Private>True</Private>
+      <HintPath>..\packages\MongoDB.Bson.2.0.1\lib\net45\MongoDB.Bson.dll</HintPath>
     </Reference>
     <Reference Include="MongoDB.Driver">
-      <HintPath>..\packages\mongocsharpdriver.1.8.1\lib\net35\MongoDB.Driver.dll</HintPath>
-      <Private>True</Private>
+      <HintPath>..\packages\MongoDB.Driver.2.0.1\lib\net45\MongoDB.Driver.dll</HintPath>
+    </Reference>
+    <Reference Include="MongoDB.Driver.Core">
+      <HintPath>..\packages\MongoDB.Driver.Core.2.0.1\lib\net45\MongoDB.Driver.Core.dll</HintPath>
     </Reference>
     <Reference Include="mscorlib" />
     <Reference Include="System" />
     <Reference Include="System.Core" />
   </ItemGroup>
-  <ItemGroup>
-    <Compile Include="SerializationOptions.fs" />
-    <Compile Include="Serializers.fs" />
-    <None Include="packages.config" />
-    <None Include="Script.fsx" />
-  </ItemGroup>
-  <PropertyGroup>
-    <MinimumVisualStudioVersion Condition="'$(MinimumVisualStudioVersion)' == ''">11</MinimumVisualStudioVersion>
-  </PropertyGroup>
-  <Import Project="$(MSBuildExtensionsPath32)\..\Microsoft SDKs\F#\3.0\Framework\v4.0\Microsoft.FSharp.Targets" Condition=" Exists('$(MSBuildExtensionsPath32)\..\Microsoft SDKs\F#\3.0\Framework\v4.0\Microsoft.FSharp.Targets')" />
-  <Import Project="$(SolutionDir)\.nuget\nuget.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">
diff --git a/MongoDB.FSharp/SerializationOptions.fs b/MongoDB.FSharp/SerializationOptions.fs
index 5b2f41f..4a6c4b9 100644
--- a/MongoDB.FSharp/SerializationOptions.fs
+++ b/MongoDB.FSharp/SerializationOptions.fs
@@ -1,50 +1,8 @@
-namespace MongoDB.FSharp
+namespace MongoDB.Driver.FSharp
 
-open System
-open MongoDB.Bson
-open MongoDB.Bson.Serialization
-open MongoDB.Bson.Serialization.Options
-open MongoDB.Bson.Serialization.Serializers
+open MongoDB.Bson 
 
 module SerializationOptions =
   type System.Object with
       member inline this.GetFriendlyTypeName() =
           this.GetType() |> BsonUtils.GetFriendlyTypeName
-
-  type ListSerializationOptions(itemOptions : IBsonSerializationOptions) =
-      inherit BsonBaseSerializationOptions()
-      let mutable itemSerializatonOptions = itemOptions
-      new() = ListSerializationOptions(null)
-
-      member val ItemSerializationOptions = itemSerializatonOptions
-
-      override this.ApplyAttribute(serializer : IBsonSerializer, attribute : Attribute) =
-          this.EnsureNotFrozen()
-          let itemSerializer = 
-              if (serializer :? IBsonArraySerializer) then
-                  let fmt = sprintf "a serialization options attribute of type %s cannot be used with serializer of type %s."
-                  let attrType = attribute.GetFriendlyTypeName()
-                  let serializerType = serializer.GetFriendlyTypeName()
-                  let msg = fmt attrType serializerType
-                  raise(NotSupportedException(msg))
-
-              (serializer :?> IBsonArraySerializer).GetItemSerializationInfo().Serializer
-
-          let ensureSerializationOptions() =
-              if itemSerializatonOptions = null then
-                  let defaultOptions = itemSerializer.GetDefaultSerializationOptions()
-                  if defaultOptions = null then
-                      let fmt = sprintf "A serialization options attribute of type %s cannot be used when the serializer is of type %s and the item serializer is of type %s."
-                      let msg = fmt (attribute.GetFriendlyTypeName()) (serializer.GetFriendlyTypeName()) 
-                      raise(NotSupportedException(msg (itemSerializer.GetFriendlyTypeName())))
-
-                  defaultOptions.Clone()
-              else
-                  itemSerializatonOptions
-
-          itemSerializatonOptions <- ensureSerializationOptions()
-          itemSerializatonOptions.ApplyAttribute(itemSerializer, attribute)
-
-        override this.Clone() = 
-            ListSerializationOptions(itemSerializatonOptions) :> IBsonSerializationOptions
-
diff --git a/MongoDB.FSharp/Serializers.fs b/MongoDB.FSharp/Serializers.fs
index 2932a5d..1a8b1d4 100644
--- a/MongoDB.FSharp/Serializers.fs
+++ b/MongoDB.FSharp/Serializers.fs
@@ -1,4 +1,4 @@
-namespace MongoDB.FSharp
+namespace MongoDB.Driver.FSharp
 
 open System
 open System.Reflection
@@ -6,258 +6,286 @@ open Microsoft.FSharp.Reflection
 open MongoDB.Bson
 open MongoDB.Bson.IO
 open MongoDB.Bson.Serialization
-open MongoDB.Bson.Serialization.Options
 open MongoDB.Bson.Serialization.Serializers
-
 open SerializationOptions
 
-module Seq =
-    let tryHead s =
-        if Seq.isEmpty s then
-            None
-        else
-            Some (s |> Seq.head)
-
-module Serializers =
+module Seq = 
+    let tryHead s = 
+        if Seq.isEmpty s then None
+        else Some(s |> Seq.head)
 
+module Serializers = 
+    open MongoDB.Bson.Serialization.Attributes
+    
     type MongoDB.Bson.IO.BsonWriter with
-        member inline this.WriteEmptyArray() =
+        member inline this.WriteEmptyArray() = 
             this.WriteStartArray()
             this.WriteEndArray()
-
-    type ListSerializer<'T>() =
-        inherit MongoDB.Bson.Serialization.Serializers.BsonBaseSerializer(ListSerializationOptions())
-
-        override this.Serialize(writer : BsonWriter, nominalType : Type, value : Object, options : IBsonSerializationOptions) =
-            if value = null then
-                // There aren't supposed to be null values in F#
-                writer.WriteEmptyArray()
-            else
-                let actualType = value.GetType()
-                this.VerifyTypes(nominalType, actualType, typeof<list<'T>>)
-
-                let lst = value :?> list<'T>
-                writer.WriteStartArray()
-                
-                lst |> List.iter (fun x -> BsonSerializer.Serialize (writer,typeof<'T>, x))
-
-                writer.WriteEndArray()
-
-        override this.Deserialize(reader : BsonReader, nominalType : Type, actualType : Type, options : IBsonSerializationOptions) =
-            let serializationOptions = this.EnsureSerializationOptions<ListSerializationOptions>(options)
-            let itemOptions = serializationOptions.ItemSerializationOptions
-            let readArray() =
-                seq {
-                    reader.ReadStartArray()
+    
+    type ListSerializer<'T when 'T : equality>() = 
+        inherit SerializerBase<list<'T>>()
+        
+        override this.Deserialize(context : BsonDeserializationContext, args : BsonDeserializationArgs) : 'T list = 
+            let readArray() = 
+                seq { 
+                    context.Reader.ReadStartArray()
                     let convention = BsonSerializer.LookupDiscriminatorConvention(typeof<'T>)
-                    while reader.ReadBsonType() <> BsonType.EndOfDocument do
-                        let actualElementType = convention.GetActualType(reader, typeof<'T>)
+                    while context.Reader.ReadBsonType() <> BsonType.EndOfDocument do
+                        let actualElementType = convention.GetActualType(context.Reader, typeof<'T>)
                         let serializer = BsonSerializer.LookupSerializer(actualElementType)
-                        let element = serializer.Deserialize(reader, typeof<'T>, itemOptions)
+                        let element = serializer.Deserialize(context, args)
                         yield element :?> 'T
-                    reader.ReadEndArray()
+                    context.Reader.ReadEndArray()
                 }
-
-            let readArrayFromObject () =
-                reader.ReadStartDocument()
-                reader.ReadString("_t") |> ignore
-                reader.ReadName("_v")
-                let value = this.Deserialize(reader, actualType, actualType, options)
-                reader.ReadEndDocument()
+            
+            let readArrayFromObject() = 
+                context.Reader.ReadStartDocument()
+                context.Reader.ReadString("_t") |> ignore
+                context.Reader.ReadName("_v")
+                let value = this.Deserialize(context, args)
+                context.Reader.ReadEndDocument()
                 value
             
-            let bsonType = reader.GetCurrentBsonType()
+            let bsonType = context.Reader.GetCurrentBsonType()
             match bsonType with
-            | BsonType.Null ->
-                reader.ReadNull()
-                null
-            | BsonType.Array -> readArray() |> List.ofSeq :> Object
-            | BsonType.Document -> readArrayFromObject ()
+            | BsonType.Null -> 
+                context.Reader.ReadNull()
+                Unchecked.defaultof<'T list>
+            | BsonType.Array -> (readArray() |> List.ofSeq :> obj) :?> 'T list
+            | BsonType.Document -> readArrayFromObject()
             | _ -> 
-                let msg = sprintf "Can't deserialize a %s from BsonType %s" actualType.FullName (bsonType.ToString())
-                raise(InvalidOperationException(msg))
-
+                let msg = 
+                    sprintf "Can't deserialize a %s from BsonType %s" args.NominalType.FullName (bsonType.ToString())
+                raise (InvalidOperationException(msg))
+        
+        override this.Serialize(context : BsonSerializationContext, args : BsonSerializationArgs, value : 'T list) = 
+            if value = Unchecked.defaultof<'T list> then 
+                // There aren't supposed to be null values in F#
+                context.Writer.WriteStartArray()
+                context.Writer.WriteEndArray()
+            else 
+                //this.VerifyTypes(nominalType, actualType, typeof<list<'T>>)
+                let lst = box value :?> list<'T>
+                context.Writer.WriteStartArray()
+                lst |> List.iter (fun x -> BsonSerializer.Serialize(context.Writer, typeof<'T>, x))
+                context.Writer.WriteEndArray()
+        
         interface IBsonArraySerializer with
-            member this.GetItemSerializationInfo() : BsonSerializationInfo =
+            member x.TryGetItemSerializationInfo(serializationInfo : byref<BsonSerializationInfo>) : bool = 
                 let elementName = null
                 let nominalType = typeof<'T>
                 let serializer = BsonSerializer.LookupSerializer nominalType
-                BsonSerializationInfo(elementName, serializer, nominalType, null)
-
-
-    let fsharpType (typ : Type) =
-        typ.GetCustomAttributes(typeof<CompilationMappingAttribute>, true) 
+                serializationInfo <- BsonSerializationInfo(elementName, serializer, nominalType)
+                true
+    
+    let fsharpType (typ : Type) = 
+        typ.GetCustomAttributes(typeof<CompilationMappingAttribute>, true)
         |> Seq.cast<CompilationMappingAttribute>
-        |> Seq.map(fun t -> t.SourceConstructFlags)
+        |> Seq.map (fun t -> t.SourceConstructFlags)
         |> Seq.tryHead
-
-    let getClassMap isClassMapRegistered (actualType : Type) =
-        let rec getMember (_type : Type) name other =
+    
+    let getClassMap isClassMapRegistered (actualType : Type) = 
+        let rec getMember (_type : Type) name other = 
             let memberInfos = _type.GetMember name
-            if not (memberInfos |> Seq.isEmpty) then
-                Some(Seq.head memberInfos)
-            elif other <> null then
-                getMember _type other null
-            else
-                None
-
-        if not (isClassMapRegistered actualType) then
+            if not (memberInfos |> Seq.isEmpty) then Some(Seq.head memberInfos)
+            elif other <> null then getMember _type other null
+            else None
+        if not (isClassMapRegistered actualType) then 
             let genericType = typedefof<BsonClassMap<_>>.MakeGenericType(actualType)
             let classMap = Activator.CreateInstance(genericType) :?> BsonClassMap
-
             classMap.AutoMap()
-
             // TODO: don't just map properties -> anything public, maybe consider using C#'s conventions to some extent
-            actualType.GetProperties() 
+            actualType.GetProperties()
             |> Seq.where (fun prop -> 
-                classMap.AllMemberMaps |> Seq.exists (fun mm -> mm.MemberInfo = (prop :> MemberInfo)) |> not
-            )
+                   classMap.AllMemberMaps
+                   |> Seq.exists (fun mm -> mm.MemberInfo = (prop :> MemberInfo))
+                   |> not)
             |> Seq.where (fun prop -> prop.GetGetMethod() <> null)
-            |> Seq.iter (fun prop -> classMap.MapMember(prop :> MemberInfo) |> ignore )
-
+            |> Seq.iter (fun prop -> classMap.MapMember(prop :> MemberInfo) |> ignore)
             // TODO: use conventions
             match getMember actualType "Id" "_id" with
             | Some memberInfo -> classMap.MapIdMember memberInfo |> ignore
             | None -> ()
-
-            match fsharpType actualType with 
+            match fsharpType actualType with
             | Some SourceConstructFlags.RecordType -> 
                 // Map creator function. Requires Mongo >1.8
-                match actualType.GetConstructors() |> Seq.sortBy (fun c -> c.GetParameters().Length) |> Seq.tryHead with
+                match actualType.GetConstructors()
+                      |> Seq.sortBy (fun c -> c.GetParameters().Length)
+                      |> Seq.tryHead with
                 | Some c -> 
-                    let parms = classMap.DeclaredMemberMaps |> Seq.map (fun m -> m.ElementName) |> Array.ofSeq
-                    classMap.MapConstructor (c, parms) |> ignore
+                    let parms = 
+                        classMap.DeclaredMemberMaps
+                        |> Seq.map (fun (m : BsonMemberMap) -> m.MemberName)
+                        |> Array.ofSeq
+                    classMap.MapConstructor(c, parms) |> ignore
                 | None -> ()
             | _ -> ()
-
             classMap.Freeze() |> Some
-        else 
-            None
-
-    let ensureClassMapRegistered actualType =
-        let fn = BsonClassMap.IsClassMapRegistered 
+        else None
+    
+    let ensureClassMapRegistered actualType = 
+        let fn = BsonClassMap.IsClassMapRegistered
         match getClassMap fn actualType with
         | Some map -> 
             map |> BsonClassMap.RegisterClassMap
             Some map
-        | None -> 
-            None
-
-    type RecordSerializer(classMap : BsonClassMap) =
-        inherit MongoDB.Bson.Serialization.Serializers.BsonBaseSerializer()
-
-        let classMapSerializer =
-            let typ = typeof<BsonClassMap>.Assembly.GetType("MongoDB.Bson.Serialization.BsonClassMapSerializer")
-            let ctor = typ.GetConstructor([ typeof<BsonClassMap> ] |> Seq.toArray)
-            ctor.Invoke([ classMap ] |> Seq.cast<Object> |> Seq.toArray) :?> IBsonSerializer
-
+        | None -> None
+    
+    type RecordSerializer<'T>(classMap : BsonClassMap) = 
+        inherit MongoDB.Bson.Serialization.BsonClassMapSerializer<'T>(classMap)
+        
+        let classMapSerializer = 
+            Activator.CreateInstance((typedefof<MongoDB.Bson.Serialization.BsonClassMapSerializer<_>>
+                                         .MakeGenericType(typedefof<'T>)), 
+                                     [ classMap ]
+                                     |> Seq.cast<Object>
+                                     |> Seq.toArray) :?> IBsonSerializer
+        
         let getter = 
             match classMap.IdMemberMap with
             | null -> None
             | mm -> Some(mm.Getter)
-
+        
         let idProvider = classMapSerializer :?> IBsonIdProvider
-
-        override this.Serialize(writer : BsonWriter, nominalType : Type, value : Object, options : IBsonSerializationOptions) =
-            classMapSerializer.Serialize(writer, nominalType, value, options)
-
-        override this.Deserialize(reader : BsonReader, nominalType : Type, options : IBsonSerializationOptions) =
-            classMapSerializer.Deserialize(reader, nominalType, options)
-
-        override this.Deserialize(reader : BsonReader, nominalType : Type, actualType : Type, options : IBsonSerializationOptions) =
-            classMapSerializer.Deserialize(reader, nominalType, actualType, options)
-
-
-        interface IBsonDocumentSerializer  with
-            member this.GetMemberSerializationInfo(memberName:string) = 
-                let m = classMap.AllMemberMaps |> Seq.tryFind (fun x -> x.MemberName = memberName)
-                match m with
-                | Some(x) -> new BsonSerializationInfo(x.ElementName, x.GetSerializer(x.MemberType), x.MemberType, x.SerializationOptions)
-                | None -> 
-                    let msg = sprintf "Class has no member called %s" memberName 
-                    raise(ArgumentOutOfRangeException(msg))       
+        override this.Serialize(ctx : BsonSerializationContext, args : BsonSerializationArgs, value : 'T) = 
+            classMapSerializer.Serialize(ctx, args, value)
+        
+        interface IBsonDocumentSerializer with
+            member x.TryGetMemberSerializationInfo(memberName : string, serializationInfo : byref<BsonSerializationInfo>) : bool = 
+                let getMemberName (map : BsonMemberMap) = 
+                    match map.MemberInfo.GetCustomAttribute(typedefof<BsonElementAttribute>) :?> BsonElementAttribute with
+                    | null -> map.ElementName
+                    | a -> a.ElementName
                 
-
+                let m = classMap.AllMemberMaps |> Seq.tryFind (fun x -> (getMemberName x) = memberName)
+                match m with
+                | Some(x) -> 
+                    serializationInfo <- (new BsonSerializationInfo(x.ElementName, x.GetSerializer(), x.MemberType))
+                    true
+                | None -> false
+        
         interface IBsonIdProvider with
-            member this.GetDocumentId(document : Object, id : Object byref, nominalType : Type byref, idGenerator : IIdGenerator byref) =
+            
+            member this.GetDocumentId(document : Object, id : Object byref, nominalType : Type byref, 
+                                      idGenerator : IIdGenerator byref) = 
                 match getter with
                 | Some(i) -> 
-                    id <- i.DynamicInvoke(([document] |> Array.ofList))
+                    id <- i.DynamicInvoke(([ document ] |> Array.ofList))
                     idProvider.GetDocumentId(document, ref id, ref nominalType, ref idGenerator)
                 | None -> false
-
+            
             member this.SetDocumentId(document : Object, id : Object) = idProvider.SetDocumentId(document, id)
-
-
-    type UnionCaseSerializer() =
-        inherit MongoDB.Bson.Serialization.Serializers.BsonBaseSerializer()
-
-        let readItems (reader : BsonReader) (types : Type seq) (options : IBsonSerializationOptions) =
-            types |> Seq.fold(fun state t ->
-                let serializer = BsonSerializer.LookupSerializer(t)
-                let item = serializer.Deserialize(reader, t, options)
-                item :: state
-            ) []
-            |> Seq.toArray |> Array.rev
-
-        override this.Serialize(writer : BsonWriter, nominalType : Type, value : Object, options : IBsonSerializationOptions) =
+    
+    type UnionCaseSerializer<'T>() = 
+        inherit SerializerBase<'T>()
+        
+        let readItems (types : Type seq) (ctx : BsonDeserializationContext) = 
+            types
+            |> Seq.fold (fun state t -> 
+                   let serializer = BsonSerializer.LookupSerializer(t)
+                   let mutable a = new BsonDeserializationArgs()
+                   a.NominalType <- t
+                   let item = serializer.Deserialize(ctx, a)
+                   item :: state) []
+            |> Seq.toArray
+            |> Array.rev
+        
+        override x.Deserialize(ctx : BsonDeserializationContext, args : BsonDeserializationArgs) = 
+            let reader = ctx.Reader
+            reader.ReadStartDocument()
+            reader.ReadName("_t")
+            let typeName = reader.ReadString()
+            
+            let unionType = 
+                FSharpType.GetUnionCases(args.NominalType)
+                |> Seq.where (fun case -> case.Name = typeName)
+                |> Seq.head
+            reader.ReadStartArray()
+            let items = readItems (unionType.GetFields() |> Seq.map (fun f -> f.PropertyType)) ctx
+            reader.ReadEndArray()
+            reader.ReadEndDocument()
+            FSharpValue.MakeUnion(unionType, items) :?> 'T
+        
+        override x.Serialize(ctx : BsonSerializationContext, args : BsonSerializationArgs, value : 'T) = 
+            let writer = ctx.Writer
             writer.WriteStartDocument()
-            let info, values = FSharpValue.GetUnionFields(value, nominalType)
+            let info, values = FSharpValue.GetUnionFields(value, typeof<'T>)
             writer.WriteName("_t")
             writer.WriteString(info.Name)
             writer.WriteName("_v")
             writer.WriteStartArray()
-            values |> Seq.zip(info.GetFields()) |> Seq.iter (fun (field, value) ->
-                let itemSerializer = BsonSerializer.LookupSerializer(field.PropertyType)
-                itemSerializer.Serialize(writer, field.PropertyType, value, options)
-            )
+            values
+            |> Seq.zip (info.GetFields())
+            |> Seq.iter (fun (field, value) -> 
+                   let itemSerializer = BsonSerializer.LookupSerializer(field.PropertyType)
+                   itemSerializer.Serialize(ctx, value))
             writer.WriteEndArray()
             writer.WriteEndDocument()
-
-        override this.Deserialize(reader : BsonReader, nominalType : Type, actualType : Type, options : IBsonSerializationOptions) =
+    
+    type OptionTypeSerializer<'T, 'U>() = 
+        inherit SerializerBase<'T>()
+        
+        override x.Deserialize(ctx : BsonDeserializationContext, args : BsonDeserializationArgs) = 
+            let reader = ctx.Reader
+            let t = typeof<'T>
+            let innerType = t.GenericTypeArguments.[0]
             reader.ReadStartDocument()
             reader.ReadName("_t")
-            let typeName = reader.ReadString()
-            let unionType = 
-                FSharpType.GetUnionCases(nominalType) 
-                |> Seq.where (fun case -> case.Name = typeName) |> Seq.head
-            reader.ReadStartArray()
-            let items = readItems reader (unionType.GetFields() |> Seq.map(fun f -> f.PropertyType)) options
-            reader.ReadEndArray()
+            let typeName = reader.ReadString()                       
+            let opt = 
+                if typeName = "Some" then 
+                    reader.ReadName("_v")
+                    Some(Unchecked.unbox<'U> (BsonSerializer.Deserialize(reader, innerType)))
+                else None
+            
             reader.ReadEndDocument()
-            FSharpValue.MakeUnion(unionType, items)
-
-    type FsharpSerializationProvider() =
-
+            (box opt) :?> 'T
+        
+        override x.Serialize(ctx : BsonSerializationContext, args : BsonSerializationArgs, value : 'T) = 
+            let writer = ctx.Writer
+            writer.WriteStartDocument()
+            writer.WriteName("_t")
+            if box (value) = null then writer.WriteString("None")
+            else writer.WriteString("Some")
+            if box (value) <> null then 
+                writer.WriteName("_v")
+                let v = value.GetType().GetProperty("Value").GetValue(value)
+                let serializer = BsonSerializer.LookupSerializer(v.GetType())
+                serializer.Serialize(ctx, v)
+            writer.WriteEndDocument()
+    
+    type FsharpSerializationProvider() = 
         interface IBsonSerializationProvider with
-            member this.GetSerializer(typ : Type) =
+            member this.GetSerializer(typ : Type) = 
                 let t = fsharpType typ
                 match t with
-                | Some SourceConstructFlags.RecordType ->
+                | Some SourceConstructFlags.RecordType -> 
                     match ensureClassMapRegistered typ with
-                    | Some classMap -> RecordSerializer(classMap) :> IBsonSerializer
+                    | Some classMap -> 
+                        Activator.CreateInstance((typedefof<RecordSerializer<_>>.MakeGenericType(typ)), classMap) :?> IBsonSerializer
                     // return null means to try the next provider to see if it has a better answer
                     | None -> null
-
                 // other F# types, when we're ready (list, seq, discriminated union)
-                | Some SourceConstructFlags.SumType ->
+                | Some SourceConstructFlags.SumType -> 
                     // Maybe it's a list?
-                    if typ.IsGenericType && typ.GetGenericTypeDefinition() = typedefof<List<_>> then
-                         typedefof<ListSerializer<_>>.MakeGenericType(typ.GetGenericArguments())
-                         |> Activator.CreateInstance :?> IBsonSerializer
-                    elif FSharpType.IsUnion typ then
-                        UnionCaseSerializer() :> IBsonSerializer
-                    else
-                        null
-
+                    if typ.IsGenericType && typ.GetGenericTypeDefinition() = typedefof<List<_>> then 
+                        typedefof<ListSerializer<_>>.MakeGenericType(typ.GetGenericArguments()) 
+                        |> Activator.CreateInstance :?> IBsonSerializer
+                    elif FSharpType.IsUnion typ then 
+                        if typ.Name = "FSharpOption`1" then 
+                            let args = [|typ;typ.GetGenericArguments().[0]|] |> Array.ofSeq
+                            typedefof<OptionTypeSerializer<_,_>>.MakeGenericType(args) |> Activator.CreateInstance :?> IBsonSerializer
+                        else 
+                            typedefof<UnionCaseSerializer<_>>.MakeGenericType(typ) |> Activator.CreateInstance :?> IBsonSerializer
+                    else null
                 | Some SourceConstructFlags.UnionCase -> UnionCaseSerializer() :> IBsonSerializer
                 | _ -> null
-
+    
     let mutable isRegistered = false
-
+    
     /// Registers all F# serializers
-    let Register() =
-        if not isRegistered then
+    let Register() = 
+        if not isRegistered then 
             BsonSerializer.RegisterSerializationProvider(FsharpSerializationProvider())
             BsonSerializer.RegisterGenericSerializerDefinition(typeof<list<_>>, typeof<ListSerializer<_>>)
-            isRegistered <- true
\ No newline at end of file
+            isRegistered <- true
diff --git a/MongoDB.FSharp/packages.config b/MongoDB.FSharp/packages.config
index 1724930..a3e0c71 100644
--- a/MongoDB.FSharp/packages.config
+++ b/MongoDB.FSharp/packages.config
@@ -1,5 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="mongocsharpdriver" version="1.8.1" targetFramework="net40" />
-  <package id="FSharp.Core.3" version="0.0.2" targetFramework="net40" />
-</packages>
+  <package id="FSharp.Core" version="3.1.2.1" targetFramework="net40" />
+  <package id="MongoDB.Bson" version="2.0.1" targetFramework="net45" />
+  <package id="MongoDB.Driver" version="2.0.1" targetFramework="net45" />
+  <package id="MongoDB.Driver.Core" version="2.0.1" targetFramework="net45" />
+</packages>
\ No newline at end of file
diff --git a/package.ps1 b/package.ps1
index 7f2242a..811e9c9 100644
--- a/package.ps1
+++ b/package.ps1
@@ -1,4 +1,4 @@
 mkdir dist -Force | Out-Null
-mkdir build\lib\net40\ -Force | Out-Null
-cp .\MongoDB.FSharp\bin\Release\MongoDB.FSharp.* .\build\lib\net40\
+mkdir build\lib\net45\ -Force | Out-Null
+cp .\MongoDB.FSharp\bin\Release\MongoDB.Driver.FSharp.* .\build\lib\net45\
 .\.nuget\NuGet.exe pack -OutputDirectory .\dist\ -BasePath .\build\