test fix

thompson-tomo · thompson-tomo · commit b71c1610cbe7 · 2025-06-10T18:35:24.000+10:00
Signed-off-by: James Thompson &lt;thompson.tomo@outlook.com&gt;
diff --git a/src/NATS.Client.Core/Internal/SubscriptionManager.cs b/src/NATS.Client.Core/Internal/SubscriptionManager.cs
@@ -17,7 +17,6 @@ internal sealed class SubscriptionManager : INatsSubscriptionManager, IAsyncDisp
     private readonly bool _debug;
     private readonly object _gate = new();
     private readonly NatsConnection _connection;
-    private readonly string _inboxPrefix;
     private readonly ConcurrentDictionary<int, SidMetadata> _bySid = new();
     private readonly ConditionalWeakTable<NatsSubBase, SubscriptionMetadata> _bySub = new();
     private readonly CancellationTokenSource _cts;
@@ -33,16 +32,14 @@ internal sealed class SubscriptionManager : INatsSubscriptionManager, IAsyncDisp
     public SubscriptionManager(NatsConnection connection, string inboxPrefix)
     {
         _connection = connection;
-        _inboxPrefix = inboxPrefix;
         _logger = _connection.Opts.LoggerFactory.CreateLogger<SubscriptionManager>();
         _debug = _logger.IsEnabled(LogLevel.Debug);
         _trace = _logger.IsEnabled(LogLevel.Trace);
         _cts = new CancellationTokenSource();
         _cleanupInterval = _connection.Opts.SubscriptionCleanUpInterval;
         _timer = Task.Run(CleanupAsync);
         InboxSubBuilder = new InboxSubBuilder(connection.Opts.LoggerFactory.CreateLogger<InboxSubBuilder>());
-        var sid = GetNextSid();
-        _inboxSubSentinel = new InboxSub(InboxSubBuilder, new NatsSubscribeProps(nameof(_inboxSubSentinel)) { SubscriptionId = sid }, default, connection, this);
+        _inboxSubSentinel = new InboxSub(InboxSubBuilder, new NatsSubscribeProps(nameof(_inboxSubSentinel)), default, connection, this);
         _inboxSub = _inboxSubSentinel;
     }
 
