Clean code up, migrate to netstandard2.0, add nuget package props

Author: Arshia Ghafoori

README.md

@@ -4,9 +4,9 @@
 
 ## How to use
 
-OrleansCassandraUtils is Orleans 2.0 compatible.
+OrleansCassandraUtils is Orleans 3.x compatible.
 
-To set it up, you first need a working Cassandra DB. Create a new keyspace and run the `InitializeOrleansDatabase.cql` script on it. Note that unlike the ADO.Net provider, you can't put data from multiple clusters into one database/keyspace. You **must** create a new keyspace for each cluster.
+To set it up, you first need a working Cassandra DB. Create a new keyspace and run the `InitializeOrleansDatabase.cql` script on it. Note that unlike the ADO.Net provider, you can't put data from multiple clusters into one database/keyspace. You must create a new keyspace for each cluster.
 
 OrleansCassandraUtils uses a custom connection string format not unlike SQL Server connection strings. The parameters (case-insensitive) are as follows:
 
@@ -23,41 +23,41 @@ Then, setup your silo as follows:
 
 ### Grain storage
 
-```
-new SiloHostBuilder().AddCassandraGrainStorageAsDefault((CassandraGrainStorageOptions o) =>
+```csharp
+siloBuilder.AddCassandraGrainStorageAsDefault((CassandraGrainStorageOptions o) =>
 {
     o.ConnctionString = myConnectionString;
     o.AddSerializationProvider(1, new MyCustomSerializationProvider());
 })
 ```
 
-You'll notice the `AddSerializationProvider` call above is unfamiliar. This is an optional feature you can use to provide your own serialization provider, either based on existing providers in Orleans or a new one altogether. You may add up to 127 providers, each with a unique code between 0 and 126. These codes must not change during the entire lifetime of a cluster, as the codes are stored alongside the data and then used to decide which deserializer to use when reading data back from the database. If you don't provide any custom serializers, Orleans' default serializer will be used. Beware however that the default serializer is **not** version-tolerant and you **will** break your entire DB if you make a change to any grain state classes. To implement a custom serializer, simply implement the `OrleansCassandraUtils.Persistence.IStorageSerializationProvider` interface.
+You'll notice the `AddSerializationProvider` call above is unfamiliar. This is an optional feature you can use to provide your own serialization provider, either based on existing providers in Orleans or a new one altogether. You may add up to 127 providers, each with a unique code between 0 and 126. These codes must not change during the entire lifetime of a cluster, as the codes are stored alongside the data and then used to decide which deserializer to use when reading data back from the database. If you don't provide any custom serializers, Orleans' default serializer will be used. Beware however that the default serializer is not version-tolerant and you *will* break your entire DB if you make a change to any grain state classes. To implement a custom serializer, simply implement the `OrleansCassandraUtils.Persistence.IStorageSerializationProvider` interface.
 
-It's also worth mentioning that all grain state is serialized as binary data, since I find XML and JSON to be very inefficient, space- and perfomance-wise ([see](http://geekswithblogs.net/LeonidGaneline/archive/2015/05/06/serializers-in-.net.-v.2.aspx) [here](https://auth0.com/blog/beating-json-performance-with-protobuf/) for example). If you need text serialization, you can turn the resulting string into a UTF-8 byte sequence, though I would recommend against this approach. I prefer [Bond](https://github.com/Microsoft/bond), but you should also check out [Protobuf](https://developers.google.com/protocol-buffers/docs/overview).
+It's also worth mentioning that all grain state is serialized as binary data, since I find XML and JSON to be very inefficient, space- and perfomance-wise ([see](http://geekswithblogs.net/LeonidGaneline/archive/2015/05/06/serializers-in-.net.-v.2.aspx) [here](https://auth0.com/blog/beating-json-performance-with-protobuf/) for example). If you need text serialization, you can turn the resulting string into a UTF-8 byte sequence. I prefer [Bond](https://github.com/Microsoft/bond), but you can also use [Protobuf](https://developers.google.com/protocol-buffers/docs/overview).
 
 ### Clustering
 
 On the silo side:
-```
-new SiloHostBuilder().UseCassandraClustering((CassandraClusteringOptions o) =>
+```csharp
+siloBuilder.UseCassandraClustering((CassandraClusteringOptions o) =>
 {
     o.ConnectionString = myConnectionString;
 })
 ```
 
 and on the client side:
 
-```
-new ClientBuilder().UseCassandraClustering((CassandraClusteringOptions o) =>
+```csharp
+clientBuilder.UseCassandraClustering((CassandraClusteringOptions o) =>
 {
     o.ConnectionString = myConnectionString;
 })
 ```
 
 ### Reminders
 
-```
-new SiloHostBuilder().UseCassandraReminderService((CassandraClusteringOptions o) =>
+```csharp
+siloBuilder.UseCassandraReminderService((CassandraClusteringOptions o) =>
 {
     o.ConnectionString = myConnectionString;
 })
@@ -67,7 +67,7 @@ new SiloHostBuilder().UseCassandraReminderService((CassandraClusteringOptions o)
 
 Cassandra clusters can be a good place to store your non-grain data as well. OrleansCassandraUtils provides the `OrleansCassandraUtils.Utils.CassandraSessionFactory` class, which you may use to acquire a Cassandra session and make custom queries against your cluster as follows:
 
-```
+```csharp
 var session = await CassandraSessionFactory.CreateSession(myConnectionString);
 var queryResults = await Session.ExecuteAsync(new SimpleStatement("select * from my_table"));
 ```

src/Directory.Build.props

@@ -0,0 +1,5 @@
+<Project>
+    <PropertyGroup>
+        <OrleansPackageVersion>3.4.0</OrleansPackageVersion>
+    </PropertyGroup>
+</Project>

src/OrleansCassandraUtils.sln

@@ -1,10 +1,15 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
-VisualStudioVersion = 15.0.27428.2015
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.31129.286
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OrleansCassandraUtils", "OrleansCassandraUtils\OrleansCassandraUtils.csproj", "{31DE8494-D9F1-4812-A877-23621437693D}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{4515FA20-C8E4-435F-8694-BD94B3FA4D56}"
+	ProjectSection(SolutionItems) = preProject
+		Directory.Build.props = Directory.Build.props
+	EndProjectSection
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU

src/OrleansCassandraUtils/Clustering/CassandraClusteringOptions.cs

@@ -1,10 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace OrleansCassandraUtils.Clustering
+namespace OrleansCassandraUtils.Clustering
 {
     public class CassandraClusteringOptions
     {

src/OrleansCassandraUtils/Clustering/CassandraClusteringTable.cs

@@ -1,16 +1,13 @@
-using Orleans;
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
+using System.Net;
 using System.Threading.Tasks;
-using Orleans.Runtime;
-using Orleans.Runtime.Configuration;
-using Orleans.Messaging;
 using Cassandra;
-using OrleansCassandraUtils.Utils;
-using System.Net;
 using Microsoft.Extensions.Options;
+using Orleans;
+using Orleans.Runtime;
+using OrleansCassandraUtils.Utils;
 
 namespace OrleansCassandraUtils.Clustering
 {

src/OrleansCassandraUtils/Clustering/CassandraGatewayListProvider.cs

@@ -1,17 +1,13 @@
-using Cassandra;
-using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Threading.Tasks;
+using Cassandra;
 using Microsoft.Extensions.Options;
 using Orleans.Configuration;
 using Orleans.Messaging;
 using Orleans.Runtime;
-using Orleans.Runtime.Configuration;
 using OrleansCassandraUtils.Utils;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Net;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace OrleansCassandraUtils.Clustering
 {