simplify implementation (#51745)

ArcturusZhang · web-flow · commit abbc9b209338 · 2025-08-06T15:51:22.000+08:00
diff --git a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/OperationMethodProviders/ExistsOperationMethodProvider.cs b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/OperationMethodProviders/ExistsOperationMethodProvider.cs
@@ -18,26 +18,20 @@ internal class ExistsOperationMethodProvider(
         ResourceCollectionClientProvider collection,
         RestClientInfo restClientInfo,
         InputServiceMethod method,
-        MethodProvider convenienceMethod,
-        bool isAsync) : ResourceOperationMethodProvider(collection, collection.ContextualPath, restClientInfo, method, convenienceMethod, isAsync)
+        bool isAsync)
+        : ResourceOperationMethodProvider(
+            collection,
+            collection.ContextualPath,
+            restClientInfo,
+            method,
+            isAsync,
+            methodName: isAsync ? "ExistsAsync" : "Exists",
+            description: $"Checks to see if the resource exists in azure.")
     {
-        protected override MethodSignature CreateSignature()
+        protected override CSharpType BuildReturnType()
         {
-            var returnType = new CSharpType(typeof(Response<>), typeof(bool))
+            return new CSharpType(typeof(Response<>), typeof(bool))
                 .WrapAsync(_isAsync);
-
-            return new MethodSignature(
-                _isAsync ? "ExistsAsync" : "Exists",
-                $"Checks to see if the resource exists in azure.",
-                _convenienceMethod.Signature.Modifiers,
-                returnType,
-                _convenienceMethod.Signature.ReturnDescription,
-                GetOperationMethodParameters(),
-                _convenienceMethod.Signature.Attributes,
-                _convenienceMethod.Signature.GenericArguments,
-                _convenienceMethod.Signature.GenericParameterConstraints,
-                _convenienceMethod.Signature.ExplicitInterface,
-                _convenienceMethod.Signature.NonDocumentComment);
         }
 
         protected override IReadOnlyList<MethodBodyStatement> BuildReturnStatements(ScopedApi<Response> responseVariable, MethodSignature signature)
diff --git a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/OperationMethodProviders/GetIfExistsOperationMethodProvider.cs b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/OperationMethodProviders/GetIfExistsOperationMethodProvider.cs
@@ -20,14 +20,12 @@ internal class GetIfExistsOperationMethodProvider(
         ResourceCollectionClientProvider collection,
         RestClientInfo restClientInfo,
         InputServiceMethod method,
-        MethodProvider convenienceMethod,
         bool isAsync)
         : ResourceOperationMethodProvider(
             collection,
             collection.ContextualPath,
             restClientInfo,
             method,
-            convenienceMethod,
             isAsync,
             methodName: isAsync ? "GetIfExistsAsync" : "GetIfExists",
             description: $"Tries to get details for this resource from the service.")
diff --git a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/OperationMethodProviders/PageableOperationMethodProvider.cs b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/OperationMethodProviders/PageableOperationMethodProvider.cs
@@ -22,7 +22,7 @@ internal class PageableOperationMethodProvider
         private readonly TypeProvider _enclosingType;
         private readonly RequestPathPattern _contextualPath;
         private readonly RestClientInfo _restClientInfo;
-        private readonly InputServiceMethod _method;
+        private readonly InputPagingServiceMethod _method;
         private readonly MethodProvider _convenienceMethod;
         private readonly bool _isAsync;
         private readonly CSharpType _itemType;
@@ -36,21 +36,19 @@ public PageableOperationMethodProvider(
             TypeProvider enclosingType,
             RequestPathPattern contextualPath,
             RestClientInfo restClientInfo,
-            InputServiceMethod method,
-            MethodProvider convenienceMethod,
+            InputPagingServiceMethod method,
             bool isAsync,
-            CSharpType itemType,
             ResourceOperationKind methodKind)
         {
             _enclosingType = enclosingType;
             _contextualPath = contextualPath;
             _restClientInfo = restClientInfo;
             _method = method;
-            _convenienceMethod = convenienceMethod;
+            _convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(_method.Operation, isAsync);
             _isAsync = isAsync;
-            _itemType = itemType;
+            _itemType = _convenienceMethod.Signature.ReturnType!.Arguments[0]; // a paging method's return type should be `Pageable<T>` or `AsyncPageable<T>`, so we can safely access the first argument as the item type.
             InitializeTypeInfo(
-                itemType,
+                _itemType,
                 ref _actualItemType!,
                 ref _itemResourceClient
             );
diff --git a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/OperationMethodProviders/ResourceOperationMethodProvider.cs b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/OperationMethodProviders/ResourceOperationMethodProvider.cs
@@ -52,7 +52,6 @@ internal class ResourceOperationMethodProvider
         /// <param name="contextualPath">The contextual path of the enclosing type. </param>
         /// <param name="restClientInfo">The rest client information containing the client provider and related fields. </param>
         /// <param name="method">The input service method that we are building from. </param>
-        /// <param name="convenienceMethod">The corresponding convenience method provided by the generator framework. </param>
         /// <param name="isAsync">Whether this method is an async method. </param>
         /// <param name="methodName">Optional override for the method name. If not provided, uses the convenience method name. </param>
         /// <param name="description">Optional override for the method description. If not provided, uses the convenience method description.</param>
@@ -62,7 +61,6 @@ public ResourceOperationMethodProvider(
             RequestPathPattern contextualPath,
             RestClientInfo restClientInfo,
             InputServiceMethod method,
-            MethodProvider convenienceMethod,
             bool isAsync,
             string? methodName = null,
             FormattableString? description = null,
@@ -72,15 +70,15 @@ public ResourceOperationMethodProvider(
             _contextualPath = contextualPath;
             _restClient = restClientInfo.RestClientProvider;
             _serviceMethod = method;
-            _convenienceMethod = convenienceMethod;
             _isAsync = isAsync;
+            _convenienceMethod = _restClient.GetConvenienceMethodByOperation(_serviceMethod.Operation, isAsync);
             InitializeLroFlags(
                 _serviceMethod,
                 forceLro: forceLro,
                 ref _isLongRunningOperation,
                 ref _isFakeLongRunningOperation);
-            _methodName = methodName ?? convenienceMethod.Signature.Name;
-            _description = description ?? convenienceMethod.Signature.Description;
+            _methodName = methodName ?? _convenienceMethod.Signature.Name;
+            _description = description ?? _convenienceMethod.Signature.Description;
             InitializeTypeInfo(
                 _serviceMethod,
                 ref _originalBodyType,
diff --git a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/OperationMethodProviders/UpdateOperationMethodProvider.cs b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/OperationMethodProviders/UpdateOperationMethodProvider.cs
@@ -3,16 +3,14 @@
 
 using Azure.Generator.Management.Models;
 using Microsoft.TypeSpec.Generator.Input;
-using Microsoft.TypeSpec.Generator.Providers;
 
 namespace Azure.Generator.Management.Providers.OperationMethodProviders
 {
     internal class UpdateOperationMethodProvider(
         ResourceClientProvider resource,
         RestClientInfo restClientInfo,
         InputServiceMethod method,
-        MethodProvider convenienceMethod,
-        bool isAsync) : ResourceOperationMethodProvider(resource, resource.ContextualPath, restClientInfo, method, convenienceMethod, isAsync, methodName: isAsync ? "UpdateAsync" : "Update")
+        bool isAsync) : ResourceOperationMethodProvider(resource, resource.ContextualPath, restClientInfo, method, isAsync, methodName: isAsync ? "UpdateAsync" : "Update")
     {
     }
 }
diff --git a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/ResourceClientProvider.cs b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/ResourceClientProvider.cs
@@ -335,12 +335,11 @@ protected override MethodProvider[] BuildMethods()
                 var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(method.Operation, false);
                 var asyncConvenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(method.Operation, true);
 
-                if (method is InputPagingServiceMethod)
+                if (method is InputPagingServiceMethod pagingMethod)
                 {
                     // Use PageableOperationMethodProvider for InputPagingServiceMethod
-                    var itemType = convenienceMethod.Signature.ReturnType!.UnWrap();
-                    operationMethods.Add(new PageableOperationMethodProvider(this, ContextualPath, restClientInfo, method, convenienceMethod, false, itemType, methodKind));
-                    operationMethods.Add(new PageableOperationMethodProvider(this, ContextualPath, restClientInfo, method, asyncConvenienceMethod, true, itemType, methodKind));
+                    operationMethods.Add(new PageableOperationMethodProvider(this, ContextualPath, restClientInfo, pagingMethod, false, methodKind));
+                    operationMethods.Add(new PageableOperationMethodProvider(this, ContextualPath, restClientInfo, pagingMethod, true, methodKind));
 
                     continue;
                 }
@@ -350,18 +349,18 @@ protected override MethodProvider[] BuildMethods()
 
                 if (isUpdateOperation)
                 {
-                    updateMethodProvider = new UpdateOperationMethodProvider(this, restClientInfo, method, convenienceMethod, false);
+                    updateMethodProvider = new UpdateOperationMethodProvider(this, restClientInfo, method, false);
                     operationMethods.Add(updateMethodProvider);
 
-                    var updateAsyncMethodProvider = new UpdateOperationMethodProvider(this, restClientInfo, method, asyncConvenienceMethod, true);
+                    var updateAsyncMethodProvider = new UpdateOperationMethodProvider(this, restClientInfo, method, true);
                     operationMethods.Add(updateAsyncMethodProvider);
                 }
                 else
                 {
                     var methodName = ResourceHelpers.GetOperationMethodName(methodKind, false);
-                    operationMethods.Add(new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, method, convenienceMethod, false, methodName, forceLro: isFakeLro));
+                    operationMethods.Add(new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, method, false, methodName, forceLro: isFakeLro));
                     var asyncMethodName = ResourceHelpers.GetOperationMethodName(methodKind, true);
-                    operationMethods.Add(new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, method, asyncConvenienceMethod, true, asyncMethodName, forceLro: isFakeLro));
+                    operationMethods.Add(new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, method, true, asyncMethodName, forceLro: isFakeLro));
                 }
             }
 
