RocksDB

neo.UnitTests/IO/Data/LevelDb/UT_Slice.cs → neo.UnitTests/IO/Data/LevelDB/UT_Slice.cs

@@ -5,7 +5,7 @@
 using System.Runtime.InteropServices;
 using System.Text;
 
-namespace Neo.UnitTests.IO.Data.LevelDb
+namespace Neo.UnitTests.IO.Data.LevelDB
 {
     public class Test { }
 

neo/IO/Data/LevelDB/Helper.cs

@@ -11,12 +11,12 @@ public static void Delete(this WriteBatch batch, byte prefix, ISerializable key)
             batch.Delete(SliceBuilder.Begin(prefix).Add(key));
         }
 
-        public static IEnumerable<T> Find<T>(this DB db, ReadOptions options, byte prefix) where T : class, ISerializable, new()
+        public static IEnumerable<T> Find<T>(this LevelDBCore db, ReadOptions options, byte prefix) where T : class, ISerializable, new()
         {
             return Find(db, options, SliceBuilder.Begin(prefix), (k, v) => v.ToArray().AsSerializable<T>());
         }
 
-        public static IEnumerable<T> Find<T>(this DB db, ReadOptions options, Slice prefix, Func<Slice, Slice, T> resultSelector)
+        public static IEnumerable<T> Find<T>(this LevelDBCore db, ReadOptions options, Slice prefix, Func<Slice, Slice, T> resultSelector)
         {
             using (Iterator it = db.NewIterator(options))
             {
@@ -32,12 +32,12 @@ public static IEnumerable<T> Find<T>(this DB db, ReadOptions options, Slice pref
             }
         }
 
-        public static T Get<T>(this DB db, ReadOptions options, byte prefix, ISerializable key) where T : class, ISerializable, new()
+        public static T Get<T>(this LevelDBCore db, ReadOptions options, byte prefix, ISerializable key) where T : class, ISerializable, new()
         {
             return db.Get(options, SliceBuilder.Begin(prefix).Add(key)).ToArray().AsSerializable<T>();
         }
 
-        public static T Get<T>(this DB db, ReadOptions options, byte prefix, ISerializable key, Func<Slice, T> resultSelector)
+        public static T Get<T>(this LevelDBCore db, ReadOptions options, byte prefix, ISerializable key, Func<Slice, T> resultSelector)
         {
             return resultSelector(db.Get(options, SliceBuilder.Begin(prefix).Add(key)));
         }
@@ -47,18 +47,16 @@ public static void Put(this WriteBatch batch, byte prefix, ISerializable key, IS
             batch.Put(SliceBuilder.Begin(prefix).Add(key), value.ToArray());
         }
 
-        public static T TryGet<T>(this DB db, ReadOptions options, byte prefix, ISerializable key) where T : class, ISerializable, new()
+        public static T TryGet<T>(this LevelDBCore db, ReadOptions options, byte prefix, ISerializable key) where T : class, ISerializable, new()
         {
-            Slice slice;
-            if (!db.TryGet(options, SliceBuilder.Begin(prefix).Add(key), out slice))
+            if (!db.TryGet(options, SliceBuilder.Begin(prefix).Add(key), out var slice))
                 return null;
             return slice.ToArray().AsSerializable<T>();
         }
 
-        public static T TryGet<T>(this DB db, ReadOptions options, byte prefix, ISerializable key, Func<Slice, T> resultSelector) where T : class
+        public static T TryGet<T>(this LevelDBCore db, ReadOptions options, byte prefix, ISerializable key, Func<Slice, T> resultSelector) where T : class
         {
-            Slice slice;
-            if (!db.TryGet(options, SliceBuilder.Begin(prefix).Add(key), out slice))
+            if (!db.TryGet(options, SliceBuilder.Begin(prefix).Add(key), out var slice))
                 return null;
             return resultSelector(slice);
         }

neo/IO/Data/LevelDB/Iterator.cs

@@ -13,8 +13,7 @@ internal Iterator(IntPtr handle)
 
         private void CheckError()
         {
-            IntPtr error;
-            Native.leveldb_iter_get_error(handle, out error);
+            Native.leveldb_iter_get_error(handle, out var error);
             NativeHelper.CheckError(error);
         }
 
@@ -29,8 +28,7 @@ public void Dispose()
 
         public Slice Key()
         {
-            UIntPtr length;
-            IntPtr key = Native.leveldb_iter_key(handle, out length);
+            IntPtr key = Native.leveldb_iter_key(handle, out var length);
             CheckError();
             return new Slice(key, length);
         }
@@ -69,8 +67,7 @@ public bool Valid()
 
         public Slice Value()
         {
-            UIntPtr length;
-            IntPtr value = Native.leveldb_iter_value(handle, out length);
+            IntPtr value = Native.leveldb_iter_value(handle, out var length);
             CheckError();
             return new Slice(value, length);
         }

neo/IO/Data/LevelDB/DB.cs → neo/IO/Data/LevelDB/LevelDBCore.cs

@@ -2,7 +2,7 @@
 
 namespace Neo.IO.Data.LevelDB
 {
-    public class DB : IDisposable
+    public class LevelDBCore : IDisposable
     {
         private IntPtr handle;
 
@@ -11,7 +11,7 @@ public class DB : IDisposable
         /// </summary>
         public bool IsDisposed => handle == IntPtr.Zero;
 
-        private DB(IntPtr handle)
+        private LevelDBCore(IntPtr handle)
         {
             this.handle = handle;
         }
@@ -27,16 +27,13 @@ public void Dispose()
 
         public void Delete(WriteOptions options, Slice key)
         {
-            IntPtr error;
-            Native.leveldb_delete(handle, options.handle, key.buffer, (UIntPtr)key.buffer.Length, out error);
+            Native.leveldb_delete(handle, options.handle, key.buffer, (UIntPtr)key.buffer.Length, out var error);
             NativeHelper.CheckError(error);
         }
 
         public Slice Get(ReadOptions options, Slice key)
         {
-            UIntPtr length;
-            IntPtr error;
-            IntPtr value = Native.leveldb_get(handle, options.handle, key.buffer, (UIntPtr)key.buffer.Length, out length, out error);
+            IntPtr value = Native.leveldb_get(handle, options.handle, key.buffer, (UIntPtr)key.buffer.Length, out var length, out var error);
             try
             {
                 NativeHelper.CheckError(error);
@@ -60,31 +57,27 @@ public Iterator NewIterator(ReadOptions options)
             return new Iterator(Native.leveldb_create_iterator(handle, options.handle));
         }
 
-        public static DB Open(string name)
+        public static LevelDBCore Open(string name)
         {
             return Open(name, Options.Default);
         }
 
-        public static DB Open(string name, Options options)
+        public static LevelDBCore Open(string name, Options options)
         {
-            IntPtr error;
-            IntPtr handle = Native.leveldb_open(options.handle, name, out error);
+            IntPtr handle = Native.leveldb_open(options.handle, name, out var error);
             NativeHelper.CheckError(error);
-            return new DB(handle);
+            return new LevelDBCore(handle);
         }
 
         public void Put(WriteOptions options, Slice key, Slice value)
         {
-            IntPtr error;
-            Native.leveldb_put(handle, options.handle, key.buffer, (UIntPtr)key.buffer.Length, value.buffer, (UIntPtr)value.buffer.Length, out error);
+            Native.leveldb_put(handle, options.handle, key.buffer, (UIntPtr)key.buffer.Length, value.buffer, (UIntPtr)value.buffer.Length, out var error);
             NativeHelper.CheckError(error);
         }
 
         public bool TryGet(ReadOptions options, Slice key, out Slice value)
         {
-            UIntPtr length;
-            IntPtr error;
-            IntPtr v = Native.leveldb_get(handle, options.handle, key.buffer, (UIntPtr)key.buffer.Length, out length, out error);
+            IntPtr v = Native.leveldb_get(handle, options.handle, key.buffer, (UIntPtr)key.buffer.Length, out var length, out var error);
             if (error != IntPtr.Zero)
             {
                 Native.leveldb_free(error);
@@ -112,8 +105,7 @@ public void Write(WriteOptions options, WriteBatch write_batch)
             {
                 try
                 {
-                    IntPtr error;
-                    Native.leveldb_write(handle, options.handle, write_batch.handle, out error);
+                    Native.leveldb_write(handle, options.handle, write_batch.handle, out var error);
                     NativeHelper.CheckError(error);
                     break;
                 }

neo/IO/Data/LevelDB/Slice.cs

@@ -1,21 +1,37 @@
 using Neo.Cryptography;
 using System;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text;
 
 namespace Neo.IO.Data.LevelDB
 {
     public struct Slice : IComparable<Slice>, IEquatable<Slice>
     {
-        internal byte[] buffer;
+        internal readonly byte[] buffer;
 
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="data">Data</param>
+        /// <param name="length">Length</param>
         internal Slice(IntPtr data, UIntPtr length)
         {
             buffer = new byte[(int)length];
             Marshal.Copy(data, buffer, 0, (int)length);
         }
 
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="input">Input</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal Slice(byte[] input)
+        {
+            buffer = input;
+        }
+
         public int CompareTo(Slice other)
         {
             for (int i = 0; i < buffer.Length && i < other.buffer.Length; i++)
@@ -34,16 +50,16 @@ public bool Equals(Slice other)
 
         public override bool Equals(object obj)
         {
-            if (ReferenceEquals(null, obj)) return false;
-            if (!(obj is Slice)) return false;
-            return Equals((Slice)obj);
+            if (!(obj is Slice slide)) return false;
+            return Equals(slide);
         }
 
         public override int GetHashCode()
         {
             return (int)buffer.Murmur32(0);
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public byte[] ToArray()
         {
             return buffer ?? new byte[0];
@@ -116,6 +132,7 @@ unsafe public float ToSingle()
             }
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public override string ToString()
         {
             return Encoding.UTF8.GetString(buffer);
@@ -151,91 +168,115 @@ unsafe public ulong ToUInt64()
             }
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator byte[](Slice value)
+        {
+            return value.buffer;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static implicit operator Slice(byte[] data)
         {
-            return new Slice { buffer = data };
+            return new Slice(data);
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static implicit operator Slice(bool data)
         {
-            return new Slice { buffer = BitConverter.GetBytes(data) };
+            return new Slice(BitConverter.GetBytes(data));
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static implicit operator Slice(byte data)
         {
-            return new Slice { buffer = new[] { data } };
+            return new Slice(new[] { data });
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static implicit operator Slice(double data)
         {
-            return new Slice { buffer = BitConverter.GetBytes(data) };
+            return new Slice(BitConverter.GetBytes(data));
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static implicit operator Slice(short data)
         {
-            return new Slice { buffer = BitConverter.GetBytes(data) };
+            return new Slice(BitConverter.GetBytes(data));
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static implicit operator Slice(int data)
         {
-            return new Slice { buffer = BitConverter.GetBytes(data) };
+            return new Slice(BitConverter.GetBytes(data));
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static implicit operator Slice(long data)
         {
-            return new Slice { buffer = BitConverter.GetBytes(data) };
+            return new Slice(BitConverter.GetBytes(data));
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static implicit operator Slice(float data)
         {
-            return new Slice { buffer = BitConverter.GetBytes(data) };
+            return new Slice(BitConverter.GetBytes(data));
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static implicit operator Slice(string data)
         {
-            return new Slice { buffer = Encoding.UTF8.GetBytes(data) };
+            return new Slice(Encoding.UTF8.GetBytes(data));
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static implicit operator Slice(ushort data)
         {
-            return new Slice { buffer = BitConverter.GetBytes(data) };
+            return new Slice(BitConverter.GetBytes(data));
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static implicit operator Slice(uint data)
         {
-            return new Slice { buffer = BitConverter.GetBytes(data) };
+            return new Slice(BitConverter.GetBytes(data));
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static implicit operator Slice(ulong data)
         {
-            return new Slice { buffer = BitConverter.GetBytes(data) };
+            return new Slice(BitConverter.GetBytes(data));
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static bool operator <(Slice x, Slice y)
         {
             return x.CompareTo(y) < 0;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static bool operator <=(Slice x, Slice y)
         {
             return x.CompareTo(y) <= 0;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static bool operator >(Slice x, Slice y)
         {
             return x.CompareTo(y) > 0;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static bool operator >=(Slice x, Slice y)
         {
             return x.CompareTo(y) >= 0;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static bool operator ==(Slice x, Slice y)
         {
             return x.Equals(y);
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static bool operator !=(Slice x, Slice y)
         {
             return !x.Equals(y);