< Summary

Class:Azure.ResourceManager.Compute.DisksOperations
Assembly:Azure.ResourceManager.Compute
File(s):C:\Git\azure-sdk-for-net\sdk\compute\Azure.ResourceManager.Compute\src\Generated\DisksOperations.cs
Covered lines:130
Uncovered lines:96
Coverable lines:226
Total lines:558
Line coverage:57.5% (130 of 226)
Covered branches:28
Total branches:56
Branch coverage:50% (28 of 56)

Metrics

MethodCyclomatic complexity Line coverage Branch coverage
get_RestClient()-100%100%
.ctor()-100%100%
.ctor(...)-100%100%
GetAsync()-100%100%
Get(...)-100%100%
ListByResourceGroupAsync(...)-36.84%50%
<ListByResourceGroupAsync()-62.5%100%
<ListByResourceGroupAsync()-0%100%
ListByResourceGroup(...)-36.84%50%
<ListAsync()-62.5%100%
<ListAsync()-0%100%
ListAsync(...)-100%100%
List(...)-100%100%
StartCreateOrUpdateAsync()-78.57%50%
StartCreateOrUpdate(...)-78.57%50%
StartUpdateAsync()-57.14%50%
StartUpdate(...)-57.14%50%
StartDeleteAsync()-58.33%50%
StartDelete(...)-58.33%50%
StartGrantAccessAsync()-57.14%50%
StartGrantAccess(...)-57.14%50%
StartRevokeAccessAsync()-58.33%50%
StartRevokeAccess(...)-58.33%50%

File(s)

C:\Git\azure-sdk-for-net\sdk\compute\Azure.ResourceManager.Compute\src\Generated\DisksOperations.cs

