Cloud AI Platform v1 API - Class TensorboardServiceClient (2.7.0)

public abstract class TensorboardServiceClient

Namespace

Assembly

Google.Cloud.AIPlatform.V1.dll

Remarks

Properties

CreateTensorboardOperationsClient

public virtual OperationsClient CreateTensorboardOperationsClient { get; }

DefaultEndpoint

public static string DefaultEndpoint { get; }

DefaultScopes

public static IReadOnlyList<string> DefaultScopes { get; }

DeleteTensorboardExperimentOperationsClient

public virtual OperationsClient DeleteTensorboardExperimentOperationsClient { get; }

DeleteTensorboardOperationsClient

public virtual OperationsClient DeleteTensorboardOperationsClient { get; }

DeleteTensorboardRunOperationsClient

public virtual OperationsClient DeleteTensorboardRunOperationsClient { get; }

DeleteTensorboardTimeSeriesOperationsClient

public virtual OperationsClient DeleteTensorboardTimeSeriesOperationsClient { get; }

GrpcClient

public virtual TensorboardService.TensorboardServiceClient GrpcClient { get; }

IAMPolicyClient

public virtual IAMPolicyClient IAMPolicyClient { get; }

LocationsClient

public virtual LocationsClient LocationsClient { get; }

ServiceMetadata

public static ServiceMetadata ServiceMetadata { get; }

UpdateTensorboardOperationsClient

public virtual OperationsClient UpdateTensorboardOperationsClient { get; }

Methods

BatchCreateTensorboardRuns(BatchCreateTensorboardRunsRequest, CallSettings)

public virtual BatchCreateTensorboardRunsResponse BatchCreateTensorboardRuns(BatchCreateTensorboardRunsRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
BatchCreateTensorboardRunsRequest request = new BatchCreateTensorboardRunsRequest
{
    ParentAsTensorboardExperimentName = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]"),
    Requests =
    {
        new CreateTensorboardRunRequest(),
    },
};
// Make the request
BatchCreateTensorboardRunsResponse response = tensorboardServiceClient.BatchCreateTensorboardRuns(request);

BatchCreateTensorboardRuns(TensorboardExperimentName, IEnumerable<CreateTensorboardRunRequest>, CallSettings)

public virtual BatchCreateTensorboardRunsResponse BatchCreateTensorboardRuns(TensorboardExperimentName parent, IEnumerable<CreateTensorboardRunRequest> requests, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
TensorboardExperimentName parent = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]");
IEnumerable<CreateTensorboardRunRequest> requests = new CreateTensorboardRunRequest[]
{
    new CreateTensorboardRunRequest(),
};
// Make the request
BatchCreateTensorboardRunsResponse response = tensorboardServiceClient.BatchCreateTensorboardRuns(parent, requests);

BatchCreateTensorboardRuns(String, IEnumerable<CreateTensorboardRunRequest>, CallSettings)

public virtual BatchCreateTensorboardRunsResponse BatchCreateTensorboardRuns(string parent, IEnumerable<CreateTensorboardRunRequest> requests, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]";
IEnumerable<CreateTensorboardRunRequest> requests = new CreateTensorboardRunRequest[]
{
    new CreateTensorboardRunRequest(),
};
// Make the request
BatchCreateTensorboardRunsResponse response = tensorboardServiceClient.BatchCreateTensorboardRuns(parent, requests);

BatchCreateTensorboardRunsAsync(BatchCreateTensorboardRunsRequest, CallSettings)

public virtual Task<BatchCreateTensorboardRunsResponse> BatchCreateTensorboardRunsAsync(BatchCreateTensorboardRunsRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
BatchCreateTensorboardRunsRequest request = new BatchCreateTensorboardRunsRequest
{
    ParentAsTensorboardExperimentName = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]"),
    Requests =
    {
        new CreateTensorboardRunRequest(),
    },
};
// Make the request
BatchCreateTensorboardRunsResponse response = await tensorboardServiceClient.BatchCreateTensorboardRunsAsync(request);

BatchCreateTensorboardRunsAsync(BatchCreateTensorboardRunsRequest, CancellationToken)

public virtual Task<BatchCreateTensorboardRunsResponse> BatchCreateTensorboardRunsAsync(BatchCreateTensorboardRunsRequest request, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
BatchCreateTensorboardRunsRequest request = new BatchCreateTensorboardRunsRequest
{
    ParentAsTensorboardExperimentName = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]"),
    Requests =
    {
        new CreateTensorboardRunRequest(),
    },
};
// Make the request
BatchCreateTensorboardRunsResponse response = await tensorboardServiceClient.BatchCreateTensorboardRunsAsync(request);

BatchCreateTensorboardRunsAsync(TensorboardExperimentName, IEnumerable<CreateTensorboardRunRequest>, CallSettings)

public virtual Task<BatchCreateTensorboardRunsResponse> BatchCreateTensorboardRunsAsync(TensorboardExperimentName parent, IEnumerable<CreateTensorboardRunRequest> requests, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
TensorboardExperimentName parent = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]");
IEnumerable<CreateTensorboardRunRequest> requests = new CreateTensorboardRunRequest[]
{
    new CreateTensorboardRunRequest(),
};
// Make the request
BatchCreateTensorboardRunsResponse response = await tensorboardServiceClient.BatchCreateTensorboardRunsAsync(parent, requests);

BatchCreateTensorboardRunsAsync(TensorboardExperimentName, IEnumerable<CreateTensorboardRunRequest>, CancellationToken)

public virtual Task<BatchCreateTensorboardRunsResponse> BatchCreateTensorboardRunsAsync(TensorboardExperimentName parent, IEnumerable<CreateTensorboardRunRequest> requests, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
TensorboardExperimentName parent = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]");
IEnumerable<CreateTensorboardRunRequest> requests = new CreateTensorboardRunRequest[]
{
    new CreateTensorboardRunRequest(),
};
// Make the request
BatchCreateTensorboardRunsResponse response = await tensorboardServiceClient.BatchCreateTensorboardRunsAsync(parent, requests);

BatchCreateTensorboardRunsAsync(String, IEnumerable<CreateTensorboardRunRequest>, CallSettings)

public virtual Task<BatchCreateTensorboardRunsResponse> BatchCreateTensorboardRunsAsync(string parent, IEnumerable<CreateTensorboardRunRequest> requests, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]";
IEnumerable<CreateTensorboardRunRequest> requests = new CreateTensorboardRunRequest[]
{
    new CreateTensorboardRunRequest(),
};
// Make the request
BatchCreateTensorboardRunsResponse response = await tensorboardServiceClient.BatchCreateTensorboardRunsAsync(parent, requests);

BatchCreateTensorboardRunsAsync(String, IEnumerable<CreateTensorboardRunRequest>, CancellationToken)

public virtual Task<BatchCreateTensorboardRunsResponse> BatchCreateTensorboardRunsAsync(string parent, IEnumerable<CreateTensorboardRunRequest> requests, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]";
IEnumerable<CreateTensorboardRunRequest> requests = new CreateTensorboardRunRequest[]
{
    new CreateTensorboardRunRequest(),
};
// Make the request
BatchCreateTensorboardRunsResponse response = await tensorboardServiceClient.BatchCreateTensorboardRunsAsync(parent, requests);

BatchCreateTensorboardTimeSeries(BatchCreateTensorboardTimeSeriesRequest, CallSettings)

public virtual BatchCreateTensorboardTimeSeriesResponse BatchCreateTensorboardTimeSeries(BatchCreateTensorboardTimeSeriesRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
BatchCreateTensorboardTimeSeriesRequest request = new BatchCreateTensorboardTimeSeriesRequest
{
    ParentAsTensorboardExperimentName = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]"),
    Requests =
    {
        new CreateTensorboardTimeSeriesRequest(),
    },
};
// Make the request
BatchCreateTensorboardTimeSeriesResponse response = tensorboardServiceClient.BatchCreateTensorboardTimeSeries(request);

BatchCreateTensorboardTimeSeries(TensorboardExperimentName, IEnumerable<CreateTensorboardTimeSeriesRequest>, CallSettings)

public virtual BatchCreateTensorboardTimeSeriesResponse BatchCreateTensorboardTimeSeries(TensorboardExperimentName parent, IEnumerable<CreateTensorboardTimeSeriesRequest> requests, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
TensorboardExperimentName parent = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]");
IEnumerable<CreateTensorboardTimeSeriesRequest> requests = new CreateTensorboardTimeSeriesRequest[]
{
    new CreateTensorboardTimeSeriesRequest(),
};
// Make the request
BatchCreateTensorboardTimeSeriesResponse response = tensorboardServiceClient.BatchCreateTensorboardTimeSeries(parent, requests);

BatchCreateTensorboardTimeSeries(String, IEnumerable<CreateTensorboardTimeSeriesRequest>, CallSettings)