diff --git a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/ResourceCollectionClientProvider.cs b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/ResourceCollectionClientProvider.cs
@@ -230,8 +230,8 @@ private MethodProvider[] BuildGetAllMethods()
             }
 
             // implement paging method GetAll
-            var getAll = BuildGetAllMethod(false);
-            var getAllAsync = BuildGetAllMethod(true);
+            var getAll = BuildGetAllMethod(_getAll, false);
+            var getAllAsync = BuildGetAllMethod(_getAll, true);
 
             return [getAllAsync, getAll];
         }
@@ -273,17 +273,20 @@ private List<MethodProvider> BuildCreateOrUpdateMethods()
             {
                 var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(_create!.Operation, isAsync);
                 var methodName = ResourceHelpers.GetOperationMethodName(ResourceOperationKind.Create, isAsync);
-                result.Add(new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, _create, convenienceMethod, isAsync, methodName, forceLro: true));
+                result.Add(new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, _create, isAsync, methodName, forceLro: true));
             }
 
             return result;
         }
 
-        private MethodProvider BuildGetAllMethod(bool isAsync)
+        private MethodProvider BuildGetAllMethod(InputServiceMethod getAll, bool isAsync)
         {
-            var restClientInfo = _resourceMetadata.GetRestClientForServiceMethod(_getAll!, _clientInfos);
-            var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(_getAll!.Operation, isAsync);
-            return new PageableOperationMethodProvider(this, this.ContextualPath, restClientInfo, _getAll, convenienceMethod, isAsync, Resource.ResourceData.Type, ResourceOperationKind.List);
+            var restClientInfo = _resourceMetadata.GetRestClientForServiceMethod(getAll, _clientInfos);
+            return getAll switch
+            {
+                InputPagingServiceMethod pagingGetAll => new PageableOperationMethodProvider(this, ContextualPath, restClientInfo, pagingGetAll, isAsync, ResourceOperationKind.List),
+                _ => new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, getAll, isAsync, ResourceHelpers.GetOperationMethodName(ResourceOperationKind.List, isAsync))
+            };
         }
 
         private List<MethodProvider> BuildGetMethods()
