< Summary

Class:	Microsoft.Azure.Batch.CloudTask
Assembly:	Microsoft.Azure.Batch
File(s):	C:\Git\azure-sdk-for-net\sdk\batch\Microsoft.Azure.Batch\src\CloudTask.cs C:\Git\azure-sdk-for-net\sdk\batch\Microsoft.Azure.Batch\src\Generated\CloudTask.cs
Covered lines:	201
Uncovered lines:	286
Coverable lines:	487
Total lines:	1106
Line coverage:	41.2% (201 of 487)
Covered branches:	4
Total branches:	12
Branch coverage:	33.3% (4 of 12)

Metrics

Method	Cyclomatic complexity	Line coverage	Branch coverage
get_State()	-	100%	100%
get_StateTransitionTime()	-	100%	100%
get_Statistics()	-	100%	100%
get_Url()	-	100%	100%
get_UserIdentity()	-	100%	100%
set_UserIdentity(...)	-	100%	100%
Microsoft.Azure.Batch.IModifiable.get_HasBeenModified()	-	100%	100%
Microsoft.Azure.Batch.IReadOnly.get_IsReadOnly()	-	100%	100%
Microsoft.Azure.Batch.IReadOnly.set_IsReadOnly(...)	-	100%	100%
Microsoft.Azure.Batch.ITransportObjectProvider<Microsoft.Azure.Batch.Protocol.Models.TaskAddParameter>.GetTransportObject()	-	100%	100%
.ctor(...)	-	100%	100%
get_BindingState()	-	100%	100%
StageFilesAsync()	-	95.65%	40%
.ctor()	-	96.67%	25%
StageFiles()	-	66.67%	100%
.ctor(...)	-	99.09%	0%
ListNodeFiles(...)	-	100%	100%
ListSubtasks(...)	-	100%	100%
CommitAsync()	-	100%	0%
Commit(...)	-	100%	100%
TerminateAsync(...)	-	40%	100%
get_ParentJobId()	-	100%	100%
Terminate(...)	-	100%	100%
.ctor(...)	-	100%	100%
DeleteAsync(...)	-	0%	100%
get_CustomBehaviors()	-	0%	100%
Delete(...)	-	66.67%	100%
get_AffinityInformation()	-	100%	100%
set_AffinityInformation(...)	-	100%	100%
get_ApplicationPackageReferences()	-	100%	100%
set_ApplicationPackageReferences(...)	-	100%	100%
ReactivateAsync(...)	-	25%	100%
get_AuthenticationTokenSettings()	-	100%	100%
set_AuthenticationTokenSettings(...)	-	100%	100%
get_CommandLine()	-	100%	100%
set_CommandLine(...)	-	100%	100%
get_ComputeNodeInformation()	-	100%	100%
Reactivate(...)	-	0%	100%
get_Constraints()	-	100%	100%
set_Constraints(...)	-	100%	100%
GetNodeFileAsync(...)	-	40%	100%
get_ContainerSettings()	-	100%	100%
set_ContainerSettings(...)	-	100%	100%
get_CreationTime()	-	100%	100%
GetNodeFile(...)	-	0%	100%
get_DependsOn()	-	100%	100%
set_DependsOn(...)	-	100%	100%
get_DisplayName()	-	100%	100%
set_DisplayName(...)	-	100%	100%
CopyNodeFileContentToStreamAsync(...)	-	30%	100%
get_EnvironmentSettings()	-	100%	100%
set_EnvironmentSettings(...)	-	100%	100%
get_ETag()	-	100%	100%
get_ExecutionInformation()	-	100%	100%
CopyNodeFileContentToStream(...)	-	0%	100%
get_ExitConditions()	-	100%	100%
set_ExitConditions(...)	-	100%	100%
get_FilesToStage()	-	100%	100%
set_FilesToStage(...)	-	100%	100%
CopyNodeFileContentToStringAsync(...)	-	22.22%	100%
get_Id()	-	100%	100%
set_Id(...)	-	100%	100%
get_LastModified()	-	100%	100%
get_MultiInstanceSettings()	-	100%	100%
set_MultiInstanceSettings(...)	-	100%	100%
CopyNodeFileContentToString(...)	-	0%	100%
get_OutputFiles()	-	100%	100%
set_OutputFiles(...)	-	100%	100%
RefreshAsync()	-	21.43%	100%
get_PreviousState()	-	100%	100%
get_PreviousStateTransitionTime()	-	100%	100%
Refresh(...)	-	33.33%	100%
get_ResourceFiles()	-	100%	100%
set_ResourceFiles(...)	-	100%	100%
.ctor()	-	0%	100%
.ctor(...)	-	0%	100%
get_ParentJobId()	-	0%	100%
.ctor(...)	-	0%	100%
get_CustomBehaviors()	-	0%	100%
get_AffinityInformation()	-	0%	100%
set_AffinityInformation(...)	-	0%	100%
get_ApplicationPackageReferences()	-	0%	100%
set_ApplicationPackageReferences(...)	-	0%	100%
get_AuthenticationTokenSettings()	-	0%	100%
set_AuthenticationTokenSettings(...)	-	0%	100%
get_CommandLine()	-	0%	100%
set_CommandLine(...)	-	0%	100%
get_ComputeNodeInformation()	-	0%	100%
get_Constraints()	-	0%	100%
set_Constraints(...)	-	0%	100%
get_ContainerSettings()	-	0%	100%
set_ContainerSettings(...)	-	0%	100%
get_CreationTime()	-	0%	100%
get_DependsOn()	-	0%	100%
set_DependsOn(...)	-	0%	100%
get_DisplayName()	-	0%	100%
set_DisplayName(...)	-	0%	100%
get_EnvironmentSettings()	-	0%	100%
set_EnvironmentSettings(...)	-	0%	100%
get_ETag()	-	0%	100%
get_ExecutionInformation()	-	0%	100%
get_ExitConditions()	-	0%	100%
set_ExitConditions(...)	-	0%	100%
get_FilesToStage()	-	0%	100%
set_FilesToStage(...)	-	0%	100%
get_Id()	-	0%	100%
set_Id(...)	-	0%	100%
get_LastModified()	-	0%	100%
get_MultiInstanceSettings()	-	0%	100%
set_MultiInstanceSettings(...)	-	0%	100%
get_OutputFiles()	-	0%	100%
set_OutputFiles(...)	-	0%	100%
get_PreviousState()	-	0%	100%
get_PreviousStateTransitionTime()	-	0%	100%
get_ResourceFiles()	-	0%	100%
set_ResourceFiles(...)	-	0%	100%
get_State()	-	0%	100%
get_StateTransitionTime()	-	0%	100%
get_Statistics()	-	0%	100%
get_Url()	-	0%	100%
get_UserIdentity()	-	0%	100%
set_UserIdentity(...)	-	0%	100%
Microsoft.Azure.Batch.IModifiable.get_HasBeenModified()	-	0%	100%
Microsoft.Azure.Batch.IReadOnly.get_IsReadOnly()	-	0%	100%
Microsoft.Azure.Batch.IReadOnly.set_IsReadOnly(...)	-	0%	100%
Microsoft.Azure.Batch.ITransportObjectProvider<Microsoft.Azure.Batch.Protocol.Models.TaskAddParameter>.GetTransportObject()	-	0%	100%

File(s)

