binding context expand

gencebay · gencebay · commit 5c579f914040 · 2018-01-22T23:29:34.000+03:00
diff --git a/src/NetCoreStack.Proxy/Binders/HttpDeleteContentBinder.cs b/src/NetCoreStack.Proxy/Binders/HttpDeleteContentBinder.cs
@@ -13,7 +13,7 @@ public override void BindContent(ContentModelBindingContext bindingContext)
         {
             ModelDictionaryResult result = bindingContext.ModelContentResolver.Resolve(bindingContext.Parameters, bindingContext.Args);
             List<string> keys = result.Dictionary.Keys.ToList();
-            EnsureTemplate(bindingContext.MethodMarkerTemplate, bindingContext.UriDefinition, result.Dictionary, keys);
+            EnsureTemplate(bindingContext, result.Dictionary, keys);
 
             bindingContext.TryUpdateUri(result.Dictionary);
         }
diff --git a/src/NetCoreStack.Proxy/Binders/HttpGetContentBinder.cs b/src/NetCoreStack.Proxy/Binders/HttpGetContentBinder.cs
@@ -13,7 +13,7 @@ public override void BindContent(ContentModelBindingContext bindingContext)
         {
             ModelDictionaryResult result = bindingContext.ModelContentResolver.Resolve(bindingContext.Parameters, bindingContext.Args);
             List<string> keys = result.Dictionary.Keys.ToList();
-            EnsureTemplate(bindingContext.MethodMarkerTemplate, bindingContext.UriDefinition, result.Dictionary, keys);
+            EnsureTemplate(bindingContext, result.Dictionary, keys);
 
             bindingContext.TryUpdateUri(result.Dictionary);
         }
