Attempt to fix the whitespace/encoding issue with Emacs.

.gitignore

-.hg
-bin
-bin.snk
-obj
-*.suo
-*.user
-*.nupkg
-packages/NuGet.CommandLine.*
-*.sln.docstates
-_ReSharper.*
-Mono/
-*.sln.ide
-*.rdb
-*.aof
-*.orig
-redis-cli.exe
-Redis Configs/*.dat
-RedisQFork*.dat
-StackExchange.Redis.*.zip
-.vs/
-*.lock.json
+.hg
+bin
+bin.snk
+obj
+*.suo
+*.user
+*.nupkg
+packages/NuGet.CommandLine.*
+*.sln.docstates
+_ReSharper.*
+Mono/
+*.sln.ide
+*.rdb
+*.aof
+*.orig
+redis-cli.exe
+Redis Configs/*.dat
+RedisQFork*.dat
+StackExchange.Redis.*.zip
+.vs/
+*.lock.json
\ No newline at end of file

StackExchange.Redis.Tests/WithKeyPrefixTests.cs

-using System;
-using NUnit.Framework;
-using StackExchange.Redis.KeyspaceIsolation;
-
-namespace StackExchange.Redis.Tests
-{
-
-    [TestFixture]
-    public class WithKeyPrefixTests : TestBase
-    {
-        [Test]
-        public void BlankPrefixYieldsSame_Bytes()
-        {
-            using (var conn = Create())
-            {
-                var raw = conn.GetDatabase(1);
-                var prefixed = raw.WithKeyPrefix(new byte[0]);
-                Assert.AreSame(raw, prefixed);
-            }
-        }
-        [Test]
-        public void BlankPrefixYieldsSame_String()
-        {
-            using (var conn = Create())
-            {
-                var raw = conn.GetDatabase(1);
-                var prefixed = raw.WithKeyPrefix("");
-                Assert.AreSame(raw, prefixed);
-            }
-        }
-        [Test]
-        public void NullPrefixIsError_Bytes()
-        {
-            Assert.Throws<ArgumentNullException>(() => {
-                using (var conn = Create())
-                {
-                    var raw = conn.GetDatabase(1);
-                    var prefixed = raw.WithKeyPrefix((byte[])null);
-                }
-            });
-        }
-
-        [Test]
-        public void NullPrefixIsError_String()
-        {
-            Assert.Throws<ArgumentNullException>(() => {
-                using (var conn = Create())
-                {
-                    var raw = conn.GetDatabase(1);
-                    var prefixed = raw.WithKeyPrefix((string)null);
-                }
-            });
-        }
-
-        [Test]
-        [TestCase("abc")]
-        [TestCase("")]
-        [TestCase(null)]
-        public void NullDatabaseIsError(string prefix)
-        {
-            Assert.Throws<ArgumentNullException>(() => {
-                IDatabase raw = null;
-                var prefixed = raw.WithKeyPrefix(prefix);
-            });
-        }
-
-        [Test]
-        public void BasicSmokeTest()
-        {
-            using(var conn = Create())
-            {
-                var raw = conn.GetDatabase(1);
-
-                var foo = raw.WithKeyPrefix("foo");
-                var foobar = foo.WithKeyPrefix("bar");
-
-                string key = Me();
-
-                string s = Guid.NewGuid().ToString(), t = Guid.NewGuid().ToString();
-
-                foo.StringSet(key, s);
-                var val = (string)foo.StringGet(key);
-                Assert.AreEqual(s, val); // fooBasicSmokeTest
-
-                foobar.StringSet(key, t);
-                val = (string)foobar.StringGet(key);
-                Assert.AreEqual(t, val); // foobarBasicSmokeTest
-
-                val = (string)foo.StringGet("bar" + key);
-                Assert.AreEqual(t, val); // foobarBasicSmokeTest
-
-                val = (string)raw.StringGet("foo" + key);
-                Assert.AreEqual(s, val); // fooBasicSmokeTest
-
-                val = (string)raw.StringGet("foobar" + key);
-                Assert.AreEqual(t, val); // foobarBasicSmokeTest
-            }
-        }
-        [Test]
-        public void ConditionTest()
-        {
-            using(var conn = Create())
-            {
-                var raw = conn.GetDatabase(2);
-
-                var foo = raw.WithKeyPrefix("tran:");
-
-                raw.KeyDelete("tran:abc");
-                raw.KeyDelete("tran:i");
-
-                // execute while key exists
-                raw.StringSet("tran:abc", "def");
-                var tran = foo.CreateTransaction();
-                tran.AddCondition(Condition.KeyExists("abc"));
-                tran.StringIncrementAsync("i");
-                tran.Execute();
-
-                int i = (int)raw.StringGet("tran:i");
-                Assert.AreEqual(1, i);
-
-                // repeat without key
-                raw.KeyDelete("tran:abc");
-                tran = foo.CreateTransaction();
-                tran.AddCondition(Condition.KeyExists("abc"));
-                tran.StringIncrementAsync("i");
-                tran.Execute();
-
-                i = (int)raw.StringGet("tran:i");
-                Assert.AreEqual(1, i);
-            }
-        }
-    }
-}
+using System;
+using NUnit.Framework;
+using StackExchange.Redis.KeyspaceIsolation;
+
+namespace StackExchange.Redis.Tests
+{
+
+    [TestFixture]
+    public class WithKeyPrefixTests : TestBase
+    {
+        [Test]
+        public void BlankPrefixYieldsSame_Bytes()
+        {
+            using (var conn = Create())
+            {
+                var raw = conn.GetDatabase(1);
+                var prefixed = raw.WithKeyPrefix(new byte[0]);
+                Assert.AreSame(raw, prefixed);
+            }
+        }
+        [Test]
+        public void BlankPrefixYieldsSame_String()
+        {
+            using (var conn = Create())
+            {
+                var raw = conn.GetDatabase(1);
+                var prefixed = raw.WithKeyPrefix("");
+                Assert.AreSame(raw, prefixed);
+            }
+        }
+        [Test]
+        public void NullPrefixIsError_Bytes()
+        {
+            Assert.Throws<ArgumentNullException>(() => {
+                using (var conn = Create())
+                {
+                    var raw = conn.GetDatabase(1);
+                    var prefixed = raw.WithKeyPrefix((byte[])null);
+                }
+            });
+        }
+        [Test]
+        public void NullPrefixIsError_String()
+        {
+            Assert.Throws<ArgumentNullException>(() => {
+                using (var conn = Create())
+                {
+                    var raw = conn.GetDatabase(1);
+                    var prefixed = raw.WithKeyPrefix((string)null);
+                }
+            });
+        }
+
+        [Test]
+        [TestCase("abc")]
+        [TestCase("")]
+        [TestCase(null)]
+        public void NullDatabaseIsError(string prefix)
+        {
+            Assert.Throws<ArgumentNullException>(() => {
+                IDatabase raw = null;
+                var prefixed = raw.WithKeyPrefix(prefix);
+            });
+        }
+        [Test]
+        public void BasicSmokeTest()
+        {
+            using(var conn = Create())
+            {
+                var raw = conn.GetDatabase(1);
+
+                var foo = raw.WithKeyPrefix("foo");
+                var foobar = foo.WithKeyPrefix("bar");
+
+                string key = Me();
+
+                string s = Guid.NewGuid().ToString(), t = Guid.NewGuid().ToString();
+
+                foo.StringSet(key, s);
+                var val = (string)foo.StringGet(key);
+                Assert.AreEqual(s, val); // fooBasicSmokeTest
+
+                foobar.StringSet(key, t);
+                val = (string)foobar.StringGet(key);
+                Assert.AreEqual(t, val); // foobarBasicSmokeTest
+
+                val = (string)foo.StringGet("bar" + key);
+                Assert.AreEqual(t, val); // foobarBasicSmokeTest
+
+                val = (string)raw.StringGet("foo" + key);
+                Assert.AreEqual(s, val); // fooBasicSmokeTest
+
+                val = (string)raw.StringGet("foobar" + key);
+                Assert.AreEqual(t, val); // foobarBasicSmokeTest
+            }
+        }
+        [Test]
+        public void ConditionTest()
+        {
+            using(var conn = Create())
+            {
+                var raw = conn.GetDatabase(2);
+
+                var foo = raw.WithKeyPrefix("tran:");
+
+                raw.KeyDelete("tran:abc");
+                raw.KeyDelete("tran:i");
+
+                // execute while key exists
+                raw.StringSet("tran:abc", "def");
+                var tran = foo.CreateTransaction();
+                tran.AddCondition(Condition.KeyExists("abc"));
+                tran.StringIncrementAsync("i");
+                tran.Execute();
+
+                int i = (int)raw.StringGet("tran:i");
+                Assert.AreEqual(1, i);
+
+                // repeat without key
+                raw.KeyDelete("tran:abc");
+                tran = foo.CreateTransaction();
+                tran.AddCondition(Condition.KeyExists("abc"));
+                tran.StringIncrementAsync("i");
+                tran.Execute();
+
+                i = (int)raw.StringGet("tran:i");
+                Assert.AreEqual(1, i);
+            }
+        }
+    }
+}

StackExchange.Redis.Tests/WrapperBaseTests.cs

@@ -16,7 +16,6 @@ public sealed class WrapperBaseTests
         private Mock<IDatabaseAsync> mock;
         private WrapperBase<IDatabaseAsync> wrapper;
 
-        //[TestFixtureSetUp]
         [OneTimeSetUp]
         public void Initialize()
         {
@@ -891,4 +890,4 @@ public void StringSetRangeAsync()
         }
     }
 }
-#endif
+#endif
\ No newline at end of file

StackExchange.Redis/StackExchange/Redis/ExtensionMethods.cs

-using System;
-using System.Collections.Generic;
-
-namespace StackExchange.Redis
-{
-    /// <summary>
-    /// Utility methods
-    /// </summary>
-    public static class ExtensionMethods
-    {
-        /// <summary>
-        /// Create a dictionary from an array of HashEntry values 
-        /// </summary>
-        public static Dictionary<string,string> ToStringDictionary(this HashEntry[] hash)
-        {
-            if (hash == null) return null;
-
-            var result = new Dictionary<string, string>(hash.Length, StringComparer.Ordinal);
-            for(int i = 0; i < hash.Length; i++)
-            {
-                result.Add(hash[i].name, hash[i].value);
-            }
-            return result;
-        }
-        /// <summary>
-        /// Create a dictionary from an array of HashEntry values 
-        /// </summary>
-        public static Dictionary<RedisValue, RedisValue> ToDictionary(this HashEntry[] hash)
-        {
-            if (hash == null) return null;
-
-            var result = new Dictionary<RedisValue, RedisValue>(hash.Length);
-            for (int i = 0; i < hash.Length; i++)
-            {
-                result.Add(hash[i].name, hash[i].value);
-            }
-            return result;
-        }
-
-        /// <summary>
-        /// Create a dictionary from an array of SortedSetEntry values 
-        /// </summary>
-        public static Dictionary<string, double> ToStringDictionary(this SortedSetEntry[] sortedSet)
-        {
-            if (sortedSet == null) return null;
-
-            var result = new Dictionary<string, double>(sortedSet.Length, StringComparer.Ordinal);
-            for (int i = 0; i < sortedSet.Length; i++)
-            {
-                result.Add(sortedSet[i].element, sortedSet[i].score);
-            }
-            return result;
-        }
-
-        /// <summary>
-        /// Create a dictionary from an array of SortedSetEntry values 
-        /// </summary>
-        public static Dictionary<RedisValue, double> ToDictionary(this SortedSetEntry[] sortedSet)
-        {
-            if (sortedSet == null) return null;
-
-            var result = new Dictionary<RedisValue, double>(sortedSet.Length);
-            for (int i = 0; i < sortedSet.Length; i++)
-            {
-                result.Add(sortedSet[i].element, sortedSet[i].score);
-            }
-            return result;
-        }
-
-        /// <summary>
-        /// Create a dictionary from an array of key/value pairs
-        /// </summary>
-        public static Dictionary<string, string> ToStringDictionary(this KeyValuePair<RedisKey, RedisValue>[] pairs)
-        {
-            if (pairs == null) return null;
-
-            var result = new Dictionary<string, string>(pairs.Length, StringComparer.Ordinal);
-            for (int i = 0; i < pairs.Length; i++)
-            {
-                result.Add(pairs[i].Key, pairs[i].Value);
-            }
-            return result;
-        }
-
-        /// <summary>
-        /// Create a dictionary from an array of key/value pairs
-        /// </summary>
-        public static Dictionary<RedisKey, RedisValue> ToDictionary(this KeyValuePair<RedisKey, RedisValue>[] pairs)
-        {
-            if (pairs == null) return null;
-
-            var result = new Dictionary<RedisKey, RedisValue>(pairs.Length);
-            for (int i = 0; i < pairs.Length; i++)
-            {
-                result.Add(pairs[i].Key, pairs[i].Value);
-            }
-            return result;
-        }
-
-        /// <summary>
-        /// Create a dictionary from an array of string pairs
-        /// </summary>
-        public static Dictionary<string, string> ToDictionary(this KeyValuePair<string, string>[] pairs)
-        {
-            if (pairs == null) return null;
-
-            var result = new Dictionary<string, string>(pairs.Length, StringComparer.Ordinal);
-            for (int i = 0; i < pairs.Length; i++)
-            {
-                result.Add(pairs[i].Key, pairs[i].Value);
-            }
-            return result;
-        }
-
-        static readonly string[] nix = new string[0];
-        /// <summary>
-        /// Create an array of strings from an array of values
-        /// </summary>
-        public static string[] ToStringArray(this RedisValue[] values)
-        {
-            if (values == null) return null;
-            if (values.Length == 0) return nix;
-            return ConvertHelper.ConvertAll(values, x => (string)x);
-        }
-    }
-}
+using System;
+using System.Collections.Generic;
+
+namespace StackExchange.Redis
+{
+    /// <summary>
+    /// Utility methods
+    /// </summary>
+    public static class ExtensionMethods
+    {
+        /// <summary>
+        /// Create a dictionary from an array of HashEntry values 
+        /// </summary>
+        public static Dictionary<string,string> ToStringDictionary(this HashEntry[] hash)
+        {
+            if (hash == null) return null;
+
+            var result = new Dictionary<string, string>(hash.Length, StringComparer.Ordinal);
+            for(int i = 0; i < hash.Length; i++)
+            {
+                result.Add(hash[i].name, hash[i].value);
+            }
+            return result;
+        }
+        /// <summary>
+        /// Create a dictionary from an array of HashEntry values 
+        /// </summary>
+        public static Dictionary<RedisValue, RedisValue> ToDictionary(this HashEntry[] hash)
+        {
+            if (hash == null) return null;
+
+            var result = new Dictionary<RedisValue, RedisValue>(hash.Length);
+            for (int i = 0; i < hash.Length; i++)
+            {
+                result.Add(hash[i].name, hash[i].value);
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// Create a dictionary from an array of SortedSetEntry values 
+        /// </summary>
+        public static Dictionary<string, double> ToStringDictionary(this SortedSetEntry[] sortedSet)
+        {
+            if (sortedSet == null) return null;
+
+            var result = new Dictionary<string, double>(sortedSet.Length, StringComparer.Ordinal);
+            for (int i = 0; i < sortedSet.Length; i++)
+            {
+                result.Add(sortedSet[i].element, sortedSet[i].score);
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// Create a dictionary from an array of SortedSetEntry values 
+        /// </summary>
+        public static Dictionary<RedisValue, double> ToDictionary(this SortedSetEntry[] sortedSet)
+        {
+            if (sortedSet == null) return null;
+
+            var result = new Dictionary<RedisValue, double>(sortedSet.Length);
+            for (int i = 0; i < sortedSet.Length; i++)
+            {
+                result.Add(sortedSet[i].element, sortedSet[i].score);
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// Create a dictionary from an array of key/value pairs
+        /// </summary>
+        public static Dictionary<string, string> ToStringDictionary(this KeyValuePair<RedisKey, RedisValue>[] pairs)
+        {
+            if (pairs == null) return null;
+
+            var result = new Dictionary<string, string>(pairs.Length, StringComparer.Ordinal);
+            for (int i = 0; i < pairs.Length; i++)
+            {
+                result.Add(pairs[i].Key, pairs[i].Value);
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// Create a dictionary from an array of key/value pairs
+        /// </summary>
+        public static Dictionary<RedisKey, RedisValue> ToDictionary(this KeyValuePair<RedisKey, RedisValue>[] pairs)
+        {
+            if (pairs == null) return null;
+
+            var result = new Dictionary<RedisKey, RedisValue>(pairs.Length);
+            for (int i = 0; i < pairs.Length; i++)
+            {
+                result.Add(pairs[i].Key, pairs[i].Value);
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// Create a dictionary from an array of string pairs
+        /// </summary>
+        public static Dictionary<string, string> ToDictionary(this KeyValuePair<string, string>[] pairs)
+        {
+            if (pairs == null) return null;
+
+            var result = new Dictionary<string, string>(pairs.Length, StringComparer.Ordinal);
+            for (int i = 0; i < pairs.Length; i++)
+            {
+                result.Add(pairs[i].Key, pairs[i].Value);
+            }
+            return result;
+        }
+
+        static readonly string[] nix = new string[0];
+        /// <summary>
+        /// Create an array of strings from an array of values
+        /// </summary>
+        public static string[] ToStringArray(this RedisValue[] values)
+        {
+            if (values == null) return null;
+            if (values.Length == 0) return nix;
+            return ConvertHelper.ConvertAll(values, x => (string)x);
+        }
+    }
+}

StackExchange.Redis/StackExchange/Redis/HashEntry.cs

-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-
-namespace StackExchange.Redis
-{
-    /// <summary>
-    /// Describes a hash-field (a name/value pair)
-    /// </summary>
-    public struct HashEntry : IEquatable<HashEntry>
-    {
-        internal readonly RedisValue name, value;
-
-        /// <summary>
-        /// Initializes a HashEntry value
-        /// </summary>
-        public HashEntry(RedisValue name, RedisValue value)
-        {
-            this.name = name;
-            this.value = value;
-        }
-        /// <summary>
-        /// The name of the hash field
-        /// </summary>
-        public RedisValue Name { get { return name; } }
-        /// <summary>
-        /// The value of the hash field
-        /// </summary>
-        public RedisValue Value{ get { return value; } }
-
-        /// <summary>
-        /// The name of the hash field
-        /// </summary>
-#if !DNXCORE50
-        [Browsable(false)]
-#endif
-        [EditorBrowsable(EditorBrowsableState.Never), Obsolete("Please use Name", false)]
-        public RedisValue Key { get { return name; } }
-
-        /// <summary>
-        /// Converts to a key/value pair
-        /// </summary>
-        public static implicit operator KeyValuePair<RedisValue, RedisValue>(HashEntry value)
-        {
-            return new KeyValuePair<RedisValue, RedisValue>(value.name, value.value);
-        }
-        /// <summary>
-        /// Converts from a key/value pair
-        /// </summary>
-        public static implicit operator HashEntry(KeyValuePair<RedisValue, RedisValue> value)
-        {
-            return new HashEntry(value.Key, value.Value);
-        }
-
-        /// <summary>
-        /// See Object.ToString()
-        /// </summary>
-        public override string ToString()
-        {
-            return name + ": " + value;
-        }
-        /// <summary>
-        /// See Object.GetHashCode()
-        /// </summary>
-        public override int GetHashCode()
-        {
-            return name.GetHashCode() ^ value.GetHashCode();
-        }
-        /// <summary>
-        /// Compares two values for equality
-        /// </summary>
-        public override bool Equals(object obj)
-        {
-            return obj is HashEntry && Equals((HashEntry)obj);
-        }
-
-        /// <summary>
-        /// Compares two values for equality
-        /// </summary>
-        public bool Equals(HashEntry value)
-        {
-            return this.name == value.name && this.value == value.value;
-        }
-        /// <summary>
-        /// Compares two values for equality
-        /// </summary>
-        public static bool operator ==(HashEntry x, HashEntry y)
-        {
-            return x.name == y.name && x.value == y.value;
-        }
-        /// <summary>
-        /// Compares two values for non-equality
-        /// </summary>
-        public static bool operator !=(HashEntry x, HashEntry y)
-        {
-            return x.name != y.name || x.value != y.value;
-        }
-    }
-}
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+
+namespace StackExchange.Redis
+{
+    /// <summary>
+    /// Describes a hash-field (a name/value pair)
+    /// </summary>
+    public struct HashEntry : IEquatable<HashEntry>
+    {
+        internal readonly RedisValue name, value;
+
+        /// <summary>
+        /// Initializes a HashEntry value
+        /// </summary>
+        public HashEntry(RedisValue name, RedisValue value)
+        {
+            this.name = name;
+            this.value = value;
+        }
+        /// <summary>
+        /// The name of the hash field
+        /// </summary>
+        public RedisValue Name { get { return name; } }
+        /// <summary>
+        /// The value of the hash field
+        /// </summary>
+        public RedisValue Value{ get { return value; } }
+
+        /// <summary>
+        /// The name of the hash field
+        /// </summary>
+#if !DNXCORE50
+        [Browsable(false)]
+#endif
+        [EditorBrowsable(EditorBrowsableState.Never), Obsolete("Please use Name", false)]
+        public RedisValue Key { get { return name; } }
+
+        /// <summary>
+        /// Converts to a key/value pair
+        /// </summary>
+        public static implicit operator KeyValuePair<RedisValue, RedisValue>(HashEntry value)
+        {
+            return new KeyValuePair<RedisValue, RedisValue>(value.name, value.value);
+        }
+        /// <summary>
+        /// Converts from a key/value pair
+        /// </summary>
+        public static implicit operator HashEntry(KeyValuePair<RedisValue, RedisValue> value)
+        {
+            return new HashEntry(value.Key, value.Value);
+        }
+
+        /// <summary>
+        /// See Object.ToString()
+        /// </summary>
+        public override string ToString()
+        {
+            return name + ": " + value;
+        }
+        /// <summary>
+        /// See Object.GetHashCode()
+        /// </summary>
+        public override int GetHashCode()
+        {
+            return name.GetHashCode() ^ value.GetHashCode();
+        }
+        /// <summary>
+        /// Compares two values for equality
+        /// </summary>
+        public override bool Equals(object obj)
+        {
+            return obj is HashEntry && Equals((HashEntry)obj);
+        }
+
+        /// <summary>
+        /// Compares two values for equality
+        /// </summary>
+        public bool Equals(HashEntry value)
+        {
+            return this.name == value.name && this.value == value.value;
+        }
+        /// <summary>
+        /// Compares two values for equality
+        /// </summary>
+        public static bool operator ==(HashEntry x, HashEntry y)
+        {
+            return x.name == y.name && x.value == y.value;
+        }
+        /// <summary>
+        /// Compares two values for non-equality
+        /// </summary>
+        public static bool operator !=(HashEntry x, HashEntry y)
+        {
+            return x.name != y.name || x.value != y.value;
+        }
+    }
+}

StackExchange.Redis/StackExchange/Redis/SortedSetEntry.cs

-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-
-namespace StackExchange.Redis
-{
-    /// <summary>
-    /// Describes a sorted-set element with the corresponding value
-    /// </summary>
-    public struct SortedSetEntry : IEquatable<SortedSetEntry>, IComparable, IComparable<SortedSetEntry>
-    {
-        internal readonly RedisValue element;
-        internal readonly double score;
-
-        /// <summary>
-        /// Initializes a SortedSetEntry value
-        /// </summary>
-        public SortedSetEntry(RedisValue element, double score)
-        {
-            this.element = element;
-            this.score = score;
-        }
-        /// <summary>
-        /// The unique element stored in the sorted set
-        /// </summary>
-        public RedisValue Element { get { return element; } }
-        /// <summary>
-        /// The score against the element
-        /// </summary>
-        public double Score { get { return score; } }
-
-        /// <summary>
-        /// The score against the element
-        /// </summary>
-#if !DNXCORE50
-        [Browsable(false)]
-#endif
-        [EditorBrowsable(EditorBrowsableState.Never), Obsolete("Please use Score", false)]
-        public double Value { get { return score; } }
-
-        /// <summary>
-        /// The unique element stored in the sorted set
-        /// </summary>
-#if !DNXCORE50
-        [Browsable(false)]
-#endif
-        [EditorBrowsable(EditorBrowsableState.Never), Obsolete("Please use Element", false)]
-        public RedisValue Key { get { return element; } }
-
-        /// <summary>
-        /// Converts to a key/value pair
-        /// </summary>
-        public static implicit operator KeyValuePair<RedisValue,double>(SortedSetEntry value)
-        {
-            return new KeyValuePair<RedisValue, double>(value.element, value.score);
-        }
-        /// <summary>
-        /// Converts from a key/value pair
-        /// </summary>
-        public static implicit operator SortedSetEntry(KeyValuePair<RedisValue, double> value)
-        {
-            return new SortedSetEntry(value.Key, value.Value);
-        }
-
-        /// <summary>
-        /// See Object.ToString()
-        /// </summary>
-        public override string ToString()
-        {
-            return element + ": " + score;
-        }
-        /// <summary>
-        /// See Object.GetHashCode()
-        /// </summary>
-        public override int GetHashCode()
-        {
-            return element.GetHashCode() ^ score.GetHashCode();
-        }
-        /// <summary>
-        /// Compares two values for equality
-        /// </summary>
-        public override bool Equals(object obj)
-        {
-            return obj is SortedSetEntry && Equals((SortedSetEntry)obj);
-        }
-
-        /// <summary>
-        /// Compares two values for equality
-        /// </summary>
-        public bool Equals(SortedSetEntry value)
-        {
-            return this.score == value.score && this.element == value.element;
-        }
-
-        /// <summary>
-        /// Compares two values by score
-        /// </summary>
-        public int CompareTo(SortedSetEntry value)
-        {
-            return this.score.CompareTo(value.score);
-        }
-
-        /// <summary>
-        /// Compares two values by score
-        /// </summary>
-        public int CompareTo(object value)
-        {
-            return value is SortedSetEntry ? CompareTo((SortedSetEntry)value) : -1;
-        }
-
-        /// <summary>
-        /// Compares two values for equality
-        /// </summary>
-        public static bool operator ==(SortedSetEntry x, SortedSetEntry y)
-        {
-            return x.score == y.score && x.element == y.element;
-        }
-        /// <summary>
-        /// Compares two values for non-equality
-        /// </summary>
-        public static bool operator !=(SortedSetEntry x, SortedSetEntry y)
-        {
-            return x.score != y.score || x.element != y.element;
-        }
-
-    }
-}
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+
+namespace StackExchange.Redis
+{
+    /// <summary>
+    /// Describes a sorted-set element with the corresponding value
+    /// </summary>
+    public struct SortedSetEntry : IEquatable<SortedSetEntry>, IComparable, IComparable<SortedSetEntry>
+    {
+        internal readonly RedisValue element;
+        internal readonly double score;
+
+        /// <summary>
+        /// Initializes a SortedSetEntry value
+        /// </summary>
+        public SortedSetEntry(RedisValue element, double score)
+        {
+            this.element = element;
+            this.score = score;
+        }
+        /// <summary>
+        /// The unique element stored in the sorted set
+        /// </summary>
+        public RedisValue Element { get { return element; } }
+        /// <summary>
+        /// The score against the element
+        /// </summary>
+        public double Score { get { return score; } }
+
+        /// <summary>
+        /// The score against the element
+        /// </summary>
+#if !DNXCORE50
+        [Browsable(false)]
+#endif
+        [EditorBrowsable(EditorBrowsableState.Never), Obsolete("Please use Score", false)]
+        public double Value { get { return score; } }
+
+        /// <summary>
+        /// The unique element stored in the sorted set
+        /// </summary>
+#if !DNXCORE50
+        [Browsable(false)]
+#endif
+        [EditorBrowsable(EditorBrowsableState.Never), Obsolete("Please use Element", false)]
+        public RedisValue Key { get { return element; } }
+
+        /// <summary>
+        /// Converts to a key/value pair
+        /// </summary>
+        public static implicit operator KeyValuePair<RedisValue,double>(SortedSetEntry value)
+        {
+            return new KeyValuePair<RedisValue, double>(value.element, value.score);
+        }
+        /// <summary>
+        /// Converts from a key/value pair
+        /// </summary>
+        public static implicit operator SortedSetEntry(KeyValuePair<RedisValue, double> value)
+        {
+            return new SortedSetEntry(value.Key, value.Value);
+        }
+
+        /// <summary>
+        /// See Object.ToString()
+        /// </summary>
+        public override string ToString()
+        {
+            return element + ": " + score;
+        }
+        /// <summary>
+        /// See Object.GetHashCode()
+        /// </summary>
+        public override int GetHashCode()
+        {
+            return element.GetHashCode() ^ score.GetHashCode();
+        }
+        /// <summary>
+        /// Compares two values for equality
+        /// </summary>
+        public override bool Equals(object obj)
+        {
+            return obj is SortedSetEntry && Equals((SortedSetEntry)obj);
+        }
+
+        /// <summary>
+        /// Compares two values for equality
+        /// </summary>
+        public bool Equals(SortedSetEntry value)
+        {
+            return this.score == value.score && this.element == value.element;
+        }
+
+        /// <summary>
+        /// Compares two values by score
+        /// </summary>
+        public int CompareTo(SortedSetEntry value)
+        {
+            return this.score.CompareTo(value.score);
+        }
+
+        /// <summary>
+        /// Compares two values by score
+        /// </summary>
+        public int CompareTo(object value)
+        {
+            return value is SortedSetEntry ? CompareTo((SortedSetEntry)value) : -1;
+        }
+
+        /// <summary>
+        /// Compares two values for equality
+        /// </summary>
+        public static bool operator ==(SortedSetEntry x, SortedSetEntry y)
+        {
+            return x.score == y.score && x.element == y.element;
+        }
+        /// <summary>
+        /// Compares two values for non-equality
+        /// </summary>
+        public static bool operator !=(SortedSetEntry x, SortedSetEntry y)
+        {
+            return x.score != y.score || x.element != y.element;
+        }
+
+    }
+}