Skip to content

Commit 09390bc

Browse files
mgravellmgravell
committed
normalize lambdas
1 parent bbcff91 commit 09390bc

File tree

1 file changed

+48
-48
lines changed

1 file changed

+48
-48
lines changed

‎src/RESPite.StackExchange.Redis/RespContextDatabase.Key.cs‎

Lines changed: 48 additions & 48 deletions
Original file line numberDiff line numberDiff line change
@@ -13,8 +13,8 @@ public bool KeyCopy(
1313
RedisKey destinationKey,
1414
int destinationDatabase = -1,
1515
bool replace = false,
16-
CommandFlags flags = CommandFlags.None) =>
17-
Keys(flags).Copy(sourceKey, destinationKey, destinationDatabase, replace).Wait(SyncTimeout);
16+
CommandFlags flags = CommandFlags.None)
17+
=> Keys(flags).Copy(sourceKey, destinationKey, destinationDatabase, replace).Wait(SyncTimeout);
1818

1919
public Task<bool> KeyCopyAsync(
2020
RedisKey sourceKey,
@@ -27,58 +27,58 @@ public Task<bool> KeyCopyAsync(
2727
public bool KeyDelete(RedisKey key, CommandFlags flags = CommandFlags.None)
2828
=> Keys(flags).Del(key).Wait(SyncTimeout);
2929

30-
public long KeyDelete(RedisKey[] keys, CommandFlags flags = CommandFlags.None) =>
31-
Keys(flags).Del(keys).Wait(SyncTimeout);
30+
public long KeyDelete(RedisKey[] keys, CommandFlags flags = CommandFlags.None)
31+
=> Keys(flags).Del(keys).Wait(SyncTimeout);
3232

3333
public Task<bool> KeyDeleteAsync(RedisKey key, CommandFlags flags = CommandFlags.None)
3434
=> Keys(flags).Del(key).AsTask();
3535

3636
public Task<long> KeyDeleteAsync(RedisKey[] keys, CommandFlags flags = CommandFlags.None)
3737
=> Keys(flags).Del(keys).AsTask();
3838

39-
public byte[]? KeyDump(RedisKey key, CommandFlags flags = CommandFlags.None) =>
40-
Keys(flags).Dump(key).Wait(SyncTimeout);
39+
public byte[]? KeyDump(RedisKey key, CommandFlags flags = CommandFlags.None)
40+
=> Keys(flags).Dump(key).Wait(SyncTimeout);
4141

4242
public Task<byte[]?> KeyDumpAsync(RedisKey key, CommandFlags flags = CommandFlags.None)
4343
=> Keys(flags).Dump(key).AsTask();
4444

45-
public string? KeyEncoding(RedisKey key, CommandFlags flags = CommandFlags.None) =>
46-
Keys(flags).ObjectEncoding(key).Wait(SyncTimeout);
45+
public string? KeyEncoding(RedisKey key, CommandFlags flags = CommandFlags.None)
46+
=> Keys(flags).ObjectEncoding(key).Wait(SyncTimeout);
4747

4848
public Task<string?> KeyEncodingAsync(RedisKey key, CommandFlags flags = CommandFlags.None)
4949
=> Keys(flags).ObjectEncoding(key).AsTask();
5050

51-
public bool KeyExists(RedisKey key, CommandFlags flags = CommandFlags.None) =>
52-
Keys(flags).Exists(key).Wait(SyncTimeout);
51+
public bool KeyExists(RedisKey key, CommandFlags flags = CommandFlags.None)
52+
=> Keys(flags).Exists(key).Wait(SyncTimeout);
5353

54-
public long KeyExists(RedisKey[] keys, CommandFlags flags = CommandFlags.None) =>
55-
Keys(flags).Exists(keys).Wait(SyncTimeout);
54+
public long KeyExists(RedisKey[] keys, CommandFlags flags = CommandFlags.None)
55+
=> Keys(flags).Exists(keys).Wait(SyncTimeout);
5656

5757
public Task<bool> KeyExistsAsync(RedisKey key, CommandFlags flags = CommandFlags.None)
5858
=> Keys(flags).Exists(key).AsTask();
5959

6060
public Task<long> KeyExistsAsync(RedisKey[] keys, CommandFlags flags = CommandFlags.None)
6161
=> Keys(flags).Exists(keys).AsTask();
6262

63-
public bool KeyExpire(RedisKey key, TimeSpan? expiry, CommandFlags flags) =>
64-
Keys(flags).Expire(key, expiry).Wait(SyncTimeout);
63+
public bool KeyExpire(RedisKey key, TimeSpan? expiry, CommandFlags flags)
64+
=> Keys(flags).Expire(key, expiry).Wait(SyncTimeout);
6565

6666
public bool KeyExpire(
6767
RedisKey key,
6868
TimeSpan? expiry,
6969
ExpireWhen when = ExpireWhen.Always,
70-
CommandFlags flags = CommandFlags.None) =>
71-
Keys(flags).Expire(key, expiry, when).Wait(SyncTimeout);
70+
CommandFlags flags = CommandFlags.None)
71+
=> Keys(flags).Expire(key, expiry, when).Wait(SyncTimeout);
7272

73-
public bool KeyExpire(RedisKey key, DateTime? expiry, CommandFlags flags) =>
74-
Keys(flags).ExpireAt(key, expiry).Wait(SyncTimeout);
73+
public bool KeyExpire(RedisKey key, DateTime? expiry, CommandFlags flags)
74+
=> Keys(flags).ExpireAt(key, expiry).Wait(SyncTimeout);
7575

7676
public bool KeyExpire(
7777
RedisKey key,
7878
DateTime? expiry,
7979
ExpireWhen when = ExpireWhen.Always,
80-
CommandFlags flags = CommandFlags.None) =>
81-
Keys(flags).ExpireAt(key, expiry, when).Wait(SyncTimeout);
80+
CommandFlags flags = CommandFlags.None)
81+
=> Keys(flags).ExpireAt(key, expiry, when).Wait(SyncTimeout);
8282

