Merge branch 'AddGeoAdd' of https://github.com/wjdavis5/StackExchange.Redis into wjdavis5-AddGeoAdd

Apply feedback from https://github.com/StackExchange/StackExchange.Redis/pull/489#issuecomment-270615647 - note still untested; that's next

# Conflicts:
#	StackExchange.Redis.Tests/ConnectionFailedErrors.cs
#	StackExchange.Redis/StackExchange/Redis/IDatabase.cs
#	StackExchange.Redis_Net40/StackExchange.Redis_Net40.StrongName.csproj
#	StackExchange.Redis_Net40/StackExchange.Redis_Net40.csproj
#	StackExchange.Redis_Net45/StackExchange.Redis_Net45.StrongName.csproj
#	StackExchange.Redis_Net45/StackExchange.Redis_Net45.csproj
#	StackExchange.Redis_Net46/StackExchange.Redis_Net46.StrongName.csproj
#	StackExchange.Redis_Net46/StackExchange.Redis_Net46.csproj

StackExchange.Redis.Tests/ConnectionFailedErrors.cs

@@ -134,6 +134,7 @@ public void CheckFailureRecovered()
                 ClearAmbientFailures();
             }
         }
+
 #endif
         [Test]
         public void TryGetAzureRoleInstanceIdNoThrow()

StackExchange.Redis.Tests/GeoTests.cs

+using System.Linq;
+using System.Runtime.Remoting;
+using NUnit.Framework;
+
+namespace StackExchange.Redis.Tests
+{
+    [TestFixture]
+    public class GeoTests : TestBase
+    {
+        [Test]
+        public void GeoAddEveryWay()
+        {
+            using (var conn = Create())
+            {
+                var db = conn.GetDatabase(3);
+                var added1 = db.GeoAdd("Sicily", 14.361389, 39.115556, "PalermoPlusOne");
+                var geo1 = new GeoEntry(13.361389, 38.115556, "Palermo");
+                var geo2 = new GeoEntry(15.087269, 37.502669, "Catania");
+                var added2 = db.GeoAdd("Sicily",new GeoEntry[] {geo1,geo2});
+                Assert.IsTrue(added1 & (added2==2));
+            }
+        }
+
+        [Test]
+        public void GetGeoDist()
+        {
+            using (var conn = Create())
+            {
+                var db = conn.GetDatabase(3);
+                var geo1 = new GeoEntry(13.361389, 38.115556, "Palermo");
+                var geo2 = new GeoEntry(15.087269, 37.502669, "Catania");
+                var added2 = db.GeoAdd("Sicily", new GeoEntry[] { geo1, geo2 });
+                var val = db.GeoDistance("Sicily", "Palermo", "Catania",GeoUnit.Meters);
+                Assert.Equals(166274.15156960039, (double) val);
+            }
+        }
+
+        [Test]
+        public void AddSetEveryWay()
+        {
+            using (var conn = Create())
+            {
+                var db = conn.GetDatabase(3);
+
+                RedisKey key = Me();
+                db.KeyDelete(key);
+                db.SetAdd(key, "a");
+                db.SetAdd(key, new RedisValue[] { "b" });
+                db.SetAdd(key, new RedisValue[] { "c", "d" });
+                db.SetAdd(key, new RedisValue[] { "e", "f", "g" });
+                db.SetAdd(key, new RedisValue[] { "h", "i", "j", "k" });
+
+                var vals = db.SetMembers(key);
+                string s = string.Join(",", vals.OrderByDescending(x => x));
+                Assert.AreEqual("k,j,i,h,g,f,e,d,c,b,a", s);
+            }
+        }
+
+        [Test]
+        public void AddSetEveryWayNumbers()
+        {
+            using (var conn = Create())
+            {
+                var db = conn.GetDatabase(3);
+
+                RedisKey key = Me();
+                db.KeyDelete(key);
+                db.SetAdd(key, "a");
+                db.SetAdd(key, new RedisValue[] { "1" });
+                db.SetAdd(key, new RedisValue[] { "11", "2" });
+                db.SetAdd(key, new RedisValue[] { "10", "3", "1.5" });
+                db.SetAdd(key, new RedisValue[] { "2.2", "-1", "s", "t" });
+
+                var vals = db.SetMembers(key);
+                string s = string.Join(",", vals.OrderByDescending(x => x));
+                Assert.AreEqual("t,s,a,11,10,3,2.2,2,1.5,1,-1", s);
+            }
+        }
+    }
+}