@@ -298,7 +301,7 @@ private List<MethodProvider> BuildGetMethods()
             foreach (var isAsync in new List<bool> { true, false })
             {
                 var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(_get!.Operation, isAsync);
-                result.Add(new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, _get, convenienceMethod, isAsync));
+                result.Add(new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, _get, isAsync));
             }
 
             return result;
@@ -316,7 +319,7 @@ private List<MethodProvider> BuildExistsMethods()
             foreach (var isAsync in new List<bool> { true, false })
             {
                 var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(_get!.Operation, isAsync);
-                var existsMethodProvider = new ExistsOperationMethodProvider(this, restClientInfo, _get, convenienceMethod, isAsync);
+                var existsMethodProvider = new ExistsOperationMethodProvider(this, restClientInfo, _get, isAsync);
                 result.Add(existsMethodProvider);
             }
 
@@ -335,7 +338,7 @@ private List<MethodProvider> BuildGetIfExistsMethods()
             foreach (var isAsync in new List<bool> { true, false })
             {
                 var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(_get!.Operation, isAsync);
-                var getIfExistsMethodProvider = new GetIfExistsOperationMethodProvider(this, restClientInfo, _get, convenienceMethod, isAsync);
+                var getIfExistsMethodProvider = new GetIfExistsOperationMethodProvider(this, restClientInfo, _get, isAsync);
                 result.Add(getIfExistsMethodProvider);
             }
 