public virtual BatchCreateTensorboardTimeSeriesResponse BatchCreateTensorboardTimeSeries(string parent, IEnumerable<CreateTensorboardTimeSeriesRequest> requests, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]";
IEnumerable<CreateTensorboardTimeSeriesRequest> requests = new CreateTensorboardTimeSeriesRequest[]
{
    new CreateTensorboardTimeSeriesRequest(),
};
// Make the request
BatchCreateTensorboardTimeSeriesResponse response = tensorboardServiceClient.BatchCreateTensorboardTimeSeries(parent, requests);

BatchCreateTensorboardTimeSeriesAsync(BatchCreateTensorboardTimeSeriesRequest, CallSettings)

public virtual Task<BatchCreateTensorboardTimeSeriesResponse> BatchCreateTensorboardTimeSeriesAsync(BatchCreateTensorboardTimeSeriesRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
BatchCreateTensorboardTimeSeriesRequest request = new BatchCreateTensorboardTimeSeriesRequest
{
    ParentAsTensorboardExperimentName = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]"),
    Requests =
    {
        new CreateTensorboardTimeSeriesRequest(),
    },
};
// Make the request
BatchCreateTensorboardTimeSeriesResponse response = await tensorboardServiceClient.BatchCreateTensorboardTimeSeriesAsync(request);

BatchCreateTensorboardTimeSeriesAsync(BatchCreateTensorboardTimeSeriesRequest, CancellationToken)

public virtual Task<BatchCreateTensorboardTimeSeriesResponse> BatchCreateTensorboardTimeSeriesAsync(BatchCreateTensorboardTimeSeriesRequest request, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
BatchCreateTensorboardTimeSeriesRequest request = new BatchCreateTensorboardTimeSeriesRequest
{
    ParentAsTensorboardExperimentName = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]"),
    Requests =
    {
        new CreateTensorboardTimeSeriesRequest(),
    },
};
// Make the request
BatchCreateTensorboardTimeSeriesResponse response = await tensorboardServiceClient.BatchCreateTensorboardTimeSeriesAsync(request);

BatchCreateTensorboardTimeSeriesAsync(TensorboardExperimentName, IEnumerable<CreateTensorboardTimeSeriesRequest>, CallSettings)

public virtual Task<BatchCreateTensorboardTimeSeriesResponse> BatchCreateTensorboardTimeSeriesAsync(TensorboardExperimentName parent, IEnumerable<CreateTensorboardTimeSeriesRequest> requests, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
TensorboardExperimentName parent = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]");
IEnumerable<CreateTensorboardTimeSeriesRequest> requests = new CreateTensorboardTimeSeriesRequest[]
{
    new CreateTensorboardTimeSeriesRequest(),
};
// Make the request
BatchCreateTensorboardTimeSeriesResponse response = await tensorboardServiceClient.BatchCreateTensorboardTimeSeriesAsync(parent, requests);

BatchCreateTensorboardTimeSeriesAsync(TensorboardExperimentName, IEnumerable<CreateTensorboardTimeSeriesRequest>, CancellationToken)

public virtual Task<BatchCreateTensorboardTimeSeriesResponse> BatchCreateTensorboardTimeSeriesAsync(TensorboardExperimentName parent, IEnumerable<CreateTensorboardTimeSeriesRequest> requests, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
TensorboardExperimentName parent = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]");
IEnumerable<CreateTensorboardTimeSeriesRequest> requests = new CreateTensorboardTimeSeriesRequest[]
{
    new CreateTensorboardTimeSeriesRequest(),
};
// Make the request
BatchCreateTensorboardTimeSeriesResponse response = await tensorboardServiceClient.BatchCreateTensorboardTimeSeriesAsync(parent, requests);

BatchCreateTensorboardTimeSeriesAsync(String, IEnumerable<CreateTensorboardTimeSeriesRequest>, CallSettings)

public virtual Task<BatchCreateTensorboardTimeSeriesResponse> BatchCreateTensorboardTimeSeriesAsync(string parent, IEnumerable<CreateTensorboardTimeSeriesRequest> requests, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]";
IEnumerable<CreateTensorboardTimeSeriesRequest> requests = new CreateTensorboardTimeSeriesRequest[]
{
    new CreateTensorboardTimeSeriesRequest(),
};
// Make the request
BatchCreateTensorboardTimeSeriesResponse response = await tensorboardServiceClient.BatchCreateTensorboardTimeSeriesAsync(parent, requests);

BatchCreateTensorboardTimeSeriesAsync(String, IEnumerable<CreateTensorboardTimeSeriesRequest>, CancellationToken)

public virtual Task<BatchCreateTensorboardTimeSeriesResponse> BatchCreateTensorboardTimeSeriesAsync(string parent, IEnumerable<CreateTensorboardTimeSeriesRequest> requests, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]";
IEnumerable<CreateTensorboardTimeSeriesRequest> requests = new CreateTensorboardTimeSeriesRequest[]
{
    new CreateTensorboardTimeSeriesRequest(),
};
// Make the request
BatchCreateTensorboardTimeSeriesResponse response = await tensorboardServiceClient.BatchCreateTensorboardTimeSeriesAsync(parent, requests);

BatchReadTensorboardTimeSeriesData(BatchReadTensorboardTimeSeriesDataRequest, CallSettings)

