FilesExpand file tree

 master

/

IDistributedLock.cs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

78 lines (73 loc) · 4.02 KB

 master

/

IDistributedLock.cs

Copy path

Top

File metadata and controls

• Code
• Blame

78 lines (73 loc) · 4.02 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

using System;

using System.Threading;

using System.Threading.Tasks;

namespace Medallion.Threading

{

/// <summary>

/// A mutex synchronization primitive which can be used to coordinate access to a resource or critical region of code

/// across processes or systems. The scope and capabilities of the lock are dependent on the particular implementation

/// </summary>

public interface IDistributedLock

{

/// <summary>

/// A name that uniquely identifies the lock

/// </summary>

string Name { get; }

/// <summary>

/// Attempts to acquire the lock synchronously. Usage:

/// <code>

/// using (var handle = myLock.TryAcquire(...))

/// {

/// if (handle != null) { /* we have the lock! */ }

/// }

/// // dispose releases the lock if we took it

/// </code>

/// </summary>

/// <param name="timeout">How long to wait before giving up on the acquisition attempt. Defaults to 0</param>

/// <param name="cancellationToken">Specifies a token by which the wait can be canceled</param>

/// <returns>An <see cref="IDistributedSynchronizationHandle"/> which can be used to release the lock or null on failure</returns>

IDistributedSynchronizationHandle? TryAcquire(TimeSpan timeout = default, CancellationToken cancellationToken = default);

/// <summary>

/// Acquires the lock synchronously, failing with <see cref="TimeoutException"/> if the attempt times out. Usage:

/// <code>

/// using (myLock.Acquire(...))

/// {

/// /* we have the lock! */

/// }

/// // dispose releases the lock

/// </code>

/// </summary>

/// <param name="timeout">How long to wait before giving up on the acquisition attempt. Defaults to <see cref="Timeout.InfiniteTimeSpan"/></param>

/// <param name="cancellationToken">Specifies a token by which the wait can be canceled</param>

/// <returns>An <see cref="IDistributedSynchronizationHandle"/> which can be used to release the lock</returns>

IDistributedSynchronizationHandle Acquire(TimeSpan? timeout = null, CancellationToken cancellationToken = default);

/// <summary>

/// Attempts to acquire the lock asynchronously. Usage:

/// <code>

/// await using (var handle = await myLock.TryAcquireAsync(...))

/// {

/// if (handle != null) { /* we have the lock! */ }

/// }

/// // dispose releases the lock if we took it

/// </code>

/// </summary>

/// <param name="timeout">How long to wait before giving up on the acquisition attempt. Defaults to 0</param>

/// <param name="cancellationToken">Specifies a token by which the wait can be canceled</param>

/// <returns>An <see cref="IDistributedSynchronizationHandle"/> which can be used to release the lock or null on failure</returns>

ValueTask<IDistributedSynchronizationHandle?> TryAcquireAsync(TimeSpan timeout = default, CancellationToken cancellationToken = default);

/// <summary>

/// Acquires the lock asynchronously, failing with <see cref="TimeoutException"/> if the attempt times out. Usage:

/// <code>

/// await using (await myLock.AcquireAsync(...))

/// {

/// /* we have the lock! */

/// }

/// // dispose releases the lock

/// </code>

/// </summary>

/// <param name="timeout">How long to wait before giving up on the acquisition attempt. Defaults to <see cref="Timeout.InfiniteTimeSpan"/></param>

/// <param name="cancellationToken">Specifies a token by which the wait can be canceled</param>

/// <returns>An <see cref="IDistributedSynchronizationHandle"/> which can be used to release the lock</returns>

ValueTask<IDistributedSynchronizationHandle> AcquireAsync(TimeSpan? timeout = null, CancellationToken cancellationToken = default);

}

}