diff --git a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Utilities/CSharpTypeExtensions.cs b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Utilities/CSharpTypeExtensions.cs
@@ -31,19 +31,5 @@ public static CSharpType WrapResponse(this CSharpType? type, bool isLongRunning)
                     : typeof(Response);
             }
         }
-
-        public static CSharpType UnWrap(this CSharpType type)
-        {
-            var currentType = type;
-
-            // Recursively unwrap any generic type with a single type argument
-            // This will find the innermost type regardless of nesting level or specific generic types
-            while (currentType.IsGenericType && currentType.Arguments.Count == 1)
-            {
-                currentType = currentType.Arguments[0];
-            }
-
-            return currentType;
-        }
     }
 }
diff --git a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Utilities/ResourceHelpers.cs b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Utilities/ResourceHelpers.cs
@@ -32,6 +32,7 @@ public static string GetRestClientFieldName(string restClientName)
             return operationKind switch
             {
                 ResourceOperationKind.Create => isAsync ? "CreateOrUpdateAsync" : "CreateOrUpdate",
+                ResourceOperationKind.List => isAsync ? "GetAllAsync" : "GetAll",
                 _ => null
             };
         }

Original file line number	Diff line number	Diff line change
`@@ -3,16 +3,14 @@`
`3`	`3`
`4`	`4`	`using Azure.Generator.Management.Models;`
`5`	`5`	`using Microsoft.TypeSpec.Generator.Input;`
`6`		`-using Microsoft.TypeSpec.Generator.Providers;`
`7`	`6`
`8`	`7`	`namespace Azure.Generator.Management.Providers.OperationMethodProviders`
`9`	`8`	`{`
`10`	`9`	`internal class UpdateOperationMethodProvider(`
`11`	`10`	`ResourceClientProvider resource,`
`12`	`11`	`RestClientInfo restClientInfo,`
`13`	`12`	`InputServiceMethod method,`
`14`		`- MethodProvider convenienceMethod,`
`15`		`- bool isAsync) : ResourceOperationMethodProvider(resource, resource.ContextualPath, restClientInfo, method, convenienceMethod, isAsync, methodName: isAsync ? "UpdateAsync" : "Update")`
	`13`	`+ bool isAsync) : ResourceOperationMethodProvider(resource, resource.ContextualPath, restClientInfo, method, isAsync, methodName: isAsync ? "UpdateAsync" : "Update")`