StackExchange.Redis.Tests/TestBase.cs

@@ -135,7 +135,7 @@ public void Teardown()
         }
 
         protected const int PrimaryPort = 6379, SlavePort = 6380, SecurePort = 6381;
-        protected const string PrimaryServer = "127.0.0.1", SecurePassword = "changeme", PrimaryPortString = "6379", SlavePortString = "6380", SecurePortString = "6381";
+        protected const string PrimaryServer = "192.168.10.120", SecurePassword = "changeme", PrimaryPortString = "6379", SlavePortString = "6380", SecurePortString = "6381";
         internal static Task Swallow(Task task)
         {
             if (task != null) task.ContinueWith(swallowErrors, TaskContinuationOptions.OnlyOnFaulted);

StackExchange.Redis/StackExchange/Redis/CommandFlags.cs

@@ -2,7 +2,7 @@
 
 namespace StackExchange.Redis
 {
-    /// <summary>
+  /// <summary>
     /// Behaviour markers associated with a given command
     /// </summary>
     [Flags]

StackExchange.Redis/StackExchange/Redis/GeoEntry.cs

+
+using System;
+
+namespace StackExchange.Redis
+{
+    /// <summary>
+    /// GeoRadius command options.
+    /// </summary>
+    [Flags]
+    public enum GeoRadiusOptions
+    {
+        /// <summary>
+        /// No Options
+        /// </summary>
+        None = 0,
+        /// <summary>
+        /// Redis will return the coordinates of any results.
+        /// </summary>
+        WithCoordinates = 1,
+        /// <summary>
+        /// Redis will return the distance from center for all results.
+        /// </summary>
+        WithDistance = 2,
+        /// <summary>
+        /// Redis will return the geo hash value as an integer. (This is the score in the sorted set)
+        /// </summary>
+        WithGeoHash = 4,
+        /// <summary>
+        /// Populates the commonly used values from the entry (the integer hash is not returned as it is not commonly useful)
+        /// </summary>
+        Default = WithCoordinates | GeoRadiusOptions.WithDistance
+    }
+
+    /// <summary>
+    /// The result of a GeoRadius command.
+    /// </summary>
+    public struct GeoRadiusResult
+    {
+        /// <summary>
+        /// The matched member.
+        /// </summary>
+        public RedisValue Member { get; }
+
+
+        /// <summary>
+        /// The distance of the matched member from the center of the geo radius command.
+        /// </summary>
+        public double? Distance { get; }
+
+        /// <summary>
+        /// The hash value of the matched member as an integer. (The key in the sorted set)
+        /// </summary>
+        /// <remarks>Note that this is not the same as the hash returned from GeoHash</remarks>
+        public long? Hash { get; }
+
+        /// <summary>
+        /// The coordinates of the matched member.
+        /// </summary>
+        public GeoPosition? Position { get; }
+
+        /// <summary>
+        /// Returns a new GeoRadiusResult
+        /// </summary>
+        internal GeoRadiusResult(RedisValue member, double? distance, long? hash, GeoPosition? position)
+        {
+            Member = member;
+            Distance = distance;
+            Hash = hash;
+            Position = position;
+        }
+    }
+
+    /// <summary>
+    /// Describes the longitude and latitude of a GeoEntry
+    /// </summary>
+    public struct GeoPosition : IEquatable<GeoPosition>
+    {
+        internal static string GetRedisUnit(GeoUnit unit)
+        {
+            switch (unit)
+            {
+                case GeoUnit.Meters: return "m";
+                case GeoUnit.Kilometers: return "km";
+                case GeoUnit.Miles: return "mi";
+                case GeoUnit.Feet: return "ft";
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(unit));
+            }
+        }
+
+        /// <summary>
+        /// The Latitude of the GeoPosition
+        /// </summary>
+        public double Latitude { get; }
+
+        /// <summary>
+        /// The Logitude of the GeoPosition
+        /// </summary>
+        public double Longitude { get; }
+
+        /// <summary>
+        /// Creates a new GeoPosition
+        /// </summary>
+        /// <param name="longitude"></param>
+        /// <param name="latitude"></param>
+        public GeoPosition(double longitude, double latitude)
+        {
+            Longitude = longitude;
+            Latitude = latitude;
+        }
+
+        /// <summary>
+        /// See Object.ToString()
+        /// </summary>
+        public override string ToString()
+        {
+            return string.Format("{0} {1}", Longitude, Latitude);
+        }
+        /// <summary>
+        /// See Object.GetHashCode()
+        /// Diagonals not an issue in the case of lat/long
+        /// </summary>
+        public override int GetHashCode()
+        {
+            // diagonals not an issue in the case of lat/long
+            return Longitude.GetHashCode() ^ Latitude.GetHashCode();
+        }
+        /// <summary>
+        /// Compares two values for equality
+        /// </summary>
+        public override bool Equals(object obj)
+        {
+            return obj is GeoPosition && Equals((GeoPosition)obj);
+        }
+        /// <summary>
+        /// Compares two values for equality
+        /// </summary>
+        public bool Equals(GeoPosition value)
+        {
+            return this == value;
+        }
+        /// <summary>
+        /// Compares two values for equality
+        /// </summary>
+        public static bool operator ==(GeoPosition x, GeoPosition y)
+        {
+            return x.Longitude == y.Longitude && x.Latitude == y.Latitude;
+        }
+        /// <summary>
+        /// Compares two values for non-equality
+        /// </summary>
+        public static bool operator !=(GeoPosition x, GeoPosition y)
+        {
+            return x.Longitude != y.Longitude || x.Latitude != y.Latitude;
+        }
+    }
+
+    /// <summary>
+    /// Describes a GeoEntry element with the corresponding value
+    /// GeoEntries are stored in redis as SortedSetEntries
+    /// </summary>
+    public struct GeoEntry : IEquatable<GeoEntry>
+    {
+        /// <summary>
+        /// The name of the geo entry
+        /// </summary>
+        public RedisValue Member { get; }
+
+        /// <summary>
+        /// Describes the longitude and latitude of a GeoEntry
+        /// </summary>
+        public GeoPosition Point { get; }
+
+        /// <summary>
+        /// Initializes a GeoEntry value
+        /// </summary>
+        public GeoEntry(double longitude, double latitude, RedisValue member)
+        {
+            Member = member;
+            Point = new GeoPosition(longitude, latitude);
+        }
+
+
+
+        /// <summary>
+        /// The longitude of the geo entry
+        /// </summary>
+        public double Longitude => Point.Longitude;
+
+        /// <summary>
+        /// The latitude of the geo entry
+        /// </summary>
+        public double Latitude => Point.Latitude;
+
+        /// <summary>
+        /// See Object.ToString()
+        /// </summary>
+        public override string ToString()
+        {
+            return $"({Longitude},{Latitude})={Member}";
+        }
+        /// <summary>
+        /// See Object.GetHashCode()
+        /// </summary>
+        public override int GetHashCode()
+        {
+            return Point.GetHashCode() ^ Member.GetHashCode();
+        }
+        /// <summary>
+        /// Compares two values for equality
+        /// </summary>
+        public override bool Equals(object obj)
+        {
+            return obj is GeoEntry && Equals((GeoEntry)obj);
+        }
+        /// <summary>
+        /// Compares two values for equality
+        /// </summary>
+        public bool Equals(GeoEntry value)
+        {
+            return this == value;
+        }
+        /// <summary>
+        /// Compares two values for equality
+        /// </summary>
+        public static bool operator ==(GeoEntry x, GeoEntry y)
+        {
+            return x.Point == y.Point && x.Member == y.Member;
+        }
+        /// <summary>
+        /// Compares two values for non-equality
+        /// </summary>
+        public static bool operator !=(GeoEntry x, GeoEntry y)
+        {
+            return x.Point != y.Point || x.Member != y.Member;
+        }
+    }
+}
\ No newline at end of file

StackExchange.Redis/StackExchange/Redis/GeoUnit.cs

+using System;
+using System.ComponentModel;
+
+namespace StackExchange.Redis
+{
+    /// <summary>
+    /// Units associated with Geo Commands
+    /// </summary>
+    public enum GeoUnit
+    {
+        /// <summary>
+        /// Meters
+        /// </summary>
+        Meters,
+        /// <summary>
+        /// Kilometers
+        /// </summary>
+        Kilometers,
+        /// <summary>
+        /// Miles
+        /// </summary>
+        Miles,
+        /// <summary>
+        /// Feet
+        /// </summary>
+        Feet
+    }
+}
\ No newline at end of file

StackExchange.Redis/StackExchange/Redis/IDatabase.cs

@@ -44,6 +44,86 @@ public interface IDatabase : IRedis, IDatabaseAsync
         /// <remarks>http://redis.io/commands/debug-object</remarks>
         RedisValue DebugObject(RedisKey key, CommandFlags flags = CommandFlags.None);
 
+        /// <summary>
+        /// Add the specified member to the set stored at key. Specified members that are already a member of this set are ignored. If key does not exist, a new set is created before adding the specified members.
+        /// </summary>
+        /// <returns>True if the specified member was not already present in the set, else False</returns>
+        /// <remarks>http://redis.io/commands/geoadd</remarks>
+        bool GeoAdd(RedisKey key, double longitude, double latitude, RedisValue member, CommandFlags flags = CommandFlags.None);
+
+
+        /// <summary>
+        /// Add the specified member to the set stored at key. Specified members that are already a member of this set are ignored. If key does not exist, a new set is created before adding the specified members.
+        /// </summary>
+        /// <returns>True if the specified member was not already present in the set, else False</returns>
+        /// <remarks>http://redis.io/commands/geoadd</remarks>
+        bool GeoAdd(RedisKey key, StackExchange.Redis.GeoEntry value, CommandFlags flags = CommandFlags.None);
+
+
+        /// <summary>
+        /// Add the specified members to the set stored at key. Specified members that are already a member of this set are ignored. If key does not exist, a new set is created before adding the specified members.
+        /// </summary>
+        /// <returns>the number of elements that were added to the set, not including all the elements already present into the set.</returns>
+        /// <remarks>http://redis.io/commands/geoadd</remarks>
+        long GeoAdd(RedisKey key, GeoEntry[] values, CommandFlags flags = CommandFlags.None);
+
+        /// <summary>
+        /// Removes the specified member from the geo sorted set stored at key. Non existing members are ignored.
+        /// </summary>
+        /// <returns>True if the member existed in the sorted set and was removed; False otherwise.</returns>
+        /// <remarks>http://redis.io/commands/zrem</remarks>
+        bool GeoRemove(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None);
+
+        /// <summary>
+        /// Return the distance between two members in the geospatial index represented by the sorted set.
+        /// </summary>
+        /// <returns>The command returns the distance as a double (represented as a string) in the specified unit, or NULL if one or both the elements are missing.</returns>
+        /// <remarks>http://redis.io/commands/geodist</remarks>
+        double GeoDistance(RedisKey key, RedisValue member1, RedisValue member2, GeoUnit unit = GeoUnit.Meters, CommandFlags flags = CommandFlags.None);
+
+        /// <summary>
+        /// Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
+        /// </summary>
+        /// <returns>The command returns an array where each element is the Geohash corresponding to each member name passed as argument to the command.</returns>
+        /// <remarks>http://redis.io/commands/geohash</remarks>
+        string[] GeoHash(RedisKey key, RedisValue[] members, CommandFlags flags = CommandFlags.None);
+
+        /// <summary>
+        /// Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
+        /// </summary>
+        /// <returns>The command returns an array where each element is the Geohash corresponding to each member name passed as argument to the command.</returns>
+        /// <remarks>http://redis.io/commands/geohash</remarks>
+        string[] GeoHash(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None);
+
+
+        /// <summary>
+        /// Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
+        /// </summary>
+        /// <returns>The command returns an array where each element is a two elements array representing longitude and latitude (x,y) of each member name passed as argument to the command.Non existing elements are reported as NULL elements of the array.</returns>
+        /// <remarks>http://redis.io/commands/geopos</remarks>
+        GeoPosition?[] GeoPosition(RedisKey key, RedisValue[] members, CommandFlags flags = CommandFlags.None);
+
+        /// <summary>
+        /// Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
+        /// </summary>
+        /// <returns>The command returns an array where each element is a two elements array representing longitude and latitude (x,y) of each member name passed as argument to the command.Non existing elements are reported as NULL elements of the array.</returns>
+        /// <remarks>http://redis.io/commands/geopos</remarks>
+        GeoPosition? GeoPosition(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None);
+
+        /// <summary>
+        /// Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
+        /// </summary>
+        /// <returns>GeoRadiusResult[]</returns>
+        /// <remarks>http://redis.io/commands/georadius</remarks>
+        GeoRadiusResult[] GeoRadius(RedisKey key, RedisValue member, double radius, GeoUnit unit = GeoUnit.Meters, int count = -1, Order? order = null, GeoRadiusOptions options = GeoRadiusOptions.Default, CommandFlags flags = CommandFlags.None);
+
+        /// <summary>
+        /// Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
+        /// </summary>
+        /// <returns>GeoRadiusResult[]</returns>
+        /// <remarks>http://redis.io/commands/georadius</remarks>
+        GeoRadiusResult[] GeoRadius(RedisKey key, double longitude, double latitude, double radius, GeoUnit unit = GeoUnit.Meters, int count = -1, Order? order = null, GeoRadiusOptions options = GeoRadiusOptions.Default, CommandFlags flags = CommandFlags.None);
+
         /// <summary>
         /// Decrements the number stored at field in the hash stored at key by decrement. If key does not exist, a new key holding a hash is created. If field does not exist or holds a string that cannot be interpreted as integer, the value is set to 0 before the operation is performed.
         /// </summary>

StackExchange.Redis/StackExchange/Redis/KeyspaceIsolation/DatabaseWrapper.cs

@@ -27,6 +27,59 @@ public RedisValue DebugObject(RedisKey key, CommandFlags flags = CommandFlags.No
             return Inner.DebugObject(ToInner(key), flags);
         }
 
+        public bool GeoAdd(RedisKey key, double longitude, double latitude, RedisValue member, CommandFlags flags = CommandFlags.None)
+        {
+            return Inner.GeoAdd(ToInner(key), longitude, latitude, member, flags);
+        }
+
+        public long GeoAdd(RedisKey key, GeoEntry[] geoEntries, CommandFlags flags = CommandFlags.None)
+        {
+            return Inner.GeoAdd(ToInner(key), geoEntries, flags);
+        }
+        public bool GeoAdd(RedisKey key, GeoEntry geoEntry, CommandFlags flags = CommandFlags.None)
+        {
+            return Inner.GeoAdd(key, geoEntry, flags);
+        }
+
+        public bool GeoRemove(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None)
+        {
+            return Inner.GeoRemove(key, member, flags);
+        }
+
+        public double GeoDistance(RedisKey key, RedisValue value0, RedisValue value1, GeoUnit geoUnit = GeoUnit.Meters,CommandFlags flags = CommandFlags.None)
+        {
+            return Inner.GeoDistance(ToInner(key), value0, value1, geoUnit, flags);
+        }
+
+        public string[] GeoHash(RedisKey key, RedisValue[] members, CommandFlags flags = CommandFlags.None)
+        {
+            return Inner.GeoHash(key, members, flags);
+        }
+
+        public string[] GeoHash(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None)
+        {
+            return Inner.GeoHash(key, member, flags);
+        }
+
+        public GeoPosition?[] GeoPosition(RedisKey key, RedisValue[] members, CommandFlags flags = CommandFlags.None)
+        {
+            return Inner.GeoPosition(key, members, flags);
+        }
+
+        public GeoPosition? GeoPosition(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None)
+        {
+            return Inner.GeoPosition(key, member, flags);
+        }
+
+        public GeoRadiusResult[] GeoRadius(RedisKey key, RedisValue member, double radius, GeoUnit unit = GeoUnit.Meters, int count = -1, Order? order = null,GeoRadiusOptions options = GeoRadiusOptions.Default, CommandFlags flags = CommandFlags.None)
+        {
+            return Inner.GeoRadius(key, member, radius, unit, count, order, options, flags);
+        }
+        public GeoRadiusResult[] GeoRadius(RedisKey key, double longitude, double latitude, double radius, GeoUnit unit = GeoUnit.Meters, int count = -1, Order? order = null, GeoRadiusOptions options = GeoRadiusOptions.Default, CommandFlags flags = CommandFlags.None)
+        {
+            return Inner.GeoRadius(key, longitude, latitude, radius, unit, count, order, options, flags);
+        }
+
         public double HashDecrement(RedisKey key, RedisValue hashField, double value, CommandFlags flags = CommandFlags.None)
         {
             return Inner.HashDecrement(ToInner(key), hashField, value, flags);

StackExchange.Redis/StackExchange/Redis/RawResult.cs

@@ -230,6 +230,64 @@ internal RedisValue[] GetItemsAsValues()
                 return arr;
             }
         }
