< Summary

Class:	Microsoft.Azure.ApplicationInsights.Query.Metrics
Assembly:	Microsoft.Azure.ApplicationInsights.Query
File(s):	C:\Git\azure-sdk-for-net\sdk\applicationinsights\Microsoft.Azure.ApplicationInsights.Query\src\Customized\Metrics.cs C:\Git\azure-sdk-for-net\sdk\applicationinsights\Microsoft.Azure.ApplicationInsights.Query\src\Generated\Metrics.cs
Covered lines:	4
Uncovered lines:	343
Coverable lines:	347
Total lines:	1116
Line coverage:	1.1% (4 of 347)
Covered branches:	1
Total branches:	144
Branch coverage:	0.6% (1 of 144)

Metrics

Method	Cyclomatic complexity	Line coverage	Branch coverage
GetMetricSummaryWithHttpMessagesAsync()	-	0%	100%
GetIntervaledMetricWithHttpMessagesAsync()	-	0%	0%
GetSegmentedMetricWithHttpMessagesAsync()	-	0%	100%
GetSegmentInfo(...)	-	0%	0%
GetIntervaledSegmentedMetricWithHttpMessagesAsync()	-	0%	0%
.ctor(...)	-	80%	50%
get_Client()	-	0%	100%
GetWithHttpMessagesAsync()	-	0%	0%
GetMultipleWithHttpMessagesAsync()	-	0%	0%
GetMetadataWithHttpMessagesAsync()	-	0%	0%

File(s)