8383
public Task<bool> KeyExpireAsync(RedisKey key, TimeSpan? expiry, CommandFlags flags)
8484
=> Keys(flags).Expire(key, expiry).AsTask();
@@ -87,8 +87,8 @@ public Task<bool> KeyExpireAsync(
8787
RedisKey key,
8888
TimeSpan? expiry,
8989
ExpireWhen when = ExpireWhen.Always,
90-
CommandFlags flags = CommandFlags.None) =>
91-
Keys(flags).Expire(key, expiry, when).AsTask();
90+
CommandFlags flags = CommandFlags.None)
91+
=> Keys(flags).Expire(key, expiry, when).AsTask();
9292

9393
public Task<bool> KeyExpireAsync(RedisKey key, DateTime? expiry, CommandFlags flags)
9494
=> Keys(flags).ExpireAt(key, expiry).AsTask();
@@ -100,44 +100,44 @@ public Task<bool> KeyExpireAsync(
100100
CommandFlags flags = CommandFlags.None)
101101
=> Keys(flags).ExpireAt(key, expiry, when).AsTask();
102102

103-
public DateTime? KeyExpireTime(RedisKey key, CommandFlags flags = CommandFlags.None) =>
104-
Keys(flags).PExpireTime(key).Wait(SyncTimeout);
103+
public DateTime? KeyExpireTime(RedisKey key, CommandFlags flags = CommandFlags.None)
104+
=> Keys(flags).PExpireTime(key).Wait(SyncTimeout);
105105

106106
public Task<DateTime?> KeyExpireTimeAsync(RedisKey key, CommandFlags flags = CommandFlags.None)
107107
=> Keys(flags).PExpireTime(key).AsTask();
108108

109-
public long? KeyFrequency(RedisKey key, CommandFlags flags = CommandFlags.None) =>
110-
Keys(flags).ObjectFreq(key).Wait(SyncTimeout);
109+
public long? KeyFrequency(RedisKey key, CommandFlags flags = CommandFlags.None)
110+
=> Keys(flags).ObjectFreq(key).Wait(SyncTimeout);
111111

112112
public Task<long?> KeyFrequencyAsync(RedisKey key, CommandFlags flags = CommandFlags.None)
113113
=> Keys(flags).ObjectFreq(key).AsTask();
114114

115-
public TimeSpan? KeyIdleTime(RedisKey key, CommandFlags flags = CommandFlags.None) =>
116-
Keys(flags).ObjectIdleTime(key).Wait(SyncTimeout);
115+
public TimeSpan? KeyIdleTime(RedisKey key, CommandFlags flags = CommandFlags.None)
116+
=> Keys(flags).ObjectIdleTime(key).Wait(SyncTimeout);
117117

118118
public Task<TimeSpan?> KeyIdleTimeAsync(RedisKey key, CommandFlags flags = CommandFlags.None)
119119
=> Keys(flags).ObjectIdleTime(key).AsTask();
120120

121-
public bool KeyMove(RedisKey key, int database, CommandFlags flags = CommandFlags.None) =>
122-
Keys(flags).Move(key, database).Wait(SyncTimeout);
121+
public bool KeyMove(RedisKey key, int database, CommandFlags flags = CommandFlags.None)
122+
=> Keys(flags).Move(key, database).Wait(SyncTimeout);
123123

124124
public Task<bool> KeyMoveAsync(RedisKey key, int database, CommandFlags flags = CommandFlags.None)
125125
=> Keys(flags).Move(key, database).AsTask();
126126

127-
public bool KeyPersist(RedisKey key, CommandFlags flags = CommandFlags.None) =>
128-
Keys(flags).Persist(key).Wait(SyncTimeout);
127+
public bool KeyPersist(RedisKey key, CommandFlags flags = CommandFlags.None)
128+
=> Keys(flags).Persist(key).Wait(SyncTimeout);
129129