#LineLine coverage
 1// Copyright (c) Microsoft Corporation. All rights reserved.
 2// Licensed under the MIT License.
 3
 4// <auto-generated/>
 5
 6#nullable disable
 7
 8using System;
 9using System.Threading;
 10using System.Threading.Tasks;
 11using Azure;
 12using Azure.Core;
 13using Azure.Core.Pipeline;
 14using Azure.ResourceManager.Compute.Models;
 15
 16namespace Azure.ResourceManager.Compute
 17{
 18    /// <summary> The Disks service client. </summary>
 19    public partial class DisksOperations
 20    {
 21        private readonly ClientDiagnostics _clientDiagnostics;
 22        private readonly HttpPipeline _pipeline;
 42823        internal DisksRestOperations RestClient { get; }
 24        /// <summary> Initializes a new instance of DisksOperations for mocking. </summary>
 39625        protected DisksOperations()
 26        {
 39627        }
 28        /// <summary> Initializes a new instance of DisksOperations. </summary>
 29        /// <param name="clientDiagnostics"> The handler for diagnostic messaging in the client. </param>
 30        /// <param name="pipeline"> The HTTP pipeline for sending and receiving REST requests and responses. </param>
 31        /// <param name="subscriptionId"> Subscription credentials which uniquely identify Microsoft Azure subscription.
 32        /// <param name="endpoint"> server parameter. </param>
 39633        internal DisksOperations(ClientDiagnostics clientDiagnostics, HttpPipeline pipeline, string subscriptionId, Uri 
 34        {
 39635            RestClient = new DisksRestOperations(clientDiagnostics, pipeline, subscriptionId, endpoint);
 39636            _clientDiagnostics = clientDiagnostics;
 39637            _pipeline = pipeline;
 39638        }
 39
 40        /// <summary> Gets information about a disk. </summary>
 41        /// <param name="resourceGroupName"> The name of the resource group. </param>
 42        /// <param name="diskName"> The name of the managed disk that is being created. The name can&apos;t be changed a
 43        /// <param name="cancellationToken"> The cancellation token to use. </param>
 44        public virtual async Task<Response<Disk>> GetAsync(string resourceGroupName, string diskName, CancellationToken 
 45        {
 4046            using var scope = _clientDiagnostics.CreateScope("DisksOperations.Get");
 4047            scope.Start();
 48            try
 49            {
 4050                return await RestClient.GetAsync(resourceGroupName, diskName, cancellationToken).ConfigureAwait(false);
 51            }
 852            catch (Exception e)
 53            {
 854                scope.Failed(e);
 855                throw;
 56            }
 3257        }
 58
 59        /// <summary> Gets information about a disk. </summary>
 60        /// <param name="resourceGroupName"> The name of the resource group. </param>
 61        /// <param name="diskName"> The name of the managed disk that is being created. The name can&apos;t be changed a
 62        /// <param name="cancellationToken"> The cancellation token to use. </param>
 63        public virtual Response<Disk> Get(string resourceGroupName, string diskName, CancellationToken cancellationToken
 64        {
 4065            using var scope = _clientDiagnostics.CreateScope("DisksOperations.Get");
 4066            scope.Start();
 67            try
 68            {
 4069                return RestClient.Get(resourceGroupName, diskName, cancellationToken);
 70            }
 871            catch (Exception e)
 72            {
 873                scope.Failed(e);
 874                throw;
 75            }
 3276        }
 77
 78        /// <summary> Lists all the disks under a resource group. </summary>
 79        /// <param name="resourceGroupName"> The name of the resource group. </param>
 80        /// <param name="cancellationToken"> The cancellation token to use. </param>
 81        public virtual AsyncPageable<Disk> ListByResourceGroupAsync(string resourceGroupName, CancellationToken cancella
 82        {
 883            if (resourceGroupName == null)
 84            {
 085                throw new ArgumentNullException(nameof(resourceGroupName));
 86            }
 87
 88            async Task<Page<Disk>> FirstPageFunc(int? pageSizeHint)
 89            {
 890                using var scope = _clientDiagnostics.CreateScope("DisksOperations.ListByResourceGroup");
 891                scope.Start();
 92                try
 93                {
 894                    var response = await RestClient.ListByResourceGroupAsync(resourceGroupName, cancellationToken).Confi
 895                    return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
 96                }
 097                catch (Exception e)
 98                {
 099                    scope.Failed(e);
 0100                    throw;
 101                }
 8102            }
 103            async Task<Page<Disk>> NextPageFunc(string nextLink, int? pageSizeHint)
 104            {
 0105                using var scope = _clientDiagnostics.CreateScope("DisksOperations.ListByResourceGroup");
 0106                scope.Start();
 107                try
 108                {
 0109                    var response = await RestClient.ListByResourceGroupNextPageAsync(nextLink, resourceGroupName, cancel
 0110                    return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
 111                }
 0112                catch (Exception e)
 113                {
 0114                    scope.Failed(e);
 0115                    throw;
 116                }
 0117            }
 8118            return PageableHelpers.CreateAsyncEnumerable(FirstPageFunc, NextPageFunc);
 119        }
 120
 121        /// <summary> Lists all the disks under a resource group. </summary>
 122        /// <param name="resourceGroupName"> The name of the resource group. </param>
 123        /// <param name="cancellationToken"> The cancellation token to use. </param>
 124        public virtual Pageable<Disk> ListByResourceGroup(string resourceGroupName, CancellationToken cancellationToken 
 125        {
 8126            if (resourceGroupName == null)
 127            {
 0128                throw new ArgumentNullException(nameof(resourceGroupName));
 129            }
 130
 131            Page<Disk> FirstPageFunc(int? pageSizeHint)
 132            {
 8133                using var scope = _clientDiagnostics.CreateScope("DisksOperations.ListByResourceGroup");
 8134                scope.Start();
 135                try
 136                {
 8137                    var response = RestClient.ListByResourceGroup(resourceGroupName, cancellationToken);
 8138                    return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
 139                }
 0140                catch (Exception e)
 141                {
 0142                    scope.Failed(e);
 0143                    throw;
 144                }
 8145            }
 146            Page<Disk> NextPageFunc(string nextLink, int? pageSizeHint)
 147            {
 0148                using var scope = _clientDiagnostics.CreateScope("DisksOperations.ListByResourceGroup");
 0149                scope.Start();
 150                try
 151                {
 0152                    var response = RestClient.ListByResourceGroupNextPage(nextLink, resourceGroupName, cancellationToken
 0153                    return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
 154                }
 0155                catch (Exception e)
 156                {
 0157                    scope.Failed(e);
 0158                    throw;
 159                }
 0160            }
 8161            return PageableHelpers.CreateEnumerable(FirstPageFunc, NextPageFunc);
 162        }
 163
 164        /// <summary> Lists all the disks under a subscription. </summary>
 165        /// <param name="cancellationToken"> The cancellation token to use. </param>
 166        public virtual AsyncPageable<Disk> ListAsync(CancellationToken cancellationToken = default)
 167        {
 168            async Task<Page<Disk>> FirstPageFunc(int? pageSizeHint)
 169            {
 4170                using var scope = _clientDiagnostics.CreateScope("DisksOperations.List");
 4171                scope.Start();
 172                try
 173                {
 4174                    var response = await RestClient.ListAsync(cancellationToken).ConfigureAwait(false);
 4175                    return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
 176                }
 0177                catch (Exception e)
 178                {
 0179                    scope.Failed(e);
 0180                    throw;
 181                }
 4182            }
 183            async Task<Page<Disk>> NextPageFunc(string nextLink, int? pageSizeHint)
 184            {
 0185                using var scope = _clientDiagnostics.CreateScope("DisksOperations.List");
 0186                scope.Start();
 187                try
 188                {
 0189                    var response = await RestClient.ListNextPageAsync(nextLink, cancellationToken).ConfigureAwait(false)
 0190                    return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
 191                }
 0192                catch (Exception e)
 193                {
 0194                    scope.Failed(e);
 0195                    throw;
 196                }
 0197            }
 4198            return PageableHelpers.CreateAsyncEnumerable(FirstPageFunc, NextPageFunc);
 199        }
 200
 201        /// <summary> Lists all the disks under a subscription. </summary>
 202        /// <param name="cancellationToken"> The cancellation token to use. </param>
 203        public virtual Pageable<Disk> List(CancellationToken cancellationToken = default)
 204        {
 205            Page<Disk> FirstPageFunc(int? pageSizeHint)
 206            {
 4207                using var scope = _clientDiagnostics.CreateScope("DisksOperations.List");
 4208                scope.Start();
 209                try
 210                {
 4211                    var response = RestClient.List(cancellationToken);
 4212                    return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
 213                }
 0214                catch (Exception e)
 215                {
 0216                    scope.Failed(e);
 0217                    throw;
 218                }
 4219            }
 220            Page<Disk> NextPageFunc(string nextLink, int? pageSizeHint)
 221            {
 0222                using var scope = _clientDiagnostics.CreateScope("DisksOperations.List");
 0223                scope.Start();
 224                try
 225                {
 0226                    var response = RestClient.ListNextPage(nextLink, cancellationToken);
 0227                    return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
 228                }
 0229                catch (Exception e)
 230                {
 0231                    scope.Failed(e);
 0232                    throw;
 233                }
 0234            }
 4235            return PageableHelpers.CreateEnumerable(FirstPageFunc, NextPageFunc);
 236        }
 237
 238        /// <summary> Creates or updates a disk. </summary>
 239        /// <param name="resourceGroupName"> The name of the resource group. </param>
 240        /// <param name="diskName"> The name of the managed disk that is being created. The name can&apos;t be changed a
 241        /// <param name="disk"> Disk object supplied in the body of the Put disk operation. </param>
 242        /// <param name="cancellationToken"> The cancellation token to use. </param>
 243        public virtual async Task<DisksCreateOrUpdateOperation> StartCreateOrUpdateAsync(string resourceGroupName, strin
 244        {
 46245            if (resourceGroupName == null)
 246            {
 0247                throw new ArgumentNullException(nameof(resourceGroupName));
 248            }
 46249            if (diskName == null)
 250            {
 0251                throw new ArgumentNullException(nameof(diskName));
 252            }
 46253            if (disk == null)
 254            {
 0255                throw new ArgumentNullException(nameof(disk));
 256            }
 257
 46258            using var scope = _clientDiagnostics.CreateScope("DisksOperations.StartCreateOrUpdate");
 46259            scope.Start();
 260            try
 261            {
 46262                var originalResponse = await RestClient.CreateOrUpdateAsync(resourceGroupName, diskName, disk, cancellat
 44263                return new DisksCreateOrUpdateOperation(_clientDiagnostics, _pipeline, RestClient.CreateCreateOrUpdateRe
 264            }
 2265            catch (Exception e)
 266            {
 2267                scope.Failed(e);
 2268                throw;
 269            }
 44270        }
 271
 272        /// <summary> Creates or updates a disk. </summary>
 273        /// <param name="resourceGroupName"> The name of the resource group. </param>
 274        /// <param name="diskName"> The name of the managed disk that is being created. The name can&apos;t be changed a
 275        /// <param name="disk"> Disk object supplied in the body of the Put disk operation. </param>
 276        /// <param name="cancellationToken"> The cancellation token to use. </param>
 277        public virtual DisksCreateOrUpdateOperation StartCreateOrUpdate(string resourceGroupName, string diskName, Disk 
 278        {
 46279            if (resourceGroupName == null)
 280            {
 0281                throw new ArgumentNullException(nameof(resourceGroupName));
 282            }
 46283            if (diskName == null)
 284            {
 0285                throw new ArgumentNullException(nameof(diskName));
 286            }
 46287            if (disk == null)
 288            {
 0289                throw new ArgumentNullException(nameof(disk));
 290            }
 291
 46292            using var scope = _clientDiagnostics.CreateScope("DisksOperations.StartCreateOrUpdate");
 46293            scope.Start();
 294            try
 295            {
 46296                var originalResponse = RestClient.CreateOrUpdate(resourceGroupName, diskName, disk, cancellationToken);
 44297                return new DisksCreateOrUpdateOperation(_clientDiagnostics, _pipeline, RestClient.CreateCreateOrUpdateRe
 298            }
 2299            catch (Exception e)
 300            {
 2301                scope.Failed(e);
 2302                throw;
 303            }
 44304        }
 305
 306        /// <summary> Updates (patches) a disk. </summary>
 307        /// <param name="resourceGroupName"> The name of the resource group. </param>
 308        /// <param name="diskName"> The name of the managed disk that is being created. The name can&apos;t be changed a
 309        /// <param name="disk"> Disk object supplied in the body of the Patch disk operation. </param>
 310        /// <param name="cancellationToken"> The cancellation token to use. </param>
 311        public virtual async Task<DisksUpdateOperation> StartUpdateAsync(string resourceGroupName, string diskName, Disk
 312        {
 6313            if (resourceGroupName == null)
 314            {
 0315                throw new ArgumentNullException(nameof(resourceGroupName));
 316            }
 6317            if (diskName == null)
 318            {
 0319                throw new ArgumentNullException(nameof(diskName));
 320            }
 6321            if (disk == null)
 322            {
 0323                throw new ArgumentNullException(nameof(disk));
 324            }
 325
 6326            using var scope = _clientDiagnostics.CreateScope("DisksOperations.StartUpdate");
 6327            scope.Start();
 328            try
 329            {
 6330                var originalResponse = await RestClient.UpdateAsync(resourceGroupName, diskName, disk, cancellationToken
 6331                return new DisksUpdateOperation(_clientDiagnostics, _pipeline, RestClient.CreateUpdateRequest(resourceGr
 332            }
 0333            catch (Exception e)
 334            {
 0335                scope.Failed(e);
 0336                throw;
 337            }
 6338        }
 339
 340        /// <summary> Updates (patches) a disk. </summary>
 341        /// <param name="resourceGroupName"> The name of the resource group. </param>
 342        /// <param name="diskName"> The name of the managed disk that is being created. The name can&apos;t be changed a
 343        /// <param name="disk"> Disk object supplied in the body of the Patch disk operation. </param>
 344        /// <param name="cancellationToken"> The cancellation token to use. </param>
 345        public virtual DisksUpdateOperation StartUpdate(string resourceGroupName, string diskName, DiskUpdate disk, Canc
 346        {
 6347            if (resourceGroupName == null)
 348            {
 0349                throw new ArgumentNullException(nameof(resourceGroupName));
 350            }
 6351            if (diskName == null)
 352            {
 0353                throw new ArgumentNullException(nameof(diskName));
 354            }
 6355            if (disk == null)
 356            {
 0357                throw new ArgumentNullException(nameof(disk));
 358            }
 359
 6360            using var scope = _clientDiagnostics.CreateScope("DisksOperations.StartUpdate");
 6361            scope.Start();
 362            try
 363            {
 6364                var originalResponse = RestClient.Update(resourceGroupName, diskName, disk, cancellationToken);
 6365                return new DisksUpdateOperation(_clientDiagnostics, _pipeline, RestClient.CreateUpdateRequest(resourceGr
 366            }
 0367            catch (Exception e)
 368            {
 0369                scope.Failed(e);
 0370                throw;
 371            }
 6372        }
 373
 374        /// <summary> Deletes a disk. </summary>
 375        /// <param name="resourceGroupName"> The name of the resource group. </param>
 376        /// <param name="diskName"> The name of the managed disk that is being created. The name can&apos;t be changed a
 377        /// <param name="cancellationToken"> The cancellation token to use. </param>
 378        public virtual async Task<DisksDeleteOperation> StartDeleteAsync(string resourceGroupName, string diskName, Canc
 379        {
 18380            if (resourceGroupName == null)
 381            {
 0382                throw new ArgumentNullException(nameof(resourceGroupName));
 383            }
 18384            if (diskName == null)
 385            {
 0386                throw new ArgumentNullException(nameof(diskName));
 387            }
 388
 18389            using var scope = _clientDiagnostics.CreateScope("DisksOperations.StartDelete");
 18390            scope.Start();
 391            try
 392            {
 18393                var originalResponse = await RestClient.DeleteAsync(resourceGroupName, diskName, cancellationToken).Conf
 18394                return new DisksDeleteOperation(_clientDiagnostics, _pipeline, RestClient.CreateDeleteRequest(resourceGr
 395            }
 0396            catch (Exception e)
 397            {
 0398                scope.Failed(e);
 0399                throw;
 400            }
 18401        }
 402
 403        /// <summary> Deletes a disk. </summary>
 404        /// <param name="resourceGroupName"> The name of the resource group. </param>
 405        /// <param name="diskName"> The name of the managed disk that is being created. The name can&apos;t be changed a
 406        /// <param name="cancellationToken"> The cancellation token to use. </param>
 407        public virtual DisksDeleteOperation StartDelete(string resourceGroupName, string diskName, CancellationToken can
 408        {
 18409            if (resourceGroupName == null)
 410            {
 0411                throw new ArgumentNullException(nameof(resourceGroupName));
 412            }
 18413            if (diskName == null)
 414            {
 0415                throw new ArgumentNullException(nameof(diskName));
 416            }
 417
 18418            using var scope = _clientDiagnostics.CreateScope("DisksOperations.StartDelete");
 18419            scope.Start();
 420            try
 421            {
 18422                var originalResponse = RestClient.Delete(resourceGroupName, diskName, cancellationToken);
 18423                return new DisksDeleteOperation(_clientDiagnostics, _pipeline, RestClient.CreateDeleteRequest(resourceGr
 424            }
 0425            catch (Exception e)
 426            {
 0427                scope.Failed(e);
 0428                throw;
 429            }
 18430        }
 431
 432        /// <summary> Grants access to a disk. </summary>
 433        /// <param name="resourceGroupName"> The name of the resource group. </param>
 434        /// <param name="diskName"> The name of the managed disk that is being created. The name can&apos;t be changed a
 435        /// <param name="grantAccessData"> Access data object supplied in the body of the get disk access operation. </p
 436        /// <param name="cancellationToken"> The cancellation token to use. </param>
 437        public virtual async Task<DisksGrantAccessOperation> StartGrantAccessAsync(string resourceGroupName, string disk
 438        {
 6439            if (resourceGroupName == null)
 440            {
 0441                throw new ArgumentNullException(nameof(resourceGroupName));
 442            }
 6443            if (diskName == null)
 444            {
 0445                throw new ArgumentNullException(nameof(diskName));
 446            }
 6447            if (grantAccessData == null)
 448            {
 0449                throw new ArgumentNullException(nameof(grantAccessData));
 450            }
 451
 6452            using var scope = _clientDiagnostics.CreateScope("DisksOperations.StartGrantAccess");
 6453            scope.Start();
 454            try
 455            {
 6456                var originalResponse = await RestClient.GrantAccessAsync(resourceGroupName, diskName, grantAccessData, c
 6457                return new DisksGrantAccessOperation(_clientDiagnostics, _pipeline, RestClient.CreateGrantAccessRequest(
 458            }
 0459            catch (Exception e)
 460            {
 0461                scope.Failed(e);
 0462                throw;
 463            }
 6464        }
 465
 466        /// <summary> Grants access to a disk. </summary>
 467        /// <param name="resourceGroupName"> The name of the resource group. </param>
 468        /// <param name="diskName"> The name of the managed disk that is being created. The name can&apos;t be changed a
 469        /// <param name="grantAccessData"> Access data object supplied in the body of the get disk access operation. </p
 470        /// <param name="cancellationToken"> The cancellation token to use. </param>
 471        public virtual DisksGrantAccessOperation StartGrantAccess(string resourceGroupName, string diskName, GrantAccess
 472        {
 6473            if (resourceGroupName == null)
 474            {
 0475                throw new ArgumentNullException(nameof(resourceGroupName));
 476            }
 6477            if (diskName == null)
 478            {
 0479                throw new ArgumentNullException(nameof(diskName));
 480            }
 6481            if (grantAccessData == null)
 482            {
 0483                throw new ArgumentNullException(nameof(grantAccessData));
 484            }
 485
 6486            using var scope = _clientDiagnostics.CreateScope("DisksOperations.StartGrantAccess");
 6487            scope.Start();
 488            try
 489            {
 6490                var originalResponse = RestClient.GrantAccess(resourceGroupName, diskName, grantAccessData, cancellation
 6491                return new DisksGrantAccessOperation(_clientDiagnostics, _pipeline, RestClient.CreateGrantAccessRequest(
 492            }
 0493            catch (Exception e)
 494            {
 0495                scope.Failed(e);
 0496                throw;
 497            }
 6498        }
 499
 500        /// <summary> Revokes access to a disk. </summary>
 501        /// <param name="resourceGroupName"> The name of the resource group. </param>
 502        /// <param name="diskName"> The name of the managed disk that is being created. The name can&apos;t be changed a
 503        /// <param name="cancellationToken"> The cancellation token to use. </param>
 504        public virtual async Task<DisksRevokeAccessOperation> StartRevokeAccessAsync(string resourceGroupName, string di
 505        {
 6506            if (resourceGroupName == null)
 507            {
 0508                throw new ArgumentNullException(nameof(resourceGroupName));
 509            }
 6510            if (diskName == null)
 511            {
 0512                throw new ArgumentNullException(nameof(diskName));
 513            }
 514
 6515            using var scope = _clientDiagnostics.CreateScope("DisksOperations.StartRevokeAccess");
 6516            scope.Start();
 517            try
 518            {
 6519                var originalResponse = await RestClient.RevokeAccessAsync(resourceGroupName, diskName, cancellationToken
 6520                return new DisksRevokeAccessOperation(_clientDiagnostics, _pipeline, RestClient.CreateRevokeAccessReques
 521            }
 0522            catch (Exception e)
 523            {
 0524                scope.Failed(e);
 0525                throw;
 526            }
 6527        }
 528
 529        /// <summary> Revokes access to a disk. </summary>
 530        /// <param name="resourceGroupName"> The name of the resource group. </param>
 531        /// <param name="diskName"> The name of the managed disk that is being created. The name can&apos;t be changed a
 532        /// <param name="cancellationToken"> The cancellation token to use. </param>
 533        public virtual DisksRevokeAccessOperation StartRevokeAccess(string resourceGroupName, string diskName, Cancellat
 534        {
 6535            if (resourceGroupName == null)
 536            {
 0537                throw new ArgumentNullException(nameof(resourceGroupName));
 538            }
 6539            if (diskName == null)
 540            {
 0541                throw new ArgumentNullException(nameof(diskName));
 542            }
 543
 6544            using var scope = _clientDiagnostics.CreateScope("DisksOperations.StartRevokeAccess");
 6545            scope.Start();
 546            try
 547            {
 6548                var originalResponse = RestClient.RevokeAccess(resourceGroupName, diskName, cancellationToken);
 6549                return new DisksRevokeAccessOperation(_clientDiagnostics, _pipeline, RestClient.CreateRevokeAccessReques
 550            }
 0551            catch (Exception e)
 552            {
 0553                scope.Failed(e);
 0554                throw;
 555            }
 6556        }
 557    }
 558}
Generated by: ReportGenerator 4.6.4.0
8/12/2020 - 3:46:44 PM
GitHub | www.palmmedia.de

Methods/Properties

get_RestClient()
.ctor()
.ctor(...)
GetAsync()
Get(...)
ListByResourceGroupAsync(...)
<ListByResourceGroupAsync()
<ListByResourceGroupAsync()
ListByResourceGroup(...)
<ListAsync()
<ListAsync()
ListAsync(...)
List(...)
StartCreateOrUpdateAsync()
StartCreateOrUpdate(...)
StartUpdateAsync()
StartUpdate(...)
StartDeleteAsync()
StartDelete(...)
StartGrantAccessAsync()
StartGrantAccess(...)
StartRevokeAccessAsync()
StartRevokeAccess(...)