< Summary

Class:	Microsoft.Azure.CognitiveServices.Vision.Face.LargePersonGroupPerson
Assembly:	Microsoft.Azure.CognitiveServices.Vision.Face
File(s):	C:\Git\azure-sdk-for-net\sdk\cognitiveservices\Vision.Face\src\Generated\LargePersonGroupPerson.cs
Covered lines:	191
Uncovered lines:	663
Coverable lines:	854
Total lines:	2013
Line coverage:	22.3% (191 of 854)
Covered branches:	95
Total branches:	470
Branch coverage:	20.2% (95 of 470)

Metrics

Method	Cyclomatic complexity	Line coverage	Branch coverage
.ctor(...)	-	80%	50%
get_Client()	-	100%	100%
CreateWithHttpMessagesAsync()	-	56.04%	51.85%
ListWithHttpMessagesAsync()	-	0%	0%
DeleteWithHttpMessagesAsync()	-	0%	0%
GetWithHttpMessagesAsync()	-	51.28%	42.5%
UpdateWithHttpMessagesAsync()	-	0%	0%
DeleteFaceWithHttpMessagesAsync()	-	0%	0%
GetFaceWithHttpMessagesAsync()	-	51.25%	42.5%
UpdateFaceWithHttpMessagesAsync()	-	0%	0%
AddFaceFromUrlWithHttpMessagesAsync()	-	0%	0%
AddFaceFromStreamWithHttpMessagesAsync()	-	53.47%	53.33%

File(s)