@@ -52,19 +49,12 @@ public SubscriptionManager(NatsConnection connection, string inboxPrefix)
 
     public ValueTask SubscribeAsync(NatsSubBase sub, CancellationToken cancellationToken)
     {
-        var props = sub.SubscriptionProps;
-
-        if (props.SubscriptionId == 0)
-        {
-            props.SubscriptionId = GetNextSid();
-        }
-
         if (Telemetry.HasListeners())
         {
             using var activity = Telemetry.StartSendActivity($"{_connection.SpanDestinationName(sub.Subject)} {Telemetry.Constants.SubscribeActivityName}", _connection, sub.Subject, null, null);
             try
             {
-                if (props.IsInboxSubject(_connection.InboxPrefix))
+                if (sub.SubscriptionProps.IsInboxSubject(_connection.InboxPrefix))
                 {
                     if (sub.QueueGroup != null)
                     {
@@ -74,7 +64,7 @@ public ValueTask SubscribeAsync(NatsSubBase sub, CancellationToken cancellationT
                     return SubscribeInboxAsync(sub, cancellationToken);
                 }
 
-                return SubscribeInternalAsync(props, sub, cancellationToken);
+                return SubscribeInternalAsync(sub, cancellationToken);
             }
             catch (Exception ex)
             {
@@ -83,7 +73,7 @@ public ValueTask SubscribeAsync(NatsSubBase sub, CancellationToken cancellationT
             }
         }
 
-        if (props.IsInboxSubject(_connection.InboxPrefix))
+        if (sub.SubscriptionProps.IsInboxSubject(_connection.InboxPrefix))
         {
             if (sub.QueueGroup != null)
             {
@@ -93,7 +83,7 @@ public ValueTask SubscribeAsync(NatsSubBase sub, CancellationToken cancellationT
             return SubscribeInboxAsync(sub, cancellationToken);
         }
 
-        return SubscribeInternalAsync(props, sub, cancellationToken);
+        return SubscribeInternalAsync(sub, cancellationToken);
     }
 
     public ValueTask PublishToClientHandlersAsync(NatsProcessProps props, in ReadOnlySequence<byte>? headersBuffer, in ReadOnlySequence<byte> payloadBuffer)
@@ -239,7 +229,7 @@ internal INatsSubscriptionManager GetManagerFor(NatsSubscribeProps props)
         return this;
     }
 
-    internal async Task InitializeInboxSubscriptionAsync(CancellationToken cancellationToken)
+    internal async Task InitializeInboxSubscriptionAsync(NatsSubscribeProps props, CancellationToken cancellationToken = default)
     {
         if (Interlocked.CompareExchange(ref _inboxSub, _inboxSubSentinel, _inboxSubSentinel) == _inboxSubSentinel)
         {
@@ -248,18 +238,12 @@ internal async Task InitializeInboxSubscriptionAsync(CancellationToken cancellat
             {
                 if (Interlocked.CompareExchange(ref _inboxSub, _inboxSubSentinel, _inboxSubSentinel) == _inboxSubSentinel)
                 {
-                    var props = new NatsSubscribeProps($"{_inboxPrefix}.*");
-                    props.SubscriptionId = GetNextSid();
-
                     // We need to subscribe to the real inbox subject before we can register the internal subject.
                     // We use 'default' options here since options provided by the user are for the internal subscription.
                     // For example if the user provides a timeout, we don't want to timeout the real inbox subscription
                     // since it must live duration of the connection.
                     _inboxSub = InboxSubBuilder.Build(props, opts: default, _connection, manager: this);
-                    await SubscribeInternalAsync(
-                        props,
-                        _inboxSub,
-                        cancellationToken).ConfigureAwait(false);
+                    await SubscribeInternalAsync(_inboxSub, cancellationToken).ConfigureAwait(false);
                 }
             }
             finally
@@ -273,40 +257,45 @@ await SubscribeInternalAsync(
 
     private async ValueTask SubscribeInboxAsync(NatsSubBase sub, CancellationToken cancellationToken)
     {
-        await InitializeInboxSubscriptionAsync(cancellationToken).ConfigureAwait(false);
+        await InitializeInboxSubscriptionAsync(sub.SubscriptionProps, cancellationToken).ConfigureAwait(false);
         await InboxSubBuilder.RegisterAsync(sub).ConfigureAwait(false);
     }
 
-    private async ValueTask SubscribeInternalAsync(NatsSubscribeProps props, NatsSubBase sub, CancellationToken cancellationToken)
+    private async ValueTask SubscribeInternalAsync(NatsSubBase sub, CancellationToken cancellationToken)
     {
+        if (sub.SubscriptionProps.UnsetSubscriptionId)
+        {
+            sub.SubscriptionProps.SubscriptionId = GetNextSid();
+        }
+
         if (sub is InboxSub)
         {
-            Interlocked.Exchange(ref _inboxSid, props.SubscriptionId);
+            Interlocked.Exchange(ref _inboxSid, sub.SubscriptionProps.SubscriptionId);
         }
 
         if (_debug)
         {
-            _logger.LogDebug(NatsLogEvents.Subscription, "New subscription {Subject}/{Sid}", sub.Subject, props.SubscriptionId);
+            _logger.LogDebug(NatsLogEvents.Subscription, "New subscription {Subject}/{Sid}", sub.Subject, sub.SubscriptionProps.SubscriptionId);
         }
 
         lock (_gate)
         {
-            _bySid[props.SubscriptionId] = new SidMetadata(Properties: props, WeakReference: new WeakReference<NatsSubBase>(sub));
+            _bySid[sub.SubscriptionProps.SubscriptionId] = new SidMetadata(Properties: sub.SubscriptionProps, WeakReference: new WeakReference<NatsSubBase>(sub));
 #if NETSTANDARD2_0
             lock (_bySub)
             {
                 if (_bySub.TryGetValue(sub, out _))
                     _bySub.Remove(sub);
-                _bySub.Add(sub, new SubscriptionMetadata(Sid: props.SubscriptionId));
+                _bySub.Add(sub, new SubscriptionMetadata(Sid: sub.SubscriptionProps.SubscriptionId));
             }
 #else
-            _bySub.AddOrUpdate(sub, new SubscriptionMetadata(Sid: props.SubscriptionId));
+            _bySub.AddOrUpdate(sub, new SubscriptionMetadata(Sid: sub.SubscriptionProps.SubscriptionId));
 #endif
         }
 
         try
         {
-            await _connection.SubscribeCoreAsync(props, sub.Opts?.MaxMsgs, cancellationToken).ConfigureAwait(false);
+            await _connection.SubscribeCoreAsync(sub.SubscriptionProps, sub.Opts?.MaxMsgs, cancellationToken).ConfigureAwait(false);
             await sub.ReadyAsync().ConfigureAwait(false);
         }
         catch
diff --git a/src/NATS.Client.Core/NatsConnection.RequestSub.cs b/src/NATS.Client.Core/NatsConnection.RequestSub.cs
@@ -15,16 +15,7 @@ public async ValueTask<NatsSub<TReply>> CreateRequestSubAsync<TRequest, TReply>(
     {
         var props = requestOpts?.Props ?? new NatsPublishProps(subject);
         props.SetReplyTo(NewInbox());
-        replySerializer ??= Opts.SerializerRegistry.GetDeserializer<TReply>();
-        var subProps = new NatsSubscribeProps(props.Subject);
-        subProps.SubscriptionId = _subscriptionManager.GetNextSid();
-        var sub = new NatsSub<TReply>(this, _subscriptionManager.InboxSubBuilder, subProps, replyOpts, replySerializer);
-        await AddSubAsync(sub, cancellationToken).ConfigureAwait(false);
-
-        requestSerializer ??= Opts.SerializerRegistry.GetSerializer<TRequest>();
-        await PublishAsync(props, data, headers, requestSerializer, cancellationToken).ConfigureAwait(false);
-
-        return sub;
+        return await CreateRequestSubAsync(props, data, headers, requestSerializer, replySerializer, replyOpts, cancellationToken).ConfigureAwait(false);
     }
 
     /// <inheritdoc />
diff --git a/src/NATS.Client.Core/NatsConnection.cs b/src/NATS.Client.Core/NatsConnection.cs
@@ -199,7 +199,8 @@ public async ValueTask ConnectAsync()
 
         if (Opts.RequestReplyMode == NatsRequestReplyMode.Direct)
         {
-            await _subscriptionManager.InitializeInboxSubscriptionAsync(_disposedCts.Token).ConfigureAwait(false);
+            var props = new NatsSubscribeProps($"{InboxPrefix}.*");
+            await _subscriptionManager.InitializeInboxSubscriptionAsync(props, _disposedCts.Token).ConfigureAwait(false);
         }
     }
 
@@ -277,7 +278,7 @@ internal ValueTask PublishToClientHandlersAsync(NatsProcessProps props, in ReadO
     {
         if (Opts.RequestReplyMode == NatsRequestReplyMode.Direct)
         {
-            if (_subscriptionManager.InboxSid == props.SubscriptionId && props.IsReplyToRequest(InboxPrefix))
+            if (_subscriptionManager.InboxSid == props.Subscription?.SubscriptionId && props.IsReplyToRequest(InboxPrefix))
             {
                 if (_replyTaskFactory.TrySetResult(props, payloadBuffer, headersBuffer))
                 {
diff --git a/src/NATS.Client.Core/NatsUnsubscribeProps.cs b/src/NATS.Client.Core/NatsUnsubscribeProps.cs
@@ -16,11 +16,13 @@ public NatsUnsubscribeProps(int subscriptionId)
     internal NatsUnsubscribeProps(string subject)
         : base(subject)
     {
-        SubscriptionId = 0;
+        SubscriptionId = -1;
     }
 
     /// <summary>
     /// A unique numeric subscription ID, generated by the client.
     /// </summary>
     public int SubscriptionId { get; set; }
+
+    internal bool UnsetSubscriptionId => SubscriptionId != -1;
 }

Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,6 @@ internal sealed class SubscriptionManager : INatsSubscriptionManager, IAsyncDisp`
`17`	`17`	`private readonly bool _debug;`
`18`	`18`	`private readonly object _gate = new();`
`19`	`19`	`private readonly NatsConnection _connection;`
`20`		`- private readonly string _inboxPrefix;`
`21`	`20`	`private readonly ConcurrentDictionary<int, SidMetadata> _bySid = new();`
`22`	`21`	`private readonly ConditionalWeakTable<NatsSubBase, SubscriptionMetadata> _bySub = new();`
`23`	`22`	`private readonly CancellationTokenSource _cts;`
`@@ -33,16 +32,14 @@ internal sealed class SubscriptionManager : INatsSubscriptionManager, IAsyncDisp`
`33`	`32`	`public SubscriptionManager(NatsConnection connection, string inboxPrefix)`
`34`	`33`	`{`
`35`	`34`	`_connection = connection;`
`36`		`- _inboxPrefix = inboxPrefix;`
`37`	`35`	`_logger = _connection.Opts.LoggerFactory.CreateLogger<SubscriptionManager>();`
`38`	`36`	`_debug = _logger.IsEnabled(LogLevel.Debug);`
`39`	`37`	`_trace = _logger.IsEnabled(LogLevel.Trace);`
`40`	`38`	`_cts = new CancellationTokenSource();`
`41`	`39`	`_cleanupInterval = _connection.Opts.SubscriptionCleanUpInterval;`
`42`	`40`	`_timer = Task.Run(CleanupAsync);`
`43`	`41`	`InboxSubBuilder = new InboxSubBuilder(connection.Opts.LoggerFactory.CreateLogger<InboxSubBuilder>());`
`44`		`- var sid = GetNextSid();`
`45`		`- _inboxSubSentinel = new InboxSub(InboxSubBuilder, new NatsSubscribeProps(nameof(_inboxSubSentinel)) { SubscriptionId = sid }, default, connection, this);`
	`42`	`+ _inboxSubSentinel = new InboxSub(InboxSubBuilder, new NatsSubscribeProps(nameof(_inboxSubSentinel)), default, connection, this);`
`46`	`43`	`_inboxSub = _inboxSubSentinel;`
`47`	`44`	`}`
`48`	`45`
`@@ -52,19 +49,12 @@ public SubscriptionManager(NatsConnection connection, string inboxPrefix)`
`52`	`49`
`53`	`50`	`public ValueTask SubscribeAsync(NatsSubBase sub, CancellationToken cancellationToken)`
`54`	`51`	`{`
`55`		`- var props = sub.SubscriptionProps;`
`56`		`-`
`57`		`- if (props.SubscriptionId == 0)`
`58`		`- {`
`59`		`- props.SubscriptionId = GetNextSid();`
`60`		`- }`
`61`		`-`
`62`	`52`	`if (Telemetry.HasListeners())`
`63`	`53`	`{`
`64`	`54`	`using var activity = Telemetry.StartSendActivity($"{_connection.SpanDestinationName(sub.Subject)} {Telemetry.Constants.SubscribeActivityName}", _connection, sub.Subject, null, null);`
`65`	`55`	`try`
`66`	`56`	`{`
`67`		`- if (props.IsInboxSubject(_connection.InboxPrefix))`
	`57`	`+ if (sub.SubscriptionProps.IsInboxSubject(_connection.InboxPrefix))`
`68`	`58`	`{`
`69`	`59`	`if (sub.QueueGroup != null)`
`70`	`60`	`{`
`@@ -74,7 +64,7 @@ public ValueTask SubscribeAsync(NatsSubBase sub, CancellationToken cancellationT`
`74`	`64`	`return SubscribeInboxAsync(sub, cancellationToken);`
`75`	`65`	`}`
`76`	`66`
`77`		`- return SubscribeInternalAsync(props, sub, cancellationToken);`
	`67`	`+ return SubscribeInternalAsync(sub, cancellationToken);`
`78`	`68`	`}`
`79`	`69`	`catch (Exception ex)`
`80`	`70`	`{`
`@@ -83,7 +73,7 @@ public ValueTask SubscribeAsync(NatsSubBase sub, CancellationToken cancellationT`
`83`	`73`	`}`
`84`	`74`	`}`
`85`	`75`
`86`		`- if (props.IsInboxSubject(_connection.InboxPrefix))`
	`76`	`+ if (sub.SubscriptionProps.IsInboxSubject(_connection.InboxPrefix))`
`87`	`77`	`{`
`88`	`78`	`if (sub.QueueGroup != null)`
`89`	`79`	`{`
`@@ -93,7 +83,7 @@ public ValueTask SubscribeAsync(NatsSubBase sub, CancellationToken cancellationT`
`93`	`83`	`return SubscribeInboxAsync(sub, cancellationToken);`
`94`	`84`	`}`
`95`	`85`
`96`		`- return SubscribeInternalAsync(props, sub, cancellationToken);`
	`86`	`+ return SubscribeInternalAsync(sub, cancellationToken);`
`97`	`87`	`}`
`98`	`88`
`99`	`89`	`public ValueTask PublishToClientHandlersAsync(NatsProcessProps props, in ReadOnlySequence<byte>? headersBuffer, in ReadOnlySequence<byte> payloadBuffer)`
`@@ -239,7 +229,7 @@ internal INatsSubscriptionManager GetManagerFor(NatsSubscribeProps props)`
`239`	`229`	`return this;`
`240`	`230`	`}`
`241`	`231`
`242`		`- internal async Task InitializeInboxSubscriptionAsync(CancellationToken cancellationToken)`
	`232`	`+ internal async Task InitializeInboxSubscriptionAsync(NatsSubscribeProps props, CancellationToken cancellationToken = default)`
`243`	`233`	`{`
`244`	`234`	`if (Interlocked.CompareExchange(ref _inboxSub, _inboxSubSentinel, _inboxSubSentinel) == _inboxSubSentinel)`
`245`	`235`	`{`
`@@ -248,18 +238,12 @@ internal async Task InitializeInboxSubscriptionAsync(CancellationToken cancellat`
`248`	`238`	`{`
`249`	`239`	`if (Interlocked.CompareExchange(ref _inboxSub, _inboxSubSentinel, _inboxSubSentinel) == _inboxSubSentinel)`
`250`	`240`	`{`
`251`		`- var props = new NatsSubscribeProps($"{_inboxPrefix}.*");`
`252`		`- props.SubscriptionId = GetNextSid();`
`253`		`-`
`254`	`241`	`// We need to subscribe to the real inbox subject before we can register the internal subject.`
`255`	`242`	`// We use 'default' options here since options provided by the user are for the internal subscription.`
`256`	`243`	`// For example if the user provides a timeout, we don't want to timeout the real inbox subscription`
`257`	`244`	`// since it must live duration of the connection.`
`258`	`245`	`_inboxSub = InboxSubBuilder.Build(props, opts: default, _connection, manager: this);`
`259`		`- await SubscribeInternalAsync(`
`260`		`- props,`
`261`		`- _inboxSub,`
`262`		`- cancellationToken).ConfigureAwait(false);`
	`246`	`+ await SubscribeInternalAsync(_inboxSub, cancellationToken).ConfigureAwait(false);`
`263`	`247`	`}`
`264`	`248`	`}`
`265`	`249`	`finally`
`@@ -273,40 +257,45 @@ await SubscribeInternalAsync(`
`273`	`257`
`274`	`258`	`private async ValueTask SubscribeInboxAsync(NatsSubBase sub, CancellationToken cancellationToken)`
`275`	`259`	`{`
`276`		`- await InitializeInboxSubscriptionAsync(cancellationToken).ConfigureAwait(false);`
	`260`	`+ await InitializeInboxSubscriptionAsync(sub.SubscriptionProps, cancellationToken).ConfigureAwait(false);`
`277`	`261`	`await InboxSubBuilder.RegisterAsync(sub).ConfigureAwait(false);`
`278`	`262`	`}`
`279`	`263`
`280`		`- private async ValueTask SubscribeInternalAsync(NatsSubscribeProps props, NatsSubBase sub, CancellationToken cancellationToken)`
	`264`	`+ private async ValueTask SubscribeInternalAsync(NatsSubBase sub, CancellationToken cancellationToken)`
`281`	`265`	`{`
	`266`	`+ if (sub.SubscriptionProps.UnsetSubscriptionId)`
	`267`	`+ {`
	`268`	`+ sub.SubscriptionProps.SubscriptionId = GetNextSid();`
	`269`	`+ }`
	`270`	`+`
`282`	`271`	`if (sub is InboxSub)`
`283`	`272`	`{`
`284`		`- Interlocked.Exchange(ref _inboxSid, props.SubscriptionId);`
	`273`	`+ Interlocked.Exchange(ref _inboxSid, sub.SubscriptionProps.SubscriptionId);`
`285`	`274`	`}`
`286`	`275`
`287`	`276`	`if (_debug)`
`288`	`277`	`{`
`289`		`- _logger.LogDebug(NatsLogEvents.Subscription, "New subscription {Subject}/{Sid}", sub.Subject, props.SubscriptionId);`
	`278`	`+ _logger.LogDebug(NatsLogEvents.Subscription, "New subscription {Subject}/{Sid}", sub.Subject, sub.SubscriptionProps.SubscriptionId);`
`290`	`279`	`}`
`291`	`280`
`292`	`281`	`lock (_gate)`
`293`	`282`	`{`
`294`		`- _bySid[props.SubscriptionId] = new SidMetadata(Properties: props, WeakReference: new WeakReference<NatsSubBase>(sub));`
	`283`	`+ _bySid[sub.SubscriptionProps.SubscriptionId] = new SidMetadata(Properties: sub.SubscriptionProps, WeakReference: new WeakReference<NatsSubBase>(sub));`
`295`	`284`	`#if NETSTANDARD2_0`
`296`	`285`	`lock (_bySub)`
`297`	`286`	`{`
`298`	`287`	`if (_bySub.TryGetValue(sub, out _))`
`299`	`288`	`_bySub.Remove(sub);`
`300`		`- _bySub.Add(sub, new SubscriptionMetadata(Sid: props.SubscriptionId));`
	`289`	`+ _bySub.Add(sub, new SubscriptionMetadata(Sid: sub.SubscriptionProps.SubscriptionId));`
`301`	`290`	`}`
`302`	`291`	`#else`
`303`		`- _bySub.AddOrUpdate(sub, new SubscriptionMetadata(Sid: props.SubscriptionId));`
	`292`	`+ _bySub.AddOrUpdate(sub, new SubscriptionMetadata(Sid: sub.SubscriptionProps.SubscriptionId));`
`304`	`293`	`#endif`
`305`	`294`	`}`
`306`	`295`
`307`	`296`	`try`
`308`	`297`	`{`
`309`		`- await _connection.SubscribeCoreAsync(props, sub.Opts?.MaxMsgs, cancellationToken).ConfigureAwait(false);`
	`298`	`+ await _connection.SubscribeCoreAsync(sub.SubscriptionProps, sub.Opts?.MaxMsgs, cancellationToken).ConfigureAwait(false);`
`310`	`299`	`await sub.ReadyAsync().ConfigureAwait(false);`
`311`	`300`	`}`
`312`	`301`	`catch`
Original file line number	Diff line number	Diff line change
`@@ -199,7 +199,8 @@ public async ValueTask ConnectAsync()`
`199`	`199`
`200`	`200`	`if (Opts.RequestReplyMode == NatsRequestReplyMode.Direct)`
`201`	`201`	`{`
`202`		`- await _subscriptionManager.InitializeInboxSubscriptionAsync(_disposedCts.Token).ConfigureAwait(false);`
	`202`	`+ var props = new NatsSubscribeProps($"{InboxPrefix}.*");`
	`203`	`+ await _subscriptionManager.InitializeInboxSubscriptionAsync(props, _disposedCts.Token).ConfigureAwait(false);`
`203`	`204`	`}`
`204`	`205`	`}`
`205`	`206`
`@@ -277,7 +278,7 @@ internal ValueTask PublishToClientHandlersAsync(NatsProcessProps props, in ReadO`
`277`	`278`	`{`
`278`	`279`	`if (Opts.RequestReplyMode == NatsRequestReplyMode.Direct)`
`279`	`280`	`{`
`280`		`- if (_subscriptionManager.InboxSid == props.SubscriptionId && props.IsReplyToRequest(InboxPrefix))`
	`281`	`+ if (_subscriptionManager.InboxSid == props.Subscription?.SubscriptionId && props.IsReplyToRequest(InboxPrefix))`
`281`	`282`	`{`
`282`	`283`	`if (_replyTaskFactory.TrySetResult(props, payloadBuffer, headersBuffer))`
`283`	`284`	`{`
Original file line number	Diff line number	Diff line change
`@@ -16,11 +16,13 @@ public NatsUnsubscribeProps(int subscriptionId)`
`16`	`16`	`internal NatsUnsubscribeProps(string subject)`
`17`	`17`	`: base(subject)`
`18`	`18`	`{`
`19`		`- SubscriptionId = 0;`
	`19`	`+ SubscriptionId = -1;`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`/// <summary>`
`23`	`23`	`/// A unique numeric subscription ID, generated by the client.`
`24`	`24`	`/// </summary>`
`25`	`25`	`public int SubscriptionId { get; set; }`
	`26`	`+`
	`27`	`+ internal bool UnsetSubscriptionId => SubscriptionId != -1;`
`26`	`28`	`}`