Merge branch 'wjdavis5-AddGeoAdd'

StackExchange.Redis.Tests/ConnectionFailedErrors.cs

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

StackExchange.Redis.Tests/GeoTests.cs

+using NUnit.Framework;
+using System;
+using System.IO;
+using System.Linq;
+
+namespace StackExchange.Redis.Tests
+{
+    public class AzureTestAttribute : TestAttribute
+    {
+        
+    }
+    [TestFixture]
+    public class GeoTests : TestBase
+    {
+        private ConnectionMultiplexer Create()
+        {
+            string name, password;
+            GetAzureCredentials(out name, out password);
+            var options = new ConfigurationOptions();
+            options.EndPoints.Add(name + ".redis.cache.windows.net");
+            options.Ssl = true;
+            options.ConnectTimeout = 5000;
+            options.Password = password;
+            options.TieBreaker = "";
+            var log = new StringWriter();
+            var conn = ConnectionMultiplexer.Connect(options, log);
+            var s = log.ToString();
+            Console.WriteLine(s);
+            return conn;
+        }
+        public const int Db = 0;
+
+        public static GeoEntry
+            palermo = new GeoEntry(13.361389, 38.115556, "Palermo"),
+            catania = new GeoEntry(15.087269, 37.502669, "Catania"),
+            agrigento = new GeoEntry(13.5765, 37.311, "Agrigento"),
+            cefal = new GeoEntry(14.0188, 38.0084, "Cefal");
+        public static GeoEntry[] all = { palermo, catania, agrigento , cefal };
+        [AzureTest]
+        public void GeoAdd()
+        {
+            using (var conn = Create())
+            {
+                var db = conn.GetDatabase(Db);
+                RedisKey key = Me();
+                db.KeyDelete(key);
+                
+                // add while not there
+                Assert.IsTrue(db.GeoAdd(key, cefal.Longitude, cefal.Latitude, cefal.Member));
+                Assert.AreEqual(2, db.GeoAdd(key, new GeoEntry[] { palermo, catania }));                
+                Assert.IsTrue(db.GeoAdd(key, agrigento));
+
+                // now add again
+                Assert.IsFalse(db.GeoAdd(key, cefal.Longitude, cefal.Latitude, cefal.Member));
+                Assert.AreEqual(0, db.GeoAdd(key, new GeoEntry[] { palermo, catania }));
+                Assert.IsFalse(db.GeoAdd(key, agrigento));
+
+
+            }
+        }
+
+        [AzureTest]
+        public void GetDistance()
+        {
+            using (var conn = Create())
+            {
+                var db = conn.GetDatabase(Db);
+                RedisKey key = Me();
+                db.KeyDelete(key);
+                db.GeoAdd(key, all);
+                var val = db.GeoDistance(key, "Palermo", "Catania", GeoUnit.Meters);
+                Assert.IsTrue(val.HasValue);
+                var rounded = Math.Round(val.Value, 10);
+                Assert.AreEqual(166274.1516, val);
+
+
+                val = db.GeoDistance(key, "Palermo", "Nowhere", GeoUnit.Meters);
+                Assert.IsFalse(val.HasValue);
+            }
+        }
+
+        [AzureTest]
+        public void GeoHash()
+        {
+            using (var conn = Create())
+            {
+                var db = conn.GetDatabase(Db);
+                RedisKey key = Me();
+                db.KeyDelete(key);
+                db.GeoAdd(key, all);
+
+                var hashes = db.GeoHash(key, new RedisValue[] { palermo.Member, "Nowhere", agrigento.Member });
+                Assert.AreEqual(3, hashes.Length);
+                Assert.AreEqual("sqc8b49rny0", hashes[0]);
+                Assert.IsNull(hashes[1]);
+                Assert.AreEqual("sq9skbq0760", hashes[2]);
+
+                var hash = db.GeoHash(key, "Palermo");
+                Assert.AreEqual("sqc8b49rny0", hash);
+
+                hash = db.GeoHash(key, "Nowhere");
+                Assert.IsNull(hash);
+            }
+        }
+
+        [AzureTest]
+        public void GeoGetPosition()
+        {
+            using (var conn = Create())
+            {
+                var db = conn.GetDatabase(Db);
+                RedisKey key = Me();
+                db.KeyDelete(key);
+                db.GeoAdd(key, all);
+
+                var pos = db.GeoPosition(key, palermo.Member);
+                Assert.IsTrue(pos.HasValue);
+                Assert.AreEqual(Math.Round(palermo.Longitude, 6), Math.Round(pos.Value.Longitude, 6));
+                Assert.AreEqual(Math.Round(palermo.Latitude, 6), Math.Round(pos.Value.Latitude, 6));
+
+                pos = db.GeoPosition(key, "Nowhere");
+                Assert.IsFalse(pos.HasValue);
+            }
+        }
+
+        [AzureTest]
+        public void GeoRemove()
+        {
+            using (var conn = Create())
+            {
+                var db = conn.GetDatabase(Db);
+                RedisKey key = Me();
+                db.KeyDelete(key);
+                db.GeoAdd(key, all);
+
+                var pos = db.GeoPosition(key, "Palermo");
+                Assert.IsTrue(pos.HasValue);
+
+                Assert.IsFalse(db.GeoRemove(key, "Nowhere"));
+                Assert.IsTrue(db.GeoRemove(key, "Palermo"));
+                Assert.IsFalse(db.GeoRemove(key, "Palermo"));
+
+                pos = db.GeoPosition(key, "Palermo");
+                Assert.IsFalse(pos.HasValue);
+            }
+        }
+
+        [AzureTest]
+        public void GeoRadius()
+        {
+            using (var conn = Create())
+            {
+                var db = conn.GetDatabase(Db);
+                RedisKey key = Me();
+                db.KeyDelete(key);
+                db.GeoAdd(key, all);
+
+                var results = db.GeoRadius(key, cefal.Member, 60, GeoUnit.Miles, 2, Order.Ascending);
+                Assert.AreEqual(2, results.Length);
+
+                Assert.AreEqual(results[0].Member, cefal.Member);
+                Assert.AreEqual(0, results[0].Distance.Value);
+                Assert.AreEqual(Math.Round(results[0].Position.Value.Longitude, 5), Math.Round(cefal.Position.Longitude, 5));
+                Assert.AreEqual(Math.Round(results[0].Position.Value.Latitude, 5), Math.Round(cefal.Position.Latitude, 5));
+                Assert.IsFalse(results[0].Hash.HasValue);
+
+                Assert.AreEqual(results[1].Member, palermo.Member);
+                Assert.AreEqual(Math.Round(36.5319, 6), Math.Round(results[1].Distance.Value, 6));
+                Assert.AreEqual(Math.Round(results[1].Position.Value.Longitude, 5), Math.Round(palermo.Position.Longitude, 5));
+                Assert.AreEqual(Math.Round(results[1].Position.Value.Latitude, 5), Math.Round(palermo.Position.Latitude, 5));
+                Assert.IsFalse(results[1].Hash.HasValue);
+
+                results = db.GeoRadius(key, cefal.Member, 60, GeoUnit.Miles, 2, Order.Ascending, GeoRadiusOptions.None);
+                Assert.AreEqual(2, results.Length);
+                Assert.AreEqual(results[0].Member, cefal.Member);
+                Assert.IsFalse(results[0].Position.HasValue);
+                Assert.IsFalse(results[0].Distance.HasValue);
+                Assert.IsFalse(results[0].Hash.HasValue);
+
+                Assert.AreEqual(results[1].Member, palermo.Member);
+                Assert.IsFalse(results[1].Position.HasValue);
+                Assert.IsFalse(results[1].Distance.HasValue);
+                Assert.IsFalse(results[1].Hash.HasValue);
+            }
+        }
+    }
+}