+        static readonly string[] NilStrings = new string[0];
+        internal string[] GetItemsAsStrings()
+        {
+            RawResult[] items = GetItems();
+            if (items == null)
+            {
+                return null;
+            }
+            else if (items.Length == 0)
+            {
+                return NilStrings;
+            }
+            else
+            {
+                var arr = new string[items.Length];
+                for (int i = 0; i < arr.Length; i++)
+                {
+                    arr[i] = (string)(items[i].AsRedisValue());
+                }
+                return arr;
+            }
+        }
+
+        internal GeoPosition?[] GetItemsAsGeoPositionArray()
+        {
+            RawResult[] items = GetItems();
+            if (items == null)
+            {
+                return null;
+            }
+            else if (items.Length == 0)
+            {
+                return new GeoPosition?[0];
+            }
+            else
+            {
+                var arr = new GeoPosition?[items.Length];
+                for (int i = 0; i < arr.Length; i++)
+                {
+                    RawResult[] item = items[i].GetArrayOfRawResults();
+                    if (item == null)
+                    {
+                        arr[i] = null;
+                    }
+                    else
+                    {
+                        arr[i] = new GeoPosition((double)item[0].AsRedisValue(), (double)item[1].AsRedisValue());
+                    }
+                }
+                return arr;
+            }
+        }
+
+        internal RawResult[] GetItemsAsRawResults()
+        {
+            return GetItems();
+        }
+
 
         // returns an array of RawResults
         internal RawResult[] GetArrayOfRawResults()