C:\Git\azure-sdk-for-net\sdk\cognitiveservices\Vision.Face\src\Generated\LargePersonGroupPerson.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.CognitiveServices.Vision.Face
		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		/// LargePersonGroupPerson operations.
		27		/// </summary>
		28		public partial class LargePersonGroupPerson : IServiceOperations<FaceClient>, ILargePersonGroupPerson
		29		{
		30		/// <summary>
		31		/// Initializes a new instance of the LargePersonGroupPerson 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>
	34	39		public LargePersonGroupPerson(FaceClient client)
		40		{
	34	41		if (client == null)
		42		{
	0	43		throw new System.ArgumentNullException("client");
		44		}
	34	45		Client = client;
	34	46		}
		47
		48		/// <summary>
		49		/// Gets a reference to the FaceClient
		50		/// </summary>
	292	51		public FaceClient Client { get; private set; }
		52
		53		/// <summary>
		54		/// Create a new person in a specified large person group.
		55		/// </summary>
		56		/// <param name='largePersonGroupId'>
		57		/// Id referencing a particular large person group.
		58		/// </param>
		59		/// <param name='name'>
		60		/// User defined name, maximum length is 128.
		61		/// </param>
		62		/// <param name='userData'>
		63		/// User specified data. Length should not exceed 16KB.
		64		/// </param>
		65		/// <param name='customHeaders'>
		66		/// Headers that will be added to request.
		67		/// </param>
		68		/// <param name='cancellationToken'>
		69		/// The cancellation token.
		70		/// </param>
		71		/// <exception cref="APIErrorException">
		72		/// Thrown when the operation returned an invalid status code
		73		/// </exception>
		74		/// <exception cref="SerializationException">
		75		/// Thrown when unable to deserialize the response
		76		/// </exception>
		77		/// <exception cref="ValidationException">
		78		/// Thrown when a required parameter is null
		79		/// </exception>
		80		/// <exception cref="System.ArgumentNullException">
		81		/// Thrown when a required parameter is null
		82		/// </exception>
		83		/// <return>
		84		/// A response object containing the response body and response headers.
		85		/// </return>
		86		public async Task<HttpOperationResponse<Person>> CreateWithHttpMessagesAsync(string largePersonGroupId, string n
		87		{
	10	88		if (Client.Endpoint == null)
		89		{
	0	90		throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.Endpoint");
		91		}
	10	92		if (largePersonGroupId == null)
		93		{
	0	94		throw new ValidationException(ValidationRules.CannotBeNull, "largePersonGroupId");
		95		}
	10	96		if (largePersonGroupId != null)
		97		{
	10	98		if (largePersonGroupId.Length > 64)
		99		{
	0	100		throw new ValidationException(ValidationRules.MaxLength, "largePersonGroupId", 64);
		101		}
	10	102		if (!System.Text.RegularExpressions.Regex.IsMatch(largePersonGroupId, "^[a-z0-9-_]+$"))
		103		{
	0	104		throw new ValidationException(ValidationRules.Pattern, "largePersonGroupId", "^[a-z0-9-_]+$");
		105		}
		106		}
	10	107		if (name != null)
		108		{
	10	109		if (name.Length > 128)
		110		{
	0	111		throw new ValidationException(ValidationRules.MaxLength, "name", 128);
		112		}
		113		}
	10	114		if (userData != null)
		115		{
	2	116		if (userData.Length > 16384)
		117		{
	0	118		throw new ValidationException(ValidationRules.MaxLength, "userData", 16384);
		119		}
		120		}
	10	121		NameAndUserDataContract body = new NameAndUserDataContract();
	10	122		if (name != null || userData != null)
		123		{
	10	124		body.Name = name;
	10	125		body.UserData = userData;
		126		}
		127		// Tracing
	10	128		bool _shouldTrace = ServiceClientTracing.IsEnabled;
	10	129		string _invocationId = null;
	10	130		if (_shouldTrace)
		131		{
	0	132		_invocationId = ServiceClientTracing.NextInvocationId.ToString();
	0	133		Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
	0	134		tracingParameters.Add("largePersonGroupId", largePersonGroupId);
	0	135		tracingParameters.Add("body", body);
	0	136		tracingParameters.Add("cancellationToken", cancellationToken);
	0	137		ServiceClientTracing.Enter(_invocationId, this, "Create", tracingParameters);
		138		}
		139		// Construct URL
	10	140		var _baseUrl = Client.BaseUri;
	10	141		var _url = _baseUrl + (_baseUrl.EndsWith("/") ? "" : "/") + "largepersongroups/{largePersonGroupId}/persons"
	10	142		_url = _url.Replace("{Endpoint}", Client.Endpoint);
	10	143		_url = _url.Replace("{largePersonGroupId}", System.Uri.EscapeDataString(largePersonGroupId));
		144		// Create HTTP transport objects
	10	145		var _httpRequest = new HttpRequestMessage();
	10	146		HttpResponseMessage _httpResponse = null;
	10	147		_httpRequest.Method = new HttpMethod("POST");
	10	148		_httpRequest.RequestUri = new System.Uri(_url);
		149		// Set Headers
		150
		151
	10	152		if (customHeaders != null)
		153		{
	0	154		foreach(var _header in customHeaders)
		155		{
	0	156		if (_httpRequest.Headers.Contains(_header.Key))
		157		{
	0	158		_httpRequest.Headers.Remove(_header.Key);
		159		}
	0	160		_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
		161		}
		162		}
		163
		164		// Serialize Request
	10	165		string _requestContent = null;
	10	166		if(body != null)
		167		{
	10	168		_requestContent = Rest.Serialization.SafeJsonConvert.SerializeObject(body, Client.SerializationSettings)
	10	169		_httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8);
	10	170		_httpRequest.Content.Headers.ContentType =System.Net.Http.Headers.MediaTypeHeaderValue.Parse("applicatio
		171		}
		172		// Set Credentials
	10	173		if (Client.Credentials != null)
		174		{
	10	175		cancellationToken.ThrowIfCancellationRequested();
	10	176		await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
		177		}
		178		// Send Request
	10	179		if (_shouldTrace)
		180		{
	0	181		ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
		182		}
	10	183		cancellationToken.ThrowIfCancellationRequested();
	10	184		_httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
	10	185		if (_shouldTrace)
		186		{
	0	187		ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
		188		}
	10	189		HttpStatusCode _statusCode = _httpResponse.StatusCode;
	10	190		cancellationToken.ThrowIfCancellationRequested();
	10	191		string _responseContent = null;
	10	192		if ((int)_statusCode != 200)
		193		{
	0	194		var ex = new APIErrorException(string.Format("Operation returned an invalid status code '{0}'", _statusC
		195		try
		196		{
	0	197		_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
	0	198		APIError _errorBody =  Rest.Serialization.SafeJsonConvert.DeserializeObject<APIError>(_responseConte
	0	199		if (_errorBody != null)
		200		{
	0	201		ex.Body = _errorBody;
		202		}
	0	203		}
	0	204		catch (JsonException)
		205		{
		206		// Ignore the exception
	0	207		}
	0	208		ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
	0	209		ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
	0	210		if (_shouldTrace)
		211		{
	0	212		ServiceClientTracing.Error(_invocationId, ex);
		213		}
	0	214		_httpRequest.Dispose();
	0	215		if (_httpResponse != null)
		216		{
	0	217		_httpResponse.Dispose();
		218		}
	0	219		throw ex;
		220		}
		221		// Create Result
	10	222		var _result = new HttpOperationResponse<Person>();
	10	223		_result.Request = _httpRequest;
	10	224		_result.Response = _httpResponse;
		225		// Deserialize Response
	10	226		if ((int)_statusCode == 200)
		227		{
	10	228		_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
		229		try
		230		{
	10	231		_result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject<Person>(_responseContent, Client
	10	232		}
	0	233		catch (JsonException ex)
		234		{
	0	235		_httpRequest.Dispose();
	0	236		if (_httpResponse != null)
		237		{
	0	238		_httpResponse.Dispose();
		239		}
	0	240		throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
		241		}
		242		}
	10	243		if (_shouldTrace)
		244		{
	0	245		ServiceClientTracing.Exit(_invocationId, _result);
		246		}
	10	247		return _result;
	10	248		}
		249
		250		/// <summary>
		251		/// List all persons in a large person group, and retrieve person information
		252		/// (including personId, name, userData and persistedFaceIds of registered
		253		/// faces of the person).
		254		/// </summary>
		255		/// <param name='largePersonGroupId'>
		256		/// Id referencing a particular large person group.
		257		/// </param>
		258		/// <param name='start'>
		259		/// Starting person id to return (used to list a range of persons).
		260		/// </param>
		261		/// <param name='top'>
		262		/// Number of persons to return starting with the person id indicated by the
		263		/// 'start' parameter.
		264		/// </param>
		265		/// <param name='customHeaders'>
		266		/// Headers that will be added to request.
		267		/// </param>
		268		/// <param name='cancellationToken'>
		269		/// The cancellation token.
		270		/// </param>
		271		/// <exception cref="APIErrorException">
		272		/// Thrown when the operation returned an invalid status code
		273		/// </exception>
		274		/// <exception cref="SerializationException">
		275		/// Thrown when unable to deserialize the response
		276		/// </exception>
		277		/// <exception cref="ValidationException">
		278		/// Thrown when a required parameter is null
		279		/// </exception>
		280		/// <exception cref="System.ArgumentNullException">
		281		/// Thrown when a required parameter is null
		282		/// </exception>
		283		/// <return>
		284		/// A response object containing the response body and response headers.
		285		/// </return>
		286		public async Task<HttpOperationResponse<IList<Person>>> ListWithHttpMessagesAsync(string largePersonGroupId, str
		287		{
	0	288		if (Client.Endpoint == null)
		289		{
	0	290		throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.Endpoint");
		291		}
	0	292		if (largePersonGroupId == null)
		293		{
	0	294		throw new ValidationException(ValidationRules.CannotBeNull, "largePersonGroupId");
		295		}
	0	296		if (largePersonGroupId != null)
		297		{
	0	298		if (largePersonGroupId.Length > 64)
		299		{
	0	300		throw new ValidationException(ValidationRules.MaxLength, "largePersonGroupId", 64);
		301		}
	0	302		if (!System.Text.RegularExpressions.Regex.IsMatch(largePersonGroupId, "^[a-z0-9-_]+$"))
		303		{
	0	304		throw new ValidationException(ValidationRules.Pattern, "largePersonGroupId", "^[a-z0-9-_]+$");
		305		}
		306		}
	0	307		if (top > 1000)
		308		{
	0	309		throw new ValidationException(ValidationRules.InclusiveMaximum, "top", 1000);
		310		}
	0	311		if (top < 1)
		312		{
	0	313		throw new ValidationException(ValidationRules.InclusiveMinimum, "top", 1);
		314		}
		315		// Tracing
	0	316		bool _shouldTrace = ServiceClientTracing.IsEnabled;
	0	317		string _invocationId = null;
	0	318		if (_shouldTrace)
		319		{
	0	320		_invocationId = ServiceClientTracing.NextInvocationId.ToString();
	0	321		Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
	0	322		tracingParameters.Add("largePersonGroupId", largePersonGroupId);
	0	323		tracingParameters.Add("start", start);
	0	324		tracingParameters.Add("top", top);
	0	325		tracingParameters.Add("cancellationToken", cancellationToken);
	0	326		ServiceClientTracing.Enter(_invocationId, this, "List", tracingParameters);
		327		}
		328		// Construct URL
	0	329		var _baseUrl = Client.BaseUri;
	0	330		var _url = _baseUrl + (_baseUrl.EndsWith("/") ? "" : "/") + "largepersongroups/{largePersonGroupId}/persons"
	0	331		_url = _url.Replace("{Endpoint}", Client.Endpoint);
	0	332		_url = _url.Replace("{largePersonGroupId}", System.Uri.EscapeDataString(largePersonGroupId));
	0	333		List<string> _queryParameters = new List<string>();
	0	334		if (start != null)
		335		{
	0	336		_queryParameters.Add(string.Format("start={0}", System.Uri.EscapeDataString(start)));
		337		}
	0	338		if (top != null)
		339		{
	0	340		_queryParameters.Add(string.Format("top={0}", System.Uri.EscapeDataString(Rest.Serialization.SafeJsonCon
		341		}
	0	342		if (_queryParameters.Count > 0)
		343		{
	0	344		_url += "?" + string.Join("&", _queryParameters);
		345		}
		346		// Create HTTP transport objects
	0	347		var _httpRequest = new HttpRequestMessage();
	0	348		HttpResponseMessage _httpResponse = null;
	0	349		_httpRequest.Method = new HttpMethod("GET");
	0	350		_httpRequest.RequestUri = new System.Uri(_url);
		351		// Set Headers
		352
		353
	0	354		if (customHeaders != null)
		355		{
	0	356		foreach(var _header in customHeaders)
		357		{
	0	358		if (_httpRequest.Headers.Contains(_header.Key))
		359		{
	0	360		_httpRequest.Headers.Remove(_header.Key);
		361		}
	0	362		_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
		363		}
		364		}
		365
		366		// Serialize Request
	0	367		string _requestContent = null;
		368		// Set Credentials
	0	369		if (Client.Credentials != null)
		370		{
	0	371		cancellationToken.ThrowIfCancellationRequested();
	0	372		await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
		373		}
		374		// Send Request
	0	375		if (_shouldTrace)
		376		{
	0	377		ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
		378		}
	0	379		cancellationToken.ThrowIfCancellationRequested();
	0	380		_httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
	0	381		if (_shouldTrace)
		382		{
	0	383		ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
		384		}
	0	385		HttpStatusCode _statusCode = _httpResponse.StatusCode;
	0	386		cancellationToken.ThrowIfCancellationRequested();
	0	387		string _responseContent = null;
	0	388		if ((int)_statusCode != 200)
		389		{
	0	390		var ex = new APIErrorException(string.Format("Operation returned an invalid status code '{0}'", _statusC
		391		try
		392		{
	0	393		_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
	0	394		APIError _errorBody =  Rest.Serialization.SafeJsonConvert.DeserializeObject<APIError>(_responseConte
	0	395		if (_errorBody != null)
		396		{
	0	397		ex.Body = _errorBody;
		398		}
	0	399		}
	0	400		catch (JsonException)
		401		{
		402		// Ignore the exception
	0	403		}
	0	404		ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
	0	405		ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
	0	406		if (_shouldTrace)
		407		{
	0	408		ServiceClientTracing.Error(_invocationId, ex);
		409		}
	0	410		_httpRequest.Dispose();
	0	411		if (_httpResponse != null)
		412		{
	0	413		_httpResponse.Dispose();
		414		}
	0	415		throw ex;
		416		}
		417		// Create Result
	0	418		var _result = new HttpOperationResponse<IList<Person>>();
	0	419		_result.Request = _httpRequest;
	0	420		_result.Response = _httpResponse;
		421		// Deserialize Response
	0	422		if ((int)_statusCode == 200)
		423		{
	0	424		_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
		425		try
		426		{
	0	427		_result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject<IList<Person>>(_responseContent,
	0	428		}
	0	429		catch (JsonException ex)
		430		{
	0	431		_httpRequest.Dispose();
	0	432		if (_httpResponse != null)
		433		{
	0	434		_httpResponse.Dispose();
		435		}
	0	436		throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
		437		}
		438		}
	0	439		if (_shouldTrace)
		440		{
	0	441		ServiceClientTracing.Exit(_invocationId, _result);
		442		}
	0	443		return _result;
	0	444		}
		445
		446		/// <summary>
		447		/// Delete an existing person from a large person group. The persistedFaceId,
		448		/// userData, person name and face feature in the person entry will all be
		449		/// deleted.
		450		/// </summary>
		451		/// <param name='largePersonGroupId'>
		452		/// Id referencing a particular large person group.
		453		/// </param>
		454		/// <param name='personId'>
		455		/// Id referencing a particular person.
		456		/// </param>
		457		/// <param name='customHeaders'>
		458		/// Headers that will be added to request.
		459		/// </param>
		460		/// <param name='cancellationToken'>
		461		/// The cancellation token.
		462		/// </param>
		463		/// <exception cref="APIErrorException">
		464		/// Thrown when the operation returned an invalid status code
		465		/// </exception>
		466		/// <exception cref="ValidationException">
		467		/// Thrown when a required parameter is null
		468		/// </exception>
		469		/// <exception cref="System.ArgumentNullException">
		470		/// Thrown when a required parameter is null
		471		/// </exception>
		472		/// <return>
		473		/// A response object containing the response body and response headers.
		474		/// </return>
		475		public async Task<HttpOperationResponse> DeleteWithHttpMessagesAsync(string largePersonGroupId, System.Guid pers
		476		{
	0	477		if (Client.Endpoint == null)
		478		{
	0	479		throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.Endpoint");
		480		}
	0	481		if (largePersonGroupId == null)
		482		{
	0	483		throw new ValidationException(ValidationRules.CannotBeNull, "largePersonGroupId");
		484		}
	0	485		if (largePersonGroupId != null)
		486		{
	0	487		if (largePersonGroupId.Length > 64)
		488		{
	0	489		throw new ValidationException(ValidationRules.MaxLength, "largePersonGroupId", 64);
		490		}
	0	491		if (!System.Text.RegularExpressions.Regex.IsMatch(largePersonGroupId, "^[a-z0-9-_]+$"))
		492		{
	0	493		throw new ValidationException(ValidationRules.Pattern, "largePersonGroupId", "^[a-z0-9-_]+$");
		494		}
		495		}
		496		// Tracing
	0	497		bool _shouldTrace = ServiceClientTracing.IsEnabled;
	0	498		string _invocationId = null;
	0	499		if (_shouldTrace)
		500		{
	0	501		_invocationId = ServiceClientTracing.NextInvocationId.ToString();
	0	502		Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
	0	503		tracingParameters.Add("largePersonGroupId", largePersonGroupId);
	0	504		tracingParameters.Add("personId", personId);
	0	505		tracingParameters.Add("cancellationToken", cancellationToken);
	0	506		ServiceClientTracing.Enter(_invocationId, this, "Delete", tracingParameters);
		507		}
		508		// Construct URL
	0	509		var _baseUrl = Client.BaseUri;
	0	510		var _url = _baseUrl + (_baseUrl.EndsWith("/") ? "" : "/") + "largepersongroups/{largePersonGroupId}/persons/
	0	511		_url = _url.Replace("{Endpoint}", Client.Endpoint);
	0	512		_url = _url.Replace("{largePersonGroupId}", System.Uri.EscapeDataString(largePersonGroupId));
	0	513		_url = _url.Replace("{personId}", System.Uri.EscapeDataString(Rest.Serialization.SafeJsonConvert.SerializeOb
		514		// Create HTTP transport objects
	0	515		var _httpRequest = new HttpRequestMessage();
	0	516		HttpResponseMessage _httpResponse = null;
	0	517		_httpRequest.Method = new HttpMethod("DELETE");
	0	518		_httpRequest.RequestUri = new System.Uri(_url);
		519		// Set Headers
		520
		521
	0	522		if (customHeaders != null)
		523		{
	0	524		foreach(var _header in customHeaders)
		525		{
	0	526		if (_httpRequest.Headers.Contains(_header.Key))
		527		{
	0	528		_httpRequest.Headers.Remove(_header.Key);
		529		}
	0	530		_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
		531		}
		532		}
		533
		534		// Serialize Request
	0	535		string _requestContent = null;
		536		// Set Credentials
	0	537		if (Client.Credentials != null)
		538		{
	0	539		cancellationToken.ThrowIfCancellationRequested();
	0	540		await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
		541		}
		542		// Send Request
	0	543		if (_shouldTrace)
		544		{
	0	545		ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
		546		}
	0	547		cancellationToken.ThrowIfCancellationRequested();
	0	548		_httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
	0	549		if (_shouldTrace)
		550		{
	0	551		ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
		552		}
	0	553		HttpStatusCode _statusCode = _httpResponse.StatusCode;
	0	554		cancellationToken.ThrowIfCancellationRequested();
	0	555		string _responseContent = null;
	0	556		if ((int)_statusCode != 200)
		557		{
	0	558		var ex = new APIErrorException(string.Format("Operation returned an invalid status code '{0}'", _statusC
		559		try
		560		{
	0	561		_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
	0	562		APIError _errorBody =  Rest.Serialization.SafeJsonConvert.DeserializeObject<APIError>(_responseConte
	0	563		if (_errorBody != null)
		564		{
	0	565		ex.Body = _errorBody;
		566		}
	0	567		}
	0	568		catch (JsonException)
		569		{
		570		// Ignore the exception
	0	571		}
	0	572		ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
	0	573		ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
	0	574		if (_shouldTrace)
		575		{
	0	576		ServiceClientTracing.Error(_invocationId, ex);
		577		}
	0	578		_httpRequest.Dispose();
	0	579		if (_httpResponse != null)
		580		{
	0	581		_httpResponse.Dispose();
		582		}
	0	583		throw ex;
		584		}
		585		// Create Result
	0	586		var _result = new HttpOperationResponse();
	0	587		_result.Request = _httpRequest;
	0	588		_result.Response = _httpResponse;
	0	589		if (_shouldTrace)
		590		{
	0	591		ServiceClientTracing.Exit(_invocationId, _result);
		592		}
	0	593		return _result;
	0	594		}
		595
		596		/// <summary>
		597		/// Retrieve a person's name and userData, and the persisted faceIds
		598		/// representing the registered person face feature.
		599		/// </summary>
		600		/// <param name='largePersonGroupId'>
		601		/// Id referencing a particular large person group.
		602		/// </param>
		603		/// <param name='personId'>
		604		/// Id referencing a particular person.
		605		/// </param>
		606		/// <param name='customHeaders'>
		607		/// Headers that will be added to request.
		608		/// </param>
		609		/// <param name='cancellationToken'>
		610		/// The cancellation token.
		611		/// </param>
		612		/// <exception cref="APIErrorException">
		613		/// Thrown when the operation returned an invalid status code
		614		/// </exception>
		615		/// <exception cref="SerializationException">
		616		/// Thrown when unable to deserialize the response
		617		/// </exception>
		618		/// <exception cref="ValidationException">
		619		/// Thrown when a required parameter is null
		620		/// </exception>
		621		/// <exception cref="System.ArgumentNullException">
		622		/// Thrown when a required parameter is null
		623		/// </exception>
		624		/// <return>
		625		/// A response object containing the response body and response headers.
		626		/// </return>
		627		public async Task<HttpOperationResponse<Person>> GetWithHttpMessagesAsync(string largePersonGroupId, System.Guid
		628		{
	2	629		if (Client.Endpoint == null)
		630		{
	0	631		throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.Endpoint");
		632		}
	2	633		if (largePersonGroupId == null)
		634		{
	0	635		throw new ValidationException(ValidationRules.CannotBeNull, "largePersonGroupId");
		636		}
	2	637		if (largePersonGroupId != null)
		638		{
	2	639		if (largePersonGroupId.Length > 64)
		640		{
	0	641		throw new ValidationException(ValidationRules.MaxLength, "largePersonGroupId", 64);
		642		}
	2	643		if (!System.Text.RegularExpressions.Regex.IsMatch(largePersonGroupId, "^[a-z0-9-_]+$"))
		644		{
	0	645		throw new ValidationException(ValidationRules.Pattern, "largePersonGroupId", "^[a-z0-9-_]+$");
		646		}
		647		}
		648		// Tracing
	2	649		bool _shouldTrace = ServiceClientTracing.IsEnabled;
	2	650		string _invocationId = null;
	2	651		if (_shouldTrace)
		652		{
	0	653		_invocationId = ServiceClientTracing.NextInvocationId.ToString();
	0	654		Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
	0	655		tracingParameters.Add("largePersonGroupId", largePersonGroupId);
	0	656		tracingParameters.Add("personId", personId);
	0	657		tracingParameters.Add("cancellationToken", cancellationToken);
	0	658		ServiceClientTracing.Enter(_invocationId, this, "Get", tracingParameters);
		659		}
		660		// Construct URL
	2	661		var _baseUrl = Client.BaseUri;
	2	662		var _url = _baseUrl + (_baseUrl.EndsWith("/") ? "" : "/") + "largepersongroups/{largePersonGroupId}/persons/
	2	663		_url = _url.Replace("{Endpoint}", Client.Endpoint);
	2	664		_url = _url.Replace("{largePersonGroupId}", System.Uri.EscapeDataString(largePersonGroupId));
	2	665		_url = _url.Replace("{personId}", System.Uri.EscapeDataString(Rest.Serialization.SafeJsonConvert.SerializeOb
		666		// Create HTTP transport objects
	2	667		var _httpRequest = new HttpRequestMessage();
	2	668		HttpResponseMessage _httpResponse = null;
	2	669		_httpRequest.Method = new HttpMethod("GET");
	2	670		_httpRequest.RequestUri = new System.Uri(_url);
		671		// Set Headers
		672
		673
	2	674		if (customHeaders != null)
		675		{
	0	676		foreach(var _header in customHeaders)
		677		{
	0	678		if (_httpRequest.Headers.Contains(_header.Key))
		679		{
	0	680		_httpRequest.Headers.Remove(_header.Key);
		681		}
	0	682		_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
		683		}
		684		}
		685
		686		// Serialize Request
	2	687		string _requestContent = null;
		688		// Set Credentials
	2	689		if (Client.Credentials != null)
		690		{
	2	691		cancellationToken.ThrowIfCancellationRequested();
	2	692		await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
		693		}
		694		// Send Request
	2	695		if (_shouldTrace)
		696		{
	0	697		ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
		698		}
	2	699		cancellationToken.ThrowIfCancellationRequested();
	2	700		_httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
	2	701		if (_shouldTrace)
		702		{
	0	703		ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
		704		}
	2	705		HttpStatusCode _statusCode = _httpResponse.StatusCode;
	2	706		cancellationToken.ThrowIfCancellationRequested();
	2	707		string _responseContent = null;
	2	708		if ((int)_statusCode != 200)
		709		{
	0	710		var ex = new APIErrorException(string.Format("Operation returned an invalid status code '{0}'", _statusC
		711		try
		712		{
	0	713		_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
	0	714		APIError _errorBody =  Rest.Serialization.SafeJsonConvert.DeserializeObject<APIError>(_responseConte
	0	715		if (_errorBody != null)
		716		{
	0	717		ex.Body = _errorBody;
		718		}
	0	719		}
	0	720		catch (JsonException)
		721		{
		722		// Ignore the exception
	0	723		}
	0	724		ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
	0	725		ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
	0	726		if (_shouldTrace)
		727		{
	0	728		ServiceClientTracing.Error(_invocationId, ex);
		729		}
	0	730		_httpRequest.Dispose();
	0	731		if (_httpResponse != null)
		732		{
	0	733		_httpResponse.Dispose();
		734		}
	0	735		throw ex;
		736		}
		737		// Create Result
	2	738		var _result = new HttpOperationResponse<Person>();
	2	739		_result.Request = _httpRequest;
	2	740		_result.Response = _httpResponse;
		741		// Deserialize Response
	2	742		if ((int)_statusCode == 200)
		743		{
	2	744		_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
		745		try
		746		{
	2	747		_result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject<Person>(_responseContent, Client
	2	748		}
	0	749		catch (JsonException ex)
		750		{
	0	751		_httpRequest.Dispose();
	0	752		if (_httpResponse != null)
		753		{
	0	754		_httpResponse.Dispose();
		755		}
	0	756		throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
		757		}
		758		}
	2	759		if (_shouldTrace)
		760		{
	0	761		ServiceClientTracing.Exit(_invocationId, _result);
		762		}
	2	763		return _result;
	2	764		}
		765
		766		/// <summary>
		767		/// Update name or userData of a person.
		768		/// </summary>
		769		/// <param name='largePersonGroupId'>
		770		/// Id referencing a particular large person group.
		771		/// </param>
		772		/// <param name='personId'>
		773		/// Id referencing a particular person.
		774		/// </param>
		775		/// <param name='name'>
		776		/// User defined name, maximum length is 128.
		777		/// </param>
		778		/// <param name='userData'>
		779		/// User specified data. Length should not exceed 16KB.
		780		/// </param>
		781		/// <param name='customHeaders'>
		782		/// Headers that will be added to request.
		783		/// </param>
		784		/// <param name='cancellationToken'>
		785		/// The cancellation token.
		786		/// </param>
		787		/// <exception cref="APIErrorException">
		788		/// Thrown when the operation returned an invalid status code
		789		/// </exception>
		790		/// <exception cref="ValidationException">
		791		/// Thrown when a required parameter is null
		792		/// </exception>
		793		/// <exception cref="System.ArgumentNullException">
		794		/// Thrown when a required parameter is null
		795		/// </exception>
		796		/// <return>
		797		/// A response object containing the response body and response headers.
		798		/// </return>
		799		public async Task<HttpOperationResponse> UpdateWithHttpMessagesAsync(string largePersonGroupId, System.Guid pers
		800		{
	0	801		if (Client.Endpoint == null)
		802		{
	0	803		throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.Endpoint");
		804		}
	0	805		if (largePersonGroupId == null)
		806		{
	0	807		throw new ValidationException(ValidationRules.CannotBeNull, "largePersonGroupId");
		808		}
	0	809		if (largePersonGroupId != null)
		810		{
	0	811		if (largePersonGroupId.Length > 64)
		812		{
	0	813		throw new ValidationException(ValidationRules.MaxLength, "largePersonGroupId", 64);
		814		}
	0	815		if (!System.Text.RegularExpressions.Regex.IsMatch(largePersonGroupId, "^[a-z0-9-_]+$"))
		816		{
	0	817		throw new ValidationException(ValidationRules.Pattern, "largePersonGroupId", "^[a-z0-9-_]+$");
		818		}
		819		}
	0	820		if (name != null)
		821		{
	0	822		if (name.Length > 128)
		823		{
	0	824		throw new ValidationException(ValidationRules.MaxLength, "name", 128);
		825		}
		826		}
	0	827		if (userData != null)
		828		{
	0	829		if (userData.Length > 16384)
		830		{
	0	831		throw new ValidationException(ValidationRules.MaxLength, "userData", 16384);
		832		}
		833		}
	0	834		NameAndUserDataContract body = new NameAndUserDataContract();
	0	835		if (name != null || userData != null)
		836		{
	0	837		body.Name = name;
	0	838		body.UserData = userData;
		839		}
		840		// Tracing
	0	841		bool _shouldTrace = ServiceClientTracing.IsEnabled;
	0	842		string _invocationId = null;
	0	843		if (_shouldTrace)
		844		{
	0	845		_invocationId = ServiceClientTracing.NextInvocationId.ToString();
	0	846		Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
	0	847		tracingParameters.Add("largePersonGroupId", largePersonGroupId);
	0	848		tracingParameters.Add("personId", personId);
	0	849		tracingParameters.Add("body", body);
	0	850		tracingParameters.Add("cancellationToken", cancellationToken);
	0	851		ServiceClientTracing.Enter(_invocationId, this, "Update", tracingParameters);
		852		}
		853		// Construct URL
	0	854		var _baseUrl = Client.BaseUri;
	0	855		var _url = _baseUrl + (_baseUrl.EndsWith("/") ? "" : "/") + "largepersongroups/{largePersonGroupId}/persons/
	0	856		_url = _url.Replace("{Endpoint}", Client.Endpoint);
	0	857		_url = _url.Replace("{largePersonGroupId}", System.Uri.EscapeDataString(largePersonGroupId));
	0	858		_url = _url.Replace("{personId}", System.Uri.EscapeDataString(Rest.Serialization.SafeJsonConvert.SerializeOb
		859		// Create HTTP transport objects
	0	860		var _httpRequest = new HttpRequestMessage();
	0	861		HttpResponseMessage _httpResponse = null;
	0	862		_httpRequest.Method = new HttpMethod("PATCH");
	0	863		_httpRequest.RequestUri = new System.Uri(_url);
		864		// Set Headers
		865
		866
	0	867		if (customHeaders != null)
		868		{
	0	869		foreach(var _header in customHeaders)
		870		{
	0	871		if (_httpRequest.Headers.Contains(_header.Key))
		872		{
	0	873		_httpRequest.Headers.Remove(_header.Key);
		874		}
	0	875		_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
		876		}
		877		}
		878
		879		// Serialize Request
	0	880		string _requestContent = null;
	0	881		if(body != null)
		882		{
	0	883		_requestContent = Rest.Serialization.SafeJsonConvert.SerializeObject(body, Client.SerializationSettings)
	0	884		_httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8);
	0	885		_httpRequest.Content.Headers.ContentType =System.Net.Http.Headers.MediaTypeHeaderValue.Parse("applicatio
		886		}
		887		// Set Credentials
	0	888		if (Client.Credentials != null)
		889		{
	0	890		cancellationToken.ThrowIfCancellationRequested();
	0	891		await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
		892		}
		893		// Send Request
	0	894		if (_shouldTrace)
		895		{
	0	896		ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
		897		}
	0	898		cancellationToken.ThrowIfCancellationRequested();
	0	899		_httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
	0	900		if (_shouldTrace)
		901		{
	0	902		ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
		903		}
	0	904		HttpStatusCode _statusCode = _httpResponse.StatusCode;
	0	905		cancellationToken.ThrowIfCancellationRequested();
	0	906		string _responseContent = null;
	0	907		if ((int)_statusCode != 200)
		908		{
	0	909		var ex = new APIErrorException(string.Format("Operation returned an invalid status code '{0}'", _statusC
		910		try
		911		{
	0	912		_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
	0	913		APIError _errorBody =  Rest.Serialization.SafeJsonConvert.DeserializeObject<APIError>(_responseConte
	0	914		if (_errorBody != null)
		915		{
	0	916		ex.Body = _errorBody;
		917		}
	0	918		}
	0	919		catch (JsonException)
		920		{
		921		// Ignore the exception
	0	922		}
	0	923		ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
	0	924		ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
	0	925		if (_shouldTrace)
		926		{
	0	927		ServiceClientTracing.Error(_invocationId, ex);
		928		}
	0	929		_httpRequest.Dispose();
	0	930		if (_httpResponse != null)
		931		{
	0	932		_httpResponse.Dispose();
		933		}
	0	934		throw ex;
		935		}
		936		// Create Result
	0	937		var _result = new HttpOperationResponse();
	0	938		_result.Request = _httpRequest;
	0	939		_result.Response = _httpResponse;
	0	940		if (_shouldTrace)
		941		{
	0	942		ServiceClientTracing.Exit(_invocationId, _result);
		943		}
	0	944		return _result;
	0	945		}
		946
		947		/// <summary>
		948		/// Delete a face from a person in a large person group by specified
		949		/// largePersonGroupId, personId and persistedFaceId.
		950		/// &lt;br /&gt; Adding/deleting faces to/from a same person will be processed
		951		/// sequentially. Adding/deleting faces to/from different persons are processed
		952		/// in parallel.
		953		/// </summary>
		954		/// <param name='largePersonGroupId'>
		955		/// Id referencing a particular large person group.
		956		/// </param>
		957		/// <param name='personId'>
		958		/// Id referencing a particular person.
		959		/// </param>
		960		/// <param name='persistedFaceId'>
		961		/// Id referencing a particular persistedFaceId of an existing face.
		962		/// </param>
		963		/// <param name='customHeaders'>
		964		/// Headers that will be added to request.
		965		/// </param>
		966		/// <param name='cancellationToken'>
		967		/// The cancellation token.
		968		/// </param>
		969		/// <exception cref="APIErrorException">
		970		/// Thrown when the operation returned an invalid status code
		971		/// </exception>
		972		/// <exception cref="ValidationException">
		973		/// Thrown when a required parameter is null
		974		/// </exception>
		975		/// <exception cref="System.ArgumentNullException">
		976		/// Thrown when a required parameter is null
		977		/// </exception>
		978		/// <return>
		979		/// A response object containing the response body and response headers.
		980		/// </return>
		981		public async Task<HttpOperationResponse> DeleteFaceWithHttpMessagesAsync(string largePersonGroupId, System.Guid
		982		{
	0	983		if (Client.Endpoint == null)
		984		{
	0	985		throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.Endpoint");
		986		}
	0	987		if (largePersonGroupId == null)
		988		{
	0	989		throw new ValidationException(ValidationRules.CannotBeNull, "largePersonGroupId");
		990		}
	0	991		if (largePersonGroupId != null)
		992		{
	0	993		if (largePersonGroupId.Length > 64)
		994		{
	0	995		throw new ValidationException(ValidationRules.MaxLength, "largePersonGroupId", 64);
		996		}
	0	997		if (!System.Text.RegularExpressions.Regex.IsMatch(largePersonGroupId, "^[a-z0-9-_]+$"))
		998		{
	0	999		throw new ValidationException(ValidationRules.Pattern, "largePersonGroupId", "^[a-z0-9-_]+$");
		1000		}
		1001		}
		1002		// Tracing
	0	1003		bool _shouldTrace = ServiceClientTracing.IsEnabled;
	0	1004		string _invocationId = null;
	0	1005		if (_shouldTrace)
		1006		{
	0	1007		_invocationId = ServiceClientTracing.NextInvocationId.ToString();
	0	1008		Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
	0	1009		tracingParameters.Add("largePersonGroupId", largePersonGroupId);
	0	1010		tracingParameters.Add("personId", personId);
	0	1011		tracingParameters.Add("persistedFaceId", persistedFaceId);
	0	1012		tracingParameters.Add("cancellationToken", cancellationToken);
	0	1013		ServiceClientTracing.Enter(_invocationId, this, "DeleteFace", tracingParameters);
		1014		}
		1015		// Construct URL
	0	1016		var _baseUrl = Client.BaseUri;
	0	1017		var _url = _baseUrl + (_baseUrl.EndsWith("/") ? "" : "/") + "largepersongroups/{largePersonGroupId}/persons/
	0	1018		_url = _url.Replace("{Endpoint}", Client.Endpoint);
	0	1019		_url = _url.Replace("{largePersonGroupId}", System.Uri.EscapeDataString(largePersonGroupId));
	0	1020		_url = _url.Replace("{personId}", System.Uri.EscapeDataString(Rest.Serialization.SafeJsonConvert.SerializeOb
	0	1021		_url = _url.Replace("{persistedFaceId}", System.Uri.EscapeDataString(Rest.Serialization.SafeJsonConvert.Seri
		1022		// Create HTTP transport objects
	0	1023		var _httpRequest = new HttpRequestMessage();
	0	1024		HttpResponseMessage _httpResponse = null;
	0	1025		_httpRequest.Method = new HttpMethod("DELETE");
	0	1026		_httpRequest.RequestUri = new System.Uri(_url);
		1027		// Set Headers
		1028
		1029
	0	1030		if (customHeaders != null)
		1031		{
	0	1032		foreach(var _header in customHeaders)
		1033		{
	0	1034		if (_httpRequest.Headers.Contains(_header.Key))
		1035		{
	0	1036		_httpRequest.Headers.Remove(_header.Key);
		1037		}
	0	1038		_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
		1039		}
		1040		}
		1041
		1042		// Serialize Request
	0	1043		string _requestContent = null;
		1044		// Set Credentials
	0	1045		if (Client.Credentials != null)
		1046		{
	0	1047		cancellationToken.ThrowIfCancellationRequested();
	0	1048		await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
		1049		}
		1050		// Send Request
	0	1051		if (_shouldTrace)
		1052		{
	0	1053		ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
		1054		}
	0	1055		cancellationToken.ThrowIfCancellationRequested();
	0	1056		_httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
	0	1057		if (_shouldTrace)
		1058		{
	0	1059		ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
		1060		}
	0	1061		HttpStatusCode _statusCode = _httpResponse.StatusCode;
	0	1062		cancellationToken.ThrowIfCancellationRequested();
	0	1063		string _responseContent = null;
	0	1064		if ((int)_statusCode != 200)
		1065		{
	0	1066		var ex = new APIErrorException(string.Format("Operation returned an invalid status code '{0}'", _statusC
		1067		try
		1068		{
	0	1069		_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
	0	1070		APIError _errorBody =  Rest.Serialization.SafeJsonConvert.DeserializeObject<APIError>(_responseConte
	0	1071		if (_errorBody != null)
		1072		{
	0	1073		ex.Body = _errorBody;
		1074		}
	0	1075		}
	0	1076		catch (JsonException)
		1077		{
		1078		// Ignore the exception
	0	1079		}
	0	1080		ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
	0	1081		ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
	0	1082		if (_shouldTrace)
		1083		{
	0	1084		ServiceClientTracing.Error(_invocationId, ex);
		1085		}
	0	1086		_httpRequest.Dispose();
	0	1087		if (_httpResponse != null)
		1088		{
	0	1089		_httpResponse.Dispose();
		1090		}
	0	1091		throw ex;
		1092		}
		1093		// Create Result
	0	1094		var _result = new HttpOperationResponse();
	0	1095		_result.Request = _httpRequest;
	0	1096		_result.Response = _httpResponse;
	0	1097		if (_shouldTrace)
		1098		{
	0	1099		ServiceClientTracing.Exit(_invocationId, _result);
		1100		}
	0	1101		return _result;
	0	1102		}
		1103
		1104		/// <summary>
		1105		/// Retrieve information about a persisted face (specified by persistedFaceId,
		1106		/// personId and its belonging largePersonGroupId).
		1107		/// </summary>
		1108		/// <param name='largePersonGroupId'>
		1109		/// Id referencing a particular large person group.
		1110		/// </param>
		1111		/// <param name='personId'>
		1112		/// Id referencing a particular person.
		1113		/// </param>
		1114		/// <param name='persistedFaceId'>
		1115		/// Id referencing a particular persistedFaceId of an existing face.
		1116		/// </param>
		1117		/// <param name='customHeaders'>
		1118		/// Headers that will be added to request.
		1119		/// </param>
		1120		/// <param name='cancellationToken'>
		1121		/// The cancellation token.
		1122		/// </param>
		1123		/// <exception cref="APIErrorException">
		1124		/// Thrown when the operation returned an invalid status code
		1125		/// </exception>
		1126		/// <exception cref="SerializationException">
		1127		/// Thrown when unable to deserialize the response
		1128		/// </exception>
		1129		/// <exception cref="ValidationException">
		1130		/// Thrown when a required parameter is null
		1131		/// </exception>
		1132		/// <exception cref="System.ArgumentNullException">
		1133		/// Thrown when a required parameter is null
		1134		/// </exception>
		1135		/// <return>
		1136		/// A response object containing the response body and response headers.
		1137		/// </return>
		1138		public async Task<HttpOperationResponse<PersistedFace>> GetFaceWithHttpMessagesAsync(string largePersonGroupId,
		1139		{
	2	1140		if (Client.Endpoint == null)
		1141		{
	0	1142		throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.Endpoint");
		1143		}
	2	1144		if (largePersonGroupId == null)
		1145		{
	0	1146		throw new ValidationException(ValidationRules.CannotBeNull, "largePersonGroupId");
		1147		}
	2	1148		if (largePersonGroupId != null)
		1149		{
	2	1150		if (largePersonGroupId.Length > 64)
		1151		{
	0	1152		throw new ValidationException(ValidationRules.MaxLength, "largePersonGroupId", 64);
		1153		}
	2	1154		if (!System.Text.RegularExpressions.Regex.IsMatch(largePersonGroupId, "^[a-z0-9-_]+$"))
		1155		{
	0	1156		throw new ValidationException(ValidationRules.Pattern, "largePersonGroupId", "^[a-z0-9-_]+$");
		1157		}
		1158		}
		1159		// Tracing
	2	1160		bool _shouldTrace = ServiceClientTracing.IsEnabled;
	2	1161		string _invocationId = null;
	2	1162		if (_shouldTrace)
		1163		{
	0	1164		_invocationId = ServiceClientTracing.NextInvocationId.ToString();
	0	1165		Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
	0	1166		tracingParameters.Add("largePersonGroupId", largePersonGroupId);
	0	1167		tracingParameters.Add("personId", personId);
	0	1168		tracingParameters.Add("persistedFaceId", persistedFaceId);
	0	1169		tracingParameters.Add("cancellationToken", cancellationToken);
	0	1170		ServiceClientTracing.Enter(_invocationId, this, "GetFace", tracingParameters);
		1171		}
		1172		// Construct URL
	2	1173		var _baseUrl = Client.BaseUri;
	2	1174		var _url = _baseUrl + (_baseUrl.EndsWith("/") ? "" : "/") + "largepersongroups/{largePersonGroupId}/persons/
	2	1175		_url = _url.Replace("{Endpoint}", Client.Endpoint);
	2	1176		_url = _url.Replace("{largePersonGroupId}", System.Uri.EscapeDataString(largePersonGroupId));
	2	1177		_url = _url.Replace("{personId}", System.Uri.EscapeDataString(Rest.Serialization.SafeJsonConvert.SerializeOb
	2	1178		_url = _url.Replace("{persistedFaceId}", System.Uri.EscapeDataString(Rest.Serialization.SafeJsonConvert.Seri
		1179		// Create HTTP transport objects
	2	1180		var _httpRequest = new HttpRequestMessage();
	2	1181		HttpResponseMessage _httpResponse = null;
	2	1182		_httpRequest.Method = new HttpMethod("GET");
	2	1183		_httpRequest.RequestUri = new System.Uri(_url);
		1184		// Set Headers
		1185
		1186
	2	1187		if (customHeaders != null)
		1188		{
	0	1189		foreach(var _header in customHeaders)
		1190		{
	0	1191		if (_httpRequest.Headers.Contains(_header.Key))
		1192		{
	0	1193		_httpRequest.Headers.Remove(_header.Key);
		1194		}
	0	1195		_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
		1196		}
		1197		}
		1198
		1199		// Serialize Request
	2	1200		string _requestContent = null;
		1201		// Set Credentials
	2	1202		if (Client.Credentials != null)
		1203		{
	2	1204		cancellationToken.ThrowIfCancellationRequested();
	2	1205		await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
		1206		}
		1207		// Send Request
	2	1208		if (_shouldTrace)
		1209		{
	0	1210		ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
		1211		}
	2	1212		cancellationToken.ThrowIfCancellationRequested();
	2	1213		_httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
	2	1214		if (_shouldTrace)
		1215		{
	0	1216		ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
		1217		}
	2	1218		HttpStatusCode _statusCode = _httpResponse.StatusCode;
	2	1219		cancellationToken.ThrowIfCancellationRequested();
	2	1220		string _responseContent = null;
	2	1221		if ((int)_statusCode != 200)
		1222		{
	0	1223		var ex = new APIErrorException(string.Format("Operation returned an invalid status code '{0}'", _statusC
		1224		try
		1225		{
	0	1226		_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
	0	1227		APIError _errorBody =  Rest.Serialization.SafeJsonConvert.DeserializeObject<APIError>(_responseConte
	0	1228		if (_errorBody != null)
		1229		{
	0	1230		ex.Body = _errorBody;
		1231		}
	0	1232		}
	0	1233		catch (JsonException)
		1234		{
		1235		// Ignore the exception
	0	1236		}
	0	1237		ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
	0	1238		ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
	0	1239		if (_shouldTrace)
		1240		{
	0	1241		ServiceClientTracing.Error(_invocationId, ex);
		1242		}
	0	1243		_httpRequest.Dispose();
	0	1244		if (_httpResponse != null)
		1245		{
	0	1246		_httpResponse.Dispose();
		1247		}
	0	1248		throw ex;
		1249		}
		1250		// Create Result
	2	1251		var _result = new HttpOperationResponse<PersistedFace>();
	2	1252		_result.Request = _httpRequest;
	2	1253		_result.Response = _httpResponse;
		1254		// Deserialize Response
	2	1255		if ((int)_statusCode == 200)
		1256		{
	2	1257		_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
		1258		try
		1259		{
	2	1260		_result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject<PersistedFace>(_responseContent,
	2	1261		}
	0	1262		catch (JsonException ex)
		1263		{
	0	1264		_httpRequest.Dispose();
	0	1265		if (_httpResponse != null)
		1266		{
	0	1267		_httpResponse.Dispose();
		1268		}
	0	1269		throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
		1270		}
		1271		}
	2	1272		if (_shouldTrace)
		1273		{
	0	1274		ServiceClientTracing.Exit(_invocationId, _result);
		1275		}
	2	1276		return _result;
	2	1277		}
		1278
		1279		/// <summary>
		1280		/// Update a person persisted face's userData field.
		1281		/// </summary>
		1282		/// <param name='largePersonGroupId'>
		1283		/// Id referencing a particular large person group.
		1284		/// </param>
		1285		/// <param name='personId'>
		1286		/// Id referencing a particular person.
		1287		/// </param>
		1288		/// <param name='persistedFaceId'>
		1289		/// Id referencing a particular persistedFaceId of an existing face.
		1290		/// </param>
		1291		/// <param name='userData'>
		1292		/// User-provided data attached to the face. The size limit is 1KB.
		1293		/// </param>
		1294		/// <param name='customHeaders'>
		1295		/// Headers that will be added to request.
		1296		/// </param>
		1297		/// <param name='cancellationToken'>
		1298		/// The cancellation token.
		1299		/// </param>
		1300		/// <exception cref="APIErrorException">
		1301		/// Thrown when the operation returned an invalid status code
		1302		/// </exception>
		1303		/// <exception cref="ValidationException">
		1304		/// Thrown when a required parameter is null
		1305		/// </exception>
		1306		/// <exception cref="System.ArgumentNullException">
		1307		/// Thrown when a required parameter is null
		1308		/// </exception>
		1309		/// <return>
		1310		/// A response object containing the response body and response headers.
		1311		/// </return>
		1312		public async Task<HttpOperationResponse> UpdateFaceWithHttpMessagesAsync(string largePersonGroupId, System.Guid
		1313		{
	0	1314		if (Client.Endpoint == null)
		1315		{
	0	1316		throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.Endpoint");
		1317		}
	0	1318		if (largePersonGroupId == null)
		1319		{
	0	1320		throw new ValidationException(ValidationRules.CannotBeNull, "largePersonGroupId");
		1321		}
	0	1322		if (largePersonGroupId != null)
		1323		{
	0	1324		if (largePersonGroupId.Length > 64)
		1325		{
	0	1326		throw new ValidationException(ValidationRules.MaxLength, "largePersonGroupId", 64);
		1327		}
	0	1328		if (!System.Text.RegularExpressions.Regex.IsMatch(largePersonGroupId, "^[a-z0-9-_]+$"))
		1329		{
	0	1330		throw new ValidationException(ValidationRules.Pattern, "largePersonGroupId", "^[a-z0-9-_]+$");
		1331		}
		1332		}
	0	1333		if (userData != null)
		1334		{
	0	1335		if (userData.Length > 1024)
		1336		{
	0	1337		throw new ValidationException(ValidationRules.MaxLength, "userData", 1024);
		1338		}
		1339		}
	0	1340		UpdateFaceRequest body = new UpdateFaceRequest();
	0	1341		if (userData != null)
		1342		{
	0	1343		body.UserData = userData;
		1344		}
		1345		// Tracing
	0	1346		bool _shouldTrace = ServiceClientTracing.IsEnabled;
	0	1347		string _invocationId = null;
	0	1348		if (_shouldTrace)
		1349		{
	0	1350		_invocationId = ServiceClientTracing.NextInvocationId.ToString();
	0	1351		Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
	0	1352		tracingParameters.Add("largePersonGroupId", largePersonGroupId);
	0	1353		tracingParameters.Add("personId", personId);
	0	1354		tracingParameters.Add("persistedFaceId", persistedFaceId);
	0	1355		tracingParameters.Add("body", body);
	0	1356		tracingParameters.Add("cancellationToken", cancellationToken);
	0	1357		ServiceClientTracing.Enter(_invocationId, this, "UpdateFace", tracingParameters);
		1358		}
		1359		// Construct URL
	0	1360		var _baseUrl = Client.BaseUri;
	0	1361		var _url = _baseUrl + (_baseUrl.EndsWith("/") ? "" : "/") + "largepersongroups/{largePersonGroupId}/persons/
	0	1362		_url = _url.Replace("{Endpoint}", Client.Endpoint);
	0	1363		_url = _url.Replace("{largePersonGroupId}", System.Uri.EscapeDataString(largePersonGroupId));
	0	1364		_url = _url.Replace("{personId}", System.Uri.EscapeDataString(Rest.Serialization.SafeJsonConvert.SerializeOb
	0	1365		_url = _url.Replace("{persistedFaceId}", System.Uri.EscapeDataString(Rest.Serialization.SafeJsonConvert.Seri
		1366		// Create HTTP transport objects
	0	1367		var _httpRequest = new HttpRequestMessage();
	0	1368		HttpResponseMessage _httpResponse = null;
	0	1369		_httpRequest.Method = new HttpMethod("PATCH");
	0	1370		_httpRequest.RequestUri = new System.Uri(_url);
		1371		// Set Headers
		1372
		1373
	0	1374		if (customHeaders != null)
		1375		{
	0	1376		foreach(var _header in customHeaders)
		1377		{
	0	1378		if (_httpRequest.Headers.Contains(_header.Key))
		1379		{
	0	1380		_httpRequest.Headers.Remove(_header.Key);
		1381		}
	0	1382		_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
		1383		}
		1384		}
		1385
		1386		// Serialize Request
	0	1387		string _requestContent = null;
	0	1388		if(body != null)
		1389		{
	0	1390		_requestContent = Rest.Serialization.SafeJsonConvert.SerializeObject(body, Client.SerializationSettings)
	0	1391		_httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8);
	0	1392		_httpRequest.Content.Headers.ContentType =System.Net.Http.Headers.MediaTypeHeaderValue.Parse("applicatio
		1393		}
		1394		// Set Credentials
	0	1395		if (Client.Credentials != null)
		1396		{
	0	1397		cancellationToken.ThrowIfCancellationRequested();
	0	1398		await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
		1399		}
		1400		// Send Request
	0	1401		if (_shouldTrace)
		1402		{
	0	1403		ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
		1404		}
	0	1405		cancellationToken.ThrowIfCancellationRequested();
	0	1406		_httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
	0	1407		if (_shouldTrace)
		1408		{
	0	1409		ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
		1410		}
	0	1411		HttpStatusCode _statusCode = _httpResponse.StatusCode;
	0	1412		cancellationToken.ThrowIfCancellationRequested();
	0	1413		string _responseContent = null;
	0	1414		if ((int)_statusCode != 200)
		1415		{
	0	1416		var ex = new APIErrorException(string.Format("Operation returned an invalid status code '{0}'", _statusC
		1417		try
		1418		{
	0	1419		_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
	0	1420		APIError _errorBody =  Rest.Serialization.SafeJsonConvert.DeserializeObject<APIError>(_responseConte
	0	1421		if (_errorBody != null)
		1422		{
	0	1423		ex.Body = _errorBody;
		1424		}
	0	1425		}
	0	1426		catch (JsonException)
		1427		{
		1428		// Ignore the exception
	0	1429		}
	0	1430		ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
	0	1431		ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
	0	1432		if (_shouldTrace)
		1433		{
	0	1434		ServiceClientTracing.Error(_invocationId, ex);
		1435		}
	0	1436		_httpRequest.Dispose();
	0	1437		if (_httpResponse != null)
		1438		{
	0	1439		_httpResponse.Dispose();
		1440		}
	0	1441		throw ex;
		1442		}
		1443		// Create Result
	0	1444		var _result = new HttpOperationResponse();
	0	1445		_result.Request = _httpRequest;
	0	1446		_result.Response = _httpResponse;
	0	1447		if (_shouldTrace)
		1448		{
	0	1449		ServiceClientTracing.Exit(_invocationId, _result);
		1450		}
	0	1451		return _result;
	0	1452		}
		1453
		1454		/// <summary>
		1455		/// Add a face to a person into a large person group for face identification or
		1456		/// verification. To deal with an image contains multiple faces, input face can
		1457		/// be specified as an image with a targetFace rectangle. It returns a
		1458		/// persistedFaceId representing the added face. No image will be stored. Only
		1459		/// the extracted face feature will be stored on server until [LargePersonGroup
		1460		/// PersonFace -
		1461		/// Delete](/docs/services/563879b61984550e40cbbe8d/operations/599ae2966ac60f11b48b5aa3),
		1462		/// [LargePersonGroup Person -
		1463		/// Delete](/docs/services/563879b61984550e40cbbe8d/operations/599ade5c6ac60f11b48b5aa2)
		1464		/// or [LargePersonGroup -
		1465		/// Delete](/docs/services/563879b61984550e40cbbe8d/operations/599adc216ac60f11b48b5a9f)
		1466		/// is called.
		1467		/// &lt;br /&gt; Note persistedFaceId is different from faceId generated by
		1468		/// [Face -
		1469		/// Detect](/docs/services/563879b61984550e40cbbe8d/operations/563879b61984550f30395236).
		1470		/// * Higher face image quality means better recognition precision. Please
		1471		/// consider high-quality faces: frontal, clear, and face size is 200x200
		1472		/// pixels (100 pixels between eyes) or bigger.
		1473		/// * Each person entry can hold up to 248 faces.
		1474		/// * JPEG, PNG, GIF (the first frame), and BMP format are supported. The
		1475		/// allowed image file size is from 1KB to 6MB.
		1476		/// * "targetFace" rectangle should contain one face. Zero or multiple faces
		1477		/// will be regarded as an error. If the provided "targetFace" rectangle is not
		1478		/// returned from [Face -
		1479		/// Detect](/docs/services/563879b61984550e40cbbe8d/operations/563879b61984550f30395236),
		1480		/// there’s no guarantee to detect and add the face successfully.
		1481		/// * Out of detectable face size (36x36 - 4096x4096 pixels), large head-pose,
		1482		/// or large occlusions will cause failures.
		1483		/// * Adding/deleting faces to/from a same person will be processed
		1484		/// sequentially. Adding/deleting faces to/from different persons are processed
		1485		/// in parallel.
		1486		/// * The minimum detectable face size is 36x36 pixels in an image no larger
		1487		/// than 1920x1080 pixels. Images with dimensions higher than 1920x1080 pixels
		1488		/// will need a proportionally larger minimum face size.
		1489		/// * Different 'detectionModel' values can be provided. To use and compare
		1490		/// different detection models, please refer to [How to specify a detection
		1491		/// model](https://docs.microsoft.com/en-us/azure/cognitive-services/face/face-api-how-to-topics/specify-detecti
		1492		/// | Model | Recommended use-case(s) |
		1493		/// | ---------- | -------- |
		1494		/// | 'detection_01': | The default detection model for [LargePersonGroup
		1495		/// Person - Add
		1496		/// Face](/docs/services/563879b61984550e40cbbe8d/operations/599adf2a3a7b9412a4d53f42).
		1497		/// Recommend for near frontal face detection. For scenarios with exceptionally
		1498		/// large angle (head-pose) faces, occluded faces or wrong image orientation,
		1499		/// the faces in such cases may not be detected. |
		1500		/// | 'detection_02': | Detection model released in 2019 May with improved
		1501		/// accuracy especially on small, side and blurry faces. |
		1502		/// </summary>
		1503		/// <param name='largePersonGroupId'>
		1504		/// Id referencing a particular large person group.
		1505		/// </param>
		1506		/// <param name='personId'>
		1507		/// Id referencing a particular person.
		1508		/// </param>
		1509		/// <param name='url'>
		1510		/// Publicly reachable URL of an image
		1511		/// </param>
		1512		/// <param name='userData'>
		1513		/// User-specified data about the face for any purpose. The maximum length is
		1514		/// 1KB.
		1515		/// </param>
		1516		/// <param name='targetFace'>
		1517		/// A face rectangle to specify the target face to be added to a person in the
		1518		/// format of "targetFace=left,top,width,height". E.g.
		1519		/// "targetFace=10,10,100,100". If there is more than one face in the image,
		1520		/// targetFace is required to specify which face to add. No targetFace means
		1521		/// there is only one face detected in the entire image.
		1522		/// </param>
		1523		/// <param name='detectionModel'>
		1524		/// Name of detection model. Detection model is used to detect faces in the
		1525		/// submitted image. A detection model name can be provided when performing
		1526		/// Face - Detect or (Large)FaceList - Add Face or (Large)PersonGroup - Add
		1527		/// Face. The default value is 'detection_01', if another model is needed,
		1528		/// please explicitly specify it. Possible values include: 'detection_01',
		1529		/// 'detection_02'
		1530		/// </param>
		1531		/// <param name='customHeaders'>
		1532		/// Headers that will be added to request.
		1533		/// </param>
		1534		/// <param name='cancellationToken'>
		1535		/// The cancellation token.
		1536		/// </param>
		1537		/// <exception cref="APIErrorException">
		1538		/// Thrown when the operation returned an invalid status code
		1539		/// </exception>
		1540		/// <exception cref="SerializationException">
		1541		/// Thrown when unable to deserialize the response
		1542		/// </exception>
		1543		/// <exception cref="ValidationException">
		1544		/// Thrown when a required parameter is null
		1545		/// </exception>
		1546		/// <exception cref="System.ArgumentNullException">
		1547		/// Thrown when a required parameter is null
		1548		/// </exception>
		1549		/// <return>
		1550		/// A response object containing the response body and response headers.
		1551		/// </return>
		1552		public async Task<HttpOperationResponse<PersistedFace>> AddFaceFromUrlWithHttpMessagesAsync(string largePersonGr
		1553		{
	0	1554		if (Client.Endpoint == null)
		1555		{
	0	1556		throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.Endpoint");
		1557		}
	0	1558		if (largePersonGroupId == null)
		1559		{
	0	1560		throw new ValidationException(ValidationRules.CannotBeNull, "largePersonGroupId");
		1561		}
	0	1562		if (largePersonGroupId != null)
		1563		{
	0	1564		if (largePersonGroupId.Length > 64)
		1565		{
	0	1566		throw new ValidationException(ValidationRules.MaxLength, "largePersonGroupId", 64);
		1567		}
	0	1568		if (!System.Text.RegularExpressions.Regex.IsMatch(largePersonGroupId, "^[a-z0-9-_]+$"))
		1569		{
	0	1570		throw new ValidationException(ValidationRules.Pattern, "largePersonGroupId", "^[a-z0-9-_]+$");
		1571		}
		1572		}
	0	1573		if (userData != null)
		1574		{
	0	1575		if (userData.Length > 1024)
		1576		{
	0	1577		throw new ValidationException(ValidationRules.MaxLength, "userData", 1024);
		1578		}
		1579		}
	0	1580		if (url == null)
		1581		{
	0	1582		throw new ValidationException(ValidationRules.CannotBeNull, "url");
		1583		}
	0	1584		ImageUrl imageUrl = new ImageUrl();
	0	1585		if (url != null)
		1586		{
	0	1587		imageUrl.Url = url;
		1588		}
		1589		// Tracing
	0	1590		bool _shouldTrace = ServiceClientTracing.IsEnabled;
	0	1591		string _invocationId = null;
	0	1592		if (_shouldTrace)
		1593		{
	0	1594		_invocationId = ServiceClientTracing.NextInvocationId.ToString();
	0	1595		Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
	0	1596		tracingParameters.Add("largePersonGroupId", largePersonGroupId);
	0	1597		tracingParameters.Add("personId", personId);
	0	1598		tracingParameters.Add("userData", userData);
	0	1599		tracingParameters.Add("targetFace", targetFace);
	0	1600		tracingParameters.Add("detectionModel", detectionModel);
	0	1601		tracingParameters.Add("imageUrl", imageUrl);
	0	1602		tracingParameters.Add("cancellationToken", cancellationToken);
	0	1603		ServiceClientTracing.Enter(_invocationId, this, "AddFaceFromUrl", tracingParameters);
		1604		}
		1605		// Construct URL
	0	1606		var _baseUrl = Client.BaseUri;
	0	1607		var _url = _baseUrl + (_baseUrl.EndsWith("/") ? "" : "/") + "largepersongroups/{largePersonGroupId}/persons/
	0	1608		_url = _url.Replace("{Endpoint}", Client.Endpoint);
	0	1609		_url = _url.Replace("{largePersonGroupId}", System.Uri.EscapeDataString(largePersonGroupId));
	0	1610		_url = _url.Replace("{personId}", System.Uri.EscapeDataString(Rest.Serialization.SafeJsonConvert.SerializeOb
	0	1611		List<string> _queryParameters = new List<string>();
	0	1612		if (userData != null)
		1613		{
	0	1614		_queryParameters.Add(string.Format("userData={0}", System.Uri.EscapeDataString(userData)));
		1615		}
	0	1616		if (targetFace != null)
		1617		{
	0	1618		_queryParameters.Add(string.Format("targetFace={0}", System.Uri.EscapeDataString(string.Join(",", target
		1619		}
	0	1620		if (detectionModel != null)
		1621		{
	0	1622		_queryParameters.Add(string.Format("detectionModel={0}", System.Uri.EscapeDataString(detectionModel)));
		1623		}
	0	1624		if (_queryParameters.Count > 0)
		1625		{
	0	1626		_url += "?" + string.Join("&", _queryParameters);
		1627		}
		1628		// Create HTTP transport objects
	0	1629		var _httpRequest = new HttpRequestMessage();
	0	1630		HttpResponseMessage _httpResponse = null;
	0	1631		_httpRequest.Method = new HttpMethod("POST");
	0	1632		_httpRequest.RequestUri = new System.Uri(_url);
		1633		// Set Headers
		1634
		1635
	0	1636		if (customHeaders != null)
		1637		{
	0	1638		foreach(var _header in customHeaders)
		1639		{
	0	1640		if (_httpRequest.Headers.Contains(_header.Key))
		1641		{
	0	1642		_httpRequest.Headers.Remove(_header.Key);
		1643		}
	0	1644		_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
		1645		}
		1646		}
		1647
		1648		// Serialize Request
	0	1649		string _requestContent = null;
	0	1650		if(imageUrl != null)
		1651		{
	0	1652		_requestContent = Rest.Serialization.SafeJsonConvert.SerializeObject(imageUrl, Client.SerializationSetti
	0	1653		_httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8);
	0	1654		_httpRequest.Content.Headers.ContentType =System.Net.Http.Headers.MediaTypeHeaderValue.Parse("applicatio
		1655		}
		1656		// Set Credentials
	0	1657		if (Client.Credentials != null)
		1658		{
	0	1659		cancellationToken.ThrowIfCancellationRequested();
	0	1660		await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
		1661		}
		1662		// Send Request
	0	1663		if (_shouldTrace)
		1664		{
	0	1665		ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
		1666		}
	0	1667		cancellationToken.ThrowIfCancellationRequested();
	0	1668		_httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
	0	1669		if (_shouldTrace)
		1670		{
	0	1671		ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
		1672		}
	0	1673		HttpStatusCode _statusCode = _httpResponse.StatusCode;
	0	1674		cancellationToken.ThrowIfCancellationRequested();
	0	1675		string _responseContent = null;
	0	1676		if ((int)_statusCode != 200)
		1677		{
	0	1678		var ex = new APIErrorException(string.Format("Operation returned an invalid status code '{0}'", _statusC
		1679		try
		1680		{
	0	1681		_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
	0	1682		APIError _errorBody =  Rest.Serialization.SafeJsonConvert.DeserializeObject<APIError>(_responseConte
	0	1683		if (_errorBody != null)
		1684		{
	0	1685		ex.Body = _errorBody;
		1686		}
	0	1687		}
	0	1688		catch (JsonException)
		1689		{
		1690		// Ignore the exception
	0	1691		}
	0	1692		ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
	0	1693		ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
	0	1694		if (_shouldTrace)
		1695		{
	0	1696		ServiceClientTracing.Error(_invocationId, ex);
		1697		}
	0	1698		_httpRequest.Dispose();
	0	1699		if (_httpResponse != null)
		1700		{
	0	1701		_httpResponse.Dispose();
		1702		}
	0	1703		throw ex;
		1704		}
		1705		// Create Result
	0	1706		var _result = new HttpOperationResponse<PersistedFace>();
	0	1707		_result.Request = _httpRequest;
	0	1708		_result.Response = _httpResponse;
		1709		// Deserialize Response
	0	1710		if ((int)_statusCode == 200)
		1711		{
	0	1712		_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
		1713		try
		1714		{
	0	1715		_result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject<PersistedFace>(_responseContent,
	0	1716		}
	0	1717		catch (JsonException ex)
		1718		{
	0	1719		_httpRequest.Dispose();
	0	1720		if (_httpResponse != null)
		1721		{
	0	1722		_httpResponse.Dispose();
		1723		}
	0	1724		throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
		1725		}
		1726		}
	0	1727		if (_shouldTrace)
		1728		{
	0	1729		ServiceClientTracing.Exit(_invocationId, _result);
		1730		}
	0	1731		return _result;
	0	1732		}
		1733
		1734		/// <summary>
		1735		/// Add a face to a person into a large person group for face identification or
		1736		/// verification. To deal with an image contains multiple faces, input face can
		1737		/// be specified as an image with a targetFace rectangle. It returns a
		1738		/// persistedFaceId representing the added face. No image will be stored. Only
		1739		/// the extracted face feature will be stored on server until [LargePersonGroup
		1740		/// PersonFace -
		1741		/// Delete](/docs/services/563879b61984550e40cbbe8d/operations/599ae2966ac60f11b48b5aa3),
		1742		/// [LargePersonGroup Person -
		1743		/// Delete](/docs/services/563879b61984550e40cbbe8d/operations/599ade5c6ac60f11b48b5aa2)
		1744		/// or [LargePersonGroup -
		1745		/// Delete](/docs/services/563879b61984550e40cbbe8d/operations/599adc216ac60f11b48b5a9f)
		1746		/// is called.
		1747		/// &lt;br /&gt; Note persistedFaceId is different from faceId generated by
		1748		/// [Face -
		1749		/// Detect](/docs/services/563879b61984550e40cbbe8d/operations/563879b61984550f30395236).
		1750		/// * Higher face image quality means better recognition precision. Please
		1751		/// consider high-quality faces: frontal, clear, and face size is 200x200
		1752		/// pixels (100 pixels between eyes) or bigger.
		1753		/// * Each person entry can hold up to 248 faces.
		1754		/// * JPEG, PNG, GIF (the first frame), and BMP format are supported. The
		1755		/// allowed image file size is from 1KB to 6MB.
		1756		/// * "targetFace" rectangle should contain one face. Zero or multiple faces
		1757		/// will be regarded as an error. If the provided "targetFace" rectangle is not
		1758		/// returned from [Face -
		1759		/// Detect](/docs/services/563879b61984550e40cbbe8d/operations/563879b61984550f30395236),
		1760		/// there’s no guarantee to detect and add the face successfully.
		1761		/// * Out of detectable face size (36x36 - 4096x4096 pixels), large head-pose,
		1762		/// or large occlusions will cause failures.
		1763		/// * Adding/deleting faces to/from a same person will be processed
		1764		/// sequentially. Adding/deleting faces to/from different persons are processed
		1765		/// in parallel.
		1766		/// * The minimum detectable face size is 36x36 pixels in an image no larger
		1767		/// than 1920x1080 pixels. Images with dimensions higher than 1920x1080 pixels
		1768		/// will need a proportionally larger minimum face size.
		1769		/// * Different 'detectionModel' values can be provided. To use and compare
		1770		/// different detection models, please refer to [How to specify a detection
		1771		/// model](https://docs.microsoft.com/en-us/azure/cognitive-services/face/face-api-how-to-topics/specify-detecti
		1772		/// | Model | Recommended use-case(s) |
		1773		/// | ---------- | -------- |
		1774		/// | 'detection_01': | The default detection model for [LargePersonGroup
		1775		/// Person - Add
		1776		/// Face](/docs/services/563879b61984550e40cbbe8d/operations/599adf2a3a7b9412a4d53f42).
		1777		/// Recommend for near frontal face detection. For scenarios with exceptionally
		1778		/// large angle (head-pose) faces, occluded faces or wrong image orientation,
		1779		/// the faces in such cases may not be detected. |
		1780		/// | 'detection_02': | Detection model released in 2019 May with improved
		1781		/// accuracy especially on small, side and blurry faces. |
		1782		/// </summary>
		1783		/// <param name='largePersonGroupId'>
		1784		/// Id referencing a particular large person group.
		1785		/// </param>
		1786		/// <param name='personId'>
		1787		/// Id referencing a particular person.
		1788		/// </param>
		1789		/// <param name='image'>
		1790		/// An image stream.
		1791		/// </param>
		1792		/// <param name='userData'>
		1793		/// User-specified data about the face for any purpose. The maximum length is
		1794		/// 1KB.
		1795		/// </param>
		1796		/// <param name='targetFace'>
		1797		/// A face rectangle to specify the target face to be added to a person in the
		1798		/// format of "targetFace=left,top,width,height". E.g.
		1799		/// "targetFace=10,10,100,100". If there is more than one face in the image,
		1800		/// targetFace is required to specify which face to add. No targetFace means
		1801		/// there is only one face detected in the entire image.
		1802		/// </param>
		1803		/// <param name='detectionModel'>
		1804		/// Name of detection model. Detection model is used to detect faces in the
		1805		/// submitted image. A detection model name can be provided when performing
		1806		/// Face - Detect or (Large)FaceList - Add Face or (Large)PersonGroup - Add
		1807		/// Face. The default value is 'detection_01', if another model is needed,
		1808		/// please explicitly specify it. Possible values include: 'detection_01',
		1809		/// 'detection_02'
		1810		/// </param>
		1811		/// <param name='customHeaders'>
		1812		/// Headers that will be added to request.
		1813		/// </param>
		1814		/// <param name='cancellationToken'>
		1815		/// The cancellation token.
		1816		/// </param>
		1817		/// <exception cref="APIErrorException">
		1818		/// Thrown when the operation returned an invalid status code
		1819		/// </exception>
		1820		/// <exception cref="SerializationException">
		1821		/// Thrown when unable to deserialize the response
		1822		/// </exception>
		1823		/// <exception cref="ValidationException">
		1824		/// Thrown when a required parameter is null
		1825		/// </exception>
		1826		/// <exception cref="System.ArgumentNullException">
		1827		/// Thrown when a required parameter is null
		1828		/// </exception>
		1829		/// <return>
		1830		/// A response object containing the response body and response headers.
		1831		/// </return>
		1832		public async Task<HttpOperationResponse<PersistedFace>> AddFaceFromStreamWithHttpMessagesAsync(string largePerso
		1833		{
	18	1834		if (Client.Endpoint == null)
		1835		{
	0	1836		throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.Endpoint");
		1837		}
	18	1838		if (largePersonGroupId == null)
		1839		{
	0	1840		throw new ValidationException(ValidationRules.CannotBeNull, "largePersonGroupId");
		1841		}
	18	1842		if (largePersonGroupId != null)
		1843		{
	18	1844		if (largePersonGroupId.Length > 64)
		1845		{
	0	1846		throw new ValidationException(ValidationRules.MaxLength, "largePersonGroupId", 64);
		1847		}
	18	1848		if (!System.Text.RegularExpressions.Regex.IsMatch(largePersonGroupId, "^[a-z0-9-_]+$"))
		1849		{
	0	1850		throw new ValidationException(ValidationRules.Pattern, "largePersonGroupId", "^[a-z0-9-_]+$");
		1851		}
		1852		}
	18	1853		if (userData != null)
		1854		{
	0	1855		if (userData.Length > 1024)
		1856		{
	0	1857		throw new ValidationException(ValidationRules.MaxLength, "userData", 1024);
		1858		}
		1859		}
	18	1860		if (image == null)
		1861		{
	0	1862		throw new ValidationException(ValidationRules.CannotBeNull, "image");
		1863		}
		1864		// Tracing
	18	1865		bool _shouldTrace = ServiceClientTracing.IsEnabled;
	18	1866		string _invocationId = null;
	18	1867		if (_shouldTrace)
		1868		{
	0	1869		_invocationId = ServiceClientTracing.NextInvocationId.ToString();
	0	1870		Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
	0	1871		tracingParameters.Add("largePersonGroupId", largePersonGroupId);
	0	1872		tracingParameters.Add("personId", personId);
	0	1873		tracingParameters.Add("userData", userData);
	0	1874		tracingParameters.Add("targetFace", targetFace);
	0	1875		tracingParameters.Add("image", image);
	0	1876		tracingParameters.Add("detectionModel", detectionModel);
	0	1877		tracingParameters.Add("cancellationToken", cancellationToken);
	0	1878		ServiceClientTracing.Enter(_invocationId, this, "AddFaceFromStream", tracingParameters);
		1879		}
		1880		// Construct URL
	18	1881		var _baseUrl = Client.BaseUri;
	18	1882		var _url = _baseUrl + (_baseUrl.EndsWith("/") ? "" : "/") + "largepersongroups/{largePersonGroupId}/persons/
	18	1883		_url = _url.Replace("{Endpoint}", Client.Endpoint);
	18	1884		_url = _url.Replace("{largePersonGroupId}", System.Uri.EscapeDataString(largePersonGroupId));
	18	1885		_url = _url.Replace("{personId}", System.Uri.EscapeDataString(Rest.Serialization.SafeJsonConvert.SerializeOb
	18	1886		List<string> _queryParameters = new List<string>();
	18	1887		if (userData != null)
		1888		{
	0	1889		_queryParameters.Add(string.Format("userData={0}", System.Uri.EscapeDataString(userData)));
		1890		}
	18	1891		if (targetFace != null)
		1892		{
	12	1893		_queryParameters.Add(string.Format("targetFace={0}", System.Uri.EscapeDataString(string.Join(",", target
		1894		}
	18	1895		if (detectionModel != null)
		1896		{
	18	1897		_queryParameters.Add(string.Format("detectionModel={0}", System.Uri.EscapeDataString(detectionModel)));
		1898		}
	18	1899		if (_queryParameters.Count > 0)
		1900		{
	18	1901		_url += "?" + string.Join("&", _queryParameters);
		1902		}
		1903		// Create HTTP transport objects
	18	1904		var _httpRequest = new HttpRequestMessage();
	18	1905		HttpResponseMessage _httpResponse = null;
	18	1906		_httpRequest.Method = new HttpMethod("POST");
	18	1907		_httpRequest.RequestUri = new System.Uri(_url);
		1908		// Set Headers
		1909
		1910
	18	1911		if (customHeaders != null)
		1912		{
	0	1913		foreach(var _header in customHeaders)
		1914		{
	0	1915		if (_httpRequest.Headers.Contains(_header.Key))
		1916		{
	0	1917		_httpRequest.Headers.Remove(_header.Key);
		1918		}
	0	1919		_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
		1920		}
		1921		}
		1922
		1923		// Serialize Request
	18	1924		string _requestContent = null;
	18	1925		if(image == null)
		1926		{
	0	1927		throw new System.ArgumentNullException("image");
		1928		}
	18	1929		if (image != null && image != Stream.Null)
		1930		{
	18	1931		_httpRequest.Content = new StreamContent(image);
	18	1932		_httpRequest.Content.Headers.ContentType =System.Net.Http.Headers.MediaTypeHeaderValue.Parse("applicatio
		1933		}
		1934		// Set Credentials
	18	1935		if (Client.Credentials != null)
		1936		{
	18	1937		cancellationToken.ThrowIfCancellationRequested();
	18	1938		await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
		1939		}
		1940		// Send Request
	18	1941		if (_shouldTrace)
		1942		{
	0	1943		ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
		1944		}
	18	1945		cancellationToken.ThrowIfCancellationRequested();
	18	1946		_httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
	18	1947		if (_shouldTrace)
		1948		{
	0	1949		ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
		1950		}
	18	1951		HttpStatusCode _statusCode = _httpResponse.StatusCode;
	18	1952		cancellationToken.ThrowIfCancellationRequested();
	18	1953		string _responseContent = null;
	18	1954		if ((int)_statusCode != 200)
		1955		{
	0	1956		var ex = new APIErrorException(string.Format("Operation returned an invalid status code '{0}'", _statusC
		1957		try
		1958		{
	0	1959		_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
	0	1960		APIError _errorBody =  Rest.Serialization.SafeJsonConvert.DeserializeObject<APIError>(_responseConte
	0	1961		if (_errorBody != null)
		1962		{
	0	1963		ex.Body = _errorBody;
		1964		}
	0	1965		}
	0	1966		catch (JsonException)
		1967		{
		1968		// Ignore the exception
	0	1969		}
	0	1970		ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
	0	1971		ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
	0	1972		if (_shouldTrace)
		1973		{
	0	1974		ServiceClientTracing.Error(_invocationId, ex);
		1975		}
	0	1976		_httpRequest.Dispose();
	0	1977		if (_httpResponse != null)
		1978		{
	0	1979		_httpResponse.Dispose();
		1980		}
	0	1981		throw ex;
		1982		}
		1983		// Create Result
	18	1984		var _result = new HttpOperationResponse<PersistedFace>();
	18	1985		_result.Request = _httpRequest;
	18	1986		_result.Response = _httpResponse;
		1987		// Deserialize Response
	18	1988		if ((int)_statusCode == 200)
		1989		{
	18	1990		_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
		1991		try
		1992		{
	18	1993		_result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject<PersistedFace>(_responseContent,
	18	1994		}
	0	1995		catch (JsonException ex)
		1996		{
	0	1997		_httpRequest.Dispose();
	0	1998		if (_httpResponse != null)
		1999		{
	0	2000		_httpResponse.Dispose();
		2001		}
	0	2002		throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
		2003		}
		2004		}
	18	2005		if (_shouldTrace)
		2006		{
	0	2007		ServiceClientTracing.Exit(_invocationId, _result);
		2008		}
	18	2009		return _result;
	18	2010		}
		2011
		2012		}
		2013		}