Allow setting the context in a temporary using scope for IEncoder instances (#3044)

* Allow setting the context in a temporary using scope for IEncoder instances

* make the setter of Current property private

Author: mrsuciu

Stack/Opc.Ua.Core/Types/BuiltIn/MessageContextExtension.cs

@@ -10,6 +10,9 @@
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 */
 
+using System;
+using System.Threading;
+
 namespace Opc.Ua
 {
     #region MessageContextExtension Class
@@ -29,7 +32,11 @@ public MessageContextExtension(IServiceMessageContext messageContext)
         /// <summary>
         /// Returns the message context associated with the current operation context.
         /// </summary>
-        public static MessageContextExtension Current => null;
+        public static MessageContextExtension Current
+        {
+            get => s_current.Value;
+            private set => s_current.Value = value;
+        }
 
         /// <summary>
         /// Returns the message context associated with the current operation context.
@@ -53,6 +60,40 @@ public static IServiceMessageContext CurrentContext
         /// The message context to use.
         /// </summary>
         public IServiceMessageContext MessageContext { get; private set; }
+
+        /// <summary>
+        /// Set the context for a specific using scope
+        /// </summary>
+        /// <param name="messageContext"></param>
+        /// <returns></returns>
+        public static IDisposable SetScopedContext(IServiceMessageContext messageContext)
+        {
+            var previousContext = Current;
+            Current = new MessageContextExtension(messageContext);
+
+            return new DisposableAction (() => Current = previousContext);
+        }
+
+        /// <summary>
+        /// Disposable wrapper for reseting the Current context to
+        /// the previous value on exiting the using scope
+        /// </summary>
+        private class DisposableAction : IDisposable
+        {
+            private readonly Action action;
+
+            public DisposableAction(Action action)
+            {
+                this.action = action;
+            }
+
+            public void Dispose()
+            {
+                action?.Invoke();
+            }
+        }
+
+        private static readonly AsyncLocal<MessageContextExtension> s_current = new AsyncLocal<MessageContextExtension>();
     }
     #endregion
 }

Tests/Opc.Ua.Client.ComplexTypes.Tests/Types/EncoderTests.cs

@@ -168,6 +168,57 @@ StructureFieldParameter structureFieldParameter
             baseType[structureFieldParameter.Name] = null;
             EncodeDecodeComplexType(EncoderContext, memoryStreamType, encoderType, jsonEncodingType, StructureType.Union, nodeId, emittedType);
         }
+
+        /// <summary>
+        /// Verify serialize/encode of a structured type initiated from outside of an IEncoder instance.
+        /// </summary>
+        [Theory]
+        [Category("ComplexTypes")]
+        public void ReEncodeComplexTypeScopedContext(
+            MemoryStreamType memoryStreamType,
+            StructureType structureType
+            )
+        {
+            ExpandedNodeId nodeId;
+            Type complexType;
+            (nodeId, complexType) = TypeDictionary[structureType];
+            object emittedType = Activator.CreateInstance(complexType);
+            var baseType = emittedType as BaseComplexType;
+            FillStructWithValues(baseType, true);
+
+            ExtensionObject extensionObject = new ExtensionObject(emittedType);
+
+            Opc.Ua.KeyValuePair keyValuePair = new Opc.Ua.KeyValuePair();
+            keyValuePair.Key = "AKEY";
+            keyValuePair.Value = extensionObject;
+
+            ServiceMessageContext localCtxt = (ServiceMessageContext)EncoderContext;
+
+            // Serialize/Encode a Variant fails without a context available
+            Assert.Throws(
+               typeof(Newtonsoft.Json.JsonSerializationException),
+               () => Newtonsoft.Json.JsonConvert.SerializeObject(keyValuePair));
+
+            // Serialize/Encode an ExtensionObject fails without a context available
+            var extObjToEncode = new ExtensionObject(keyValuePair);
+            Assert.Throws(
+                typeof(Newtonsoft.Json.JsonSerializationException),
+                () => Newtonsoft.Json.JsonConvert.SerializeObject(extObjToEncode));
+
+            // Serialize/Encode a Variant succeeds with a context available
+            using (MessageContextExtension.SetScopedContext(localCtxt))
+            {
+                _ = Newtonsoft.Json.JsonConvert.SerializeObject(keyValuePair);
+            }
+
+            // Serialize/Encode an ExtensionObject succeeds with a context available
+            using (MessageContextExtension.SetScopedContext(localCtxt))
+            {
+                _ = Newtonsoft.Json.JsonConvert.SerializeObject(extensionObject);
+            }
+
+
+        }
         #endregion Test Methods
     }
 }