130130
public Task<bool> KeyPersistAsync(RedisKey key, CommandFlags flags = CommandFlags.None)
131131
=> Keys(flags).Persist(key).AsTask();
132132

133-
public RedisKey KeyRandom(CommandFlags flags = CommandFlags.None) =>
134-
Keys(flags).RandomKey().Wait(SyncTimeout);
133+
public RedisKey KeyRandom(CommandFlags flags = CommandFlags.None)
134+
=> Keys(flags).RandomKey().Wait(SyncTimeout);
135135

136136
public Task<RedisKey> KeyRandomAsync(CommandFlags flags = CommandFlags.None)
137137
=> Keys(flags).RandomKey().AsTask();
138138

139-
public long? KeyRefCount(RedisKey key, CommandFlags flags = CommandFlags.None) =>
140-
Keys(flags).ObjectRefCount(key).Wait(SyncTimeout);
139+
public long? KeyRefCount(RedisKey key, CommandFlags flags = CommandFlags.None)
140+
=> Keys(flags).ObjectRefCount(key).Wait(SyncTimeout);
141141

142142
public Task<long?> KeyRefCountAsync(RedisKey key, CommandFlags flags = CommandFlags.None)
143143
=> Keys(flags).ObjectRefCount(key).AsTask();
@@ -146,8 +146,8 @@ public bool KeyRename(
146146
RedisKey key,
147147
RedisKey newKey,
148148
When when = When.Always,
149-
CommandFlags flags = CommandFlags.None) =>
150-
Keys(flags).Rename(key, newKey, when).Wait(SyncTimeout);
149+
CommandFlags flags = CommandFlags.None)
150+
=> Keys(flags).Rename(key, newKey, when).Wait(SyncTimeout);
151151

152152
public Task<bool> KeyRenameAsync(
153153
RedisKey key,
@@ -160,8 +160,8 @@ public void KeyRestore(
160160
RedisKey key,
161161
byte[] value,
162162
TimeSpan? expiry = null,
163-
CommandFlags flags = CommandFlags.None) =>
164-
Keys(flags).Restore(key, expiry, value).Wait(SyncTimeout);
163+
CommandFlags flags = CommandFlags.None)
164+
=> Keys(flags).Restore(key, expiry, value).Wait(SyncTimeout);
165165

166166
public Task KeyRestoreAsync(
167167
RedisKey key,
@@ -170,26 +170,26 @@ public Task KeyRestoreAsync(
170170
CommandFlags flags = CommandFlags.None)
171171
=> Keys(flags).Restore(key, expiry, value).AsTask();
172172

173-
public TimeSpan? KeyTimeToLive(RedisKey key, CommandFlags flags = CommandFlags.None) =>
174-
Keys(flags).Pttl(key).Wait(SyncTimeout);
173+
public TimeSpan? KeyTimeToLive(RedisKey key, CommandFlags flags = CommandFlags.None)
174+
=> Keys(flags).Pttl(key).Wait(SyncTimeout);
175175

176176
public Task<TimeSpan?> KeyTimeToLiveAsync(RedisKey key, CommandFlags flags = CommandFlags.None)
177177
=> Keys(flags).Pttl(key).AsTask();
178178

179-
public bool KeyTouch(RedisKey key, CommandFlags flags = CommandFlags.None) =>
180-
Keys(flags).Touch(key).Wait(SyncTimeout);
179+
public bool KeyTouch(RedisKey key, CommandFlags flags = CommandFlags.None)
180+
=> Keys(flags).Touch(key).Wait(SyncTimeout);
181181

182-
public long KeyTouch(RedisKey[] keys, CommandFlags flags = CommandFlags.None) =>
183-
Keys(flags).Touch(keys).Wait(SyncTimeout);
182+
public long KeyTouch(RedisKey[] keys, CommandFlags flags = CommandFlags.None)
183+
=> Keys(flags).Touch(keys).Wait(SyncTimeout);
184184

185185
public Task<bool> KeyTouchAsync(RedisKey key, CommandFlags flags = CommandFlags.None)
186186
=> Keys(flags).Touch(key).AsTask();
187187

188188
public Task<long> KeyTouchAsync(RedisKey[] keys, CommandFlags flags = CommandFlags.None)
189189
=> Keys(flags).Touch(keys).AsTask();
190190

191-
public RedisType KeyType(RedisKey key, CommandFlags flags = CommandFlags.None) =>
192-
Keys(flags).Type(key).Wait(SyncTimeout);
191+
public RedisType KeyType(RedisKey key, CommandFlags flags = CommandFlags.None)
192+
=> Keys(flags).Type(key).Wait(SyncTimeout);
193193

194194
public Task<RedisType> KeyTypeAsync(RedisKey key, CommandFlags flags = CommandFlags.None)
195195
=> Keys(flags).Type(key).AsTask();

0 commit comments

Comments
 (0)