public virtual BatchReadTensorboardTimeSeriesDataResponse BatchReadTensorboardTimeSeriesData(BatchReadTensorboardTimeSeriesDataRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
BatchReadTensorboardTimeSeriesDataRequest request = new BatchReadTensorboardTimeSeriesDataRequest
{
    TensorboardAsTensorboardName = TensorboardName.FromProjectLocationTensorboard("[PROJECT]", "[LOCATION]", "[TENSORBOARD]"),
    TimeSeriesAsTensorboardTimeSeriesNames =
    {
        TensorboardTimeSeriesName.FromProjectLocationTensorboardExperimentRunTimeSeries("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]", "[TIME_SERIES]"),
    },
};
// Make the request
BatchReadTensorboardTimeSeriesDataResponse response = tensorboardServiceClient.BatchReadTensorboardTimeSeriesData(request);

BatchReadTensorboardTimeSeriesData(TensorboardName, CallSettings)

public virtual BatchReadTensorboardTimeSeriesDataResponse BatchReadTensorboardTimeSeriesData(TensorboardName tensorboard, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
TensorboardName tensorboard = TensorboardName.FromProjectLocationTensorboard("[PROJECT]", "[LOCATION]", "[TENSORBOARD]");
// Make the request
BatchReadTensorboardTimeSeriesDataResponse response = tensorboardServiceClient.BatchReadTensorboardTimeSeriesData(tensorboard);

BatchReadTensorboardTimeSeriesData(String, CallSettings)

public virtual BatchReadTensorboardTimeSeriesDataResponse BatchReadTensorboardTimeSeriesData(string tensorboard, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
string tensorboard = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]";
// Make the request
BatchReadTensorboardTimeSeriesDataResponse response = tensorboardServiceClient.BatchReadTensorboardTimeSeriesData(tensorboard);

BatchReadTensorboardTimeSeriesDataAsync(BatchReadTensorboardTimeSeriesDataRequest, CallSettings)

public virtual Task<BatchReadTensorboardTimeSeriesDataResponse> BatchReadTensorboardTimeSeriesDataAsync(BatchReadTensorboardTimeSeriesDataRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
BatchReadTensorboardTimeSeriesDataRequest request = new BatchReadTensorboardTimeSeriesDataRequest
{
    TensorboardAsTensorboardName = TensorboardName.FromProjectLocationTensorboard("[PROJECT]", "[LOCATION]", "[TENSORBOARD]"),
    TimeSeriesAsTensorboardTimeSeriesNames =
    {
        TensorboardTimeSeriesName.FromProjectLocationTensorboardExperimentRunTimeSeries("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]", "[TIME_SERIES]"),
    },
};
// Make the request
BatchReadTensorboardTimeSeriesDataResponse response = await tensorboardServiceClient.BatchReadTensorboardTimeSeriesDataAsync(request);

BatchReadTensorboardTimeSeriesDataAsync(BatchReadTensorboardTimeSeriesDataRequest, CancellationToken)

public virtual Task<BatchReadTensorboardTimeSeriesDataResponse> BatchReadTensorboardTimeSeriesDataAsync(BatchReadTensorboardTimeSeriesDataRequest request, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
BatchReadTensorboardTimeSeriesDataRequest request = new BatchReadTensorboardTimeSeriesDataRequest
{
    TensorboardAsTensorboardName = TensorboardName.FromProjectLocationTensorboard("[PROJECT]", "[LOCATION]", "[TENSORBOARD]"),
    TimeSeriesAsTensorboardTimeSeriesNames =
    {
        TensorboardTimeSeriesName.FromProjectLocationTensorboardExperimentRunTimeSeries("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]", "[TIME_SERIES]"),
    },
};
// Make the request
BatchReadTensorboardTimeSeriesDataResponse response = await tensorboardServiceClient.BatchReadTensorboardTimeSeriesDataAsync(request);

BatchReadTensorboardTimeSeriesDataAsync(TensorboardName, CallSettings)

public virtual Task<BatchReadTensorboardTimeSeriesDataResponse> BatchReadTensorboardTimeSeriesDataAsync(TensorboardName tensorboard, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
TensorboardName tensorboard = TensorboardName.FromProjectLocationTensorboard("[PROJECT]", "[LOCATION]", "[TENSORBOARD]");
// Make the request
BatchReadTensorboardTimeSeriesDataResponse response = await tensorboardServiceClient.BatchReadTensorboardTimeSeriesDataAsync(tensorboard);

BatchReadTensorboardTimeSeriesDataAsync(TensorboardName, CancellationToken)

public virtual Task<BatchReadTensorboardTimeSeriesDataResponse> BatchReadTensorboardTimeSeriesDataAsync(TensorboardName tensorboard, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
TensorboardName tensorboard = TensorboardName.FromProjectLocationTensorboard("[PROJECT]", "[LOCATION]", "[TENSORBOARD]");
// Make the request
BatchReadTensorboardTimeSeriesDataResponse response = await tensorboardServiceClient.BatchReadTensorboardTimeSeriesDataAsync(tensorboard);

BatchReadTensorboardTimeSeriesDataAsync(String, CallSettings)

public virtual Task<BatchReadTensorboardTimeSeriesDataResponse> BatchReadTensorboardTimeSeriesDataAsync(string tensorboard, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
string tensorboard = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]";
// Make the request
BatchReadTensorboardTimeSeriesDataResponse response = await tensorboardServiceClient.BatchReadTensorboardTimeSeriesDataAsync(tensorboard);

BatchReadTensorboardTimeSeriesDataAsync(String, CancellationToken)

public virtual Task<BatchReadTensorboardTimeSeriesDataResponse> BatchReadTensorboardTimeSeriesDataAsync(string tensorboard, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
string tensorboard = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]";
// Make the request
BatchReadTensorboardTimeSeriesDataResponse response = await tensorboardServiceClient.BatchReadTensorboardTimeSeriesDataAsync(tensorboard);

Create()

public static TensorboardServiceClient Create()

CreateAsync(CancellationToken)

public static Task<TensorboardServiceClient> CreateAsync(CancellationToken cancellationToken = default(CancellationToken))

CreateTensorboard(CreateTensorboardRequest, CallSettings)

public virtual Operation<Tensorboard, CreateTensorboardOperationMetadata> CreateTensorboard(CreateTensorboardRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
CreateTensorboardRequest request = new CreateTensorboardRequest
{
    ParentAsTensorboardName = TensorboardName.FromProjectLocationTensorboard("[PROJECT]", "[LOCATION]", "[TENSORBOARD]"),
    Tensorboard = new Tensorboard(),
};
// Make the request
Operation<Tensorboard, CreateTensorboardOperationMetadata> response = tensorboardServiceClient.CreateTensorboard(request);

// Poll until the returned long-running operation is complete
Operation<Tensorboard, CreateTensorboardOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Tensorboard result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Tensorboard, CreateTensorboardOperationMetadata> retrievedResponse = tensorboardServiceClient.PollOnceCreateTensorboard(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Tensorboard retrievedResult = retrievedResponse.Result;
}

CreateTensorboard(TensorboardName, Tensorboard, CallSettings)

public virtual Operation<Tensorboard, CreateTensorboardOperationMetadata> CreateTensorboard(TensorboardName parent, Tensorboard tensorboard, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
TensorboardName parent = TensorboardName.FromProjectLocationTensorboard("[PROJECT]", "[LOCATION]", "[TENSORBOARD]");
Tensorboard tensorboard = new Tensorboard();
// Make the request
Operation<Tensorboard, CreateTensorboardOperationMetadata> response = tensorboardServiceClient.CreateTensorboard(parent, tensorboard);

// Poll until the returned long-running operation is complete
Operation<Tensorboard, CreateTensorboardOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Tensorboard result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Tensorboard, CreateTensorboardOperationMetadata> retrievedResponse = tensorboardServiceClient.PollOnceCreateTensorboard(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Tensorboard retrievedResult = retrievedResponse.Result;
}

CreateTensorboard(String, Tensorboard, CallSettings)

public virtual Operation<Tensorboard, CreateTensorboardOperationMetadata> CreateTensorboard(string parent, Tensorboard tensorboard, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]";
Tensorboard tensorboard = new Tensorboard();
// Make the request
Operation<Tensorboard, CreateTensorboardOperationMetadata> response = tensorboardServiceClient.CreateTensorboard(parent, tensorboard);

// Poll until the returned long-running operation is complete
Operation<Tensorboard, CreateTensorboardOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Tensorboard result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Tensorboard, CreateTensorboardOperationMetadata> retrievedResponse = tensorboardServiceClient.PollOnceCreateTensorboard(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Tensorboard retrievedResult = retrievedResponse.Result;
}

CreateTensorboardAsync(CreateTensorboardRequest, CallSettings)

public virtual Task<Operation<Tensorboard, CreateTensorboardOperationMetadata>> CreateTensorboardAsync(CreateTensorboardRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
CreateTensorboardRequest request = new CreateTensorboardRequest
{
    ParentAsTensorboardName = TensorboardName.FromProjectLocationTensorboard("[PROJECT]", "[LOCATION]", "[TENSORBOARD]"),
    Tensorboard = new Tensorboard(),
};
// Make the request
Operation<Tensorboard, CreateTensorboardOperationMetadata> response = await tensorboardServiceClient.CreateTensorboardAsync(request);

// Poll until the returned long-running operation is complete
Operation<Tensorboard, CreateTensorboardOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Tensorboard result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Tensorboard, CreateTensorboardOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceCreateTensorboardAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Tensorboard retrievedResult = retrievedResponse.Result;
}

CreateTensorboardAsync(CreateTensorboardRequest, CancellationToken)

public virtual Task<Operation<Tensorboard, CreateTensorboardOperationMetadata>> CreateTensorboardAsync(CreateTensorboardRequest request, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
CreateTensorboardRequest request = new CreateTensorboardRequest
{
    ParentAsTensorboardName = TensorboardName.FromProjectLocationTensorboard("[PROJECT]", "[LOCATION]", "[TENSORBOARD]"),
    Tensorboard = new Tensorboard(),
};
// Make the request
Operation<Tensorboard, CreateTensorboardOperationMetadata> response = await tensorboardServiceClient.CreateTensorboardAsync(request);

// Poll until the returned long-running operation is complete
Operation<Tensorboard, CreateTensorboardOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Tensorboard result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Tensorboard, CreateTensorboardOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceCreateTensorboardAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Tensorboard retrievedResult = retrievedResponse.Result;
}

CreateTensorboardAsync(TensorboardName, Tensorboard, CallSettings)

public virtual Task<Operation<Tensorboard, CreateTensorboardOperationMetadata>> CreateTensorboardAsync(TensorboardName parent, Tensorboard tensorboard, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
TensorboardName parent = TensorboardName.FromProjectLocationTensorboard("[PROJECT]", "[LOCATION]", "[TENSORBOARD]");
Tensorboard tensorboard = new Tensorboard();
// Make the request
Operation<Tensorboard, CreateTensorboardOperationMetadata> response = await tensorboardServiceClient.CreateTensorboardAsync(parent, tensorboard);

// Poll until the returned long-running operation is complete
Operation<Tensorboard, CreateTensorboardOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Tensorboard result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Tensorboard, CreateTensorboardOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceCreateTensorboardAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Tensorboard retrievedResult = retrievedResponse.Result;
}

CreateTensorboardAsync(TensorboardName, Tensorboard, CancellationToken)

public virtual Task<Operation<Tensorboard, CreateTensorboardOperationMetadata>> CreateTensorboardAsync(TensorboardName parent, Tensorboard tensorboard, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
TensorboardName parent = TensorboardName.FromProjectLocationTensorboard("[PROJECT]", "[LOCATION]", "[TENSORBOARD]");
Tensorboard tensorboard = new Tensorboard();
// Make the request
Operation<Tensorboard, CreateTensorboardOperationMetadata> response = await tensorboardServiceClient.CreateTensorboardAsync(parent, tensorboard);

// Poll until the returned long-running operation is complete
Operation<Tensorboard, CreateTensorboardOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Tensorboard result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Tensorboard, CreateTensorboardOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceCreateTensorboardAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Tensorboard retrievedResult = retrievedResponse.Result;
}

CreateTensorboardAsync(String, Tensorboard, CallSettings)

public virtual Task<Operation<Tensorboard, CreateTensorboardOperationMetadata>> CreateTensorboardAsync(string parent, Tensorboard tensorboard, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]";
Tensorboard tensorboard = new Tensorboard();
// Make the request
Operation<Tensorboard, CreateTensorboardOperationMetadata> response = await tensorboardServiceClient.CreateTensorboardAsync(parent, tensorboard);

// Poll until the returned long-running operation is complete
Operation<Tensorboard, CreateTensorboardOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Tensorboard result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Tensorboard, CreateTensorboardOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceCreateTensorboardAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Tensorboard retrievedResult = retrievedResponse.Result;
}

CreateTensorboardAsync(String, Tensorboard, CancellationToken)

public virtual Task<Operation<Tensorboard, CreateTensorboardOperationMetadata>> CreateTensorboardAsync(string parent, Tensorboard tensorboard, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]";
Tensorboard tensorboard = new Tensorboard();
// Make the request
Operation<Tensorboard, CreateTensorboardOperationMetadata> response = await tensorboardServiceClient.CreateTensorboardAsync(parent, tensorboard);

// Poll until the returned long-running operation is complete
Operation<Tensorboard, CreateTensorboardOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Tensorboard result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Tensorboard, CreateTensorboardOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceCreateTensorboardAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Tensorboard retrievedResult = retrievedResponse.Result;
}

CreateTensorboardExperiment(CreateTensorboardExperimentRequest, CallSettings)

public virtual TensorboardExperiment CreateTensorboardExperiment(CreateTensorboardExperimentRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
CreateTensorboardExperimentRequest request = new CreateTensorboardExperimentRequest
{
    ParentAsTensorboardExperimentName = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]"),
    TensorboardExperiment = new TensorboardExperiment(),
    TensorboardExperimentId = "",
};
// Make the request
TensorboardExperiment response = tensorboardServiceClient.CreateTensorboardExperiment(request);

CreateTensorboardExperiment(TensorboardExperimentName, TensorboardExperiment, String, CallSettings)

public virtual TensorboardExperiment CreateTensorboardExperiment(TensorboardExperimentName parent, TensorboardExperiment tensorboardExperiment, string tensorboardExperimentId, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
TensorboardExperimentName parent = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]");
TensorboardExperiment tensorboardExperiment = new TensorboardExperiment();
string tensorboardExperimentId = "";
// Make the request
TensorboardExperiment response = tensorboardServiceClient.CreateTensorboardExperiment(parent, tensorboardExperiment, tensorboardExperimentId);

CreateTensorboardExperiment(String, TensorboardExperiment, String, CallSettings)

public virtual TensorboardExperiment CreateTensorboardExperiment(string parent, TensorboardExperiment tensorboardExperiment, string tensorboardExperimentId, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]";
TensorboardExperiment tensorboardExperiment = new TensorboardExperiment();
string tensorboardExperimentId = "";
// Make the request
TensorboardExperiment response = tensorboardServiceClient.CreateTensorboardExperiment(parent, tensorboardExperiment, tensorboardExperimentId);

CreateTensorboardExperimentAsync(CreateTensorboardExperimentRequest, CallSettings)

public virtual Task<TensorboardExperiment> CreateTensorboardExperimentAsync(CreateTensorboardExperimentRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
CreateTensorboardExperimentRequest request = new CreateTensorboardExperimentRequest
{
    ParentAsTensorboardExperimentName = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]"),
    TensorboardExperiment = new TensorboardExperiment(),
    TensorboardExperimentId = "",
};
// Make the request
TensorboardExperiment response = await tensorboardServiceClient.CreateTensorboardExperimentAsync(request);

CreateTensorboardExperimentAsync(CreateTensorboardExperimentRequest, CancellationToken)

public virtual Task<TensorboardExperiment> CreateTensorboardExperimentAsync(CreateTensorboardExperimentRequest request, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
CreateTensorboardExperimentRequest request = new CreateTensorboardExperimentRequest
{
    ParentAsTensorboardExperimentName = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]"),
    TensorboardExperiment = new TensorboardExperiment(),
    TensorboardExperimentId = "",
};
// Make the request
TensorboardExperiment response = await tensorboardServiceClient.CreateTensorboardExperimentAsync(request);

CreateTensorboardExperimentAsync(TensorboardExperimentName, TensorboardExperiment, String, CallSettings)

public virtual Task<TensorboardExperiment> CreateTensorboardExperimentAsync(TensorboardExperimentName parent, TensorboardExperiment tensorboardExperiment, string tensorboardExperimentId, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
TensorboardExperimentName parent = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]");
TensorboardExperiment tensorboardExperiment = new TensorboardExperiment();
string tensorboardExperimentId = "";
// Make the request
TensorboardExperiment response = await tensorboardServiceClient.CreateTensorboardExperimentAsync(parent, tensorboardExperiment, tensorboardExperimentId);

CreateTensorboardExperimentAsync(TensorboardExperimentName, TensorboardExperiment, String, CancellationToken)

public virtual Task<TensorboardExperiment> CreateTensorboardExperimentAsync(TensorboardExperimentName parent, TensorboardExperiment tensorboardExperiment, string tensorboardExperimentId, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
TensorboardExperimentName parent = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]");
TensorboardExperiment tensorboardExperiment = new TensorboardExperiment();
string tensorboardExperimentId = "";
// Make the request
TensorboardExperiment response = await tensorboardServiceClient.CreateTensorboardExperimentAsync(parent, tensorboardExperiment, tensorboardExperimentId);

CreateTensorboardExperimentAsync(String, TensorboardExperiment, String, CallSettings)

public virtual Task<TensorboardExperiment> CreateTensorboardExperimentAsync(string parent, TensorboardExperiment tensorboardExperiment, string tensorboardExperimentId, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]";
TensorboardExperiment tensorboardExperiment = new TensorboardExperiment();
string tensorboardExperimentId = "";
// Make the request
TensorboardExperiment response = await tensorboardServiceClient.CreateTensorboardExperimentAsync(parent, tensorboardExperiment, tensorboardExperimentId);

CreateTensorboardExperimentAsync(String, TensorboardExperiment, String, CancellationToken)

public virtual Task<TensorboardExperiment> CreateTensorboardExperimentAsync(string parent, TensorboardExperiment tensorboardExperiment, string tensorboardExperimentId, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]";
TensorboardExperiment tensorboardExperiment = new TensorboardExperiment();
string tensorboardExperimentId = "";
// Make the request
TensorboardExperiment response = await tensorboardServiceClient.CreateTensorboardExperimentAsync(parent, tensorboardExperiment, tensorboardExperimentId);

CreateTensorboardRun(CreateTensorboardRunRequest, CallSettings)

public virtual TensorboardRun CreateTensorboardRun(CreateTensorboardRunRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
CreateTensorboardRunRequest request = new CreateTensorboardRunRequest
{
    ParentAsTensorboardRunName = TensorboardRunName.FromProjectLocationTensorboardExperimentRun("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]"),
    TensorboardRun = new TensorboardRun(),
    TensorboardRunId = "",
};
// Make the request
TensorboardRun response = tensorboardServiceClient.CreateTensorboardRun(request);

CreateTensorboardRun(TensorboardRunName, TensorboardRun, String, CallSettings)

public virtual TensorboardRun CreateTensorboardRun(TensorboardRunName parent, TensorboardRun tensorboardRun, string tensorboardRunId, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
TensorboardRunName parent = TensorboardRunName.FromProjectLocationTensorboardExperimentRun("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]");
TensorboardRun tensorboardRun = new TensorboardRun();
string tensorboardRunId = "";
// Make the request
TensorboardRun response = tensorboardServiceClient.CreateTensorboardRun(parent, tensorboardRun, tensorboardRunId);

CreateTensorboardRun(String, TensorboardRun, String, CallSettings)

public virtual TensorboardRun CreateTensorboardRun(string parent, TensorboardRun tensorboardRun, string tensorboardRunId, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]/runs/[RUN]";
TensorboardRun tensorboardRun = new TensorboardRun();
string tensorboardRunId = "";
// Make the request
TensorboardRun response = tensorboardServiceClient.CreateTensorboardRun(parent, tensorboardRun, tensorboardRunId);

CreateTensorboardRunAsync(CreateTensorboardRunRequest, CallSettings)

public virtual Task<TensorboardRun> CreateTensorboardRunAsync(CreateTensorboardRunRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
CreateTensorboardRunRequest request = new CreateTensorboardRunRequest
{
    ParentAsTensorboardRunName = TensorboardRunName.FromProjectLocationTensorboardExperimentRun("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]"),
    TensorboardRun = new TensorboardRun(),
    TensorboardRunId = "",
};
// Make the request
TensorboardRun response = await tensorboardServiceClient.CreateTensorboardRunAsync(request);

CreateTensorboardRunAsync(CreateTensorboardRunRequest, CancellationToken)

public virtual Task<TensorboardRun> CreateTensorboardRunAsync(CreateTensorboardRunRequest request, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
CreateTensorboardRunRequest request = new CreateTensorboardRunRequest
{
    ParentAsTensorboardRunName = TensorboardRunName.FromProjectLocationTensorboardExperimentRun("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]"),
    TensorboardRun = new TensorboardRun(),
    TensorboardRunId = "",
};
// Make the request
TensorboardRun response = await tensorboardServiceClient.CreateTensorboardRunAsync(request);

CreateTensorboardRunAsync(TensorboardRunName, TensorboardRun, String, CallSettings)

public virtual Task<TensorboardRun> CreateTensorboardRunAsync(TensorboardRunName parent, TensorboardRun tensorboardRun, string tensorboardRunId, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
TensorboardRunName parent = TensorboardRunName.FromProjectLocationTensorboardExperimentRun("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]");
TensorboardRun tensorboardRun = new TensorboardRun();
string tensorboardRunId = "";
// Make the request
TensorboardRun response = await tensorboardServiceClient.CreateTensorboardRunAsync(parent, tensorboardRun, tensorboardRunId);

CreateTensorboardRunAsync(TensorboardRunName, TensorboardRun, String, CancellationToken)

public virtual Task<TensorboardRun> CreateTensorboardRunAsync(TensorboardRunName parent, TensorboardRun tensorboardRun, string tensorboardRunId, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
TensorboardRunName parent = TensorboardRunName.FromProjectLocationTensorboardExperimentRun("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]");
TensorboardRun tensorboardRun = new TensorboardRun();
string tensorboardRunId = "";
// Make the request
TensorboardRun response = await tensorboardServiceClient.CreateTensorboardRunAsync(parent, tensorboardRun, tensorboardRunId);

CreateTensorboardRunAsync(String, TensorboardRun, String, CallSettings)

public virtual Task<TensorboardRun> CreateTensorboardRunAsync(string parent, TensorboardRun tensorboardRun, string tensorboardRunId, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]/runs/[RUN]";
TensorboardRun tensorboardRun = new TensorboardRun();
string tensorboardRunId = "";
// Make the request
TensorboardRun response = await tensorboardServiceClient.CreateTensorboardRunAsync(parent, tensorboardRun, tensorboardRunId);

CreateTensorboardRunAsync(String, TensorboardRun, String, CancellationToken)

public virtual Task<TensorboardRun> CreateTensorboardRunAsync(string parent, TensorboardRun tensorboardRun, string tensorboardRunId, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]/runs/[RUN]";
TensorboardRun tensorboardRun = new TensorboardRun();
string tensorboardRunId = "";
// Make the request
TensorboardRun response = await tensorboardServiceClient.CreateTensorboardRunAsync(parent, tensorboardRun, tensorboardRunId);

CreateTensorboardTimeSeries(CreateTensorboardTimeSeriesRequest, CallSettings)

public virtual TensorboardTimeSeries CreateTensorboardTimeSeries(CreateTensorboardTimeSeriesRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
CreateTensorboardTimeSeriesRequest request = new CreateTensorboardTimeSeriesRequest
{
    ParentAsTensorboardTimeSeriesName = TensorboardTimeSeriesName.FromProjectLocationTensorboardExperimentRunTimeSeries("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]", "[TIME_SERIES]"),
    TensorboardTimeSeries = new TensorboardTimeSeries(),
    TensorboardTimeSeriesId = "",
};
// Make the request
TensorboardTimeSeries response = tensorboardServiceClient.CreateTensorboardTimeSeries(request);

CreateTensorboardTimeSeries(TensorboardTimeSeriesName, TensorboardTimeSeries, CallSettings)

public virtual TensorboardTimeSeries CreateTensorboardTimeSeries(TensorboardTimeSeriesName parent, TensorboardTimeSeries tensorboardTimeSeries, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
TensorboardTimeSeriesName parent = TensorboardTimeSeriesName.FromProjectLocationTensorboardExperimentRunTimeSeries("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]", "[TIME_SERIES]");
TensorboardTimeSeries tensorboardTimeSeries = new TensorboardTimeSeries();
// Make the request
TensorboardTimeSeries response = tensorboardServiceClient.CreateTensorboardTimeSeries(parent, tensorboardTimeSeries);

CreateTensorboardTimeSeries(String, TensorboardTimeSeries, CallSettings)

public virtual TensorboardTimeSeries CreateTensorboardTimeSeries(string parent, TensorboardTimeSeries tensorboardTimeSeries, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]/runs/[RUN]/timeSeries/[TIME_SERIES]";
TensorboardTimeSeries tensorboardTimeSeries = new TensorboardTimeSeries();
// Make the request
TensorboardTimeSeries response = tensorboardServiceClient.CreateTensorboardTimeSeries(parent, tensorboardTimeSeries);

CreateTensorboardTimeSeriesAsync(CreateTensorboardTimeSeriesRequest, CallSettings)

public virtual Task<TensorboardTimeSeries> CreateTensorboardTimeSeriesAsync(CreateTensorboardTimeSeriesRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
CreateTensorboardTimeSeriesRequest request = new CreateTensorboardTimeSeriesRequest
{
    ParentAsTensorboardTimeSeriesName = TensorboardTimeSeriesName.FromProjectLocationTensorboardExperimentRunTimeSeries("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]", "[TIME_SERIES]"),
    TensorboardTimeSeries = new TensorboardTimeSeries(),
    TensorboardTimeSeriesId = "",
};
// Make the request
TensorboardTimeSeries response = await tensorboardServiceClient.CreateTensorboardTimeSeriesAsync(request);

CreateTensorboardTimeSeriesAsync(CreateTensorboardTimeSeriesRequest, CancellationToken)

public virtual Task<TensorboardTimeSeries> CreateTensorboardTimeSeriesAsync(CreateTensorboardTimeSeriesRequest request, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
CreateTensorboardTimeSeriesRequest request = new CreateTensorboardTimeSeriesRequest
{
    ParentAsTensorboardTimeSeriesName = TensorboardTimeSeriesName.FromProjectLocationTensorboardExperimentRunTimeSeries("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]", "[TIME_SERIES]"),
    TensorboardTimeSeries = new TensorboardTimeSeries(),
    TensorboardTimeSeriesId = "",
};
// Make the request
TensorboardTimeSeries response = await tensorboardServiceClient.CreateTensorboardTimeSeriesAsync(request);

CreateTensorboardTimeSeriesAsync(TensorboardTimeSeriesName, TensorboardTimeSeries, CallSettings)

public virtual Task<TensorboardTimeSeries> CreateTensorboardTimeSeriesAsync(TensorboardTimeSeriesName parent, TensorboardTimeSeries tensorboardTimeSeries, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
TensorboardTimeSeriesName parent = TensorboardTimeSeriesName.FromProjectLocationTensorboardExperimentRunTimeSeries("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]", "[TIME_SERIES]");
TensorboardTimeSeries tensorboardTimeSeries = new TensorboardTimeSeries();
// Make the request
TensorboardTimeSeries response = await tensorboardServiceClient.CreateTensorboardTimeSeriesAsync(parent, tensorboardTimeSeries);

CreateTensorboardTimeSeriesAsync(TensorboardTimeSeriesName, TensorboardTimeSeries, CancellationToken)

public virtual Task<TensorboardTimeSeries> CreateTensorboardTimeSeriesAsync(TensorboardTimeSeriesName parent, TensorboardTimeSeries tensorboardTimeSeries, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
TensorboardTimeSeriesName parent = TensorboardTimeSeriesName.FromProjectLocationTensorboardExperimentRunTimeSeries("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]", "[TIME_SERIES]");
TensorboardTimeSeries tensorboardTimeSeries = new TensorboardTimeSeries();
// Make the request
TensorboardTimeSeries response = await tensorboardServiceClient.CreateTensorboardTimeSeriesAsync(parent, tensorboardTimeSeries);

CreateTensorboardTimeSeriesAsync(String, TensorboardTimeSeries, CallSettings)

public virtual Task<TensorboardTimeSeries> CreateTensorboardTimeSeriesAsync(string parent, TensorboardTimeSeries tensorboardTimeSeries, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]/runs/[RUN]/timeSeries/[TIME_SERIES]";
TensorboardTimeSeries tensorboardTimeSeries = new TensorboardTimeSeries();
// Make the request
TensorboardTimeSeries response = await tensorboardServiceClient.CreateTensorboardTimeSeriesAsync(parent, tensorboardTimeSeries);

CreateTensorboardTimeSeriesAsync(String, TensorboardTimeSeries, CancellationToken)

public virtual Task<TensorboardTimeSeries> CreateTensorboardTimeSeriesAsync(string parent, TensorboardTimeSeries tensorboardTimeSeries, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]/runs/[RUN]/timeSeries/[TIME_SERIES]";
TensorboardTimeSeries tensorboardTimeSeries = new TensorboardTimeSeries();
// Make the request
TensorboardTimeSeries response = await tensorboardServiceClient.CreateTensorboardTimeSeriesAsync(parent, tensorboardTimeSeries);

DeleteTensorboard(DeleteTensorboardRequest, CallSettings)

public virtual Operation<Empty, DeleteOperationMetadata> DeleteTensorboard(DeleteTensorboardRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
DeleteTensorboardRequest request = new DeleteTensorboardRequest
{
    TensorboardName = TensorboardName.FromProjectLocationTensorboard("[PROJECT]", "[LOCATION]", "[TENSORBOARD]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = tensorboardServiceClient.DeleteTensorboard(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = tensorboardServiceClient.PollOnceDeleteTensorboard(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboard(TensorboardName, CallSettings)

public virtual Operation<Empty, DeleteOperationMetadata> DeleteTensorboard(TensorboardName name, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
TensorboardName name = TensorboardName.FromProjectLocationTensorboard("[PROJECT]", "[LOCATION]", "[TENSORBOARD]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = tensorboardServiceClient.DeleteTensorboard(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = tensorboardServiceClient.PollOnceDeleteTensorboard(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboard(String, CallSettings)

public virtual Operation<Empty, DeleteOperationMetadata> DeleteTensorboard(string name, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = tensorboardServiceClient.DeleteTensorboard(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = tensorboardServiceClient.PollOnceDeleteTensorboard(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardAsync(DeleteTensorboardRequest, CallSettings)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteTensorboardAsync(DeleteTensorboardRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteTensorboardRequest request = new DeleteTensorboardRequest
{
    TensorboardName = TensorboardName.FromProjectLocationTensorboard("[PROJECT]", "[LOCATION]", "[TENSORBOARD]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await tensorboardServiceClient.DeleteTensorboardAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceDeleteTensorboardAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardAsync(DeleteTensorboardRequest, CancellationToken)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteTensorboardAsync(DeleteTensorboardRequest request, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteTensorboardRequest request = new DeleteTensorboardRequest
{
    TensorboardName = TensorboardName.FromProjectLocationTensorboard("[PROJECT]", "[LOCATION]", "[TENSORBOARD]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await tensorboardServiceClient.DeleteTensorboardAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceDeleteTensorboardAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardAsync(TensorboardName, CallSettings)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteTensorboardAsync(TensorboardName name, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
TensorboardName name = TensorboardName.FromProjectLocationTensorboard("[PROJECT]", "[LOCATION]", "[TENSORBOARD]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await tensorboardServiceClient.DeleteTensorboardAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceDeleteTensorboardAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardAsync(TensorboardName, CancellationToken)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteTensorboardAsync(TensorboardName name, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
TensorboardName name = TensorboardName.FromProjectLocationTensorboard("[PROJECT]", "[LOCATION]", "[TENSORBOARD]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await tensorboardServiceClient.DeleteTensorboardAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceDeleteTensorboardAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardAsync(String, CallSettings)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteTensorboardAsync(string name, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await tensorboardServiceClient.DeleteTensorboardAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceDeleteTensorboardAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardAsync(String, CancellationToken)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteTensorboardAsync(string name, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await tensorboardServiceClient.DeleteTensorboardAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceDeleteTensorboardAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardExperiment(DeleteTensorboardExperimentRequest, CallSettings)

public virtual Operation<Empty, DeleteOperationMetadata> DeleteTensorboardExperiment(DeleteTensorboardExperimentRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
DeleteTensorboardExperimentRequest request = new DeleteTensorboardExperimentRequest
{
    TensorboardExperimentName = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = tensorboardServiceClient.DeleteTensorboardExperiment(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = tensorboardServiceClient.PollOnceDeleteTensorboardExperiment(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardExperiment(TensorboardExperimentName, CallSettings)

public virtual Operation<Empty, DeleteOperationMetadata> DeleteTensorboardExperiment(TensorboardExperimentName name, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
TensorboardExperimentName name = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = tensorboardServiceClient.DeleteTensorboardExperiment(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = tensorboardServiceClient.PollOnceDeleteTensorboardExperiment(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardExperiment(String, CallSettings)

public virtual Operation<Empty, DeleteOperationMetadata> DeleteTensorboardExperiment(string name, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = tensorboardServiceClient.DeleteTensorboardExperiment(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = tensorboardServiceClient.PollOnceDeleteTensorboardExperiment(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardExperimentAsync(DeleteTensorboardExperimentRequest, CallSettings)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteTensorboardExperimentAsync(DeleteTensorboardExperimentRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteTensorboardExperimentRequest request = new DeleteTensorboardExperimentRequest
{
    TensorboardExperimentName = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await tensorboardServiceClient.DeleteTensorboardExperimentAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceDeleteTensorboardExperimentAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardExperimentAsync(DeleteTensorboardExperimentRequest, CancellationToken)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteTensorboardExperimentAsync(DeleteTensorboardExperimentRequest request, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteTensorboardExperimentRequest request = new DeleteTensorboardExperimentRequest
{
    TensorboardExperimentName = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await tensorboardServiceClient.DeleteTensorboardExperimentAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceDeleteTensorboardExperimentAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardExperimentAsync(TensorboardExperimentName, CallSettings)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteTensorboardExperimentAsync(TensorboardExperimentName name, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
TensorboardExperimentName name = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await tensorboardServiceClient.DeleteTensorboardExperimentAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceDeleteTensorboardExperimentAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardExperimentAsync(TensorboardExperimentName, CancellationToken)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteTensorboardExperimentAsync(TensorboardExperimentName name, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
TensorboardExperimentName name = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await tensorboardServiceClient.DeleteTensorboardExperimentAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceDeleteTensorboardExperimentAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardExperimentAsync(String, CallSettings)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteTensorboardExperimentAsync(string name, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await tensorboardServiceClient.DeleteTensorboardExperimentAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceDeleteTensorboardExperimentAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardExperimentAsync(String, CancellationToken)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteTensorboardExperimentAsync(string name, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await tensorboardServiceClient.DeleteTensorboardExperimentAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceDeleteTensorboardExperimentAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardRun(DeleteTensorboardRunRequest, CallSettings)

public virtual Operation<Empty, DeleteOperationMetadata> DeleteTensorboardRun(DeleteTensorboardRunRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
DeleteTensorboardRunRequest request = new DeleteTensorboardRunRequest
{
    TensorboardRunName = TensorboardRunName.FromProjectLocationTensorboardExperimentRun("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = tensorboardServiceClient.DeleteTensorboardRun(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = tensorboardServiceClient.PollOnceDeleteTensorboardRun(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardRun(TensorboardRunName, CallSettings)

public virtual Operation<Empty, DeleteOperationMetadata> DeleteTensorboardRun(TensorboardRunName name, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
TensorboardRunName name = TensorboardRunName.FromProjectLocationTensorboardExperimentRun("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = tensorboardServiceClient.DeleteTensorboardRun(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = tensorboardServiceClient.PollOnceDeleteTensorboardRun(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardRun(String, CallSettings)

public virtual Operation<Empty, DeleteOperationMetadata> DeleteTensorboardRun(string name, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]/runs/[RUN]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = tensorboardServiceClient.DeleteTensorboardRun(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = tensorboardServiceClient.PollOnceDeleteTensorboardRun(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardRunAsync(DeleteTensorboardRunRequest, CallSettings)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteTensorboardRunAsync(DeleteTensorboardRunRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteTensorboardRunRequest request = new DeleteTensorboardRunRequest
{
    TensorboardRunName = TensorboardRunName.FromProjectLocationTensorboardExperimentRun("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await tensorboardServiceClient.DeleteTensorboardRunAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceDeleteTensorboardRunAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardRunAsync(DeleteTensorboardRunRequest, CancellationToken)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteTensorboardRunAsync(DeleteTensorboardRunRequest request, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteTensorboardRunRequest request = new DeleteTensorboardRunRequest
{
    TensorboardRunName = TensorboardRunName.FromProjectLocationTensorboardExperimentRun("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await tensorboardServiceClient.DeleteTensorboardRunAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceDeleteTensorboardRunAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardRunAsync(TensorboardRunName, CallSettings)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteTensorboardRunAsync(TensorboardRunName name, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
TensorboardRunName name = TensorboardRunName.FromProjectLocationTensorboardExperimentRun("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await tensorboardServiceClient.DeleteTensorboardRunAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceDeleteTensorboardRunAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardRunAsync(TensorboardRunName, CancellationToken)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteTensorboardRunAsync(TensorboardRunName name, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
TensorboardRunName name = TensorboardRunName.FromProjectLocationTensorboardExperimentRun("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await tensorboardServiceClient.DeleteTensorboardRunAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceDeleteTensorboardRunAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardRunAsync(String, CallSettings)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteTensorboardRunAsync(string name, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]/runs/[RUN]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await tensorboardServiceClient.DeleteTensorboardRunAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceDeleteTensorboardRunAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardRunAsync(String, CancellationToken)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteTensorboardRunAsync(string name, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]/runs/[RUN]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await tensorboardServiceClient.DeleteTensorboardRunAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceDeleteTensorboardRunAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardTimeSeries(DeleteTensorboardTimeSeriesRequest, CallSettings)

public virtual Operation<Empty, DeleteOperationMetadata> DeleteTensorboardTimeSeries(DeleteTensorboardTimeSeriesRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
DeleteTensorboardTimeSeriesRequest request = new DeleteTensorboardTimeSeriesRequest
{
    TensorboardTimeSeriesName = TensorboardTimeSeriesName.FromProjectLocationTensorboardExperimentRunTimeSeries("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]", "[TIME_SERIES]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = tensorboardServiceClient.DeleteTensorboardTimeSeries(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = tensorboardServiceClient.PollOnceDeleteTensorboardTimeSeries(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardTimeSeries(TensorboardTimeSeriesName, CallSettings)

public virtual Operation<Empty, DeleteOperationMetadata> DeleteTensorboardTimeSeries(TensorboardTimeSeriesName name, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
TensorboardTimeSeriesName name = TensorboardTimeSeriesName.FromProjectLocationTensorboardExperimentRunTimeSeries("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]", "[TIME_SERIES]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = tensorboardServiceClient.DeleteTensorboardTimeSeries(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = tensorboardServiceClient.PollOnceDeleteTensorboardTimeSeries(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardTimeSeries(String, CallSettings)

public virtual Operation<Empty, DeleteOperationMetadata> DeleteTensorboardTimeSeries(string name, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]/runs/[RUN]/timeSeries/[TIME_SERIES]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = tensorboardServiceClient.DeleteTensorboardTimeSeries(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = tensorboardServiceClient.PollOnceDeleteTensorboardTimeSeries(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardTimeSeriesAsync(DeleteTensorboardTimeSeriesRequest, CallSettings)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteTensorboardTimeSeriesAsync(DeleteTensorboardTimeSeriesRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteTensorboardTimeSeriesRequest request = new DeleteTensorboardTimeSeriesRequest
{
    TensorboardTimeSeriesName = TensorboardTimeSeriesName.FromProjectLocationTensorboardExperimentRunTimeSeries("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]", "[TIME_SERIES]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await tensorboardServiceClient.DeleteTensorboardTimeSeriesAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceDeleteTensorboardTimeSeriesAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardTimeSeriesAsync(DeleteTensorboardTimeSeriesRequest, CancellationToken)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteTensorboardTimeSeriesAsync(DeleteTensorboardTimeSeriesRequest request, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteTensorboardTimeSeriesRequest request = new DeleteTensorboardTimeSeriesRequest
{
    TensorboardTimeSeriesName = TensorboardTimeSeriesName.FromProjectLocationTensorboardExperimentRunTimeSeries("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]", "[TIME_SERIES]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await tensorboardServiceClient.DeleteTensorboardTimeSeriesAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceDeleteTensorboardTimeSeriesAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardTimeSeriesAsync(TensorboardTimeSeriesName, CallSettings)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteTensorboardTimeSeriesAsync(TensorboardTimeSeriesName name, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
TensorboardTimeSeriesName name = TensorboardTimeSeriesName.FromProjectLocationTensorboardExperimentRunTimeSeries("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]", "[TIME_SERIES]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await tensorboardServiceClient.DeleteTensorboardTimeSeriesAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceDeleteTensorboardTimeSeriesAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardTimeSeriesAsync(TensorboardTimeSeriesName, CancellationToken)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteTensorboardTimeSeriesAsync(TensorboardTimeSeriesName name, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
TensorboardTimeSeriesName name = TensorboardTimeSeriesName.FromProjectLocationTensorboardExperimentRunTimeSeries("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]", "[TIME_SERIES]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await tensorboardServiceClient.DeleteTensorboardTimeSeriesAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceDeleteTensorboardTimeSeriesAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardTimeSeriesAsync(String, CallSettings)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteTensorboardTimeSeriesAsync(string name, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]/runs/[RUN]/timeSeries/[TIME_SERIES]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await tensorboardServiceClient.DeleteTensorboardTimeSeriesAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceDeleteTensorboardTimeSeriesAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteTensorboardTimeSeriesAsync(String, CancellationToken)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteTensorboardTimeSeriesAsync(string name, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]/runs/[RUN]/timeSeries/[TIME_SERIES]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await tensorboardServiceClient.DeleteTensorboardTimeSeriesAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await tensorboardServiceClient.PollOnceDeleteTensorboardTimeSeriesAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

ExportTensorboardTimeSeriesData(ExportTensorboardTimeSeriesDataRequest, CallSettings)

public virtual PagedEnumerable<ExportTensorboardTimeSeriesDataResponse, TimeSeriesDataPoint> ExportTensorboardTimeSeriesData(ExportTensorboardTimeSeriesDataRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
ExportTensorboardTimeSeriesDataRequest request = new ExportTensorboardTimeSeriesDataRequest
{
    TensorboardTimeSeriesAsTensorboardTimeSeriesName = TensorboardTimeSeriesName.FromProjectLocationTensorboardExperimentRunTimeSeries("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]", "[TIME_SERIES]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedEnumerable<ExportTensorboardTimeSeriesDataResponse, TimeSeriesDataPoint> response = tensorboardServiceClient.ExportTensorboardTimeSeriesData(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (TimeSeriesDataPoint item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ExportTensorboardTimeSeriesDataResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (TimeSeriesDataPoint item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<TimeSeriesDataPoint> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (TimeSeriesDataPoint item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ExportTensorboardTimeSeriesData(TensorboardTimeSeriesName, String, Nullable<Int32>, CallSettings)

public virtual PagedEnumerable<ExportTensorboardTimeSeriesDataResponse, TimeSeriesDataPoint> ExportTensorboardTimeSeriesData(TensorboardTimeSeriesName tensorboardTimeSeries, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
TensorboardTimeSeriesName tensorboardTimeSeries = TensorboardTimeSeriesName.FromProjectLocationTensorboardExperimentRunTimeSeries("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]", "[TIME_SERIES]");
// Make the request
PagedEnumerable<ExportTensorboardTimeSeriesDataResponse, TimeSeriesDataPoint> response = tensorboardServiceClient.ExportTensorboardTimeSeriesData(tensorboardTimeSeries);

// Iterate over all response items, lazily performing RPCs as required
foreach (TimeSeriesDataPoint item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ExportTensorboardTimeSeriesDataResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (TimeSeriesDataPoint item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<TimeSeriesDataPoint> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (TimeSeriesDataPoint item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ExportTensorboardTimeSeriesData(String, String, Nullable<Int32>, CallSettings)

public virtual PagedEnumerable<ExportTensorboardTimeSeriesDataResponse, TimeSeriesDataPoint> ExportTensorboardTimeSeriesData(string tensorboardTimeSeries, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
string tensorboardTimeSeries = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]/runs/[RUN]/timeSeries/[TIME_SERIES]";
// Make the request
PagedEnumerable<ExportTensorboardTimeSeriesDataResponse, TimeSeriesDataPoint> response = tensorboardServiceClient.ExportTensorboardTimeSeriesData(tensorboardTimeSeries);

// Iterate over all response items, lazily performing RPCs as required
foreach (TimeSeriesDataPoint item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ExportTensorboardTimeSeriesDataResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (TimeSeriesDataPoint item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<TimeSeriesDataPoint> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (TimeSeriesDataPoint item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ExportTensorboardTimeSeriesDataAsync(ExportTensorboardTimeSeriesDataRequest, CallSettings)

public virtual PagedAsyncEnumerable<ExportTensorboardTimeSeriesDataResponse, TimeSeriesDataPoint> ExportTensorboardTimeSeriesDataAsync(ExportTensorboardTimeSeriesDataRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
ExportTensorboardTimeSeriesDataRequest request = new ExportTensorboardTimeSeriesDataRequest
{
    TensorboardTimeSeriesAsTensorboardTimeSeriesName = TensorboardTimeSeriesName.FromProjectLocationTensorboardExperimentRunTimeSeries("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]", "[TIME_SERIES]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedAsyncEnumerable<ExportTensorboardTimeSeriesDataResponse, TimeSeriesDataPoint> response = tensorboardServiceClient.ExportTensorboardTimeSeriesDataAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((TimeSeriesDataPoint item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ExportTensorboardTimeSeriesDataResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (TimeSeriesDataPoint item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<TimeSeriesDataPoint> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (TimeSeriesDataPoint item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ExportTensorboardTimeSeriesDataAsync(TensorboardTimeSeriesName, String, Nullable<Int32>, CallSettings)

public virtual PagedAsyncEnumerable<ExportTensorboardTimeSeriesDataResponse, TimeSeriesDataPoint> ExportTensorboardTimeSeriesDataAsync(TensorboardTimeSeriesName tensorboardTimeSeries, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
TensorboardTimeSeriesName tensorboardTimeSeries = TensorboardTimeSeriesName.FromProjectLocationTensorboardExperimentRunTimeSeries("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]", "[RUN]", "[TIME_SERIES]");
// Make the request
PagedAsyncEnumerable<ExportTensorboardTimeSeriesDataResponse, TimeSeriesDataPoint> response = tensorboardServiceClient.ExportTensorboardTimeSeriesDataAsync(tensorboardTimeSeries);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((TimeSeriesDataPoint item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ExportTensorboardTimeSeriesDataResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (TimeSeriesDataPoint item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<TimeSeriesDataPoint> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (TimeSeriesDataPoint item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ExportTensorboardTimeSeriesDataAsync(String, String, Nullable<Int32>, CallSettings)

public virtual PagedAsyncEnumerable<ExportTensorboardTimeSeriesDataResponse, TimeSeriesDataPoint> ExportTensorboardTimeSeriesDataAsync(string tensorboardTimeSeries, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
string tensorboardTimeSeries = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]/runs/[RUN]/timeSeries/[TIME_SERIES]";
// Make the request
PagedAsyncEnumerable<ExportTensorboardTimeSeriesDataResponse, TimeSeriesDataPoint> response = tensorboardServiceClient.ExportTensorboardTimeSeriesDataAsync(tensorboardTimeSeries);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((TimeSeriesDataPoint item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ExportTensorboardTimeSeriesDataResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (TimeSeriesDataPoint item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<TimeSeriesDataPoint> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (TimeSeriesDataPoint item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

GetTensorboard(GetTensorboardRequest, CallSettings)

public virtual Tensorboard GetTensorboard(GetTensorboardRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
GetTensorboardRequest request = new GetTensorboardRequest
{
    TensorboardName = TensorboardName.FromProjectLocationTensorboard("[PROJECT]", "[LOCATION]", "[TENSORBOARD]"),
};
// Make the request
Tensorboard response = tensorboardServiceClient.GetTensorboard(request);

GetTensorboard(TensorboardName, CallSettings)

public virtual Tensorboard GetTensorboard(TensorboardName name, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
TensorboardName name = TensorboardName.FromProjectLocationTensorboard("[PROJECT]", "[LOCATION]", "[TENSORBOARD]");
// Make the request
Tensorboard response = tensorboardServiceClient.GetTensorboard(name);

GetTensorboard(String, CallSettings)

public virtual Tensorboard GetTensorboard(string name, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]";
// Make the request
Tensorboard response = tensorboardServiceClient.GetTensorboard(name);

GetTensorboardAsync(GetTensorboardRequest, CallSettings)

public virtual Task<Tensorboard> GetTensorboardAsync(GetTensorboardRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
GetTensorboardRequest request = new GetTensorboardRequest
{
    TensorboardName = TensorboardName.FromProjectLocationTensorboard("[PROJECT]", "[LOCATION]", "[TENSORBOARD]"),
};
// Make the request
Tensorboard response = await tensorboardServiceClient.GetTensorboardAsync(request);

GetTensorboardAsync(GetTensorboardRequest, CancellationToken)

public virtual Task<Tensorboard> GetTensorboardAsync(GetTensorboardRequest request, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
GetTensorboardRequest request = new GetTensorboardRequest
{
    TensorboardName = TensorboardName.FromProjectLocationTensorboard("[PROJECT]", "[LOCATION]", "[TENSORBOARD]"),
};
// Make the request
Tensorboard response = await tensorboardServiceClient.GetTensorboardAsync(request);

GetTensorboardAsync(TensorboardName, CallSettings)

public virtual Task<Tensorboard> GetTensorboardAsync(TensorboardName name, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
TensorboardName name = TensorboardName.FromProjectLocationTensorboard("[PROJECT]", "[LOCATION]", "[TENSORBOARD]");
// Make the request
Tensorboard response = await tensorboardServiceClient.GetTensorboardAsync(name);

GetTensorboardAsync(TensorboardName, CancellationToken)

public virtual Task<Tensorboard> GetTensorboardAsync(TensorboardName name, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
TensorboardName name = TensorboardName.FromProjectLocationTensorboard("[PROJECT]", "[LOCATION]", "[TENSORBOARD]");
// Make the request
Tensorboard response = await tensorboardServiceClient.GetTensorboardAsync(name);

GetTensorboardAsync(String, CallSettings)

public virtual Task<Tensorboard> GetTensorboardAsync(string name, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]";
// Make the request
Tensorboard response = await tensorboardServiceClient.GetTensorboardAsync(name);

GetTensorboardAsync(String, CancellationToken)

public virtual Task<Tensorboard> GetTensorboardAsync(string name, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]";
// Make the request
Tensorboard response = await tensorboardServiceClient.GetTensorboardAsync(name);

GetTensorboardExperiment(GetTensorboardExperimentRequest, CallSettings)

public virtual TensorboardExperiment GetTensorboardExperiment(GetTensorboardExperimentRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
GetTensorboardExperimentRequest request = new GetTensorboardExperimentRequest
{
    TensorboardExperimentName = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]"),
};
// Make the request
TensorboardExperiment response = tensorboardServiceClient.GetTensorboardExperiment(request);

GetTensorboardExperiment(TensorboardExperimentName, CallSettings)

public virtual TensorboardExperiment GetTensorboardExperiment(TensorboardExperimentName name, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
TensorboardExperimentName name = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]");
// Make the request
TensorboardExperiment response = tensorboardServiceClient.GetTensorboardExperiment(name);

GetTensorboardExperiment(String, CallSettings)

public virtual TensorboardExperiment GetTensorboardExperiment(string name, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = TensorboardServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]";
// Make the request
TensorboardExperiment response = tensorboardServiceClient.GetTensorboardExperiment(name);

GetTensorboardExperimentAsync(GetTensorboardExperimentRequest, CallSettings)

public virtual Task<TensorboardExperiment> GetTensorboardExperimentAsync(GetTensorboardExperimentRequest request, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
GetTensorboardExperimentRequest request = new GetTensorboardExperimentRequest
{
    TensorboardExperimentName = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]"),
};
// Make the request
TensorboardExperiment response = await tensorboardServiceClient.GetTensorboardExperimentAsync(request);

GetTensorboardExperimentAsync(GetTensorboardExperimentRequest, CancellationToken)

public virtual Task<TensorboardExperiment> GetTensorboardExperimentAsync(GetTensorboardExperimentRequest request, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
GetTensorboardExperimentRequest request = new GetTensorboardExperimentRequest
{
    TensorboardExperimentName = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]"),
};
// Make the request
TensorboardExperiment response = await tensorboardServiceClient.GetTensorboardExperimentAsync(request);

GetTensorboardExperimentAsync(TensorboardExperimentName, CallSettings)

public virtual Task<TensorboardExperiment> GetTensorboardExperimentAsync(TensorboardExperimentName name, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
TensorboardExperimentName name = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]");
// Make the request
TensorboardExperiment response = await tensorboardServiceClient.GetTensorboardExperimentAsync(name);

GetTensorboardExperimentAsync(TensorboardExperimentName, CancellationToken)

public virtual Task<TensorboardExperiment> GetTensorboardExperimentAsync(TensorboardExperimentName name, CancellationToken cancellationToken)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
TensorboardExperimentName name = TensorboardExperimentName.FromProjectLocationTensorboardExperiment("[PROJECT]", "[LOCATION]", "[TENSORBOARD]", "[EXPERIMENT]");
// Make the request
TensorboardExperiment response = await tensorboardServiceClient.GetTensorboardExperimentAsync(name);

GetTensorboardExperimentAsync(String, CallSettings)

public virtual Task<TensorboardExperiment> GetTensorboardExperimentAsync(string name, CallSettings callSettings = null)

// Create client
TensorboardServiceClient tensorboardServiceClient = await TensorboardServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/tensorboards/[TENSORBOARD]/experiments/[EXPERIMENT]";
// Make the request
TensorboardExperiment response = await tensorboardServiceClient.GetTensorboardExperimentAsync(name);

GetTensorboardExperimentAsync(String, CancellationToken)

public virtual Task<TensorboardExperiment> GetTensorboardExperimentAsync(string name, CancellationToken cancellationToken)