We need a way to test for space existance without exception

src/progaudi.tarantool/ISchema.cs

@@ -1,18 +1,16 @@
 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace ProGaudi.Tarantool.Client
 {
-    public interface ISchema
+    public interface ISchema : IReadOnlyDictionary<string, ISpace>, IReadOnlyDictionary<uint, ISpace>
     {
         [Obsolete("Use indexer")]
         Task<ISpace> GetSpace(string name);
         [Obsolete("Use indexer")]
         Task<ISpace> GetSpace(uint id);
 
-        ISpace this[string name] { get; }
-        ISpace this[uint id] { get; }
-
         Task Reload();
 
         DateTimeOffset LastReloadTime { get; }

src/progaudi.tarantool/ISpace.cs

@@ -8,7 +8,7 @@
 
 namespace ProGaudi.Tarantool.Client
 {
-    public interface ISpace
+    public interface ISpace : IReadOnlyDictionary<string, IIndex>, IReadOnlyDictionary<uint, IIndex>
     {
         uint Id { get; }
 
@@ -30,10 +30,6 @@ public interface ISpace
         [Obsolete("Use indexer")]
         Task<IIndex> GetIndex(uint indexId);
 
-        IIndex this[string name] { get; }
-
-        IIndex this[uint id] { get; }
-
         Task<DataResponse<TTuple[]>> Insert<TTuple>(TTuple tuple);
 
         Task<DataResponse<TTuple[]>> Select<TKey, TTuple>(TKey selectKey);
@@ -50,10 +46,6 @@ public interface ISpace
 
         Task<DataResponse<TTuple[]>> Delete<TKey, TTuple>(TKey key);
 
-        Task<uint> Count<TKey>(TKey key);
-
-        Task<uint> Length();
-
         Task<DataResponse<TTuple[]>> Increment<TTuple, TKey>(TKey key);
 
         Task<DataResponse<TTuple[]>> Decrement<TTuple, TKey>(TKey key);

src/progaudi.tarantool/Schema.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
@@ -31,9 +32,13 @@ public Schema(ILogicalConnection logicalConnection)
 
         public Task<ISpace> GetSpace(uint id) => Task.FromResult(this[id]);
 
-        public ISpace this[string name] => _indexByName.TryGetValue(name, out var space) ? space : throw ExceptionHelper.InvalidSpaceName(name);
+        public ISpace this[string name] => _indexByName.TryGetValue(name, out var space)
+            ? space
+            : throw ExceptionHelper.InvalidSpaceName(name);
 
-        public ISpace this[uint id] => _indexById.TryGetValue(id, out var space) ? space : throw ExceptionHelper.InvalidSpaceId(id);
+        public ISpace this[uint id] => _indexById.TryGetValue(id, out var space)
+            ? space
+            : throw ExceptionHelper.InvalidSpaceId(id);
 
         public DateTimeOffset LastReloadTime { get; private set; }
 
@@ -65,5 +70,31 @@ private async Task<T[]> Select<T>(uint spaceId, Iterator iterator = Iterator.All
                 .ConfigureAwait(false);
             return response.Data;
         }
+
+        IEnumerator<KeyValuePair<uint, ISpace>> IEnumerable<KeyValuePair<uint, ISpace>>.GetEnumerator() => _indexById.GetEnumerator();
+
+        IEnumerator<KeyValuePair<string, ISpace>> IEnumerable<KeyValuePair<string, ISpace>>.GetEnumerator() => _indexByName.GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => throw new InvalidOperationException();
+
+        int IReadOnlyCollection<KeyValuePair<string, ISpace>>.Count => _indexById.Count;
+
+        bool IReadOnlyDictionary<string, ISpace>.ContainsKey(string key) => _indexByName.ContainsKey(key);
+
+        bool IReadOnlyDictionary<string, ISpace>.TryGetValue(string key, out ISpace value) => _indexByName.TryGetValue(key, out value);
+
+        bool IReadOnlyDictionary<uint, ISpace>.ContainsKey(uint key) => _indexById.ContainsKey(key);
+
+        bool IReadOnlyDictionary<uint, ISpace>.TryGetValue(uint key, out ISpace value) => _indexById.TryGetValue(key, out value);
+
+        IEnumerable<uint> IReadOnlyDictionary<uint, ISpace>.Keys => _indexById.Keys;
+
+        IEnumerable<ISpace> IReadOnlyDictionary<uint, ISpace>.Values => _indexById.Values;
+
+        IEnumerable<string> IReadOnlyDictionary<string, ISpace>.Keys => _indexByName.Keys;
+
+        IEnumerable<ISpace> IReadOnlyDictionary<string, ISpace>.Values => _indexByName.Values;
+
+        int IReadOnlyCollection<KeyValuePair<uint, ISpace>>.Count => _indexById.Count;
     }
 }

src/progaudi.tarantool/Space.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
@@ -60,13 +61,17 @@ internal void SetIndices(IReadOnlyCollection<Index> value)
 
         public IReadOnlyCollection<SpaceField> Fields { get; }
 
-        public Task<IIndex> GetIndex(string name) => Task.FromResult(_indexByName.TryGetValue(name, out var index) ? index : throw ExceptionHelper.InvalidIndexName(name, Name));
+        public Task<IIndex> GetIndex(string name) => Task.FromResult(this[name]);
 
-        public Task<IIndex> GetIndex(uint id) => Task.FromResult(_indexById.TryGetValue(id, out var index) ? index : throw ExceptionHelper.InvalidIndexId(id, Name));
+        public Task<IIndex> GetIndex(uint id) => Task.FromResult(this[id]);
 
-        public IIndex this[string name] => _indexByName.TryGetValue(name, out var index) ? index : throw ExceptionHelper.InvalidIndexName(name, Name);
+        public IIndex this[string name] => _indexByName.TryGetValue(name, out var index)
+            ? index
+            : throw ExceptionHelper.InvalidIndexName(name, Name);
 
-        public IIndex this[uint id] => _indexById.TryGetValue(id, out var index) ? index : throw ExceptionHelper.InvalidIndexId(id, Name);
+        public IIndex this[uint id] => _indexById.TryGetValue(id, out var index)
+            ? index
+            : throw ExceptionHelper.InvalidIndexId(id, Name);
 
         public async Task<DataResponse<TTuple[]>> Insert<TTuple>(TTuple tuple)
         {
@@ -117,16 +122,6 @@ public async Task<DataResponse<TTuple[]>> Delete<TKey, TTuple>(TKey key)
             return await LogicalConnection.SendRequest<DeleteRequest<TKey>, TTuple>(deleteRequest).ConfigureAwait(false);
         }
 
-        public Task<uint> Count<TKey>(TKey key)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task<uint> Length()
-        {
-            throw new NotImplementedException();
-        }
-
         public Task<DataResponse<TTuple[]>> Increment<TTuple, TKey>(TKey key)
         {
             // Currently we can't impelment that method because Upsert returns void.
@@ -143,5 +138,31 @@ public override string ToString()
         {
             return $"{Name}, id={Id}";
         }
+
+        IEnumerator<KeyValuePair<uint, IIndex>> IEnumerable<KeyValuePair<uint, IIndex>>.GetEnumerator() => _indexById.GetEnumerator();
+
+        IEnumerator<KeyValuePair<string, IIndex>> IEnumerable<KeyValuePair<string, IIndex>>.GetEnumerator() => _indexByName.GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => throw new InvalidOperationException();
+
+        int IReadOnlyCollection<KeyValuePair<string, IIndex>>.Count => _indexById.Count;
+
+        bool IReadOnlyDictionary<string, IIndex>.ContainsKey(string key) => _indexByName.ContainsKey(key);
+
+        bool IReadOnlyDictionary<string, IIndex>.TryGetValue(string key, out IIndex value) => _indexByName.TryGetValue(key, out value);
+
+        bool IReadOnlyDictionary<uint, IIndex>.ContainsKey(uint key) => _indexById.ContainsKey(key);
+
+        bool IReadOnlyDictionary<uint, IIndex>.TryGetValue(uint key, out IIndex value) => _indexById.TryGetValue(key, out value);
+
+        IEnumerable<uint> IReadOnlyDictionary<uint, IIndex>.Keys => _indexById.Keys;
+
+        IEnumerable<IIndex> IReadOnlyDictionary<uint, IIndex>.Values => _indexById.Values;
+
+        IEnumerable<string> IReadOnlyDictionary<string, IIndex>.Keys => _indexByName.Keys;
+
+        IEnumerable<IIndex> IReadOnlyDictionary<string, IIndex>.Values => _indexByName.Values;
+
+        int IReadOnlyCollection<KeyValuePair<uint, IIndex>>.Count => _indexById.Count;
     }
 }

tests/progaudi.tarantool.tests/Schema/GetSpace_Should.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 
 using Xunit;
@@ -81,5 +82,17 @@ public async Task read_multiple_spaces_in_a_row()
                 }
             }
         }
+
+        [Fact]
+        public async Task iterating_over_schema()
+        {
+            using (var tarantoolClient = await Client.Box.Connect(ConnectionStringFactory.GetReplicationSource_1_7()))
+            {
+                foreach (var pair in (IReadOnlyDictionary<string, ISpace>)tarantoolClient.Schema)
+                {
+                    pair.Value.Name.ShouldBe(pair.Key);
+                }
+            }
+        }
     }
 }