StackExchange.Redis.Tests/HyperLogLog.cs

 using NUnit.Framework;
+using System.IO;
 
 namespace StackExchange.Redis.Tests
 {

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>
+        /// Indicate the member being represented
+        /// </summary>
+        public override string ToString() => Member.ToString();
+        /// <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 Position { get; }
+
+        /// <summary>
+        /// Initializes a GeoEntry value
+        /// </summary>
+        public GeoEntry(double longitude, double latitude, RedisValue member)
+        {
+            Member = member;
+            Position = new GeoPosition(longitude, latitude);
+        }
+
+
+
+        /// <summary>
+        /// The longitude of the geo entry
+        /// </summary>
+        public double Longitude => Position.Longitude;
+
+        /// <summary>
+        /// The latitude of the geo entry
+        /// </summary>
+        public double Latitude => Position.Latitude;
+
+        /// <summary>
+        /// See Object.ToString()
+        /// </summary>
+        public override string ToString()
+        {
+            return $"({Longitude},{Latitude})={Member}";
+        }
+        /// <summary>
+        /// See Object.GetHashCode()
+        /// </summary>
+        public override int GetHashCode()
+        {
+            return Position.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.Position == y.Position && x.Member == y.Member;
+        }
+        /// <summary>
+        /// Compares two values for non-equality
+        /// </summary>
+        public static bool operator !=(GeoEntry x, GeoEntry y)
+        {
+            return x.Position != y.Position || 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/IDatabaseAsync.cs

@@ -16,6 +16,87 @@ public interface IDatabaseAsync : IRedisAsync
         /// <remarks>http://redis.io/commands/debug-object</remarks>
         Task<RedisValue> DebugObjectAsync(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>
+        Task<bool> GeoAddAsync(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>
+        Task<bool> GeoAddAsync(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>
+        Task<long> GeoAddAsync(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>
+        Task<bool> GeoRemoveAsync(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>
+        Task<double?> GeoDistanceAsync(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>
+        Task<string[]> GeoHashAsync(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>
+        Task<string> GeoHashAsync(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>
+        Task<GeoPosition?[]> GeoPositionAsync(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>
+        Task<GeoPosition?> GeoPositionAsync(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>
+        Task<GeoRadiusResult[]> GeoRadiusAsync(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>
+        Task<GeoRadiusResult[]> GeoRadiusAsync(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>
         /// Increments the number stored at field in the hash stored at key by increment. 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(ToInner(key), geoEntry, flags);
+        }
+
+        public bool GeoRemove(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None)
+        {
+            return Inner.GeoRemove(ToInner(key), member, flags);
+        }
+
+        public double? GeoDistance(RedisKey key, RedisValue value0, RedisValue value1, GeoUnit unit = GeoUnit.Meters,CommandFlags flags = CommandFlags.None)
+        {
+            return Inner.GeoDistance(ToInner(key), value0, value1, unit, flags);
+        }
+
+        public string[] GeoHash(RedisKey key, RedisValue[] members, CommandFlags flags = CommandFlags.None)
+        {
+            return Inner.GeoHash(ToInner(key), members, flags);
+        }
+
+        public string GeoHash(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None)
+        {
+            return Inner.GeoHash(ToInner(key), member, flags);
+        }
+
+        public GeoPosition?[] GeoPosition(RedisKey key, RedisValue[] members, CommandFlags flags = CommandFlags.None)
+        {
+            return Inner.GeoPosition(ToInner(key), members, flags);
+        }
+
+        public GeoPosition? GeoPosition(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None)
+        {
+            return Inner.GeoPosition(ToInner(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(ToInner(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(ToInner(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/KeyspaceIsolation/WrapperBase.cs

@@ -24,6 +24,41 @@ public Task<RedisValue> DebugObjectAsync(RedisKey key, CommandFlags flags = Comm
             return Inner.DebugObjectAsync(ToInner(key), flags);
         }
 
+        public Task<bool> GeoAddAsync(RedisKey key, double longitude, double latitude, RedisValue member, CommandFlags flags = CommandFlags.None)
+            => Inner.GeoAddAsync(ToInner(key), longitude, latitude, member, flags);
+
+        public Task<bool> GeoAddAsync(RedisKey key, StackExchange.Redis.GeoEntry value, CommandFlags flags = CommandFlags.None)
+            => Inner.GeoAddAsync(ToInner(key), value, flags);
+
+        public Task<long> GeoAddAsync(RedisKey key, StackExchange.Redis.GeoEntry[] values, CommandFlags flags = CommandFlags.None)
+            => Inner.GeoAddAsync(ToInner(key), values, flags);
+
+        public Task<bool> GeoRemoveAsync(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None)
+            => Inner.GeoRemoveAsync(ToInner(key), member, flags);
+
+        public Task<double?> GeoDistanceAsync(RedisKey key, RedisValue member1, RedisValue member2, GeoUnit unit = GeoUnit.Meters, CommandFlags flags = CommandFlags.None)
+            => Inner.GeoDistanceAsync(ToInner(key), member1, member2, unit, flags);
+
+        public Task<string[]> GeoHashAsync(RedisKey key, RedisValue[] members, CommandFlags flags = CommandFlags.None)
+            => Inner.GeoHashAsync(ToInner(key), members, flags);
+
+        public Task<string> GeoHashAsync(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None)
+            => Inner.GeoHashAsync(ToInner(key), member, flags);
+
+
+        public Task<GeoPosition?[]> GeoPositionAsync(RedisKey key, RedisValue[] members, CommandFlags flags = CommandFlags.None)
+            => Inner.GeoPositionAsync(ToInner(key), members, flags);
+
+        public Task<GeoPosition?> GeoPositionAsync(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None)
+            => Inner.GeoPositionAsync(ToInner(key), member, flags);
+
+        public Task<GeoRadiusResult[]> GeoRadiusAsync(RedisKey key, RedisValue member, double radius, GeoUnit unit = GeoUnit.Meters, int count = -1, Order? order = null, GeoRadiusOptions options = GeoRadiusOptions.Default, CommandFlags flags = CommandFlags.None)
+            => Inner.GeoRadiusAsync(ToInner(key), member, radius, unit, count, order, options, flags);
+
+        public Task<GeoRadiusResult[]> GeoRadiusAsync(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)
+            => Inner.GeoRadiusAsync(ToInner(key), longitude, latitude, radius, unit, count, order, options, flags);
+
+
         public Task<double> HashDecrementAsync(RedisKey key, RedisValue hashField, double value, CommandFlags flags = CommandFlags.None)
         {
             return Inner.HashDecrementAsync(ToInner(key), hashField, value, flags);

StackExchange.Redis/StackExchange/Redis/RawResult.cs

@@ -230,6 +230,78 @@ 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? GetItemsAsGeoPosition()
+        {
+            RawResult[] items = GetItems();
+            if (items == null || items.Length == 0)
+            {
+                return null;
+            }
+           
+            var coords = items[0].GetArrayOfRawResults();
+            if (coords == null)
+            {
+                return null;
+            }            
+            return new GeoPosition((double)coords[0].AsRedisValue(), (double)coords[1].AsRedisValue());
+        }
+        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/RedisFeatures.cs

@@ -27,7 +27,8 @@ public struct RedisFeatures
                                          v2_8_12 = new Version(2, 8, 12),
                                          v2_8_18 = new Version(2, 8, 18),
                                          v2_9_5 = new Version(2, 9, 5),
-                                         v3_0_0 = new Version(3, 0, 0);
+                                         v3_0_0 = new Version(3, 0, 0),
+                                         v3_2_0 = new Version(3, 2, 0);
 
         private readonly Version version;
         /// <summary>
@@ -144,6 +145,11 @@ public RedisFeatures(Version version)
         /// </summary>
         public bool HyperLogLogCountSlaveSafe => Version >= v2_8_18;
 
+        /// <summary>
+        /// Are the GEO commands available?
+        /// </summary>
+        public bool Geo => Version >= v3_2_0;
+
         /// <summary>
         /// The Redis version of the server
         /// </summary>

StackExchange.Redis/StackExchange/Redis/SortedSetEntry.cs

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