StackExchange.Redis/StackExchange/Redis/RedisCommand.cs

@@ -38,6 +38,13 @@ enum RedisCommand
         FLUSHALL,
         FLUSHDB,
 
+        GEOADD,
+        GEODIST,
+        GEOHASH,
+        GEOPOS,
+        GEORADIUS,
+        GEORADIUSBYMEMBER,
+
         GET,
         GETBIT,
         GETRANGE,

StackExchange.Redis/StackExchange/Redis/RedisDatabase.cs

 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Net;
 using System.Threading.Tasks;
 
@@ -45,6 +46,102 @@ public RedisValue DebugObject(RedisKey key, CommandFlags flags = CommandFlags.No
             return ExecuteSync(msg, ResultProcessor.RedisValue);
         }
 
+        public bool GeoAdd(RedisKey key, double longitude, double latitude, RedisValue member, CommandFlags flags = CommandFlags.None)
+        {
+            return GeoAdd(key, new GeoEntry(longitude, latitude, member), flags);
+        }
+
+        public bool GeoAdd(RedisKey key, GeoEntry value, CommandFlags flags = CommandFlags.None)
+        {
+            var msg = Message.Create(Database, flags, RedisCommand.GEOADD, key, value.Longitude, value.Latitude, value.Member);
+            return ExecuteSync(msg, ResultProcessor.Boolean);
+        }
+
+        public long GeoAdd(RedisKey key, GeoEntry[] values, CommandFlags flags = CommandFlags.None)
+        {
+            var msg = Message.Create(Database, flags, RedisCommand.GEOADD, key, values);
+            return ExecuteSync(msg, ResultProcessor.Int64);
+        }
+
+        public bool GeoRemove(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None)
+        {
+            return SortedSetRemove(key, member, flags);
+        }
+
+        public double GeoDistance(RedisKey key, RedisValue value0, RedisValue value1, GeoUnit unit = GeoUnit.Meters, CommandFlags flags = CommandFlags.None)
+        {
+            var msg = Message.Create(Database, flags, RedisCommand.GEODIST, key, value0, value1, StackExchange.Redis.GeoPosition.GetRedisUnit(unit));
+            return (double)ExecuteSync(msg, ResultProcessor.RedisValue);
+        }
+
+        public string[] GeoHash(RedisKey key, RedisValue[] members, CommandFlags flags = CommandFlags.None)
+        {
+            if (members == null) throw new ArgumentNullException(nameof(members));
+            var redisValues = new RedisValue[members.Length];
+            for (var i = 0; i < members.Length; i++) redisValues[i] = members[i];
+            var msg = Message.Create(Database, flags, RedisCommand.GEOHASH, key, redisValues);
+            return ExecuteSync(msg, ResultProcessor.StringArray);
+        }
+
+        public string[] GeoHash(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None)
+        {
+            return GeoHash(key, new[] { member }, flags);
+        }
+
+        public GeoPosition?[] GeoPosition(RedisKey key, RedisValue[] members, CommandFlags flags = CommandFlags.None)
+        {
+            if (members == null) throw new ArgumentNullException(nameof(members));
+            var redisValues = new RedisValue[members.Length];
+            for (var i = 0; i < members.Length; i++) redisValues[i] = members[i];
+            var msg = Message.Create(Database, flags, RedisCommand.GEOPOS, key, redisValues);
+            return ExecuteSync(msg, ResultProcessor.RedisGeoPosition);
+        }
+
+        public GeoPosition? GeoPosition(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None)
+        {
+            return GeoPosition(key, new[] { member }, flags)[0];
+        }
+        private Message GetGeoRadiusMessage(RedisKey key, RedisValue? member, double longitude, double latitude, double radius, GeoUnit unit, int count, Order? order, GeoRadiusOptions options, CommandFlags flags)
+        {
+            var redisValues = new List<RedisValue>();
+            RedisCommand command;
+            if (member == null)
+            {
+                redisValues.Add(longitude);
+                redisValues.Add(latitude);
+                command = RedisCommand.GEORADIUS;
+            }
+            else
+            {
+                redisValues.Add(member.Value);
+                command = RedisCommand.GEORADIUSBYMEMBER;
+            }
+            redisValues.Add(radius);
+            redisValues.Add(StackExchange.Redis.GeoPosition.GetRedisUnit(unit));
+            if ((options & GeoRadiusOptions.WithCoordinates) != 0) redisValues.Add("WITHCOORD");
+            if ((options & GeoRadiusOptions.WithDistance) != 0) redisValues.Add("WITHDIST");
+            if ((options & GeoRadiusOptions.WithGeoHash) != 0) redisValues.Add("WITHHASH");
+            if (count > 0) redisValues.Add(count);
+            if (order != null)
+            {
+                switch (order.Value)
+                {
+                    case Order.Ascending: redisValues.Add("ASC"); break;
+                    case Order.Descending: redisValues.Add("DESC"); break;
+                    default: throw new ArgumentOutOfRangeException(nameof(order));
+                }
+            }
+
+            return Message.Create(Database, flags, command, key, redisValues.ToArray());
+        }
+        public GeoRadiusResult[] GeoRadius(RedisKey key, RedisValue member, double radius, GeoUnit unit, int count, Order? order, GeoRadiusOptions options, CommandFlags flags)
+        {
+            return ExecuteSync(GetGeoRadiusMessage(key, member, double.NaN, double.NaN, radius, unit, count, order, options, flags), ResultProcessor.GeoRadiusArray(options));
+        }
+        public GeoRadiusResult[] GeoRadius(RedisKey key, double longitude, double latitude, double radius, GeoUnit unit, int count, Order? order, GeoRadiusOptions options, CommandFlags flags)
+        {
+            return ExecuteSync(GetGeoRadiusMessage(key, null, longitude, latitude, radius, unit, count, order, options, flags), ResultProcessor.GeoRadiusArray(options));
+        }
         public Task<RedisValue> DebugObjectAsync(RedisKey key, CommandFlags flags = CommandFlags.None)
         {
             var msg = Message.Create(Database, flags, RedisCommand.DEBUG, RedisLiterals.OBJECT, key);
@@ -310,7 +407,7 @@ public long HyperLogLogLength(RedisKey[] keys, CommandFlags flags = CommandFlags
                 var features = GetFeatures(Database, keys[0], flags, out server);
                 // technically a write / master-only command until 2.8.18
                 if (server != null && !features.HyperLogLogCountSlaveSafe) cmd.SetMasterOnly();
-            }            
+            }
             return ExecuteSync(cmd, ResultProcessor.Int64, server);
         }
 