`16`	`14`	`{`
`17`	`15`	`}`
`18`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -335,12 +335,11 @@ protected override MethodProvider[] BuildMethods()`
`335`	`335`	`var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(method.Operation, false);`
`336`	`336`	`var asyncConvenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(method.Operation, true);`
`337`	`337`
`338`		`- if (method is InputPagingServiceMethod)`
	`338`	`+ if (method is InputPagingServiceMethod pagingMethod)`
`339`	`339`	`{`
`340`	`340`	`// Use PageableOperationMethodProvider for InputPagingServiceMethod`
`341`		`- var itemType = convenienceMethod.Signature.ReturnType!.UnWrap();`
`342`		`- operationMethods.Add(new PageableOperationMethodProvider(this, ContextualPath, restClientInfo, method, convenienceMethod, false, itemType, methodKind));`
`343`		`- operationMethods.Add(new PageableOperationMethodProvider(this, ContextualPath, restClientInfo, method, asyncConvenienceMethod, true, itemType, methodKind));`
	`341`	`+ operationMethods.Add(new PageableOperationMethodProvider(this, ContextualPath, restClientInfo, pagingMethod, false, methodKind));`
	`342`	`+ operationMethods.Add(new PageableOperationMethodProvider(this, ContextualPath, restClientInfo, pagingMethod, true, methodKind));`
`344`	`343`
`345`	`344`	`continue;`
`346`	`345`	`}`
`@@ -350,18 +349,18 @@ protected override MethodProvider[] BuildMethods()`
`350`	`349`
`351`	`350`	`if (isUpdateOperation)`
`352`	`351`	`{`
`353`		`- updateMethodProvider = new UpdateOperationMethodProvider(this, restClientInfo, method, convenienceMethod, false);`
	`352`	`+ updateMethodProvider = new UpdateOperationMethodProvider(this, restClientInfo, method, false);`
`354`	`353`	`operationMethods.Add(updateMethodProvider);`
`355`	`354`
`356`		`- var updateAsyncMethodProvider = new UpdateOperationMethodProvider(this, restClientInfo, method, asyncConvenienceMethod, true);`
	`355`	`+ var updateAsyncMethodProvider = new UpdateOperationMethodProvider(this, restClientInfo, method, true);`
`357`	`356`	`operationMethods.Add(updateAsyncMethodProvider);`
`358`	`357`	`}`
`359`	`358`	`else`
`360`	`359`	`{`
`361`	`360`	`var methodName = ResourceHelpers.GetOperationMethodName(methodKind, false);`
`362`		`- operationMethods.Add(new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, method, convenienceMethod, false, methodName, forceLro: isFakeLro));`
	`361`	`+ operationMethods.Add(new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, method, false, methodName, forceLro: isFakeLro));`
`363`	`362`	`var asyncMethodName = ResourceHelpers.GetOperationMethodName(methodKind, true);`
`364`		`- operationMethods.Add(new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, method, asyncConvenienceMethod, true, asyncMethodName, forceLro: isFakeLro));`
	`363`	`+ operationMethods.Add(new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, method, true, asyncMethodName, forceLro: isFakeLro));`
`365`	`364`	`}`
`366`	`365`	`}`
`367`	`366`
Original file line number	Diff line number	Diff line change
`@@ -230,8 +230,8 @@ private MethodProvider[] BuildGetAllMethods()`
`230`	`230`	`}`
`231`	`231`
`232`	`232`	`// implement paging method GetAll`
`233`		`- var getAll = BuildGetAllMethod(false);`
`234`		`- var getAllAsync = BuildGetAllMethod(true);`
	`233`	`+ var getAll = BuildGetAllMethod(_getAll, false);`
	`234`	`+ var getAllAsync = BuildGetAllMethod(_getAll, true);`
`235`	`235`
`236`	`236`	`return [getAllAsync, getAll];`
`237`	`237`	`}`
`@@ -273,17 +273,20 @@ private List<MethodProvider> BuildCreateOrUpdateMethods()`
`273`	`273`	`{`
`274`	`274`	`var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(_create!.Operation, isAsync);`
`275`	`275`	`var methodName = ResourceHelpers.GetOperationMethodName(ResourceOperationKind.Create, isAsync);`
`276`		`- result.Add(new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, _create, convenienceMethod, isAsync, methodName, forceLro: true));`
	`276`	`+ result.Add(new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, _create, isAsync, methodName, forceLro: true));`
`277`	`277`	`}`
`278`	`278`
`279`	`279`	`return result;`
`280`	`280`	`}`
`281`	`281`
`282`		`- private MethodProvider BuildGetAllMethod(bool isAsync)`
	`282`	`+ private MethodProvider BuildGetAllMethod(InputServiceMethod getAll, bool isAsync)`
`283`	`283`	`{`
`284`		`- var restClientInfo = _resourceMetadata.GetRestClientForServiceMethod(_getAll!, _clientInfos);`
`285`		`- var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(_getAll!.Operation, isAsync);`
`286`		`- return new PageableOperationMethodProvider(this, this.ContextualPath, restClientInfo, _getAll, convenienceMethod, isAsync, Resource.ResourceData.Type, ResourceOperationKind.List);`
	`284`	`+ var restClientInfo = _resourceMetadata.GetRestClientForServiceMethod(getAll, _clientInfos);`
	`285`	`+ return getAll switch`
	`286`	`+ {`
	`287`	`+ InputPagingServiceMethod pagingGetAll => new PageableOperationMethodProvider(this, ContextualPath, restClientInfo, pagingGetAll, isAsync, ResourceOperationKind.List),`
	`288`	`+ _ => new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, getAll, isAsync, ResourceHelpers.GetOperationMethodName(ResourceOperationKind.List, isAsync))`
	`289`	`+ };`
`287`	`290`	`}`
`288`	`291`
`289`	`292`	`private List<MethodProvider> BuildGetMethods()`
`@@ -298,7 +301,7 @@ private List<MethodProvider> BuildGetMethods()`
`298`	`301`	`foreach (var isAsync in new List<bool> { true, false })`
`299`	`302`	`{`
`300`	`303`	`var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(_get!.Operation, isAsync);`
`301`		`- result.Add(new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, _get, convenienceMethod, isAsync));`
	`304`	`+ result.Add(new ResourceOperationMethodProvider(this, ContextualPath, restClientInfo, _get, isAsync));`
`302`	`305`	`}`
`303`	`306`
`304`	`307`	`return result;`
`@@ -316,7 +319,7 @@ private List<MethodProvider> BuildExistsMethods()`
`316`	`319`	`foreach (var isAsync in new List<bool> { true, false })`
`317`	`320`	`{`
`318`	`321`	`var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(_get!.Operation, isAsync);`
`319`		`- var existsMethodProvider = new ExistsOperationMethodProvider(this, restClientInfo, _get, convenienceMethod, isAsync);`
	`322`	`+ var existsMethodProvider = new ExistsOperationMethodProvider(this, restClientInfo, _get, isAsync);`
`320`	`323`	`result.Add(existsMethodProvider);`
`321`	`324`	`}`
`322`	`325`
`@@ -335,7 +338,7 @@ private List<MethodProvider> BuildGetIfExistsMethods()`
`335`	`338`	`foreach (var isAsync in new List<bool> { true, false })`
`336`	`339`	`{`
`337`	`340`	`var convenienceMethod = restClientInfo.RestClientProvider.GetConvenienceMethodByOperation(_get!.Operation, isAsync);`
`338`		`- var getIfExistsMethodProvider = new GetIfExistsOperationMethodProvider(this, restClientInfo, _get, convenienceMethod, isAsync);`
	`341`	`+ var getIfExistsMethodProvider = new GetIfExistsOperationMethodProvider(this, restClientInfo, _get, isAsync);`
`339`	`342`	`result.Add(getIfExistsMethodProvider);`
`340`	`343`	`}`
`341`	`344`
Original file line number	Diff line number	Diff line change
`@@ -31,19 +31,5 @@ public static CSharpType WrapResponse(this CSharpType? type, bool isLongRunning)`
`31`	`31`	`: typeof(Response);`
`32`	`32`	`}`
`33`	`33`	`}`
`34`		`-`
`35`		`- public static CSharpType UnWrap(this CSharpType type)`
`36`		`- {`
`37`		`- var currentType = type;`
`38`		`-`
`39`		`- // Recursively unwrap any generic type with a single type argument`
`40`		`- // This will find the innermost type regardless of nesting level or specific generic types`
`41`		`- while (currentType.IsGenericType && currentType.Arguments.Count == 1)`
`42`		`- {`
`43`		`- currentType = currentType.Arguments[0];`
`44`		`- }`
`45`		`-`
`46`		`- return currentType;`
`47`		`- }`
`48`	`34`	`}`
`49`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,7 @@ public static string GetRestClientFieldName(string restClientName)`
`32`	`32`	`return operationKind switch`
`33`	`33`	`{`
`34`	`34`	`ResourceOperationKind.Create => isAsync ? "CreateOrUpdateAsync" : "CreateOrUpdate",`
	`35`	`+ ResourceOperationKind.List => isAsync ? "GetAllAsync" : "GetAll",`
`35`	`36`	`_ => null`
`36`	`37`	`};`
`37`	`38`	`}`