C:\Git\azure-sdk-for-net\sdk\batch\Microsoft.Azure.Batch\src\CloudTask.cs

	#	Line		Line coverage
		1		// Copyright (c) Microsoft Corporation. All rights reserved.
		2		// Licensed under the MIT License. See License.txt in the project root for license information.
		3
		4		using System.IO;
		5		using System.Text;
		6
		7		namespace Microsoft.Azure.Batch
		8		{
		9		using System;
		10		using System.Collections.Concurrent;
		11		using System.Collections.Generic;
		12		using System.Threading;
		13		using System.Threading.Tasks;
		14		using Microsoft.Azure.Batch.Common;
		15		using Microsoft.Azure.Batch.FileStaging;
		16		using Microsoft.Rest.Azure;
		17		using Models = Microsoft.Azure.Batch.Protocol.Models;
		18
		19		/// <summary>
		20		/// An Azure Batch task.  A task is a piece of work that is associated with a job and runs on a compute node.
		21		/// </summary>
		22		public partial class CloudTask : IRefreshable
		23		{
		24		#region // Constructors
		25
		26		/// <summary>
		27		/// Initializes a new instance of the <see cref="CloudTask"/> class.
		28		/// </summary>
		29		/// <param name="id">The id of the task.</param>
		30		/// <param name="commandline">The command line of the task.</param>
		31		/// <remarks>The newly created CloudTask is initially not associated with any task in the Batch service.
		32		/// To associate it with a job and submit it to the Batch service, use <see cref="JobOperations.AddTaskAsync(str
	1026	33		public CloudTask(string id, string commandline)
		34		{
	1026	35		this.propertyContainer = new PropertyContainer();
		36
		37		// set initial conditions
	1026	38		this.Id = id;
	1026	39		this.CommandLine = commandline;
		40
		41		// set up custom behaviors
	1026	42		InheritUtil.InheritClientBehaviorsAndSetPublicProperty(this, null);
	1026	43		}
		44
		45		#endregion // Constructors
		46
		47		internal BindingState BindingState
		48		{
	908	49		get { return this.propertyContainer.BindingState; }
		50		}
		51
		52		/// <summary>
		53		/// Stages the files listed in the <see cref="FilesToStage"/> list.
		54		/// </summary>
		55		/// <param name="allFileStagingArtifacts">An optional collection to customize and receive information about the
		56		/// For more information see <see cref="IFileStagingArtifact"/>.</param>
		57		/// <returns>A <see cref="System.Threading.Tasks.Task"/> that represents the asynchronous operation.</returns>
		58		/// <remarks>The staging operation runs asynchronously.</remarks>
		59		public async System.Threading.Tasks.Task StageFilesAsync(ConcurrentDictionary<Type, IFileStagingArtifact> allFil
		60		{
		61		// stage all these files
		62		// TODO: align this copy with threadsafe implementation of the IList<>
	8	63		List<IFileStagingProvider> allFiles = this.FilesToStage == null ? new List<IFileStagingProvider>() : new Lis
		64
		65		//TODO: There is a threading issue doing this - expose a change tracking box directly and use a lock?
	8	66		if (this.FilesToStage != null && this.ResourceFiles == null)
	1026	67		{
	0	68		this.ResourceFiles = new List<ResourceFile>(); //We're about to have some resource files
	1026	69		}
	1026	70
	1026	71		// now we have all files, send off to file staging machine
	1034	72		System.Threading.Tasks.Task fileStagingTask = FileStagingUtils.StageFilesAsync(allFiles, allFileStagingArtif
	1026	73
	1026	74		// wait for file staging async task
	1034	75		await fileStagingTask.ConfigureAwait(continueOnCapturedContext: false);
	1026	76
	1026	77		// now update Task with its new ResourceFiles
	1026	78		foreach (IFileStagingProvider curFile in allFiles)
	1026	79		{
	1026	80		IEnumerable<ResourceFile> curStagedFiles = curFile.StagedFiles;
	1026	81
	1026	82		foreach (ResourceFile curStagedFile in curStagedFiles)
	1026	83		{
	1026	84		this.ResourceFiles.Add(curStagedFile);
	1026	85		}
	1026	86		}
	1034	87		}
	1026	88
	1026	89		/// <summary>
	1026	90		/// Stages the files listed in the <see cref="FilesToStage"/> list.
	1026	91		/// </summary>
	1026	92		/// <returns>A collection of information about the file staging process.
	1026	93		/// For more information see <see cref="IFileStagingArtifact"/>.</returns>
	1026	94		/// <remarks>This is a blocking operation. For a non-blocking equivalent, see <see cref="StageFilesAsync"/>.</re
	1026	95		public ConcurrentDictionary<Type, IFileStagingArtifact> StageFiles()
	1026	96		{
	0	97		ConcurrentDictionary<Type, IFileStagingArtifact> allFileStagingArtifacts = new ConcurrentDictionary<Type,IFi
	1021	98
	0	99		Task asyncTask = StageFilesAsync(allFileStagingArtifacts);
	1021	100		asyncTask.WaitAndUnaggregateException();
	1530	101
	1021	102		return allFileStagingArtifacts;
	1021	103		}
	1021	104
	1021	105		/// <summary>
	1021	106		/// Enumerates the files in the <see cref="CloudTask"/>'s directory on its compute node.
	1021	107		/// </summary>
	1021	108		/// <param name="recursive">If true, performs a recursive list of all files of the task. If false, returns only
	1532	109		/// <param name="detailLevel">A <see cref="DetailLevel"/> used for filtering the list and for controlling which
	1021	110		/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are appli
	1021	111		/// <returns>An <see cref="IPagedEnumerable{NodeFile}"/> that can be used to enumerate files asynchronously or s
	1021	112		/// <remarks>This method returns immediately; the file data is retrieved from the Batch service only when the co
	1021	113		/// Retrieval is non-atomic; file data is retrieved in pages during enumeration of the collection.</remarks>
	1021	114		public IPagedEnumerable<NodeFile> ListNodeFiles(bool? recursive = null, DetailLevel detailLevel = null, IEnumera
	1021	115		{
	1021	116		UtilitiesInternal.ThrowOnUnbound(this.propertyContainer.BindingState);
	1506	117
	1021	118		// craft the behavior manager for this call
	1021	119		BehaviorManager bhMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors);
	1021	120
	1527	121		IPagedEnumerable<NodeFile> enumerator = this.parentBatchClient.JobOperations.ListNodeFilesImpl(this.parentJo
	1021	122
	1021	123		return enumerator;
	1021	124		}
	1516	125
	1021	126		/// <summary>
	1021	127		/// Enumerates the subtasks of the multi-instance <see cref="CloudTask"/>.
	1021	128		/// </summary>
	1021	129		/// <param name="detailLevel">A <see cref="DetailLevel"/> used for filtering the list and for controlling which
	1021	130		/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are appli
	1021	131		/// <returns>An <see cref="IPagedEnumerable{SubtaskInformation}"/> that can be used to enumerate files asynchron
	1021	132		/// <remarks>This method returns immediately; the file data is retrieved from the Batch service only when the co
	1528	133		/// Retrieval is non-atomic; file data is retrieved in pages during enumeration of the collection.</remarks>
	1021	134		public IPagedEnumerable<SubtaskInformation> ListSubtasks(DetailLevel detailLevel = null, IEnumerable<BatchClient
	1021	135		{
	1021	136		UtilitiesInternal.ThrowOnUnbound(this.propertyContainer.BindingState);
	1021	137
	1021	138		// craft the behavior manager for this call
	1021	139		BehaviorManager bhMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors);
	1021	140
	1021	141		IPagedEnumerable<SubtaskInformation> enumerator = this.parentBatchClient.JobOperations.ListSubtasksImpl(this
	1021	142
	1021	143		return enumerator;
	1021	144		}
	1021	145
	1021	146		/// <summary>
	1021	147		/// Commits all pending changes to this <see cref="CloudTask" /> to the Azure Batch service.
	1021	148		/// </summary>
	1539	149		/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are appli
	1021	150		/// <param name="cancellationToken">A <see cref="CancellationToken"/> for controlling the lifetime of the asynch
	1021	151		/// <returns>A <see cref="System.Threading.Tasks.Task"/> object that represents the asynchronous operation.</ret
	1021	152		/// <remarks>The commit operation runs asynchronously.</remarks>
	1525	153		public async System.Threading.Tasks.Task CommitAsync(IEnumerable<BatchClientBehavior> additionalBehaviors = null
	1021	154		{
	1021	155		this.propertyContainer.IsReadOnly = true;
	1021	156
	1021	157		// craft the behavior manager for this call
	1021	158		BehaviorManager bhMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors);
	1021	159
	1021	160		if (BindingState.Unbound == this.propertyContainer.BindingState)
	1021	161		{
	1021	162		//TODO: Implement task submission via .Commit here
	1021	163		UtilitiesInternal.ThrowOnUnbound(this.propertyContainer.BindingState);
	1021	164		}
	1021	165		else
	1021	166		{
	1021	167		Models.TaskConstraints protoTaskConstraints = UtilitiesInternal.CreateObjectWithNullCheck(this.Constrain
	1539	168
	1021	169		System.Threading.Tasks.Task<AzureOperationHeaderResponse<Models.TaskUpdateHeaders>> asyncTaskUpdate =
	1021	170		this.parentBatchClient.ProtocolLayer.UpdateTask(
	1021	171		this.parentJobId,
	1021	172		this.Id,
	1021	173		protoTaskConstraints,
	1021	174		bhMgr,
	1021	175		cancellationToken);
	1021	176
	1021	177		await asyncTaskUpdate.ConfigureAwait(continueOnCapturedContext: false);
	1021	178		}
	1021	179		}
	1021	180
	1021	181		/// <summary>
	1021	182		/// Commits all pending changes to this <see cref="CloudTask" /> to the Azure Batch service.
	1021	183		/// </summary>
	1021	184		/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are appli
	1021	185		/// <returns>A <see cref="System.Threading.Tasks.Task"/> object that represents the asynchronous operation.</ret
	1021	186		/// <remarks>
	1021	187		/// <para>This is a blocking operation. For a non-blocking equivalent, see <see cref="CommitAsync"/>.</para>
	1021	188		/// </remarks>
	1021	189		public void Commit(IEnumerable<BatchClientBehavior> additionalBehaviors = null)
	1021	190		{
	1021	191		Task asyncTask = CommitAsync(additionalBehaviors);
	1021	192		asyncTask.WaitAndUnaggregateException(this.CustomBehaviors, additionalBehaviors);
	1021	193		}
	1021	194
	1021	195		/// <summary>
	1498	196		/// Terminates this <see cref="CloudTask"/>, marking it as completed.
	1021	197		/// </summary>
	1021	198		/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are appli
	1021	199		/// <param name="cancellationToken">A <see cref="CancellationToken"/> for controlling the lifetime of the asynch
	1021	200		/// <returns>A <see cref="Task"/> object that represents the asynchronous operation.</returns>
	1021	201		/// <remarks>The terminate operation runs asynchronously.</remarks>
	1021	202		public System.Threading.Tasks.Task TerminateAsync(IEnumerable<BatchClientBehavior> additionalBehaviors = null, C
	1021	203		{
	1526	204		UtilitiesInternal.ThrowOnUnbound(this.propertyContainer.BindingState);
	1021	205
	1021	206		// create the behavior manager
	1021	207		BehaviorManager bhMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors);
		208
	0	209		System.Threading.Tasks.Task asyncTask = this.parentBatchClient.ProtocolLayer.TerminateTask(
	0	210		this.parentJobId,
	0	211		this.Id,
	0	212		bhMgr,
	0	213		cancellationToken);
		214
	0	215		return asyncTask;
		216		}
		217
		218		/// <summary>
	6	219		/// Terminates this <see cref="CloudTask"/>, marking it as completed.
		220		/// </summary>
		221		/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are appli
		222		/// <remarks>This is a blocking operation. For a non-blocking equivalent, see <see cref="TerminateAsync"/>.</rem
		223		public void Terminate(IEnumerable<BatchClientBehavior> additionalBehaviors = null)
		224		{
	1021	225		Task asyncTask = TerminateAsync(additionalBehaviors);
	1021	226		asyncTask.WaitAndUnaggregateException(this.CustomBehaviors, additionalBehaviors);
	1021	227		}
	1021	228
	1021	229
		230		/// <summary>
	1021	231		/// Deletes this <see cref="CloudTask"/>.
	1021	232		/// </summary>
	1021	233		/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are appli
	1021	234		/// <param name="cancellationToken">A <see cref="CancellationToken"/> for controlling the lifetime of the asynch
	1021	235		/// <returns>A <see cref="System.Threading.Tasks.Task"/> that represents the asynchronous operation.</returns>
		236		/// <remarks>The delete operation runs asynchronously.</remarks>
		237		public System.Threading.Tasks.Task DeleteAsync(IEnumerable<BatchClientBehavior> additionalBehaviors = null, Canc
		238		{
	0	239		UtilitiesInternal.ThrowOnUnbound(this.propertyContainer.BindingState);
		240
		241		// create the behavior manager
	0	242		BehaviorManager bhMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors);
		243
	0	244		System.Threading.Tasks.Task asyncTask = this.parentBatchClient.ProtocolLayer.DeleteTask(
	0	245		this.parentJobId,
	0	246		this.Id,
	0	247		bhMgr,
	0	248		cancellationToken);
	0	249
	0	250		return asyncTask;
		251		}
		252
		253		/// <summary>
		254		/// Deletes this <see cref="CloudTask"/>.
		255		/// </summary>
		256		/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are appli
		257		/// <remarks>This is a blocking operation. For a non-blocking equivalent, see <see cref="DeleteAsync"/>.</remark
		258		public void Delete(IEnumerable<BatchClientBehavior> additionalBehaviors = null)
		259		{
	2111	260		Task asyncTask = DeleteAsync(additionalBehaviors);
	107	261		asyncTask.WaitAndUnaggregateException(this.CustomBehaviors, additionalBehaviors);
	0	262		}
		263
		264		/// <summary>
		265		/// Reactivates this <see cref="CloudTask"/>, allowing it to run again even if its retry count has been exhauste
		266		/// </summary>
		267		/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are appli
		268		/// <param name="cancellationToken">A <see cref="CancellationToken"/> for controlling the lifetime of the asynch
		269		/// <returns>A <see cref="System.Threading.Tasks.Task"/> that represents the asynchronous operation.</returns>
	2111	270		/// <remarks>
		271		/// <para>
		272		/// Reactivation makes a task eligible to be retried again up to its maximum retry count.
	45	273		/// </para>
	44	274		/// <para>
		275		/// This operation will fail for tasks that are not completed or that previously completed successfully (with an
		276		/// Additionally, this will fail if the job is in the <see cref="JobState.Completed"/> or <see cref="JobState.Te
		277		/// </para>
		278		/// <para>
		279		/// The reactivate operation runs asynchronously.
		280		/// </para>
		281		/// </remarks>
		282		public System.Threading.Tasks.Task ReactivateAsync(IEnumerable<BatchClientBehavior> additionalBehaviors = null,
		283		{
	0	284		UtilitiesInternal.ThrowOnUnbound(this.propertyContainer.BindingState);
		285
		286		// create the behavior manager
	0	287		BehaviorManager bhMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors);
		288
	2111	289		System.Threading.Tasks.Task asyncTask = this.parentBatchClient.ProtocolLayer.ReactivateTask(
	93	290		this.parentJobId,
	0	291		this.Id,
	0	292		bhMgr,
	0	293		cancellationToken);
		294
	0	295		return asyncTask;
		296		}
		297
		298		/// <summary>
		299		/// Reactivates this <see cref="CloudTask"/>, allowing it to run again even if its retry count has been exhauste
		300		/// </summary>
		301		/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are appli
		302		/// <remarks>
		303		/// <para>
		304		/// Reactivation makes a task eligible to be retried again up to its maximum retry count.
	2111	305		/// </para>
	2154	306		/// <para>
		307		/// This operation will fail for tasks that are not completed or that previously completed successfully (with an
		308		/// Additionally, this will fail if the job is in the <see cref="JobState.Completed"/> or <see cref="JobState.Te
		309		/// </para>
		310		/// <para>
		311		/// This is a blocking operation. For a non-blocking equivalent, see <see cref="ReactivateAsync"/>.
		312		/// </para>
		313		/// </remarks>
	1001	314		public void Reactivate(IEnumerable<BatchClientBehavior> additionalBehaviors = null)
		315		{
	0	316		Task asyncTask = ReactivateAsync(additionalBehaviors);
	0	317		asyncTask.WaitAndUnaggregateException(this.CustomBehaviors, additionalBehaviors);
	0	318		}
		319
		320		/// <summary>
		321		/// Gets the specified <see cref="NodeFile"/> from the <see cref="CloudTask"/>'s directory on its compute node.
	2113	322		/// </summary>
	91	323		/// <param name="filePath">The path of the file to retrieve.</param>
		324		/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are appli
		325		/// <param name="cancellationToken">A <see cref="CancellationToken"/> for controlling the lifetime of the asynch
		326		/// <returns>A <see cref="NodeFile"/> representing the specified file.</returns>
		327		/// <remarks>The get file operation runs asynchronously.</remarks>
		328		public System.Threading.Tasks.Task<NodeFile> GetNodeFileAsync(
		329		string filePath,
		330		IEnumerable<BatchClientBehavior> additionalBehaviors = null,
		331		CancellationToken cancellationToken = default(CancellationToken))
		332		{
	0	333		UtilitiesInternal.ThrowOnUnbound(this.propertyContainer.BindingState);
		334
		335		//create the behavior manager
	0	336		BehaviorManager bhMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors);
		337
		338		//make the call
	0	339		System.Threading.Tasks.Task<NodeFile> asyncTask = this.parentBatchClient.JobOperations.GetNodeFileAsyncImpl(
	2111	340
	87	341		return asyncTask;
		342		}
		343
		344
		345		/// <summary>
		346		/// Gets the specified <see cref="NodeFile"/> from the <see cref="CloudTask"/>'s directory on its compute node.
		347		/// </summary>
		348		/// <param name="filePath">The path of the file to retrieve.</param>
	1001	349		/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are appli
		350		/// <returns>A <see cref="NodeFile"/> representing the specified file.</returns>
		351		/// <remarks>This is a blocking operation. For a non-blocking equivalent, see <see cref="GetNodeFileAsync"/>.</r
		352		public NodeFile GetNodeFile(string filePath, IEnumerable<BatchClientBehavior> additionalBehaviors = null)
		353		{
	0	354		Task<NodeFile> asyncTask = this.GetNodeFileAsync(filePath, additionalBehaviors);
	0	355		NodeFile file = asyncTask.WaitAndUnaggregateException(this.CustomBehaviors, additionalBehaviors);
		356
	0	357		return file;
		358		}
		359
		360		/// <summary>
		361		/// Copies the contents of a file in the task's directory from the node to the given <see cref="Stream"/>.
	2112	362		/// </summary>
	107	363		/// <param name="filePath">The path of the file to retrieve.</param>
		364		/// <param name="stream">The stream to copy the file contents to.</param>
		365		/// <param name="byteRange">A byte range defining what section of the file to copy. If omitted, the entire file
		366		/// <param name="additionalBehaviors">A collection of BatchClientBehavior instances that are applied after the C
		367		/// <param name="cancellationToken">A <see cref="CancellationToken"/> for controlling the lifetime of the asynch
		368		/// <returns>A <see cref="System.Threading.Tasks.Task"/> object that represents the asynchronous operation.</ret
		369		public Task CopyNodeFileContentToStreamAsync(
		370		string filePath,
	2111	371		Stream stream,
	101	372		GetFileRequestByteRange byteRange = null,
		373		IEnumerable<BatchClientBehavior> additionalBehaviors = null,
		374		CancellationToken cancellationToken = default(CancellationToken))
		375		{
		376		// create the behavior manager
	0	377		BehaviorManager bhMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors);
	0	378		Task asyncTask = this.parentBatchClient.JobOperations.CopyNodeFileContentToStreamAsyncImpl(
	0	379		this.parentJobId,
	2111	380		this.Id,
	0	381		filePath,
	0	382		stream,
	45	383		byteRange,
	44	384		bhMgr,
	0	385		cancellationToken);
		386
	0	387		return asyncTask;
		388		}
		389
		390		/// <summary>
		391		/// Copies the contents of a file in the task's directory from the node to the given <see cref="Stream"/>.
	1001	392		/// </summary>
		393		/// <param name="filePath">The path of the file to retrieve.</param>
		394		/// <param name="stream">The stream to copy the file contents to.</param>
		395		/// <param name="byteRange">A byte range defining what section of the file to copy. If omitted, the entire file
		396		/// <param name="additionalBehaviors">A collection of BatchClientBehavior instances that are applied after the C
		397		/// <returns>A bound <see cref="NodeFile"/> object.</returns>
		398		public void CopyNodeFileContentToStream(
		399		string filePath,
	1001	400		Stream stream,
		401		GetFileRequestByteRange byteRange = null,
		402		IEnumerable<BatchClientBehavior> additionalBehaviors = null)
		403		{
	0	404		Task asyncTask = this.CopyNodeFileContentToStreamAsync(filePath, stream, byteRange, additionalBehaviors);
	0	405		asyncTask.WaitAndUnaggregateException(this.CustomBehaviors, additionalBehaviors);
	0	406		}
		407
	2115	408		/// <summary>
	102	409		/// Reads the contents of a file in the task's directory on its compute node into a string.
		410		/// </summary>
		411		/// <param name="filePath">The path of the file to retrieve.</param>
		412		/// <param name="encoding">The encoding to use. If no value or null is specified, UTF8 is used.</param>
		413		/// <param name="byteRange">A byte range defining what section of the file to copy. If omitted, the entire file
		414		/// <param name="additionalBehaviors">A collection of BatchClientBehavior instances that are applied after the C
		415		/// <param name="cancellationToken">A <see cref="CancellationToken"/> for controlling the lifetime of the asynch
		416		/// <returns>A <see cref="System.Threading.Tasks.Task"/> object that represents the asynchronous operation.</ret
	1821	417		public Task<string> CopyNodeFileContentToStringAsync(
		418		string filePath,
		419		Encoding encoding = null,
	45	420		GetFileRequestByteRange byteRange = null,
	44	421		IEnumerable<BatchClientBehavior> additionalBehaviors = null,
		422		CancellationToken cancellationToken = default(CancellationToken))
		423		{
		424		// create the behavior manager
	0	425		BehaviorManager bhMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors);
	0	426		return this.parentBatchClient.JobOperations.CopyNodeFileContentToStringAsyncImpl(
	0	427		this.parentJobId,
	0	428		this.Id,
	3034	429		filePath,
	2127	430		encoding,
	0	431		byteRange,
	0	432		bhMgr,
	0	433		cancellationToken);
		434		}
		435
		436		/// <summary>
		437		/// Reads the contents of a file in the task's directory on its compute node into a string.
	1001	438		/// </summary>
		439		/// <param name="filePath">The path of the file to retrieve.</param>
		440		/// <param name="encoding">The encoding to use. If no value or null is specified, UTF8 is used.</param>
		441		/// <param name="byteRange">A byte range defining what section of the file to copy. If omitted, the entire file
		442		/// <param name="additionalBehaviors">A collection of BatchClientBehavior instances that are applied after the C
		443		/// <returns>A bound <see cref="NodeFile"/> object.</returns>
		444		public string CopyNodeFileContentToString(
		445		string filePath,
	2111	446		Encoding encoding = null,
	65	447		GetFileRequestByteRange byteRange = null,
		448		IEnumerable<BatchClientBehavior> additionalBehaviors = null)
		449		{
	0	450		Task<string> asyncTask = this.CopyNodeFileContentToStringAsync(filePath, encoding, byteRange, additionalBeha
	0	451		return asyncTask.WaitAndUnaggregateException(this.CustomBehaviors, additionalBehaviors);
		452		}
		453
		454		#region IRefreshable
		455
	2111	456		/// <summary>
		457		/// Refreshes the current <see cref="CloudTask"/>.
		458		/// </summary>
	57	459		/// <param name="detailLevel">The detail level for the refresh.  If a detail level which omits the <see cref="Id
	56	460		/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are appli
		461		/// <param name="cancellationToken">A <see cref="CancellationToken"/> for controlling the lifetime of the asynch
		462		/// <returns>A <see cref="System.Threading.Tasks.Task"/> that represents the asynchronous operation.</returns>
		463		public async System.Threading.Tasks.Task RefreshAsync(
		464		DetailLevel detailLevel = null,
		465		IEnumerable<BatchClientBehavior> additionalBehaviors = null,
		466		CancellationToken cancellationToken = default(CancellationToken))
		467		{
	1	468		UtilitiesInternal.ThrowOnUnbound(this.propertyContainer.BindingState);
		469
		470		// create the behavior managaer
	0	471		BehaviorManager bhMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors, detailLevel);
	1001	472
	0	473		System.Threading.Tasks.Task<AzureOperationResponse<Models.CloudTask, Models.TaskGetHeaders>> asyncTask =
	0	474		this.parentBatchClient.ProtocolLayer.GetTask(
	0	475		this.parentJobId,
	0	476		this.Id,
	0	477		bhMgr,
	0	478		cancellationToken);
		479
	0	480		AzureOperationResponse<Models.CloudTask, Models.TaskGetHeaders> response = await asyncTask.ConfigureAwait(co
		481
		482		// get task from response
	0	483		Models.CloudTask newProtocolTask = response.Body;
	1001	484
		485		// immediately available to all threads
	0	486		this.propertyContainer = new PropertyContainer(newProtocolTask);
	0	487		}
		488
		489		/// <summary>
		490		/// Refreshes the current <see cref="CloudTask"/>.
		491		/// </summary>
		492		/// <param name="detailLevel">The detail level for the refresh.  If a detail level which omits the <see cref="Id
		493		/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are appli
		494		public void Refresh(
		495		DetailLevel detailLevel = null,
		496		IEnumerable<BatchClientBehavior> additionalBehaviors = null)
		497		{
	2111	498		Task asyncTask = RefreshAsync(detailLevel, additionalBehaviors);
	0	499		asyncTask.WaitAndUnaggregateException(this.CustomBehaviors, additionalBehaviors);
	0	500		}
	48	501
	47	502		#endregion IRefreshable
		503		}
		504		}

C:\Git\azure-sdk-for-net\sdk\batch\Microsoft.Azure.Batch\src\Generated\CloudTask.cs

	#	Line		Line coverage
		1		// Copyright (c) Microsoft Corporation. All rights reserved.
		2		// Licensed under the MIT License. See License.txt in the project root for license information.
		3		//
		4		// Code generated by Microsoft (R) AutoRest Code Generator.
		5		// Changes may cause incorrect behavior and will be lost if the code is
		6		// regenerated.
		7
		8		//
		9		// This file was autogenerated by a tool.
		10		// Do not modify it.
		11		//
		12
		13		namespace Microsoft.Azure.Batch
		14		{
		15		using FileStaging;
		16		using Models = Microsoft.Azure.Batch.Protocol.Models;
		17		using System;
		18		using System.Collections.Generic;
		19		using System.Linq;
		20
		21		/// <summary>
		22		/// An Azure Batch task. A task is a piece of work that is associated with a job and runs on a compute node.
		23		/// </summary>
		24		/// <remarks>
		25		/// Batch will retry tasks when a recovery operation is triggered on a compute node. Examples of recovery operations
		26		/// include (but are not limited to) when an unhealthy compute node is rebooted or a compute node disappeared due to
		27		/// host failure. Retries due to recovery operations are independent of and are not counted against the <see cref="T
		28		/// />. Even if the <see cref="TaskConstraints.MaxTaskRetryCount" /> is 0, an internal retry due to a recovery opera
		29		/// may occur. Because of this, all tasks should be idempotent. This means tasks need to tolerate being interrupted
		30		/// restarted without causing any corruption or duplicate data. The best practice for long running tasks is to use s
		31		/// form of checkpointing. The maximum lifetime of a task from addition to completion is 180 days. If a task has not
		32		/// completed within 180 days of being added it will be terminated by the Batch service and left in whatever state i
		33		/// was in at that time.
		34		/// </remarks>
		35		public partial class CloudTask : ITransportObjectProvider<Models.TaskAddParameter>, IInheritedBehaviors, IPropertyMe
		36		{
		37		private class PropertyContainer : PropertyCollection
		38		{
		39		public readonly PropertyAccessor<AffinityInformation> AffinityInformationProperty;
		40		public readonly PropertyAccessor<IList<ApplicationPackageReference>> ApplicationPackageReferencesProperty;
		41		public readonly PropertyAccessor<AuthenticationTokenSettings> AuthenticationTokenSettingsProperty;
		42		public readonly PropertyAccessor<string> CommandLineProperty;
		43		public readonly PropertyAccessor<ComputeNodeInformation> ComputeNodeInformationProperty;
		44		public readonly PropertyAccessor<TaskConstraints> ConstraintsProperty;
		45		public readonly PropertyAccessor<TaskContainerSettings> ContainerSettingsProperty;
		46		public readonly PropertyAccessor<DateTime?> CreationTimeProperty;
		47		public readonly PropertyAccessor<TaskDependencies> DependsOnProperty;
		48		public readonly PropertyAccessor<string> DisplayNameProperty;
		49		public readonly PropertyAccessor<IList<EnvironmentSetting>> EnvironmentSettingsProperty;
		50		public readonly PropertyAccessor<string> ETagProperty;
		51		public readonly PropertyAccessor<TaskExecutionInformation> ExecutionInformationProperty;
		52		public readonly PropertyAccessor<ExitConditions> ExitConditionsProperty;
		53		public readonly PropertyAccessor<IList<IFileStagingProvider>> FilesToStageProperty;
		54		public readonly PropertyAccessor<string> IdProperty;
		55		public readonly PropertyAccessor<DateTime?> LastModifiedProperty;
		56		public readonly PropertyAccessor<MultiInstanceSettings> MultiInstanceSettingsProperty;
		57		public readonly PropertyAccessor<IList<OutputFile>> OutputFilesProperty;
		58		public readonly PropertyAccessor<Common.TaskState?> PreviousStateProperty;
		59		public readonly PropertyAccessor<DateTime?> PreviousStateTransitionTimeProperty;
		60		public readonly PropertyAccessor<IList<ResourceFile>> ResourceFilesProperty;
		61		public readonly PropertyAccessor<Common.TaskState?> StateProperty;
		62		public readonly PropertyAccessor<DateTime?> StateTransitionTimeProperty;
		63		public readonly PropertyAccessor<TaskStatistics> StatisticsProperty;
		64		public readonly PropertyAccessor<string> UrlProperty;
		65		public readonly PropertyAccessor<UserIdentity> UserIdentityProperty;
		66
	0	67		public PropertyContainer() : base(BindingState.Unbound)
		68		{
	0	69		this.AffinityInformationProperty = this.CreatePropertyAccessor<AffinityInformation>(nameof(AffinityInfor
	0	70		this.ApplicationPackageReferencesProperty = this.CreatePropertyAccessor<IList<ApplicationPackageReferenc
	0	71		this.AuthenticationTokenSettingsProperty = this.CreatePropertyAccessor<AuthenticationTokenSettings>(name
	0	72		this.CommandLineProperty = this.CreatePropertyAccessor<string>(nameof(CommandLine), BindingAccess.Read |
	0	73		this.ComputeNodeInformationProperty = this.CreatePropertyAccessor<ComputeNodeInformation>(nameof(Compute
	0	74		this.ConstraintsProperty = this.CreatePropertyAccessor<TaskConstraints>(nameof(Constraints), BindingAcce
	0	75		this.ContainerSettingsProperty = this.CreatePropertyAccessor<TaskContainerSettings>(nameof(ContainerSett
	0	76		this.CreationTimeProperty = this.CreatePropertyAccessor<DateTime?>(nameof(CreationTime), BindingAccess.N
	0	77		this.DependsOnProperty = this.CreatePropertyAccessor<TaskDependencies>(nameof(DependsOn), BindingAccess.
	0	78		this.DisplayNameProperty = this.CreatePropertyAccessor<string>(nameof(DisplayName), BindingAccess.Read |
	0	79		this.EnvironmentSettingsProperty = this.CreatePropertyAccessor<IList<EnvironmentSetting>>(nameof(Environ
	0	80		this.ETagProperty = this.CreatePropertyAccessor<string>(nameof(ETag), BindingAccess.None);
	0	81		this.ExecutionInformationProperty = this.CreatePropertyAccessor<TaskExecutionInformation>(nameof(Executi
	0	82		this.ExitConditionsProperty = this.CreatePropertyAccessor<ExitConditions>(nameof(ExitConditions), Bindin
	0	83		this.FilesToStageProperty = this.CreatePropertyAccessor<IList<IFileStagingProvider>>(nameof(FilesToStage
	0	84		this.IdProperty = this.CreatePropertyAccessor<string>(nameof(Id), BindingAccess.Read | BindingAccess.Wri
	0	85		this.LastModifiedProperty = this.CreatePropertyAccessor<DateTime?>(nameof(LastModified), BindingAccess.N
	0	86		this.MultiInstanceSettingsProperty = this.CreatePropertyAccessor<MultiInstanceSettings>(nameof(MultiInst
	0	87		this.OutputFilesProperty = this.CreatePropertyAccessor<IList<OutputFile>>(nameof(OutputFiles), BindingAc
	0	88		this.PreviousStateProperty = this.CreatePropertyAccessor<Common.TaskState?>(nameof(PreviousState), Bindi
	0	89		this.PreviousStateTransitionTimeProperty = this.CreatePropertyAccessor<DateTime?>(nameof(PreviousStateTr
	0	90		this.ResourceFilesProperty = this.CreatePropertyAccessor<IList<ResourceFile>>(nameof(ResourceFiles), Bin
	0	91		this.StateProperty = this.CreatePropertyAccessor<Common.TaskState?>(nameof(State), BindingAccess.None);
	0	92		this.StateTransitionTimeProperty = this.CreatePropertyAccessor<DateTime?>(nameof(StateTransitionTime), B
	0	93		this.StatisticsProperty = this.CreatePropertyAccessor<TaskStatistics>(nameof(Statistics), BindingAccess.
	0	94		this.UrlProperty = this.CreatePropertyAccessor<string>(nameof(Url), BindingAccess.None);
	0	95		this.UserIdentityProperty = this.CreatePropertyAccessor<UserIdentity>(nameof(UserIdentity), BindingAcces
	0	96		}
		97
	0	98		public PropertyContainer(Models.CloudTask protocolObject) : base(BindingState.Bound)
		99		{
	0	100		this.AffinityInformationProperty = this.CreatePropertyAccessor(
	0	101		UtilitiesInternal.CreateObjectWithNullCheck(protocolObject.AffinityInfo, o => new AffinityInformatio
	0	102		nameof(AffinityInformation),
	0	103		BindingAccess.Read);
	0	104		this.ApplicationPackageReferencesProperty = this.CreatePropertyAccessor(
	0	105		ApplicationPackageReference.ConvertFromProtocolCollectionAndFreeze(protocolObject.ApplicationPackage
	0	106		nameof(ApplicationPackageReferences),
	0	107		BindingAccess.Read);
	0	108		this.AuthenticationTokenSettingsProperty = this.CreatePropertyAccessor(
	0	109		UtilitiesInternal.CreateObjectWithNullCheck(protocolObject.AuthenticationTokenSettings, o => new Aut
	0	110		nameof(AuthenticationTokenSettings),
	0	111		BindingAccess.Read);
	0	112		this.CommandLineProperty = this.CreatePropertyAccessor(
	0	113		protocolObject.CommandLine,
	0	114		nameof(CommandLine),
	0	115		BindingAccess.Read);
	0	116		this.ComputeNodeInformationProperty = this.CreatePropertyAccessor(
	0	117		UtilitiesInternal.CreateObjectWithNullCheck(protocolObject.NodeInfo, o => new ComputeNodeInformation
	0	118		nameof(ComputeNodeInformation),
	0	119		BindingAccess.Read);
	0	120		this.ConstraintsProperty = this.CreatePropertyAccessor(
	0	121		UtilitiesInternal.CreateObjectWithNullCheck(protocolObject.Constraints, o => new TaskConstraints(o))
	0	122		nameof(Constraints),
	0	123		BindingAccess.Read | BindingAccess.Write);
	0	124		this.ContainerSettingsProperty = this.CreatePropertyAccessor(
	0	125		UtilitiesInternal.CreateObjectWithNullCheck(protocolObject.ContainerSettings, o => new TaskContainer
	0	126		nameof(ContainerSettings),
	0	127		BindingAccess.Read);
	0	128		this.CreationTimeProperty = this.CreatePropertyAccessor(
	0	129		protocolObject.CreationTime,
	0	130		nameof(CreationTime),
	0	131		BindingAccess.Read);
	0	132		this.DependsOnProperty = this.CreatePropertyAccessor(
	0	133		UtilitiesInternal.CreateObjectWithNullCheck(protocolObject.DependsOn, o => new TaskDependencies(o).F
	0	134		nameof(DependsOn),
	0	135		BindingAccess.Read);
	0	136		this.DisplayNameProperty = this.CreatePropertyAccessor(
	0	137		protocolObject.DisplayName,
	0	138		nameof(DisplayName),
	0	139		BindingAccess.Read);
	0	140		this.EnvironmentSettingsProperty = this.CreatePropertyAccessor(
	0	141		EnvironmentSetting.ConvertFromProtocolCollectionAndFreeze(protocolObject.EnvironmentSettings),
	0	142		nameof(EnvironmentSettings),
	0	143		BindingAccess.Read);
	0	144		this.ETagProperty = this.CreatePropertyAccessor(
	0	145		protocolObject.ETag,
	0	146		nameof(ETag),
	0	147		BindingAccess.Read);
	0	148		this.ExecutionInformationProperty = this.CreatePropertyAccessor(
	0	149		UtilitiesInternal.CreateObjectWithNullCheck(protocolObject.ExecutionInfo, o => new TaskExecutionInfo
	0	150		nameof(ExecutionInformation),
	0	151		BindingAccess.Read);
	0	152		this.ExitConditionsProperty = this.CreatePropertyAccessor(
	0	153		UtilitiesInternal.CreateObjectWithNullCheck(protocolObject.ExitConditions, o => new ExitConditions(o
	0	154		nameof(ExitConditions),
	0	155		BindingAccess.Read);
	0	156		this.FilesToStageProperty = this.CreatePropertyAccessor<IList<IFileStagingProvider>>(
	0	157		nameof(FilesToStage),
	0	158		BindingAccess.None);
	0	159		this.IdProperty = this.CreatePropertyAccessor(
	0	160		protocolObject.Id,
	0	161		nameof(Id),
	0	162		BindingAccess.Read);
	0	163		this.LastModifiedProperty = this.CreatePropertyAccessor(
	0	164		protocolObject.LastModified,
	0	165		nameof(LastModified),
	0	166		BindingAccess.Read);
	0	167		this.MultiInstanceSettingsProperty = this.CreatePropertyAccessor(
	0	168		UtilitiesInternal.CreateObjectWithNullCheck(protocolObject.MultiInstanceSettings, o => new MultiInst
	0	169		nameof(MultiInstanceSettings),
	0	170		BindingAccess.Read);
	0	171		this.OutputFilesProperty = this.CreatePropertyAccessor(
	0	172		OutputFile.ConvertFromProtocolCollectionAndFreeze(protocolObject.OutputFiles),
	0	173		nameof(OutputFiles),
	0	174		BindingAccess.Read);
	0	175		this.PreviousStateProperty = this.CreatePropertyAccessor(
	0	176		UtilitiesInternal.MapNullableEnum<Models.TaskState, Common.TaskState>(protocolObject.PreviousState),
	0	177		nameof(PreviousState),
	0	178		BindingAccess.Read);
	0	179		this.PreviousStateTransitionTimeProperty = this.CreatePropertyAccessor(
	0	180		protocolObject.PreviousStateTransitionTime,
	0	181		nameof(PreviousStateTransitionTime),
	0	182		BindingAccess.Read);
	0	183		this.ResourceFilesProperty = this.CreatePropertyAccessor(
	0	184		ResourceFile.ConvertFromProtocolCollectionAndFreeze(protocolObject.ResourceFiles),
	0	185		nameof(ResourceFiles),
	0	186		BindingAccess.Read);
	0	187		this.StateProperty = this.CreatePropertyAccessor(
	0	188		UtilitiesInternal.MapNullableEnum<Models.TaskState, Common.TaskState>(protocolObject.State),
	0	189		nameof(State),
	0	190		BindingAccess.Read);
	0	191		this.StateTransitionTimeProperty = this.CreatePropertyAccessor(
	0	192		protocolObject.StateTransitionTime,
	0	193		nameof(StateTransitionTime),
	0	194		BindingAccess.Read);
	0	195		this.StatisticsProperty = this.CreatePropertyAccessor(
	0	196		UtilitiesInternal.CreateObjectWithNullCheck(protocolObject.Stats, o => new TaskStatistics(o).Freeze(
	0	197		nameof(Statistics),
	0	198		BindingAccess.Read);
	0	199		this.UrlProperty = this.CreatePropertyAccessor(
	0	200		protocolObject.Url,
	0	201		nameof(Url),
	0	202		BindingAccess.Read);
	0	203		this.UserIdentityProperty = this.CreatePropertyAccessor(
	0	204		UtilitiesInternal.CreateObjectWithNullCheck(protocolObject.UserIdentity, o => new UserIdentity(o).Fr
	0	205		nameof(UserIdentity),
	0	206		BindingAccess.Read);
	0	207		}
		208		}
		209
		210		private PropertyContainer propertyContainer;
		211
		212		private readonly BatchClient parentBatchClient;
		213		private readonly string parentJobId;
		214
		215		internal string ParentJobId
		216		{
		217		get
		218		{
	0	219		return this.parentJobId;
		220		}
		221		}
		222
		223		#region Constructors
		224
	0	225		internal CloudTask(
	0	226		BatchClient parentBatchClient,
	0	227		string parentJobId,
	0	228		Models.CloudTask protocolObject,
	0	229		IEnumerable<BatchClientBehavior> baseBehaviors)
		230		{
	0	231		this.parentJobId = parentJobId;
	0	232		this.parentBatchClient = parentBatchClient;
	0	233		InheritUtil.InheritClientBehaviorsAndSetPublicProperty(this, baseBehaviors);
	0	234		this.propertyContainer = new PropertyContainer(protocolObject);
	0	235		}
		236
		237		#endregion Constructors
		238
		239		#region IInheritedBehaviors
		240
		241		/// <summary>
		242		/// Gets or sets a list of behaviors that modify or customize requests to the Batch service
		243		/// made via this <see cref="CloudTask"/>.
		244		/// </summary>
		245		/// <remarks>
		246		/// <para>These behaviors are inherited by child objects.</para>
		247		/// <para>Modifications are applied in the order of the collection. The last write wins.</para>
		248		/// </remarks>
	0	249		public IList<BatchClientBehavior> CustomBehaviors { get; set; }
		250
		251		#endregion IInheritedBehaviors
		252
		253		#region CloudTask
		254
		255		/// <summary>
		256		/// Gets or sets a locality hint that can be used by the Batch service to select a node on which to start the ta
		257		/// </summary>
		258		public AffinityInformation AffinityInformation
		259		{
	0	260		get { return this.propertyContainer.AffinityInformationProperty.Value; }
	0	261		set { this.propertyContainer.AffinityInformationProperty.Value = value; }
		262		}
		263
		264		/// <summary>
		265		/// Gets or sets a list of application packages that the Batch service will deploy to the compute node before ru
		266		/// the command line.
		267		/// </summary>
		268		public IList<ApplicationPackageReference> ApplicationPackageReferences
		269		{
	0	270		get { return this.propertyContainer.ApplicationPackageReferencesProperty.Value; }
		271		set
		272		{
	0	273		this.propertyContainer.ApplicationPackageReferencesProperty.Value = ConcurrentChangeTrackedModifiableLis
	0	274		}
		275		}
		276
		277		/// <summary>
		278		/// Gets or sets the settings for an authentication token that the task can use to perform Batch service operati
		279		/// </summary>
		280		/// <remarks>
		281		/// If this property is set, the Batch service provides the task with an authentication token which can be used
		282		/// authenticate Batch service operations without requiring an account access key. The token is provided via the
		283		/// AZ_BATCH_AUTHENTICATION_TOKEN environment variable. The operations that the task can carry out using the tok
		284		/// depend on the settings. For example, a task can request job permissions in order to add other tasks to the j
		285		/// or check the status of the job or of other tasks.
		286		/// </remarks>
		287		public AuthenticationTokenSettings AuthenticationTokenSettings
		288		{
	0	289		get { return this.propertyContainer.AuthenticationTokenSettingsProperty.Value; }
	0	290		set { this.propertyContainer.AuthenticationTokenSettingsProperty.Value = value; }
		291		}
		292
		293		/// <summary>
		294		/// Gets or sets the command line of the task.
		295		/// </summary>
		296		/// <remarks>
		297		/// The command line does not run under a shell, and therefore cannot take advantage of shell features such as e
		298		/// variable expansion. If you want to take advantage of such features, you should invoke the shell in the comma
		299		/// line, for example using \"cmd /c MyCommand\" in Windows or \"/bin/sh -c MyCommand\" in Linux. If the command
		300		/// line refers to file paths, it should use a relative path (relative to the task working directory), or use th
		301		/// Batch provided environment variables (https://docs.microsoft.com/en-us/azure/batch/batch-compute-node-enviro
		302		/// </remarks>
		303		public string CommandLine
		304		{
	0	305		get { return this.propertyContainer.CommandLineProperty.Value; }
	0	306		set { this.propertyContainer.CommandLineProperty.Value = value; }
		307		}
		308
		309		/// <summary>
		310		/// Gets information about the compute node on which the task ran.
		311		/// </summary>
		312		public ComputeNodeInformation ComputeNodeInformation
		313		{
	0	314		get { return this.propertyContainer.ComputeNodeInformationProperty.Value; }
		315		}
		316
		317		/// <summary>
		318		/// Gets or sets the execution constraints that apply to this task.
		319		/// </summary>
		320		public TaskConstraints Constraints
		321		{
	0	322		get { return this.propertyContainer.ConstraintsProperty.Value; }
	0	323		set { this.propertyContainer.ConstraintsProperty.Value = value; }
		324		}
		325
		326		/// <summary>
		327		/// Gets or sets the settings for the container under which the task runs.
		328		/// </summary>
		329		/// <remarks>
		330		/// If the pool that will run this task has <see cref="VirtualMachineConfiguration.ContainerConfiguration"/> set
		331		/// this must be set as well. If the pool that will run this task doesn't have <see cref="VirtualMachineConfigur
		332		/// set, this must not be set. When this is specified, all directories recursively below the AZ_BATCH_NODE_ROOT_
		333		/// (the root of Azure Batch directories on the node) are mapped into the container, all task environment variab
		334		/// are mapped into the container, and the task command line is executed in the container. Files produced in the
		335		/// container outside of AZ_BATCH_NODE_ROOT_DIR might not be reflected to the host disk, meaning that Batch file
		336		/// APIs will not be able to access them.
		337		/// </remarks>
		338		public TaskContainerSettings ContainerSettings
		339		{
	0	340		get { return this.propertyContainer.ContainerSettingsProperty.Value; }
	0	341		set { this.propertyContainer.ContainerSettingsProperty.Value = value; }
		342		}
		343
		344		/// <summary>
		345		/// Gets the creation time of the task.
		346		/// </summary>
		347		public DateTime? CreationTime
		348		{
	0	349		get { return this.propertyContainer.CreationTimeProperty.Value; }
		350		}
		351
		352		/// <summary>
		353		/// Gets or sets any other tasks that this <see cref="CloudTask"/> depends on. The task will not be scheduled un
		354		/// all depended-on tasks have completed successfully.
		355		/// </summary>
		356		/// <remarks>
		357		/// The job must set <see cref="CloudJob.UsesTaskDependencies"/> to true in order to use task dependencies. If U
		358		/// is false (the default), adding a task with dependencies will fail with an error.
		359		/// </remarks>
		360		public TaskDependencies DependsOn
		361		{
	0	362		get { return this.propertyContainer.DependsOnProperty.Value; }
	0	363		set { this.propertyContainer.DependsOnProperty.Value = value; }
		364		}
		365
		366		/// <summary>
		367		/// Gets or sets the display name of the task.
		368		/// </summary>
		369		public string DisplayName
		370		{
	0	371		get { return this.propertyContainer.DisplayNameProperty.Value; }
	0	372		set { this.propertyContainer.DisplayNameProperty.Value = value; }
		373		}
		374
		375		/// <summary>
		376		/// Gets or sets a list of environment variable settings for the task.
		377		/// </summary>
		378		public IList<EnvironmentSetting> EnvironmentSettings
		379		{
	0	380		get { return this.propertyContainer.EnvironmentSettingsProperty.Value; }
		381		set
		382		{
	0	383		this.propertyContainer.EnvironmentSettingsProperty.Value = ConcurrentChangeTrackedModifiableList<Environ
	0	384		}
		385		}
		386
		387		/// <summary>
		388		/// Gets the ETag for the task.
		389		/// </summary>
		390		public string ETag
		391		{
	0	392		get { return this.propertyContainer.ETagProperty.Value; }
		393		}
		394
		395		/// <summary>
		396		/// Gets the execution information for the task.
		397		/// </summary>
		398		public TaskExecutionInformation ExecutionInformation
		399		{
	0	400		get { return this.propertyContainer.ExecutionInformationProperty.Value; }
		401		}
		402
		403		/// <summary>
		404		/// Gets or sets how the Batch service should respond when the task completes.
		405		/// </summary>
		406		public ExitConditions ExitConditions
		407		{
	0	408		get { return this.propertyContainer.ExitConditionsProperty.Value; }
	0	409		set { this.propertyContainer.ExitConditionsProperty.Value = value; }
		410		}
		411
		412		/// <summary>
		413		/// Gets or sets a list of files to be staged for the task.
		414		/// </summary>
		415		public IList<IFileStagingProvider> FilesToStage
		416		{
	0	417		get { return this.propertyContainer.FilesToStageProperty.Value; }
		418		set
		419		{
	0	420		this.propertyContainer.FilesToStageProperty.Value = ConcurrentChangeTrackedList<IFileStagingProvider>.Tr
	0	421		}
		422		}
		423
		424		/// <summary>
		425		/// Gets or sets the id of the task.
		426		/// </summary>
		427		public string Id
		428		{
	0	429		get { return this.propertyContainer.IdProperty.Value; }
	0	430		set { this.propertyContainer.IdProperty.Value = value; }
		431		}
		432
		433		/// <summary>
		434		/// Gets the last modified time of the task.
		435		/// </summary>
		436		public DateTime? LastModified
		437		{
	0	438		get { return this.propertyContainer.LastModifiedProperty.Value; }
		439		}
		440
		441		/// <summary>
		442		/// Gets or sets information about how to run the multi-instance task.
		443		/// </summary>
		444		public MultiInstanceSettings MultiInstanceSettings
		445		{
	0	446		get { return this.propertyContainer.MultiInstanceSettingsProperty.Value; }
	0	447		set { this.propertyContainer.MultiInstanceSettingsProperty.Value = value; }
		448		}
		449
		450		/// <summary>
		451		/// Gets or sets a list of files that the Batch service will upload from the compute node after running the comm
		452		/// line.
		453		/// </summary>
		454		public IList<OutputFile> OutputFiles
		455		{
	0	456		get { return this.propertyContainer.OutputFilesProperty.Value; }
		457		set
		458		{
	0	459		this.propertyContainer.OutputFilesProperty.Value = ConcurrentChangeTrackedModifiableList<OutputFile>.Tra
	0	460		}
		461		}
		462
		463		/// <summary>
		464		/// Gets the previous state of the task.
		465		/// </summary>
		466		/// <remarks>
		467		/// If the task is in its initial <see cref="Common.TaskState.Active"/> state, the PreviousState property is not
		468		/// defined.
		469		/// </remarks>
		470		public Common.TaskState? PreviousState
		471		{
	0	472		get { return this.propertyContainer.PreviousStateProperty.Value; }
		473		}
		474
		475		/// <summary>
		476		/// Gets the time at which the task entered its previous state.
		477		/// </summary>
		478		/// <remarks>
		479		/// If the task is in its initial <see cref="Common.TaskState.Active"/> state, the PreviousStateTransitionTime p
		480		/// is not defined.
		481		/// </remarks>
		482		public DateTime? PreviousStateTransitionTime
		483		{
	0	484		get { return this.propertyContainer.PreviousStateTransitionTimeProperty.Value; }
		485		}
		486
		487		/// <summary>
		488		/// Gets or sets a list of files that the Batch service will download to the compute node before running the com
		489		/// line.
		490		/// </summary>
		491		/// <remarks>
		492		/// There is a maximum size for the list of resource files. When the max size is exceeded, the request will fail
		493		/// and the response error code will be RequestEntityTooLarge. If this occurs, the collection of resource files
		494		/// be reduced in size. This can be achieved using .zip files, Application Packages, or Docker Containers.
		495		/// </remarks>
		496		public IList<ResourceFile> ResourceFiles
		497		{
	0	498		get { return this.propertyContainer.ResourceFilesProperty.Value; }
		499		set
		500		{
	0	501		this.propertyContainer.ResourceFilesProperty.Value = ConcurrentChangeTrackedModifiableList<ResourceFile>
	0	502		}
		503		}
		504
		505		/// <summary>
		506		/// Gets the current state of the task.
		507		/// </summary>
		508		public Common.TaskState? State
		509		{
	0	510		get { return this.propertyContainer.StateProperty.Value; }
		511		}
		512
		513		/// <summary>
		514		/// Gets the time at which the task entered its current state.
		515		/// </summary>
		516		public DateTime? StateTransitionTime
		517		{
	0	518		get { return this.propertyContainer.StateTransitionTimeProperty.Value; }
		519		}
		520
		521		/// <summary>
		522		/// Gets resource usage statistics for the task.
		523		/// </summary>
		524		/// <remarks>
		525		/// This property is populated only if the <see cref="CloudTask"/> was retrieved with an <see cref="ODATADetailL
		526		/// including the 'stats' attribute; otherwise it is null.
		527		/// </remarks>
		528		public TaskStatistics Statistics
		529		{
	0	530		get { return this.propertyContainer.StatisticsProperty.Value; }
		531		}
		532
		533		/// <summary>
		534		/// Gets the URL of the task.
		535		/// </summary>
		536		public string Url
		537		{
	0	538		get { return this.propertyContainer.UrlProperty.Value; }
		539		}
		540
		541		/// <summary>
		542		/// Gets or sets the user identity under which the task runs.
		543		/// </summary>
		544		/// <remarks>
		545		/// If omitted, the task runs as a non-administrative user unique to the task.
		546		/// </remarks>
		547		public UserIdentity UserIdentity
		548		{
	0	549		get { return this.propertyContainer.UserIdentityProperty.Value; }
	0	550		set { this.propertyContainer.UserIdentityProperty.Value = value; }
		551		}
		552
		553		#endregion // CloudTask
		554
		555		#region IPropertyMetadata
		556
		557		bool IModifiable.HasBeenModified
		558		{
	0	559		get { return this.propertyContainer.HasBeenModified; }
		560		}
		561
		562		bool IReadOnly.IsReadOnly
		563		{
	0	564		get { return this.propertyContainer.IsReadOnly; }
	0	565		set { this.propertyContainer.IsReadOnly = value; }
		566		}
		567
		568		#endregion //IPropertyMetadata
		569
		570		#region Internal/private methods
		571		/// <summary>
		572		/// Return a protocol object of the requested type.
		573		/// </summary>
		574		/// <returns>The protocol object of the requested type.</returns>
		575		Models.TaskAddParameter ITransportObjectProvider<Models.TaskAddParameter>.GetTransportObject()
		576		{
	0	577		Models.TaskAddParameter result = new Models.TaskAddParameter()
	0	578		{
	0	579		AffinityInfo = UtilitiesInternal.CreateObjectWithNullCheck(this.AffinityInformation, (o) => o.GetTranspo
	0	580		ApplicationPackageReferences = UtilitiesInternal.ConvertToProtocolCollection(this.ApplicationPackageRefe
	0	581		AuthenticationTokenSettings = UtilitiesInternal.CreateObjectWithNullCheck(this.AuthenticationTokenSettin
	0	582		CommandLine = this.CommandLine,
	0	583		Constraints = UtilitiesInternal.CreateObjectWithNullCheck(this.Constraints, (o) => o.GetTransportObject(
	0	584		ContainerSettings = UtilitiesInternal.CreateObjectWithNullCheck(this.ContainerSettings, (o) => o.GetTran
	0	585		DependsOn = UtilitiesInternal.CreateObjectWithNullCheck(this.DependsOn, (o) => o.GetTransportObject()),
	0	586		DisplayName = this.DisplayName,
	0	587		EnvironmentSettings = UtilitiesInternal.ConvertToProtocolCollection(this.EnvironmentSettings),
	0	588		ExitConditions = UtilitiesInternal.CreateObjectWithNullCheck(this.ExitConditions, (o) => o.GetTransportO
	0	589		Id = this.Id,
	0	590		MultiInstanceSettings = UtilitiesInternal.CreateObjectWithNullCheck(this.MultiInstanceSettings, (o) => o
	0	591		OutputFiles = UtilitiesInternal.ConvertToProtocolCollection(this.OutputFiles),
	0	592		ResourceFiles = UtilitiesInternal.ConvertToProtocolCollection(this.ResourceFiles),
	0	593		UserIdentity = UtilitiesInternal.CreateObjectWithNullCheck(this.UserIdentity, (o) => o.GetTransportObjec
	0	594		};
		595
	0	596		return result;
		597		}
		598
		599
		600		#endregion // Internal/private methods
		601		}
		602		}