diff --git a/src/NetCoreStack.Proxy/Binders/HttpPutContentBinder.cs b/src/NetCoreStack.Proxy/Binders/HttpPutContentBinder.cs
@@ -11,7 +11,15 @@ public class HttpPutContentBinder : BodyContentBinder
         public override void BindContent(ContentModelBindingContext bindingContext)
         {
             var isMultiPartFormData = bindingContext.IsMultiPartFormData;
-            //var templateParameterKeys = bindingContext.UriDefinition.TemplateParameterKeys;
+            var hasAnyTemplateParameterKey = bindingContext.HasAnyTemplateParameterKey;
+            if (bindingContext.ArgsLength == 1 && hasAnyTemplateParameterKey)
+            {
+                ModelDictionaryResult mdr = bindingContext.ModelContentResolver.Resolve(bindingContext.Parameters, bindingContext.Args);
+                List<string> mdrKeys = mdr.Dictionary.Keys.ToList();
+                EnsureTemplate(bindingContext, mdr.Dictionary, mdrKeys);
+                return;
+            }
+
             //List<ProxyModelMetadata> modelMetadataKeyList = new List<ProxyModelMetadata>();
             //int parameterOffset = 0;
             //foreach (var key in templateParameterKeys)
@@ -26,9 +34,10 @@ public override void BindContent(ContentModelBindingContext bindingContext)
             //    }
             //}
 
+
             ModelDictionaryResult result = bindingContext.ModelContentResolver.Resolve(bindingContext.Parameters, bindingContext.Args);
             List<string> keys = result.Dictionary.Keys.ToList();
-            EnsureTemplate(bindingContext.MethodMarkerTemplate, bindingContext.UriDefinition, result.Dictionary, keys);
+            EnsureTemplate(bindingContext, result.Dictionary, keys);
 
             if (isMultiPartFormData)
             { 
diff --git a/src/NetCoreStack.Proxy/DefaultProxyContentStreamProvider.cs b/src/NetCoreStack.Proxy/DefaultProxyContentStreamProvider.cs
@@ -26,15 +26,11 @@ public async Task CreateRequestContentAsync(RequestDescriptor requestContext,
             var isMultiPartFormData = descriptor.IsMultiPartFormData;
             var contentModelBinder = ContentBinderFactory.GetContentModelBinder(httpMethod);
 
-            var bindingContext = new ContentModelBindingContext
+            var bindingContext = new ContentModelBindingContext(httpMethod, descriptor, proxyUriDefinition)
             {
-                HttpMethod = httpMethod,
-                UriDefinition = proxyUriDefinition,
-                MethodMarkerTemplate = descriptor.MethodMarkerTemplate,
                 IsMultiPartFormData = isMultiPartFormData,
                 ModelContentResolver = ContentResolver,
                 Args = requestContext.Args,
-                Parameters = descriptor.Parameters
             };
 
             contentModelBinder.BindContent(bindingContext);
diff --git a/src/NetCoreStack.Proxy/DefaultProxyEndpointManager.cs b/src/NetCoreStack.Proxy/DefaultProxyEndpointManager.cs
@@ -13,7 +13,7 @@ public DefaultProxyEndpointManager(RoundRobinManager roundRobinManager)
             RoundRobinManager = roundRobinManager;
         }
 
-        public ProxyUriDefinition CreateUriDefinition(ProxyDescriptor descriptor, string regionKey, string targetMethodName)
+        public ProxyUriDefinition CreateUriDefinition(ProxyMethodDescriptor methodDescriptor, string route, string regionKey, string targetMethodName)
         {
             var uriBuilder = RoundRobinManager.RoundRobinUri(regionKey);
             if (uriBuilder == null)
@@ -23,21 +23,20 @@ public ProxyUriDefinition CreateUriDefinition(ProxyDescriptor descriptor, string
 
             var uriDefinition = new ProxyUriDefinition(uriBuilder);
 
-            if (!string.IsNullOrEmpty(descriptor.Route))
+            if (!string.IsNullOrEmpty(route))
             {
                 if (targetMethodName.ToLower() == HttpMethod.Get.Method.ToLower())
                 {
                     var path = uriDefinition.UriBuilder.Path ?? string.Empty;
-                    path += $"{descriptor.Route}/";
+                    path += $"{route}/";
                     uriDefinition.UriBuilder.Path = path;
                 }
                 else
                 {
                     if (targetMethodName.StartsWith("/"))
                         targetMethodName = targetMethodName.Substring(1);
 
-                    var routeTemplate = TemplateParser.Parse(targetMethodName);
-                    uriDefinition.ResolveTemplate(routeTemplate, descriptor.Route, targetMethodName);
+                    uriDefinition.ResolveTemplate(methodDescriptor, route, targetMethodName);
                 }
             }
 
diff --git a/src/NetCoreStack.Proxy/Interfaces/IProxyEndpointManager.cs b/src/NetCoreStack.Proxy/Interfaces/IProxyEndpointManager.cs
@@ -2,6 +2,6 @@
 {
     public interface IProxyEndpointManager
     {
-        ProxyUriDefinition CreateUriDefinition(ProxyDescriptor descriptor, string regionKey, string targetMethodName);
+        ProxyUriDefinition CreateUriDefinition(ProxyMethodDescriptor methodDescriptor, string route, string regionKey, string targetMethodName);
     }
 }
diff --git a/src/NetCoreStack.Proxy/Internal/DefaultProxyTypeManager.cs b/src/NetCoreStack.Proxy/Internal/DefaultProxyTypeManager.cs
@@ -1,4 +1,5 @@
-﻿using NetCoreStack.Contracts;
+﻿using Microsoft.AspNetCore.Routing.Template;
+using NetCoreStack.Contracts;
 using NetCoreStack.Proxy.Extensions;
 using System;
 using System.Collections.Generic;
@@ -83,7 +84,24 @@ private IList<ProxyDescriptor> GetProxyDescriptors()
                     if (httpMethodAttribute != null)
                     {
                         if (httpMethodAttribute.Template.HasValue())
-                            proxyMethodDescriptor.MethodMarkerTemplate = httpMethodAttribute.Template;
+                        {
+                            var template = httpMethodAttribute.Template;
+                            proxyMethodDescriptor.MethodMarkerTemplate = template;
+                            var routeTemplate = TemplateParser.Parse(template);
+                            if (routeTemplate != null)
+                            {
+                                proxyMethodDescriptor.RouteTemplate = routeTemplate;
+                                proxyMethodDescriptor.ParameterParts = new List<TemplatePart>(routeTemplate.Parameters);
+
+                                proxyMethodDescriptor.TemplateKeys = routeTemplate.Segments
+                                    .SelectMany(s => s.Parts.Where(p => p.IsLiteral)
+                                    .Select(t => t.Text)).ToList();
+
+                                proxyMethodDescriptor.TemplateParameterKeys = routeTemplate.Segments
+                                    .SelectMany(s => s.Parts.Where(p => p.IsParameter)
+                                    .Select(t => t.Name)).ToList();
+                            }
+                        }
 
                         if (httpMethodAttribute is HttpGetMarkerAttribute)
                             proxyMethodDescriptor.HttpMethod = HttpMethod.Get;
diff --git a/src/NetCoreStack.Proxy/Internal/ProxyManager.cs b/src/NetCoreStack.Proxy/Internal/ProxyManager.cs
@@ -117,7 +117,7 @@ public async Task<RequestContext> CreateRequestAsync(RequestDescriptor descripto
             if (methodDescriptor.MethodMarkerTemplate.HasValue())
                 methodPath = methodDescriptor.MethodMarkerTemplate;
 
-            ProxyUriDefinition proxyUriDefinition = _endpointManager.CreateUriDefinition(proxyDescriptor, regionKey, methodPath);
+            ProxyUriDefinition proxyUriDefinition = _endpointManager.CreateUriDefinition(methodDescriptor, proxyDescriptor.Route, regionKey, methodPath);
             TimeSpan? timeout = methodDescriptor.Timeout;
 
             request.RequestUri = proxyUriDefinition.UriBuilder.Uri;
diff --git a/src/NetCoreStack.Proxy/Types/ContentModelBinder.cs b/src/NetCoreStack.Proxy/Types/ContentModelBinder.cs
@@ -1,27 +1,22 @@
 ﻿using System.Collections.Generic;
+using System.Linq;
 using System.Net;
 
 namespace NetCoreStack.Proxy
 {
     public abstract class ContentModelBinder : IContentModelBinder
     {
-        protected virtual void EnsureTemplate(string methodMarkerTemplate,
-            ProxyUriDefinition proxyUriDefinition,
-            Dictionary<string, string> argsDic,
-            List<string> keys)
+        protected virtual void EnsureTemplate(ContentModelBindingContext context, Dictionary<string, string> argsDic, List<string> keys)
         {
-            if (!string.IsNullOrEmpty(methodMarkerTemplate))
+            if (!string.IsNullOrEmpty(context.MethodMarkerTemplate))
             {
-                if (proxyUriDefinition.HasParameter)
+                for (int i = 0; i < context.ParameterParts.Count; i++)
                 {
-                    for (int i = 0; i < proxyUriDefinition.ParameterParts.Count; i++)
+                    var key = keys[i];
+                    if (argsDic.TryGetValue(key, out string value))
                     {
-                        var key = keys[i];
-                        if(argsDic.TryGetValue(key, out string value))
-                        {
-                            proxyUriDefinition.UriBuilder.Path += ($"/{WebUtility.UrlEncode(value)}");
-                            argsDic.Remove(key);
-                        }
+                        context.UriBuilder.Path += ($"/{WebUtility.UrlEncode(value)}");
+                        argsDic.Remove(key);
                     }
                 }
             }
diff --git a/src/NetCoreStack.Proxy/Types/ContentModelBindingContext.cs b/src/NetCoreStack.Proxy/Types/ContentModelBindingContext.cs
@@ -1,5 +1,7 @@
-﻿using System;
+﻿using Microsoft.AspNetCore.Routing.Template;
+using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Net.Http;
 
 namespace NetCoreStack.Proxy
@@ -14,15 +16,33 @@ public int ArgsLength
             }
         }
 
-        public UriBuilder UriBuilder => UriDefinition?.UriBuilder;
+        public bool HasAnyTemplateParameterKey
+        {
+            get
+            {
+                return TemplateParameterKeys.Any();
+            }
+        }
+
+        public UriBuilder UriBuilder => UriDefinition.UriBuilder;
         public Uri Uri => UriBuilder.Uri;
-        public string MethodMarkerTemplate { get; set; }
+        public string MethodMarkerTemplate => MethodDescriptor.MethodMarkerTemplate;
+        public List<TemplatePart> ParameterParts => MethodDescriptor.ParameterParts;
+        public List<string> TemplateParameterKeys => MethodDescriptor.TemplateParameterKeys;
+        public List<ProxyModelMetadata> Parameters => MethodDescriptor.Parameters;
         public bool IsMultiPartFormData { get; set; }
+        public ContentModelBindingResult ContentResult { get; set; }
         public object[] Args { get; set; }
         public IModelContentResolver ModelContentResolver { get; set; }
-        public List<ProxyModelMetadata> Parameters { get; set; }
-        public ContentModelBindingResult ContentResult { get; set; }
-        public ProxyUriDefinition UriDefinition { get; set; }
-        public HttpMethod HttpMethod { get; set; }
+        public HttpMethod HttpMethod { get; }
+        public ProxyUriDefinition UriDefinition { get; }
+        public ProxyMethodDescriptor MethodDescriptor { get; }
+
+        public ContentModelBindingContext(HttpMethod httpMethod, ProxyMethodDescriptor methodDescriptor, ProxyUriDefinition proxyUriDefinition)
+        {
+            HttpMethod = httpMethod ?? throw new ArgumentNullException(nameof(httpMethod));
+            MethodDescriptor = methodDescriptor ?? throw new ArgumentNullException(nameof(methodDescriptor));
+            UriDefinition = proxyUriDefinition ?? throw new ArgumentNullException(nameof(proxyUriDefinition));
+        }
     }
 }
diff --git a/src/NetCoreStack.Proxy/Types/ProxyMethodDescriptor.cs b/src/NetCoreStack.Proxy/Types/ProxyMethodDescriptor.cs
@@ -1,6 +1,8 @@
-﻿using NetCoreStack.Proxy.Extensions;
+﻿using Microsoft.AspNetCore.Routing.Template;
+using NetCoreStack.Proxy.Extensions;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Net.Http;
 using System.Reflection;
 using System.Threading.Tasks;
@@ -20,6 +22,7 @@ public class ProxyMethodDescriptor
         public HttpMethod HttpMethod { get; set; }
 
         public TimeSpan? Timeout { get; set; }
+        public RouteTemplate RouteTemplate { get; set; }
 
         public bool IsMultiPartFormData { get; set; }
 
@@ -31,6 +34,14 @@ public class ProxyMethodDescriptor
 
         public bool IsGenericTaskReturn { get; }
 
+        public List<string> TemplateKeys { get; set; }
+
+        public List<string> TemplateParameterKeys { get; set; }
+
+        public List<TemplatePart> ParameterParts { get; set; }
+
+        public bool HasAnyTemplateParameterKey => TemplateParameterKeys.Any();
+
         public Dictionary<string, string> Headers { get; }
 
         public ProxyMethodDescriptor(MethodInfo methodInfo)
@@ -42,6 +53,9 @@ public ProxyMethodDescriptor(MethodInfo methodInfo)
             IsGenericTaskReturn = ReturnType.IsGenericTask() ? true : false;
             Headers = new Dictionary<string, string>(StringComparer.Ordinal);
             Parameters = new List<ProxyModelMetadata>();
+            ParameterParts = new List<TemplatePart>();
+            TemplateKeys = new List<string>();
+            TemplateParameterKeys = new List<string>();
 
             if (IsGenericTaskReturn)
             {
diff --git a/src/NetCoreStack.Proxy/Types/ProxyUriDefinition.cs b/src/NetCoreStack.Proxy/Types/ProxyUriDefinition.cs
@@ -1,7 +1,5 @@
-﻿using Microsoft.AspNetCore.Routing.Template;
-using System;
+﻿using System;
 using System.Collections.Generic;
-using System.Linq;
 
 namespace NetCoreStack.Proxy
 {
@@ -14,28 +12,19 @@ public class ProxyUriDefinition
 
         public bool HasParameter { get; private set; }
 
-        public List<string> TemplateKeys { get; private set; }
-
-        public List<string> TemplateParameterKeys { get; private set; }
-
-        public List<TemplatePart> ParameterParts { get; private set; }
-
         public ProxyUriDefinition(UriBuilder uriBuilder)
         {
             UriBuilder = uriBuilder;
-            TemplateKeys = new List<string>();
-            TemplateParameterKeys = new List<string>();
         }
 
-        public void ResolveTemplate(RouteTemplate routeTemplate, string route, string template)
+        public void ResolveTemplate(ProxyMethodDescriptor methodDescriptor, string route, string template)
         {
             var path = UriBuilder.Path ?? string.Empty;
-            if (routeTemplate != null)
+            if (methodDescriptor.RouteTemplate != null)
             {
-                if (routeTemplate.Parameters.Count > 0)
+                if (methodDescriptor.RouteTemplate.Parameters.Count > 0)
                 {
                     HasParameter = true;
-                    ParameterParts = new List<TemplatePart>(routeTemplate.Parameters);
                     var key = route + "/" + template;
                     if (TemplateCache.TryGetValue(key, out string tmpl))
                     {
@@ -44,15 +33,7 @@ public void ResolveTemplate(RouteTemplate routeTemplate, string route, string te
                         return;
                     }
 
-                    TemplateKeys = routeTemplate.Segments
-                        .SelectMany(s => s.Parts.Where(p => p.IsLiteral)
-                        .Select(t => t.Text)).ToList();
-
-                    TemplateParameterKeys = routeTemplate.Segments
-                        .SelectMany(s => s.Parts.Where(p => p.IsParameter)
-                        .Select(t => t.Name)).ToList();
-
-                    tmpl = string.Join("/", TemplateKeys);
+                    tmpl = string.Join("/", methodDescriptor.TemplateKeys);
                     TemplateCache.Add(key, tmpl);
 
                     path += $"{route}/{tmpl}";
diff --git a/test/NetCoreStack.Proxy.Mvc.Hosting/Controllers/GuidelineController.cs b/test/NetCoreStack.Proxy.Mvc.Hosting/Controllers/GuidelineController.cs
@@ -87,5 +87,10 @@ public async Task TaskActionDelete(long id)
             await Task.CompletedTask;
             _logger.LogWarning(JsonConvert.SerializeObject(new { id }));
         }
+
+        public Task<bool> CreateOrUpdateKey(string key)
+        {
+            throw new NotImplementedException();
+        }
     }
 }
diff --git a/test/NetCoreStack.Proxy.Test.Contracts/IGuidelineApi.cs b/test/NetCoreStack.Proxy.Test.Contracts/IGuidelineApi.cs
@@ -33,6 +33,9 @@ public interface IGuidelineApi : IApiContract
         [HttpPutMarker(Template = "kv/{key}")]
         Task<bool> CreateOrUpdateKey(string key, Bar body);
 
+        [HttpPutMarker(Template = "kv/nobody/{key}")]
+        Task<bool> CreateOrUpdateKey(string key);
+
         [HttpDeleteMarker]
         Task TaskActionDelete(long id);
     }
diff --git a/test/NetCoreStack.Proxy.Tests/ProxyCreationTests.cs b/test/NetCoreStack.Proxy.Tests/ProxyCreationTests.cs
@@ -119,6 +119,14 @@ public async Task GetCollectionStreamTest()
             Assert.True(collection.Data.Count() == 5);
         }
 
+        [Fact]
+        public async Task CreateOrUpdateNoBodyKeyTest()
+        {
+            var guidelineApi = Resolver.GetService<IGuidelineApi>();
+            var result = await guidelineApi.CreateOrUpdateKey(_someKey);
+            Assert.True(result);
+        }
+
         [Fact]
         public async Task CreateOrUpdateKeyTest()
         {
diff --git a/test/NetCoreStack.Proxy.Tests/httplive.db b/test/NetCoreStack.Proxy.Tests/httplive.db

Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ public override void BindContent(ContentModelBindingContext bindingContext)`
`13`	`13`	`{`
`14`	`14`	`ModelDictionaryResult result = bindingContext.ModelContentResolver.Resolve(bindingContext.Parameters, bindingContext.Args);`
`15`	`15`	`List<string> keys = result.Dictionary.Keys.ToList();`
`16`		`- EnsureTemplate(bindingContext.MethodMarkerTemplate, bindingContext.UriDefinition, result.Dictionary, keys);`
	`16`	`+ EnsureTemplate(bindingContext, result.Dictionary, keys);`
`17`	`17`
`18`	`18`	`bindingContext.TryUpdateUri(result.Dictionary);`
`19`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ public DefaultProxyEndpointManager(RoundRobinManager roundRobinManager)`
`13`	`13`	`RoundRobinManager = roundRobinManager;`
`14`	`14`	`}`
`15`	`15`
`16`		`- public ProxyUriDefinition CreateUriDefinition(ProxyDescriptor descriptor, string regionKey, string targetMethodName)`
	`16`	`+ public ProxyUriDefinition CreateUriDefinition(ProxyMethodDescriptor methodDescriptor, string route, string regionKey, string targetMethodName)`
`17`	`17`	`{`
`18`	`18`	`var uriBuilder = RoundRobinManager.RoundRobinUri(regionKey);`
`19`	`19`	`if (uriBuilder == null)`
`@@ -23,21 +23,20 @@ public ProxyUriDefinition CreateUriDefinition(ProxyDescriptor descriptor, string`
`23`	`23`
`24`	`24`	`var uriDefinition = new ProxyUriDefinition(uriBuilder);`
`25`	`25`
`26`		`- if (!string.IsNullOrEmpty(descriptor.Route))`
	`26`	`+ if (!string.IsNullOrEmpty(route))`
`27`	`27`	`{`
`28`	`28`	`if (targetMethodName.ToLower() == HttpMethod.Get.Method.ToLower())`
`29`	`29`	`{`
`30`	`30`	`var path = uriDefinition.UriBuilder.Path ?? string.Empty;`
`31`		`- path += $"{descriptor.Route}/";`
	`31`	`+ path += $"{route}/";`
`32`	`32`	`uriDefinition.UriBuilder.Path = path;`
`33`	`33`	`}`
`34`	`34`	`else`
`35`	`35`	`{`
`36`	`36`	`if (targetMethodName.StartsWith("/"))`
`37`	`37`	`targetMethodName = targetMethodName.Substring(1);`
`38`	`38`
`39`		`- var routeTemplate = TemplateParser.Parse(targetMethodName);`
`40`		`- uriDefinition.ResolveTemplate(routeTemplate, descriptor.Route, targetMethodName);`
	`39`	`+ uriDefinition.ResolveTemplate(methodDescriptor, route, targetMethodName);`
`41`	`40`	`}`
`42`	`41`	`}`
`43`	`42`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,6 @@`
`2`	`2`	`{`
`3`	`3`	`public interface IProxyEndpointManager`
`4`	`4`	`{`
`5`		`- ProxyUriDefinition CreateUriDefinition(ProxyDescriptor descriptor, string regionKey, string targetMethodName);`
	`5`	`+ ProxyUriDefinition CreateUriDefinition(ProxyMethodDescriptor methodDescriptor, string route, string regionKey, string targetMethodName);`
`6`	`6`	`}`
`7`	`7`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,27 +1,22 @@`
`1`	`1`	`using System.Collections.Generic;`
	`2`	`+using System.Linq;`
`2`	`3`	`using System.Net;`
`3`	`4`
`4`	`5`	`namespace NetCoreStack.Proxy`
`5`	`6`	`{`
`6`	`7`	`public abstract class ContentModelBinder : IContentModelBinder`
`7`	`8`	`{`
`8`		`- protected virtual void EnsureTemplate(string methodMarkerTemplate,`
`9`		`- ProxyUriDefinition proxyUriDefinition,`
`10`		`- Dictionary<string, string> argsDic,`
`11`		`- List<string> keys)`
	`9`	`+ protected virtual void EnsureTemplate(ContentModelBindingContext context, Dictionary<string, string> argsDic, List<string> keys)`
`12`	`10`	`{`
`13`		`- if (!string.IsNullOrEmpty(methodMarkerTemplate))`
	`11`	`+ if (!string.IsNullOrEmpty(context.MethodMarkerTemplate))`
`14`	`12`	`{`
`15`		`- if (proxyUriDefinition.HasParameter)`
	`13`	`+ for (int i = 0; i < context.ParameterParts.Count; i++)`
`16`	`14`	`{`
`17`		`- for (int i = 0; i < proxyUriDefinition.ParameterParts.Count; i++)`
	`15`	`+ var key = keys[i];`
	`16`	`+ if (argsDic.TryGetValue(key, out string value))`
`18`	`17`	`{`
`19`		`- var key = keys[i];`
`20`		`- if(argsDic.TryGetValue(key, out string value))`
`21`		`- {`
`22`		`- proxyUriDefinition.UriBuilder.Path += ($"/{WebUtility.UrlEncode(value)}");`
`23`		`- argsDic.Remove(key);`
`24`		`- }`
	`18`	`+ context.UriBuilder.Path += ($"/{WebUtility.UrlEncode(value)}");`
	`19`	`+ argsDic.Remove(key);`
`25`	`20`	`}`
`26`	`21`	`}`
`27`	`22`	`}`