C:\Git\azure-sdk-for-net\sdk\applicationinsights\Microsoft.Azure.ApplicationInsights.Query\src\Customized\Metrics.cs

	#	Line		Line coverage
		1		using Microsoft.Azure.ApplicationInsights.Query.Models;
		2		using Microsoft.Rest;
		3		using System.Collections.Generic;
		4		using System.Linq;
		5		using System.Net.Http;
		6		using System.Threading;
		7		using System.Threading.Tasks;
		8
		9		namespace Microsoft.Azure.ApplicationInsights.Query
		10		{
		11		public partial class Metrics : IServiceOperations<ApplicationInsightsDataClient>, IMetrics  {
		12		#region Metric Extensions
		13
		14		/// <summary>
		15		/// Retrieve summary metric data
		16		/// </summary>
		17		/// <remarks>
		18		/// Gets summary metric values for a single metric
		19		/// </remarks>
		20		/// <param name='appId'>
		21		/// ID of the application. This is Application ID from the API Access settings
		22		/// blade in the Azure portal.
		23		/// </param>
		24		/// <param name='metricId'>
		25		/// ID of the metric. This is either a standard AI metric, or an
		26		/// application-specific custom metric. Possible values include:
		27		/// 'requests/count', 'requests/duration', 'requests/failed',
		28		/// 'users/count', 'users/authenticated', 'pageViews/count',
		29		/// 'pageViews/duration', 'client/processingDuration',
		30		/// 'client/receiveDuration', 'client/networkDuration',
		31		/// 'client/sendDuration', 'client/totalDuration',
		32		/// 'dependencies/count', 'dependencies/failed',
		33		/// 'dependencies/duration', 'exceptions/count', 'exceptions/browser',
		34		/// 'exceptions/server', 'sessions/count',
		35		/// 'performanceCounters/requestExecutionTime',
		36		/// 'performanceCounters/requestsPerSecond',
		37		/// 'performanceCounters/requestsInQueue',
		38		/// 'performanceCounters/memoryAvailableBytes',
		39		/// 'performanceCounters/exceptionsPerSecond',
		40		/// 'performanceCounters/processCpuPercentage',
		41		/// 'performanceCounters/processIOBytesPerSecond',
		42		/// 'performanceCounters/processPrivateBytes',
		43		/// 'performanceCounters/processorCpuPercentage',
		44		/// 'availabilityResults/availabilityPercentage',
		45		/// 'availabilityResults/duration', 'billing/telemetryCount',
		46		/// 'customEvents/count'
		47		/// </param>
		48		/// <param name='timespan'>
		49		/// The timespan over which to retrieve metric values. This is an
		50		/// ISO8601 time period value. If timespan is omitted, a default time
		51		/// range of `PT12H` ("last 12 hours") is used. The actual timespan
		52		/// that is queried may be adjusted by the server based. In all cases,
		53		/// the actual time span used for the query is included in the
		54		/// response.
		55		/// </param>
		56		/// <param name='aggregation'>
		57		/// The aggregation to use when computing the metric values. To
		58		/// retrieve more than one aggregation at a time, separate them with a
		59		/// comma. If no aggregation is specified, then the default aggregation
		60		/// for the metric is used.
		61		/// </param>
		62		/// <param name='top'>
		63		/// The number of segments to return.  This value is only valid when
		64		/// segment is specified.
		65		/// </param>
		66		/// <param name='orderby'>
		67		/// The aggregation function and direction to sort the segments by.
		68		/// This value is only valid when segment is specified.
		69		/// </param>
		70		/// <param name='filter'>
		71		/// An expression used to filter the results.  This value should be a
		72		/// valid OData filter expression where the keys of each clause should
		73		/// be applicable dimensions for the metric you are retrieving.
		74		/// </param>
		75		/// <param name='customHeaders'>
		76		/// The headers that will be added to request.
		77		/// </param>
		78		/// <param name='cancellationToken'>
		79		/// The cancellation token.
		80		/// </param>
		81		public async Task<HttpOperationResponse<MetricsSummaryResult>> GetMetricSummaryWithHttpMessagesAsync(string appI
		82		int? top = default(int?), string orderby = default(string), string filter = default(string), Dictionary<stri
		83		CancellationToken cancellationToken = default(CancellationToken))
		84		{
	0	85		var realResult = await GetWithHttpMessagesAsync(appId, metricId, timespan, null, aggregation, null, top, ord
	0	86		var realBody = realResult.Body.Value;
	0	87		return new HttpOperationResponse<MetricsSummaryResult>
	0	88		{
	0	89		Request = realResult.Request,
	0	90		Response = realResult.Response,
	0	91		Body = new MetricsSummaryResult
	0	92		{
	0	93		Start = realBody.Start,
	0	94		End = realBody.End,
	0	95		Sum = realBody.GetSum(),
	0	96		Average = realBody.GetAverage(),
	0	97		Min = realBody.GetMin(),
	0	98		Max = realBody.GetMax(),
	0	99		Count = realBody.GetCount()
	0	100		}
	0	101		};
	0	102		}
		103
		104		/// <summary>
		105		/// Retrieve metric data
		106		/// </summary>
		107		/// <remarks>
		108		/// Gets metric values for a single metric
		109		/// </remarks>
		110		/// <param name='appId'>
		111		/// ID of the application. This is Application ID from the API Access settings
		112		/// blade in the Azure portal.
		113		/// </param>
		114		/// <param name='metricId'>
		115		/// ID of the metric. This is either a standard AI metric, or an
		116		/// application-specific custom metric. Possible values include:
		117		/// 'requests/count', 'requests/duration', 'requests/failed',
		118		/// 'users/count', 'users/authenticated', 'pageViews/count',
		119		/// 'pageViews/duration', 'client/processingDuration',
		120		/// 'client/receiveDuration', 'client/networkDuration',
		121		/// 'client/sendDuration', 'client/totalDuration',
		122		/// 'dependencies/count', 'dependencies/failed',
		123		/// 'dependencies/duration', 'exceptions/count', 'exceptions/browser',
		124		/// 'exceptions/server', 'sessions/count',
		125		/// 'performanceCounters/requestExecutionTime',
		126		/// 'performanceCounters/requestsPerSecond',
		127		/// 'performanceCounters/requestsInQueue',
		128		/// 'performanceCounters/memoryAvailableBytes',
		129		/// 'performanceCounters/exceptionsPerSecond',
		130		/// 'performanceCounters/processCpuPercentage',
		131		/// 'performanceCounters/processIOBytesPerSecond',
		132		/// 'performanceCounters/processPrivateBytes',
		133		/// 'performanceCounters/processorCpuPercentage',
		134		/// 'availabilityResults/availabilityPercentage',
		135		/// 'availabilityResults/duration', 'billing/telemetryCount',
		136		/// 'customEvents/count'
		137		/// </param>
		138		/// <param name='timespan'>
		139		/// The timespan over which to retrieve metric values. This is an
		140		/// ISO8601 time period value. If timespan is omitted, a default time
		141		/// range of `PT12H` ("last 12 hours") is used. The actual timespan
		142		/// that is queried may be adjusted by the server based. In all cases,
		143		/// the actual time span used for the query is included in the
		144		/// response.
		145		/// </param>
		146		/// <param name='interval'>
		147		/// The time interval to use when retrieving metric values. This is an
		148		/// ISO8601 duration. If interval is omitted, the metric value is
		149		/// aggregated across the entire timespan. If interval is supplied, the
		150		/// server may adjust the interval to a more appropriate size based on
		151		/// the timespan used for the query. In all cases, the actual interval
		152		/// used for the query is included in the response.
		153		/// </param>
		154		/// <param name='aggregation'>
		155		/// The aggregation to use when computing the metric values. To
		156		/// retrieve more than one aggregation at a time, separate them with a
		157		/// comma. If no aggregation is specified, then the default aggregation
		158		/// for the metric is used.
		159		/// </param>
		160		/// <param name='segment'>
		161		/// The name of the dimension to segment the metric values by. This
		162		/// dimension must be applicable to the metric you are retrieving. To
		163		/// segment by more than one dimension at a time, separate them with a
		164		/// comma (,). In this case, the metric data will be segmented in the
		165		/// order the dimensions are listed in the parameter.
		166		/// </param>
		167		/// <param name='top'>
		168		/// The number of segments to return.  This value is only valid when
		169		/// segment is specified.
		170		/// </param>
		171		/// <param name='orderby'>
		172		/// The aggregation function and direction to sort the segments by.
		173		/// This value is only valid when segment is specified.
		174		/// </param>
		175		/// <param name='filter'>
		176		/// An expression used to filter the results.  This value should be a
		177		/// valid OData filter expression where the keys of each clause should
		178		/// be applicable dimensions for the metric you are retrieving.
		179		/// </param>
		180		/// <param name='customHeaders'>
		181		/// The headers that will be added to request.
		182		/// </param>
		183		/// <param name='cancellationToken'>
		184		/// The cancellation token.
		185		/// </param>
		186		public async Task<HttpOperationResponse<MetricsIntervaledResult>> GetIntervaledMetricWithHttpMessagesAsync(strin
		187		string metricId, string timespan = default(string),
		188		System.TimeSpan? interval = default(System.TimeSpan?), IList<string> aggregation = default(IList<string>),
		189		IList<string> segment = default(IList<string>), int? top = default(int?), string orderby = default(string),
		190		string filter = default(string), Dictionary<string, List<string>> customHeaders = null, CancellationToken c
		191		{
	0	192		var realResult = await GetWithHttpMessagesAsync(appId, metricId, timespan, interval, aggregation, null, top,
	0	193		var realBody = realResult.Body.Value;
	0	194		return new HttpOperationResponse<MetricsIntervaledResult>
	0	195		{
	0	196		Request = realResult.Request,
	0	197		Response = realResult.Response,
	0	198		Body = new MetricsIntervaledResult
	0	199		{
	0	200		Start = realBody.Start,
	0	201		End = realBody.End,
	0	202		Interval = realBody.Interval,
	0	203		Intervals = realBody.Segments?.Select(inter =>
		204		new MetricsIntervaledData
		205		{
		206		Sum = inter.GetSum(),
		207		Average = inter.GetAverage(),
		208		Min = inter.GetMin(),
		209		Max = inter.GetMax(),
		210		Count = inter.GetCount()
		211		}
	0	212		).ToList()
	0	213		}
	0	214		};
	0	215		}
		216
		217		/// <summary>
		218		/// Retrieve metric data
		219		/// </summary>
		220		/// <remarks>
		221		/// Gets metric values for a single metric
		222		/// </remarks>
		223		/// <param name='appId'>
		224		/// ID of the application. This is Application ID from the API Access settings
		225		/// blade in the Azure portal.
		226		/// </param>
		227		/// <param name='metricId'>
		228		/// ID of the metric. This is either a standard AI metric, or an
		229		/// application-specific custom metric. Possible values include:
		230		/// 'requests/count', 'requests/duration', 'requests/failed',
		231		/// 'users/count', 'users/authenticated', 'pageViews/count',
		232		/// 'pageViews/duration', 'client/processingDuration',
		233		/// 'client/receiveDuration', 'client/networkDuration',
		234		/// 'client/sendDuration', 'client/totalDuration',
		235		/// 'dependencies/count', 'dependencies/failed',
		236		/// 'dependencies/duration', 'exceptions/count', 'exceptions/browser',
		237		/// 'exceptions/server', 'sessions/count',
		238		/// 'performanceCounters/requestExecutionTime',
		239		/// 'performanceCounters/requestsPerSecond',
		240		/// 'performanceCounters/requestsInQueue',
		241		/// 'performanceCounters/memoryAvailableBytes',
		242		/// 'performanceCounters/exceptionsPerSecond',
		243		/// 'performanceCounters/processCpuPercentage',
		244		/// 'performanceCounters/processIOBytesPerSecond',
		245		/// 'performanceCounters/processPrivateBytes',
		246		/// 'performanceCounters/processorCpuPercentage',
		247		/// 'availabilityResults/availabilityPercentage',
		248		/// 'availabilityResults/duration', 'billing/telemetryCount',
		249		/// 'customEvents/count'
		250		/// </param>
		251		/// <param name='timespan'>
		252		/// The timespan over which to retrieve metric values. This is an
		253		/// ISO8601 time period value. If timespan is omitted, a default time
		254		/// range of `PT12H` ("last 12 hours") is used. The actual timespan
		255		/// that is queried may be adjusted by the server based. In all cases,
		256		/// the actual time span used for the query is included in the
		257		/// response.
		258		/// </param>
		259		/// <param name='aggregation'>
		260		/// The aggregation to use when computing the metric values. To
		261		/// retrieve more than one aggregation at a time, separate them with a
		262		/// comma. If no aggregation is specified, then the default aggregation
		263		/// for the metric is used.
		264		/// </param>
		265		/// <param name='segment'>
		266		/// The name of the dimension to segment the metric values by. This
		267		/// dimension must be applicable to the metric you are retrieving. To
		268		/// segment by more than one dimension at a time, separate them with a
		269		/// comma (,). In this case, the metric data will be segmented in the
		270		/// order the dimensions are listed in the parameter.
		271		/// </param>
		272		/// <param name='top'>
		273		/// The number of segments to return.  This value is only valid when
		274		/// segment is specified.
		275		/// </param>
		276		/// <param name='orderby'>
		277		/// The aggregation function and direction to sort the segments by.
		278		/// This value is only valid when segment is specified.
		279		/// </param>
		280		/// <param name='filter'>
		281		/// An expression used to filter the results.  This value should be a
		282		/// valid OData filter expression where the keys of each clause should
		283		/// be applicable dimensions for the metric you are retrieving.
		284		/// </param>
		285		/// <param name='customHeaders'>
		286		/// The headers that will be added to request.
		287		/// </param>
		288		/// <param name='cancellationToken'>
		289		/// The cancellation token.
		290		/// </param>
		291		public async Task<HttpOperationResponse<MetricsSegmentedResult>> GetSegmentedMetricWithHttpMessagesAsync(string
		292		string timespan = default(string), IList<string> aggregation = default(IList<string>),
		293		IList<string> segment = default(IList<string>), int? top = default(int?), string orderby = default(string),
		294		string filter = default(string), Dictionary<string, List<string>> customHeaders = null,
		295		CancellationToken cancellationToken = default(CancellationToken))
		296		{
	0	297		var realResult = await GetWithHttpMessagesAsync(appId, metricId, timespan, null, aggregation, segment, top,
	0	298		var realBody = realResult.Body.Value;
	0	299		return new HttpOperationResponse<MetricsSegmentedResult>
	0	300		{
	0	301		Request = realResult.Request,
	0	302		Response = realResult.Response,
	0	303		Body = new MetricsSegmentedResult
	0	304		{
	0	305		Start = realBody.Start,
	0	306		End = realBody.End,
	0	307		Segments= GetSegmentInfo(realBody.Segments),
	0	308		}
	0	309		};
	0	310		}
		311
		312		private static IList<IMetricsBaseSegmentInfo> GetSegmentInfo(IList<MetricsSegmentInfo> segments)
		313		{
	0	314		return segments?.Select(seg =>
	0	315		{
	0	316		IMetricsBaseSegmentInfo result;
	0	317		if (seg.Segments != null && seg.Segments.Count != 0)
	0	318		{
	0	319		result = new MetricsNestedSegment()
	0	320		{
	0	321		SegmentId = seg.SegmentId,
	0	322		SegmentValue = seg.SegmentValue,
	0	323		Segments = GetSegmentInfo(seg.Segments),
	0	324		};
	0	325		}
	0	326		else
	0	327		{
	0	328		result = new MetricsSegmentedData
	0	329		{
	0	330		SegmentId = seg.SegmentId,
	0	331		SegmentValue = seg.SegmentValue,
	0	332		Sum = seg.GetSum(),
	0	333		Average = seg.GetAverage(),
	0	334		Min = seg.GetMin(),
	0	335		Max = seg.GetMax(),
	0	336		Count = seg.GetCount()
	0	337		};
	0	338		}
	0	339
	0	340		return result;
	0	341		}).ToList();
		342		}
		343
		344		/// <summary>
		345		/// Retrieve metric data
		346		/// </summary>
		347		/// <remarks>
		348		/// Gets metric values for a single metric
		349		/// </remarks>
		350		/// <param name='appId'>
		351		/// ID of the application. This is Application ID from the API Access settings
		352		/// blade in the Azure portal.
		353		/// </param>
		354		/// <param name='metricId'>
		355		/// ID of the metric. This is either a standard AI metric, or an
		356		/// application-specific custom metric. Possible values include:
		357		/// 'requests/count', 'requests/duration', 'requests/failed',
		358		/// 'users/count', 'users/authenticated', 'pageViews/count',
		359		/// 'pageViews/duration', 'client/processingDuration',
		360		/// 'client/receiveDuration', 'client/networkDuration',
		361		/// 'client/sendDuration', 'client/totalDuration',
		362		/// 'dependencies/count', 'dependencies/failed',
		363		/// 'dependencies/duration', 'exceptions/count', 'exceptions/browser',
		364		/// 'exceptions/server', 'sessions/count',
		365		/// 'performanceCounters/requestExecutionTime',
		366		/// 'performanceCounters/requestsPerSecond',
		367		/// 'performanceCounters/requestsInQueue',
		368		/// 'performanceCounters/memoryAvailableBytes',
		369		/// 'performanceCounters/exceptionsPerSecond',
		370		/// 'performanceCounters/processCpuPercentage',
		371		/// 'performanceCounters/processIOBytesPerSecond',
		372		/// 'performanceCounters/processPrivateBytes',
		373		/// 'performanceCounters/processorCpuPercentage',
		374		/// 'availabilityResults/availabilityPercentage',
		375		/// 'availabilityResults/duration', 'billing/telemetryCount',
		376		/// 'customEvents/count'
		377		/// </param>
		378		/// <param name='timespan'>
		379		/// The timespan over which to retrieve metric values. This is an
		380		/// ISO8601 time period value. If timespan is omitted, a default time
		381		/// range of `PT12H` ("last 12 hours") is used. The actual timespan
		382		/// that is queried may be adjusted by the server based. In all cases,
		383		/// the actual time span used for the query is included in the
		384		/// response.
		385		/// </param>
		386		/// <param name='interval'>
		387		/// The time interval to use when retrieving metric values. This is an
		388		/// ISO8601 duration. If interval is omitted, the metric value is
		389		/// aggregated across the entire timespan. If interval is supplied, the
		390		/// server may adjust the interval to a more appropriate size based on
		391		/// the timespan used for the query. In all cases, the actual interval
		392		/// used for the query is included in the response.
		393		/// </param>
		394		/// <param name='aggregation'>
		395		/// The aggregation to use when computing the metric values. To
		396		/// retrieve more than one aggregation at a time, separate them with a
		397		/// comma. If no aggregation is specified, then the default aggregation
		398		/// for the metric is used.
		399		/// </param>
		400		/// <param name='segment'>
		401		/// The name of the dimension to segment the metric values by. This
		402		/// dimension must be applicable to the metric you are retrieving. To
		403		/// segment by more than one dimension at a time, separate them with a
		404		/// comma (,). In this case, the metric data will be segmented in the
		405		/// order the dimensions are listed in the parameter.
		406		/// </param>
		407		/// <param name='top'>
		408		/// The number of segments to return.  This value is only valid when
		409		/// segment is specified.
		410		/// </param>
		411		/// <param name='orderby'>
		412		/// The aggregation function and direction to sort the segments by.
		413		/// This value is only valid when segment is specified.
		414		/// </param>
		415		/// <param name='filter'>
		416		/// An expression used to filter the results.  This value should be a
		417		/// valid OData filter expression where the keys of each clause should
		418		/// be applicable dimensions for the metric you are retrieving.
		419		/// </param>
		420		/// <param name='customHeaders'>
		421		/// The headers that will be added to request.
		422		/// </param>
		423		/// <param name='cancellationToken'>
		424		/// The cancellation token.
		425		/// </param>
		426		public async Task<HttpOperationResponse<MetricsIntervaledSegmentedResult>> GetIntervaledSegmentedMetricWithHttpM
		427		string appId, string metricId,
		428		string timespan = default(string), System.TimeSpan? interval = default(System.TimeSpan?),
		429		IList<string> aggregation = default(IList<string>), IList<string> segment = default(IList<string>),
		430		int? top = default(int?), string orderby = default(string), string filter = default(string),
		431		Dictionary<string, List<string>> customHeaders = null,
		432		CancellationToken cancellationToken = default(CancellationToken))
		433		{
	0	434		var realResult = await GetWithHttpMessagesAsync(appId, metricId, timespan, interval, aggregation, segment, t
	0	435		var realBody = realResult.Body.Value;
	0	436		return new HttpOperationResponse<MetricsIntervaledSegmentedResult>
	0	437		{
	0	438		Request = realResult.Request,
	0	439		Response = realResult.Response,
	0	440		Body = new MetricsIntervaledSegmentedResult
	0	441		{
	0	442		Start = realBody.Start,
	0	443		End = realBody.End,
	0	444		Interval = realBody.Interval,
	0	445		Intervals = realBody.Segments?.Select(inter =>
		446		new MetricsSegmentedIntervalData
		447		{
		448		Start = inter.Start,
		449		End = inter.End,
		450		Segments = GetSegmentInfo(inter.Segments),
		451		}
	0	452		).ToList()
	0	453		}
	0	454		};
	0	455		}
		456
		457		#endregion
		458		}
		459		}

C:\Git\azure-sdk-for-net\sdk\applicationinsights\Microsoft.Azure.ApplicationInsights.Query\src\Generated\Metrics.cs

	#	Line		Line coverage
		1		// <auto-generated>
		2		// Copyright (c) Microsoft Corporation. All rights reserved.
		3		// Licensed under the MIT License. See License.txt in the project root for
		4		// license information.
		5		//
		6		// Code generated by Microsoft (R) AutoRest Code Generator.
		7		// Changes may cause incorrect behavior and will be lost if the code is
		8		// regenerated.
		9		// </auto-generated>
		10
		11		namespace Microsoft.Azure.ApplicationInsights.Query
		12		{
		13		using Microsoft.Rest;
		14		using Models;
		15		using Newtonsoft.Json;
		16		using System.Collections;
		17		using System.Collections.Generic;
		18		using System.IO;
		19		using System.Linq;
		20		using System.Net;
		21		using System.Net.Http;
		22		using System.Threading;
		23		using System.Threading.Tasks;
		24
		25		/// <summary>
		26		/// Metrics operations.
		27		/// </summary>
		28		public partial class Metrics : IServiceOperations<ApplicationInsightsDataClient>, IMetrics
		29		{
		30		/// <summary>
		31		/// Initializes a new instance of the Metrics class.
		32		/// </summary>
		33		/// <param name='client'>
		34		/// Reference to the service client.
		35		/// </param>
		36		/// <exception cref="System.ArgumentNullException">
		37		/// Thrown when a required parameter is null
		38		/// </exception>
	20	39		public Metrics(ApplicationInsightsDataClient client)
		40		{
	20	41		if (client == null)
		42		{
	0	43		throw new System.ArgumentNullException("client");
		44		}
	20	45		Client = client;
	20	46		}
		47
		48		/// <summary>
		49		/// Gets a reference to the ApplicationInsightsDataClient
		50		/// </summary>
	0	51		public ApplicationInsightsDataClient Client { get; private set; }
		52
		53		/// <summary>
		54		/// Retrieve metric data
		55		/// </summary>
		56		/// <remarks>
		57		/// Gets metric values for a single metric
		58		/// </remarks>
		59		/// <param name='appId'>
		60		/// ID of the application. This is Application ID from the API Access settings
		61		/// blade in the Azure portal.
		62		/// </param>
		63		/// <param name='metricId'>
		64		/// ID of the metric. This is either a standard AI metric, or an
		65		/// application-specific custom metric. Possible values include:
		66		/// 'requests/count', 'requests/duration', 'requests/failed', 'users/count',
		67		/// 'users/authenticated', 'pageViews/count', 'pageViews/duration',
		68		/// 'client/processingDuration', 'client/receiveDuration',
		69		/// 'client/networkDuration', 'client/sendDuration', 'client/totalDuration',
		70		/// 'dependencies/count', 'dependencies/failed', 'dependencies/duration',
		71		/// 'exceptions/count', 'exceptions/browser', 'exceptions/server',
		72		/// 'sessions/count', 'performanceCounters/requestExecutionTime',
		73		/// 'performanceCounters/requestsPerSecond',
		74		/// 'performanceCounters/requestsInQueue',
		75		/// 'performanceCounters/memoryAvailableBytes',
		76		/// 'performanceCounters/exceptionsPerSecond',
		77		/// 'performanceCounters/processCpuPercentage',
		78		/// 'performanceCounters/processIOBytesPerSecond',
		79		/// 'performanceCounters/processPrivateBytes',
		80		/// 'performanceCounters/processorCpuPercentage',
		81		/// 'availabilityResults/availabilityPercentage',
		82		/// 'availabilityResults/duration', 'billing/telemetryCount',
		83		/// 'customEvents/count'
		84		/// </param>
		85		/// <param name='timespan'>
		86		/// The timespan over which to retrieve metric values. This is an ISO8601 time
		87		/// period value. If timespan is omitted, a default time range of `PT12H`
		88		/// ("last 12 hours") is used. The actual timespan that is queried may be
		89		/// adjusted by the server based. In all cases, the actual time span used for
		90		/// the query is included in the response.
		91		/// </param>
		92		/// <param name='interval'>
		93		/// The time interval to use when retrieving metric values. This is an ISO8601
		94		/// duration. If interval is omitted, the metric value is aggregated across the
		95		/// entire timespan. If interval is supplied, the server may adjust the
		96		/// interval to a more appropriate size based on the timespan used for the
		97		/// query. In all cases, the actual interval used for the query is included in
		98		/// the response.
		99		/// </param>
		100		/// <param name='aggregation'>
		101		/// The aggregation to use when computing the metric values. To retrieve more
		102		/// than one aggregation at a time, separate them with a comma. If no
		103		/// aggregation is specified, then the default aggregation for the metric is
		104		/// used.
		105		/// </param>
		106		/// <param name='segment'>
		107		/// The name of the dimension to segment the metric values by. This dimension
		108		/// must be applicable to the metric you are retrieving. To segment by more
		109		/// than one dimension at a time, separate them with a comma (,). In this case,
		110		/// the metric data will be segmented in the order the dimensions are listed in
		111		/// the parameter.
		112		/// </param>
		113		/// <param name='top'>
		114		/// The number of segments to return.  This value is only valid when segment is
		115		/// specified.
		116		/// </param>
		117		/// <param name='orderby'>
		118		/// The aggregation function and direction to sort the segments by.  This value
		119		/// is only valid when segment is specified.
		120		/// </param>
		121		/// <param name='filter'>
		122		/// An expression used to filter the results.  This value should be a valid
		123		/// OData filter expression where the keys of each clause should be applicable
		124		/// dimensions for the metric you are retrieving.
		125		/// </param>
		126		/// <param name='customHeaders'>
		127		/// Headers that will be added to request.
		128		/// </param>
		129		/// <param name='cancellationToken'>
		130		/// The cancellation token.
		131		/// </param>
		132		/// <exception cref="ErrorResponseException">
		133		/// Thrown when the operation returned an invalid status code
		134		/// </exception>
		135		/// <exception cref="SerializationException">
		136		/// Thrown when unable to deserialize the response
		137		/// </exception>
		138		/// <exception cref="ValidationException">
		139		/// Thrown when a required parameter is null
		140		/// </exception>
		141		/// <exception cref="System.ArgumentNullException">
		142		/// Thrown when a required parameter is null
		143		/// </exception>
		144		/// <return>
		145		/// A response object containing the response body and response headers.
		146		/// </return>
		147		public async Task<HttpOperationResponse<MetricsResult>> GetWithHttpMessagesAsync(string appId, string metricId,
		148		{
	0	149		if (appId == null)
		150		{
	0	151		throw new ValidationException(ValidationRules.CannotBeNull, "appId");
		152		}
	0	153		if (metricId == null)
		154		{
	0	155		throw new ValidationException(ValidationRules.CannotBeNull, "metricId");
		156		}
	0	157		if (aggregation != null)
		158		{
	0	159		if (aggregation.Count < 1)
		160		{
	0	161		throw new ValidationException(ValidationRules.MinItems, "aggregation", 1);
		162		}
		163		}
	0	164		if (segment != null)
		165		{
	0	166		if (segment.Count < 1)
		167		{
	0	168		throw new ValidationException(ValidationRules.MinItems, "segment", 1);
		169		}
		170		}
		171		// Tracing
	0	172		bool _shouldTrace = ServiceClientTracing.IsEnabled;
	0	173		string _invocationId = null;
	0	174		if (_shouldTrace)
		175		{
	0	176		_invocationId = ServiceClientTracing.NextInvocationId.ToString();
	0	177		Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
	0	178		tracingParameters.Add("appId", appId);
	0	179		tracingParameters.Add("metricId", metricId);
	0	180		tracingParameters.Add("timespan", timespan);
	0	181		tracingParameters.Add("interval", interval);
	0	182		tracingParameters.Add("aggregation", aggregation);
	0	183		tracingParameters.Add("segment", segment);
	0	184		tracingParameters.Add("top", top);
	0	185		tracingParameters.Add("orderby", orderby);
	0	186		tracingParameters.Add("filter", filter);
	0	187		tracingParameters.Add("cancellationToken", cancellationToken);
	0	188		ServiceClientTracing.Enter(_invocationId, this, "Get", tracingParameters);
		189		}
		190		// Construct URL
	0	191		var _baseUrl = Client.BaseUri.AbsoluteUri;
	0	192		var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "apps/{appId}/metr
	0	193		_url = _url.Replace("{appId}", System.Uri.EscapeDataString(appId));
	0	194		_url = _url.Replace("{metricId}", System.Uri.EscapeDataString(metricId));
	0	195		List<string> _queryParameters = new List<string>();
	0	196		if (timespan != null)
		197		{
	0	198		_queryParameters.Add(string.Format("timespan={0}", System.Uri.EscapeDataString(timespan)));
		199		}
	0	200		if (interval != null)
		201		{
	0	202		_queryParameters.Add(string.Format("interval={0}", System.Uri.EscapeDataString(Rest.Serialization.SafeJs
		203		}
	0	204		if (aggregation != null)
		205		{
	0	206		_queryParameters.Add(string.Format("aggregation={0}", System.Uri.EscapeDataString(string.Join(",", aggre
		207		}
	0	208		if (segment != null)
		209		{
	0	210		_queryParameters.Add(string.Format("segment={0}", System.Uri.EscapeDataString(string.Join(",", segment))
		211		}
	0	212		if (top != null)
		213		{
	0	214		_queryParameters.Add(string.Format("top={0}", System.Uri.EscapeDataString(Rest.Serialization.SafeJsonCon
		215		}
	0	216		if (orderby != null)
		217		{
	0	218		_queryParameters.Add(string.Format("orderby={0}", System.Uri.EscapeDataString(orderby)));
		219		}
	0	220		if (filter != null)
		221		{
	0	222		_queryParameters.Add(string.Format("filter={0}", System.Uri.EscapeDataString(filter)));
		223		}
	0	224		if (_queryParameters.Count > 0)
		225		{
	0	226		_url += "?" + string.Join("&", _queryParameters);
		227		}
		228		// Create HTTP transport objects
	0	229		var _httpRequest = new HttpRequestMessage();
	0	230		HttpResponseMessage _httpResponse = null;
	0	231		_httpRequest.Method = new HttpMethod("GET");
	0	232		_httpRequest.RequestUri = new System.Uri(_url);
		233		// Set Headers
		234
		235
	0	236		if (customHeaders != null)
		237		{
	0	238		foreach(var _header in customHeaders)
		239		{
	0	240		if (_httpRequest.Headers.Contains(_header.Key))
		241		{
	0	242		_httpRequest.Headers.Remove(_header.Key);
		243		}
	0	244		_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
		245		}
		246		}
		247
		248		// Serialize Request
	0	249		string _requestContent = null;
		250		// Set Credentials
	0	251		if (Client.Credentials != null)
		252		{
	0	253		cancellationToken.ThrowIfCancellationRequested();
	0	254		await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
		255		}
		256		// Send Request
	0	257		if (_shouldTrace)
		258		{
	0	259		ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
		260		}
	0	261		cancellationToken.ThrowIfCancellationRequested();
	0	262		_httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
	0	263		if (_shouldTrace)
		264		{
	0	265		ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
		266		}
	0	267		HttpStatusCode _statusCode = _httpResponse.StatusCode;
	0	268		cancellationToken.ThrowIfCancellationRequested();
	0	269		string _responseContent = null;
	0	270		if ((int)_statusCode != 200)
		271		{
	0	272		var ex = new ErrorResponseException(string.Format("Operation returned an invalid status code '{0}'", _st
		273		try
		274		{
	0	275		_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
	0	276		ErrorResponse _errorBody =  Rest.Serialization.SafeJsonConvert.DeserializeObject<ErrorResponse>(_res
	0	277		if (_errorBody != null)
		278		{
	0	279		ex.Body = _errorBody;
		280		}
	0	281		}
	0	282		catch (JsonException)
		283		{
		284		// Ignore the exception
	0	285		}
	0	286		ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
	0	287		ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
	0	288		if (_shouldTrace)
		289		{
	0	290		ServiceClientTracing.Error(_invocationId, ex);
		291		}
	0	292		_httpRequest.Dispose();
	0	293		if (_httpResponse != null)
		294		{
	0	295		_httpResponse.Dispose();
		296		}
	0	297		throw ex;
		298		}
		299		// Create Result
	0	300		var _result = new HttpOperationResponse<MetricsResult>();
	0	301		_result.Request = _httpRequest;
	0	302		_result.Response = _httpResponse;
		303		// Deserialize Response
	0	304		if ((int)_statusCode == 200)
		305		{
	0	306		_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
		307		try
		308		{
	0	309		_result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject<MetricsResult>(_responseContent,
	0	310		}
	0	311		catch (JsonException ex)
		312		{
	0	313		_httpRequest.Dispose();
	0	314		if (_httpResponse != null)
		315		{
	0	316		_httpResponse.Dispose();
		317		}
	0	318		throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
		319		}
		320		}
	0	321		if (_shouldTrace)
		322		{
	0	323		ServiceClientTracing.Exit(_invocationId, _result);
		324		}
	0	325		return _result;
	0	326		}
		327
		328		/// <summary>
		329		/// Retrieve metric data
		330		/// </summary>
		331		/// <remarks>
		332		/// Gets metric values for multiple metrics
		333		/// </remarks>
		334		/// <param name='appId'>
		335		/// ID of the application. This is Application ID from the API Access settings
		336		/// blade in the Azure portal.
		337		/// </param>
		338		/// <param name='body'>
		339		/// The batched metrics query.
		340		/// </param>
		341		/// <param name='customHeaders'>
		342		/// Headers that will be added to request.
		343		/// </param>
		344		/// <param name='cancellationToken'>
		345		/// The cancellation token.
		346		/// </param>
		347		/// <exception cref="ErrorResponseException">
		348		/// Thrown when the operation returned an invalid status code
		349		/// </exception>
		350		/// <exception cref="SerializationException">
		351		/// Thrown when unable to deserialize the response
		352		/// </exception>
		353		/// <exception cref="ValidationException">
		354		/// Thrown when a required parameter is null
		355		/// </exception>
		356		/// <exception cref="System.ArgumentNullException">
		357		/// Thrown when a required parameter is null
		358		/// </exception>
		359		/// <return>
		360		/// A response object containing the response body and response headers.
		361		/// </return>
		362		public async Task<HttpOperationResponse<IList<MetricsResultsItem>>> GetMultipleWithHttpMessagesAsync(string appI
		363		{
	0	364		if (appId == null)
		365		{
	0	366		throw new ValidationException(ValidationRules.CannotBeNull, "appId");
		367		}
	0	368		if (body == null)
		369		{
	0	370		throw new ValidationException(ValidationRules.CannotBeNull, "body");
		371		}
	0	372		if (body != null)
		373		{
	0	374		foreach (var element in body)
		375		{
	0	376		if (element != null)
		377		{
	0	378		element.Validate();
		379		}
		380		}
		381		}
		382		// Tracing
	0	383		bool _shouldTrace = ServiceClientTracing.IsEnabled;
	0	384		string _invocationId = null;
	0	385		if (_shouldTrace)
		386		{
	0	387		_invocationId = ServiceClientTracing.NextInvocationId.ToString();
	0	388		Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
	0	389		tracingParameters.Add("appId", appId);
	0	390		tracingParameters.Add("body", body);
	0	391		tracingParameters.Add("cancellationToken", cancellationToken);
	0	392		ServiceClientTracing.Enter(_invocationId, this, "GetMultiple", tracingParameters);
		393		}
		394		// Construct URL
	0	395		var _baseUrl = Client.BaseUri.AbsoluteUri;
	0	396		var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "apps/{appId}/metr
	0	397		_url = _url.Replace("{appId}", System.Uri.EscapeDataString(appId));
		398		// Create HTTP transport objects
	0	399		var _httpRequest = new HttpRequestMessage();
	0	400		HttpResponseMessage _httpResponse = null;
	0	401		_httpRequest.Method = new HttpMethod("POST");
	0	402		_httpRequest.RequestUri = new System.Uri(_url);
		403		// Set Headers
		404
		405
	0	406		if (customHeaders != null)
		407		{
	0	408		foreach(var _header in customHeaders)
		409		{
	0	410		if (_httpRequest.Headers.Contains(_header.Key))
		411		{
	0	412		_httpRequest.Headers.Remove(_header.Key);
		413		}
	0	414		_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
		415		}
		416		}
		417
		418		// Serialize Request
	0	419		string _requestContent = null;
	0	420		if(body != null)
		421		{
	0	422		_requestContent = Rest.Serialization.SafeJsonConvert.SerializeObject(body, Client.SerializationSettings)
	0	423		_httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8);
	0	424		_httpRequest.Content.Headers.ContentType =System.Net.Http.Headers.MediaTypeHeaderValue.Parse("applicatio
		425		}
		426		// Set Credentials
	0	427		if (Client.Credentials != null)
		428		{
	0	429		cancellationToken.ThrowIfCancellationRequested();
	0	430		await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
		431		}
		432		// Send Request
	0	433		if (_shouldTrace)
		434		{
	0	435		ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
		436		}
	0	437		cancellationToken.ThrowIfCancellationRequested();
	0	438		_httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
	0	439		if (_shouldTrace)
		440		{
	0	441		ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
		442		}
	0	443		HttpStatusCode _statusCode = _httpResponse.StatusCode;
	0	444		cancellationToken.ThrowIfCancellationRequested();
	0	445		string _responseContent = null;
	0	446		if ((int)_statusCode != 200)
		447		{
	0	448		var ex = new ErrorResponseException(string.Format("Operation returned an invalid status code '{0}'", _st
		449		try
		450		{
	0	451		_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
	0	452		ErrorResponse _errorBody =  Rest.Serialization.SafeJsonConvert.DeserializeObject<ErrorResponse>(_res
	0	453		if (_errorBody != null)
		454		{
	0	455		ex.Body = _errorBody;
		456		}
	0	457		}
	0	458		catch (JsonException)
		459		{
		460		// Ignore the exception
	0	461		}
	0	462		ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
	0	463		ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
	0	464		if (_shouldTrace)
		465		{
	0	466		ServiceClientTracing.Error(_invocationId, ex);
		467		}
	0	468		_httpRequest.Dispose();
	0	469		if (_httpResponse != null)
		470		{
	0	471		_httpResponse.Dispose();
		472		}
	0	473		throw ex;
		474		}
		475		// Create Result
	0	476		var _result = new HttpOperationResponse<IList<MetricsResultsItem>>();
	0	477		_result.Request = _httpRequest;
	0	478		_result.Response = _httpResponse;
		479		// Deserialize Response
	0	480		if ((int)_statusCode == 200)
		481		{
	0	482		_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
		483		try
		484		{
	0	485		_result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject<IList<MetricsResultsItem>>(_resp
	0	486		}
	0	487		catch (JsonException ex)
		488		{
	0	489		_httpRequest.Dispose();
	0	490		if (_httpResponse != null)
		491		{
	0	492		_httpResponse.Dispose();
		493		}
	0	494		throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
		495		}
		496		}
	0	497		if (_shouldTrace)
		498		{
	0	499		ServiceClientTracing.Exit(_invocationId, _result);
		500		}
	0	501		return _result;
	0	502		}
		503
		504		/// <summary>
		505		/// Retrieve metric metatadata
		506		/// </summary>
		507		/// <remarks>
		508		/// Gets metadata describing the available metrics
		509		/// </remarks>
		510		/// <param name='appId'>
		511		/// ID of the application. This is Application ID from the API Access settings
		512		/// blade in the Azure portal.
		513		/// </param>
		514		/// <param name='customHeaders'>
		515		/// Headers that will be added to request.
		516		/// </param>
		517		/// <param name='cancellationToken'>
		518		/// The cancellation token.
		519		/// </param>
		520		/// <exception cref="ErrorResponseException">
		521		/// Thrown when the operation returned an invalid status code
		522		/// </exception>
		523		/// <exception cref="SerializationException">
		524		/// Thrown when unable to deserialize the response
		525		/// </exception>
		526		/// <exception cref="ValidationException">
		527		/// Thrown when a required parameter is null
		528		/// </exception>
		529		/// <exception cref="System.ArgumentNullException">
		530		/// Thrown when a required parameter is null
		531		/// </exception>
		532		/// <return>
		533		/// A response object containing the response body and response headers.
		534		/// </return>
		535		public async Task<HttpOperationResponse<object>> GetMetadataWithHttpMessagesAsync(string appId, Dictionary<strin
		536		{
	0	537		if (appId == null)
		538		{
	0	539		throw new ValidationException(ValidationRules.CannotBeNull, "appId");
		540		}
		541		// Tracing
	0	542		bool _shouldTrace = ServiceClientTracing.IsEnabled;
	0	543		string _invocationId = null;
	0	544		if (_shouldTrace)
		545		{
	0	546		_invocationId = ServiceClientTracing.NextInvocationId.ToString();
	0	547		Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
	0	548		tracingParameters.Add("appId", appId);
	0	549		tracingParameters.Add("cancellationToken", cancellationToken);
	0	550		ServiceClientTracing.Enter(_invocationId, this, "GetMetadata", tracingParameters);
		551		}
		552		// Construct URL
	0	553		var _baseUrl = Client.BaseUri.AbsoluteUri;
	0	554		var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "apps/{appId}/metr
	0	555		_url = _url.Replace("{appId}", System.Uri.EscapeDataString(appId));
		556		// Create HTTP transport objects
	0	557		var _httpRequest = new HttpRequestMessage();
	0	558		HttpResponseMessage _httpResponse = null;
	0	559		_httpRequest.Method = new HttpMethod("GET");
	0	560		_httpRequest.RequestUri = new System.Uri(_url);
		561		// Set Headers
		562
		563
	0	564		if (customHeaders != null)
		565		{
	0	566		foreach(var _header in customHeaders)
		567		{
	0	568		if (_httpRequest.Headers.Contains(_header.Key))
		569		{
	0	570		_httpRequest.Headers.Remove(_header.Key);
		571		}
	0	572		_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
		573		}
		574		}
		575
		576		// Serialize Request
	0	577		string _requestContent = null;
		578		// Set Credentials
	0	579		if (Client.Credentials != null)
		580		{
	0	581		cancellationToken.ThrowIfCancellationRequested();
	0	582		await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
		583		}
		584		// Send Request
	0	585		if (_shouldTrace)
		586		{
	0	587		ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
		588		}
	0	589		cancellationToken.ThrowIfCancellationRequested();
	0	590		_httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
	0	591		if (_shouldTrace)
		592		{
	0	593		ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
		594		}
	0	595		HttpStatusCode _statusCode = _httpResponse.StatusCode;
	0	596		cancellationToken.ThrowIfCancellationRequested();
	0	597		string _responseContent = null;
	0	598		if ((int)_statusCode != 200)
		599		{
	0	600		var ex = new ErrorResponseException(string.Format("Operation returned an invalid status code '{0}'", _st
		601		try
		602		{
	0	603		_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
	0	604		ErrorResponse _errorBody =  Rest.Serialization.SafeJsonConvert.DeserializeObject<ErrorResponse>(_res
	0	605		if (_errorBody != null)
		606		{
	0	607		ex.Body = _errorBody;
		608		}
	0	609		}
	0	610		catch (JsonException)
		611		{
		612		// Ignore the exception
	0	613		}
	0	614		ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
	0	615		ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
	0	616		if (_shouldTrace)
		617		{
	0	618		ServiceClientTracing.Error(_invocationId, ex);
		619		}
	0	620		_httpRequest.Dispose();
	0	621		if (_httpResponse != null)
		622		{
	0	623		_httpResponse.Dispose();
		624		}
	0	625		throw ex;
		626		}
		627		// Create Result
	0	628		var _result = new HttpOperationResponse<object>();
	0	629		_result.Request = _httpRequest;
	0	630		_result.Response = _httpResponse;
		631		// Deserialize Response
	0	632		if ((int)_statusCode == 200)
		633		{
	0	634		_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
		635		try
		636		{
	0	637		_result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject<object>(_responseContent, Client
	0	638		}
	0	639		catch (JsonException ex)
		640		{
	0	641		_httpRequest.Dispose();
	0	642		if (_httpResponse != null)
		643		{
	0	644		_httpResponse.Dispose();
		645		}
	0	646		throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
		647		}
		648		}
	0	649		if (_shouldTrace)
		650		{
	0	651		ServiceClientTracing.Exit(_invocationId, _result);
		652		}
	0	653		return _result;
	0	654		}
		655
		656		}
		657		}