@@ -926,7 +1023,6 @@ public Task<RedisResult> ScriptEvaluateAsync(LoadedLuaScript script, object para
         {
             return script.EvaluateAsync(this, parameters, null, flags);
         }
-
         public bool SetAdd(RedisKey key, RedisValue value, CommandFlags flags = CommandFlags.None)
         {
             var msg = Message.Create(Database, flags, RedisCommand.SADD, key, value);
@@ -1685,8 +1781,9 @@ private Message GetHashSetMessage(RedisKey key, HashEntry[] hashFields, CommandF
             switch (hashFields.Length)
             {
                 case 0: return null;
-                case 1: return Message.Create(Database, flags, RedisCommand.HMSET, key,
-                        hashFields[0].name, hashFields[0].value);
+                case 1:
+                    return Message.Create(Database, flags, RedisCommand.HMSET, key,
+                    hashFields[0].name, hashFields[0].value);
                 case 2:
                     return Message.Create(Database, flags, RedisCommand.HMSET, key,
                         hashFields[0].name, hashFields[0].value,
@@ -2471,4 +2568,4 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
             }
         }
     }
-}
+}

StackExchange.Redis/StackExchange/Redis/SortedSetEntry.cs

@@ -4,6 +4,10 @@
 
 namespace StackExchange.Redis
 {
+
+
+    
+
     /// <summary>
     /// Describes a sorted-set element with the corresponding value
     /// </summary>