Class MetadataServiceClient (2.0.0)

public abstract class MetadataServiceClient

MetadataService client wrapper, for convenient use.

Inheritance

Object > MetadataServiceClient

Inherited Members

Object.GetHashCode()

Object.GetType()

Object.MemberwiseClone()

Object.ToString()

Derived Types

MetadataServiceClientImpl

Namespace

Google.Cloud.AIPlatform.V1

Assembly

Google.Cloud.AIPlatform.V1.dll

Remarks

Service for reading and writing metadata entries.

Properties

CreateMetadataStoreOperationsClient

public virtual OperationsClient CreateMetadataStoreOperationsClient { get; }

The long-running operations client for CreateMetadataStore.

Property Value
Type	Description
`OperationsClient`

DefaultEndpoint

public static string DefaultEndpoint { get; }

The default endpoint for the MetadataService service, which is a host of "aiplatform.googleapis.com" and a port of 443.

Property Value
Type	Description
`String`

DefaultScopes

public static IReadOnlyList<string> DefaultScopes { get; }

The default MetadataService scopes.

Property Value
Type	Description
`IReadOnlyList<String>`

Remarks

The default MetadataService scopes are:

https://www.googleapis.com/auth/cloud-platform

DeleteArtifactOperationsClient

public virtual OperationsClient DeleteArtifactOperationsClient { get; }

The long-running operations client for DeleteArtifact.

Property Value
Type	Description
`OperationsClient`

DeleteContextOperationsClient

public virtual OperationsClient DeleteContextOperationsClient { get; }

The long-running operations client for DeleteContext.

Property Value
Type	Description
`OperationsClient`

DeleteExecutionOperationsClient

public virtual OperationsClient DeleteExecutionOperationsClient { get; }

The long-running operations client for DeleteExecution.

Property Value
Type	Description
`OperationsClient`

DeleteMetadataStoreOperationsClient

public virtual OperationsClient DeleteMetadataStoreOperationsClient { get; }

The long-running operations client for DeleteMetadataStore.

Property Value
Type	Description
`OperationsClient`

GrpcClient

public virtual MetadataService.MetadataServiceClient GrpcClient { get; }

The underlying gRPC MetadataService client

Property Value
Type	Description
`MetadataService.MetadataServiceClient`

PurgeArtifactsOperationsClient

public virtual OperationsClient PurgeArtifactsOperationsClient { get; }

The long-running operations client for PurgeArtifacts.

Property Value
Type	Description
`OperationsClient`

PurgeContextsOperationsClient

public virtual OperationsClient PurgeContextsOperationsClient { get; }

The long-running operations client for PurgeContexts.

Property Value
Type	Description
`OperationsClient`

PurgeExecutionsOperationsClient

public virtual OperationsClient PurgeExecutionsOperationsClient { get; }

The long-running operations client for PurgeExecutions.

Property Value
Type	Description
`OperationsClient`

ServiceMetadata

public static ServiceMetadata ServiceMetadata { get; }

The service metadata associated with this client type.

Property Value
Type	Description
`ServiceMetadata`

Methods

AddContextArtifactsAndExecutions(AddContextArtifactsAndExecutionsRequest, CallSettings)

public virtual AddContextArtifactsAndExecutionsResponse AddContextArtifactsAndExecutions(AddContextArtifactsAndExecutionsRequest request, CallSettings callSettings = null)

Adds a set of Artifacts and Executions to a Context. If any of the Artifacts or Executions have already been added to a Context, they are simply skipped.

Parameters
Name	Description
`request`	`AddContextArtifactsAndExecutionsRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`AddContextArtifactsAndExecutionsResponse`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
AddContextArtifactsAndExecutionsRequest request = new AddContextArtifactsAndExecutionsRequest
{
    ContextAsContextName = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]"),
    ArtifactsAsArtifactNames =
    {
        ArtifactName.FromProjectLocationMetadataStoreArtifact("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]"),
    },
    ExecutionsAsExecutionNames =
    {
        ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]"),
    },
};
// Make the request
AddContextArtifactsAndExecutionsResponse response = metadataServiceClient.AddContextArtifactsAndExecutions(request);

AddContextArtifactsAndExecutions(ContextName, IEnumerable<ArtifactName>, IEnumerable<ExecutionName>, CallSettings)

public virtual AddContextArtifactsAndExecutionsResponse AddContextArtifactsAndExecutions(ContextName context, IEnumerable<ArtifactName> artifacts, IEnumerable<ExecutionName> executions, CallSettings callSettings = null)

Adds a set of Artifacts and Executions to a Context. If any of the Artifacts or Executions have already been added to a Context, they are simply skipped.

Parameters
Name	Description
`context`	`ContextName` Required. The resource name of the Context that the Artifacts and Executions belong to. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`
`artifacts`	`IEnumerable<ArtifactName>` The resource names of the Artifacts to attribute to the Context. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}`
`executions`	`IEnumerable<ExecutionName>` The resource names of the Executions to associate with the Context. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`AddContextArtifactsAndExecutionsResponse`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
ContextName context = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]");
IEnumerable<ArtifactName> artifacts = new ArtifactName[]
{
    ArtifactName.FromProjectLocationMetadataStoreArtifact("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]"),
};
IEnumerable<ExecutionName> executions = new ExecutionName[]
{
    ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]"),
};
// Make the request
AddContextArtifactsAndExecutionsResponse response = metadataServiceClient.AddContextArtifactsAndExecutions(context, artifacts, executions);

AddContextArtifactsAndExecutions(String, IEnumerable<String>, IEnumerable<String>, CallSettings)

public virtual AddContextArtifactsAndExecutionsResponse AddContextArtifactsAndExecutions(string context, IEnumerable<string> artifacts, IEnumerable<string> executions, CallSettings callSettings = null)

Adds a set of Artifacts and Executions to a Context. If any of the Artifacts or Executions have already been added to a Context, they are simply skipped.

Parameters
Name	Description
`context`	`String` Required. The resource name of the Context that the Artifacts and Executions belong to. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`
`artifacts`	`IEnumerable<String>` The resource names of the Artifacts to attribute to the Context. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}`
`executions`	`IEnumerable<String>` The resource names of the Executions to associate with the Context. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`AddContextArtifactsAndExecutionsResponse`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string context = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/contexts/[CONTEXT]";
IEnumerable<string> artifacts = new string[]
{
    "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/artifacts/[ARTIFACT]",
};
IEnumerable<string> executions = new string[]
{
    "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/executions/[EXECUTION]",
};
// Make the request
AddContextArtifactsAndExecutionsResponse response = metadataServiceClient.AddContextArtifactsAndExecutions(context, artifacts, executions);

AddContextArtifactsAndExecutionsAsync(AddContextArtifactsAndExecutionsRequest, CallSettings)

public virtual Task<AddContextArtifactsAndExecutionsResponse> AddContextArtifactsAndExecutionsAsync(AddContextArtifactsAndExecutionsRequest request, CallSettings callSettings = null)

Adds a set of Artifacts and Executions to a Context. If any of the Artifacts or Executions have already been added to a Context, they are simply skipped.

Parameters
Name	Description
`request`	`AddContextArtifactsAndExecutionsRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<AddContextArtifactsAndExecutionsResponse>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
AddContextArtifactsAndExecutionsRequest request = new AddContextArtifactsAndExecutionsRequest
{
    ContextAsContextName = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]"),
    ArtifactsAsArtifactNames =
    {
        ArtifactName.FromProjectLocationMetadataStoreArtifact("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]"),
    },
    ExecutionsAsExecutionNames =
    {
        ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]"),
    },
};
// Make the request
AddContextArtifactsAndExecutionsResponse response = await metadataServiceClient.AddContextArtifactsAndExecutionsAsync(request);

AddContextArtifactsAndExecutionsAsync(AddContextArtifactsAndExecutionsRequest, CancellationToken)

public virtual Task<AddContextArtifactsAndExecutionsResponse> AddContextArtifactsAndExecutionsAsync(AddContextArtifactsAndExecutionsRequest request, CancellationToken cancellationToken)

Adds a set of Artifacts and Executions to a Context. If any of the Artifacts or Executions have already been added to a Context, they are simply skipped.

Parameters
Name	Description
`request`	`AddContextArtifactsAndExecutionsRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<AddContextArtifactsAndExecutionsResponse>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
AddContextArtifactsAndExecutionsRequest request = new AddContextArtifactsAndExecutionsRequest
{
    ContextAsContextName = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]"),
    ArtifactsAsArtifactNames =
    {
        ArtifactName.FromProjectLocationMetadataStoreArtifact("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]"),
    },
    ExecutionsAsExecutionNames =
    {
        ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]"),
    },
};
// Make the request
AddContextArtifactsAndExecutionsResponse response = await metadataServiceClient.AddContextArtifactsAndExecutionsAsync(request);

AddContextArtifactsAndExecutionsAsync(ContextName, IEnumerable<ArtifactName>, IEnumerable<ExecutionName>, CallSettings)

public virtual Task<AddContextArtifactsAndExecutionsResponse> AddContextArtifactsAndExecutionsAsync(ContextName context, IEnumerable<ArtifactName> artifacts, IEnumerable<ExecutionName> executions, CallSettings callSettings = null)

Adds a set of Artifacts and Executions to a Context. If any of the Artifacts or Executions have already been added to a Context, they are simply skipped.

Parameters
Name	Description
`context`	`ContextName` Required. The resource name of the Context that the Artifacts and Executions belong to. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`
`artifacts`	`IEnumerable<ArtifactName>` The resource names of the Artifacts to attribute to the Context. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}`
`executions`	`IEnumerable<ExecutionName>` The resource names of the Executions to associate with the Context. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<AddContextArtifactsAndExecutionsResponse>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ContextName context = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]");
IEnumerable<ArtifactName> artifacts = new ArtifactName[]
{
    ArtifactName.FromProjectLocationMetadataStoreArtifact("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]"),
};
IEnumerable<ExecutionName> executions = new ExecutionName[]
{
    ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]"),
};
// Make the request
AddContextArtifactsAndExecutionsResponse response = await metadataServiceClient.AddContextArtifactsAndExecutionsAsync(context, artifacts, executions);

AddContextArtifactsAndExecutionsAsync(ContextName, IEnumerable<ArtifactName>, IEnumerable<ExecutionName>, CancellationToken)

public virtual Task<AddContextArtifactsAndExecutionsResponse> AddContextArtifactsAndExecutionsAsync(ContextName context, IEnumerable<ArtifactName> artifacts, IEnumerable<ExecutionName> executions, CancellationToken cancellationToken)

Adds a set of Artifacts and Executions to a Context. If any of the Artifacts or Executions have already been added to a Context, they are simply skipped.

Parameters
Name	Description
`context`	`ContextName` Required. The resource name of the Context that the Artifacts and Executions belong to. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`
`artifacts`	`IEnumerable<ArtifactName>` The resource names of the Artifacts to attribute to the Context. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}`
`executions`	`IEnumerable<ExecutionName>` The resource names of the Executions to associate with the Context. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<AddContextArtifactsAndExecutionsResponse>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ContextName context = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]");
IEnumerable<ArtifactName> artifacts = new ArtifactName[]
{
    ArtifactName.FromProjectLocationMetadataStoreArtifact("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]"),
};
IEnumerable<ExecutionName> executions = new ExecutionName[]
{
    ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]"),
};
// Make the request
AddContextArtifactsAndExecutionsResponse response = await metadataServiceClient.AddContextArtifactsAndExecutionsAsync(context, artifacts, executions);

AddContextArtifactsAndExecutionsAsync(String, IEnumerable<String>, IEnumerable<String>, CallSettings)

public virtual Task<AddContextArtifactsAndExecutionsResponse> AddContextArtifactsAndExecutionsAsync(string context, IEnumerable<string> artifacts, IEnumerable<string> executions, CallSettings callSettings = null)

Adds a set of Artifacts and Executions to a Context. If any of the Artifacts or Executions have already been added to a Context, they are simply skipped.

Parameters
Name	Description
`context`	`String` Required. The resource name of the Context that the Artifacts and Executions belong to. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`
`artifacts`	`IEnumerable<String>` The resource names of the Artifacts to attribute to the Context. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}`
`executions`	`IEnumerable<String>` The resource names of the Executions to associate with the Context. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<AddContextArtifactsAndExecutionsResponse>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string context = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/contexts/[CONTEXT]";
IEnumerable<string> artifacts = new string[]
{
    "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/artifacts/[ARTIFACT]",
};
IEnumerable<string> executions = new string[]
{
    "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/executions/[EXECUTION]",
};
// Make the request
AddContextArtifactsAndExecutionsResponse response = await metadataServiceClient.AddContextArtifactsAndExecutionsAsync(context, artifacts, executions);

AddContextArtifactsAndExecutionsAsync(String, IEnumerable<String>, IEnumerable<String>, CancellationToken)

public virtual Task<AddContextArtifactsAndExecutionsResponse> AddContextArtifactsAndExecutionsAsync(string context, IEnumerable<string> artifacts, IEnumerable<string> executions, CancellationToken cancellationToken)

Adds a set of Artifacts and Executions to a Context. If any of the Artifacts or Executions have already been added to a Context, they are simply skipped.

Parameters
Name	Description
`context`	`String` Required. The resource name of the Context that the Artifacts and Executions belong to. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`
`artifacts`	`IEnumerable<String>` The resource names of the Artifacts to attribute to the Context. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}`
`executions`	`IEnumerable<String>` The resource names of the Executions to associate with the Context. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<AddContextArtifactsAndExecutionsResponse>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string context = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/contexts/[CONTEXT]";
IEnumerable<string> artifacts = new string[]
{
    "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/artifacts/[ARTIFACT]",
};
IEnumerable<string> executions = new string[]
{
    "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/executions/[EXECUTION]",
};
// Make the request
AddContextArtifactsAndExecutionsResponse response = await metadataServiceClient.AddContextArtifactsAndExecutionsAsync(context, artifacts, executions);

AddContextChildren(AddContextChildrenRequest, CallSettings)

public virtual AddContextChildrenResponse AddContextChildren(AddContextChildrenRequest request, CallSettings callSettings = null)

Adds a set of Contexts as children to a parent Context. If any of the child Contexts have already been added to the parent Context, they are simply skipped. If this call would create a cycle or cause any Context to have more than 10 parents, the request will fail with an INVALID_ARGUMENT error.

Parameters
Name	Description
`request`	`AddContextChildrenRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`AddContextChildrenResponse`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
AddContextChildrenRequest request = new AddContextChildrenRequest
{
    ContextAsContextName = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]"),
    ChildContextsAsContextNames =
    {
        ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]"),
    },
};
// Make the request
AddContextChildrenResponse response = metadataServiceClient.AddContextChildren(request);

AddContextChildren(ContextName, IEnumerable<ContextName>, CallSettings)

public virtual AddContextChildrenResponse AddContextChildren(ContextName context, IEnumerable<ContextName> childContexts, CallSettings callSettings = null)

Parameters
Name	Description
`context`	`ContextName` Required. The resource name of the parent Context. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`
`childContexts`	`IEnumerable<ContextName>` The resource names of the child Contexts.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`AddContextChildrenResponse`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
ContextName context = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]");
IEnumerable<ContextName> childContexts = new ContextName[]
{
    ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]"),
};
// Make the request
AddContextChildrenResponse response = metadataServiceClient.AddContextChildren(context, childContexts);

AddContextChildren(String, IEnumerable<String>, CallSettings)

public virtual AddContextChildrenResponse AddContextChildren(string context, IEnumerable<string> childContexts, CallSettings callSettings = null)

Parameters
Name	Description
`context`	`String` Required. The resource name of the parent Context. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`
`childContexts`	`IEnumerable<String>` The resource names of the child Contexts.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`AddContextChildrenResponse`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string context = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/contexts/[CONTEXT]";
IEnumerable<string> childContexts = new string[]
{
    "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/contexts/[CONTEXT]",
};
// Make the request
AddContextChildrenResponse response = metadataServiceClient.AddContextChildren(context, childContexts);

AddContextChildrenAsync(AddContextChildrenRequest, CallSettings)

public virtual Task<AddContextChildrenResponse> AddContextChildrenAsync(AddContextChildrenRequest request, CallSettings callSettings = null)

Parameters
Name	Description
`request`	`AddContextChildrenRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<AddContextChildrenResponse>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
AddContextChildrenRequest request = new AddContextChildrenRequest
{
    ContextAsContextName = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]"),
    ChildContextsAsContextNames =
    {
        ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]"),
    },
};
// Make the request
AddContextChildrenResponse response = await metadataServiceClient.AddContextChildrenAsync(request);

AddContextChildrenAsync(AddContextChildrenRequest, CancellationToken)

public virtual Task<AddContextChildrenResponse> AddContextChildrenAsync(AddContextChildrenRequest request, CancellationToken cancellationToken)

Parameters
Name	Description
`request`	`AddContextChildrenRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<AddContextChildrenResponse>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
AddContextChildrenRequest request = new AddContextChildrenRequest
{
    ContextAsContextName = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]"),
    ChildContextsAsContextNames =
    {
        ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]"),
    },
};
// Make the request
AddContextChildrenResponse response = await metadataServiceClient.AddContextChildrenAsync(request);

AddContextChildrenAsync(ContextName, IEnumerable<ContextName>, CallSettings)

public virtual Task<AddContextChildrenResponse> AddContextChildrenAsync(ContextName context, IEnumerable<ContextName> childContexts, CallSettings callSettings = null)

Parameters
Name	Description
`context`	`ContextName` Required. The resource name of the parent Context. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`
`childContexts`	`IEnumerable<ContextName>` The resource names of the child Contexts.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<AddContextChildrenResponse>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ContextName context = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]");
IEnumerable<ContextName> childContexts = new ContextName[]
{
    ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]"),
};
// Make the request
AddContextChildrenResponse response = await metadataServiceClient.AddContextChildrenAsync(context, childContexts);

AddContextChildrenAsync(ContextName, IEnumerable<ContextName>, CancellationToken)

public virtual Task<AddContextChildrenResponse> AddContextChildrenAsync(ContextName context, IEnumerable<ContextName> childContexts, CancellationToken cancellationToken)

Parameters
Name	Description
`context`	`ContextName` Required. The resource name of the parent Context. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`
`childContexts`	`IEnumerable<ContextName>` The resource names of the child Contexts.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<AddContextChildrenResponse>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ContextName context = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]");
IEnumerable<ContextName> childContexts = new ContextName[]
{
    ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]"),
};
// Make the request
AddContextChildrenResponse response = await metadataServiceClient.AddContextChildrenAsync(context, childContexts);

AddContextChildrenAsync(String, IEnumerable<String>, CallSettings)

public virtual Task<AddContextChildrenResponse> AddContextChildrenAsync(string context, IEnumerable<string> childContexts, CallSettings callSettings = null)

Parameters
Name	Description
`context`	`String` Required. The resource name of the parent Context. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`
`childContexts`	`IEnumerable<String>` The resource names of the child Contexts.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<AddContextChildrenResponse>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string context = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/contexts/[CONTEXT]";
IEnumerable<string> childContexts = new string[]
{
    "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/contexts/[CONTEXT]",
};
// Make the request
AddContextChildrenResponse response = await metadataServiceClient.AddContextChildrenAsync(context, childContexts);

AddContextChildrenAsync(String, IEnumerable<String>, CancellationToken)

public virtual Task<AddContextChildrenResponse> AddContextChildrenAsync(string context, IEnumerable<string> childContexts, CancellationToken cancellationToken)

Parameters
Name	Description
`context`	`String` Required. The resource name of the parent Context. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`
`childContexts`	`IEnumerable<String>` The resource names of the child Contexts.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<AddContextChildrenResponse>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string context = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/contexts/[CONTEXT]";
IEnumerable<string> childContexts = new string[]
{
    "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/contexts/[CONTEXT]",
};
// Make the request
AddContextChildrenResponse response = await metadataServiceClient.AddContextChildrenAsync(context, childContexts);

AddExecutionEvents(AddExecutionEventsRequest, CallSettings)

public virtual AddExecutionEventsResponse AddExecutionEvents(AddExecutionEventsRequest request, CallSettings callSettings = null)

Adds Events to the specified Execution. An Event indicates whether an Artifact was used as an input or output for an Execution. If an Event already exists between the Execution and the Artifact, the Event is skipped.

Parameters
Name	Description
`request`	`AddExecutionEventsRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`AddExecutionEventsResponse`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
AddExecutionEventsRequest request = new AddExecutionEventsRequest
{
    ExecutionAsExecutionName = ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]"),
    Events = { new Event(), },
};
// Make the request
AddExecutionEventsResponse response = metadataServiceClient.AddExecutionEvents(request);

AddExecutionEvents(ExecutionName, IEnumerable<Event>, CallSettings)

public virtual AddExecutionEventsResponse AddExecutionEvents(ExecutionName execution, IEnumerable<Event> events, CallSettings callSettings = null)

Parameters
Name	Description
`execution`	`ExecutionName` Required. The resource name of the Execution that the Events connect Artifacts with. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`events`	`IEnumerable<Event>` The Events to create and add.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`AddExecutionEventsResponse`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
ExecutionName execution = ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]");
IEnumerable<Event> events = new Event[] { new Event(), };
// Make the request
AddExecutionEventsResponse response = metadataServiceClient.AddExecutionEvents(execution, events);

AddExecutionEvents(String, IEnumerable<Event>, CallSettings)

public virtual AddExecutionEventsResponse AddExecutionEvents(string execution, IEnumerable<Event> events, CallSettings callSettings = null)

Parameters
Name	Description
`execution`	`String` Required. The resource name of the Execution that the Events connect Artifacts with. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`events`	`IEnumerable<Event>` The Events to create and add.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`AddExecutionEventsResponse`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string execution = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/executions/[EXECUTION]";
IEnumerable<Event> events = new Event[] { new Event(), };
// Make the request
AddExecutionEventsResponse response = metadataServiceClient.AddExecutionEvents(execution, events);

AddExecutionEventsAsync(AddExecutionEventsRequest, CallSettings)

public virtual Task<AddExecutionEventsResponse> AddExecutionEventsAsync(AddExecutionEventsRequest request, CallSettings callSettings = null)

Parameters
Name	Description
`request`	`AddExecutionEventsRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<AddExecutionEventsResponse>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
AddExecutionEventsRequest request = new AddExecutionEventsRequest
{
    ExecutionAsExecutionName = ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]"),
    Events = { new Event(), },
};
// Make the request
AddExecutionEventsResponse response = await metadataServiceClient.AddExecutionEventsAsync(request);

AddExecutionEventsAsync(AddExecutionEventsRequest, CancellationToken)

public virtual Task<AddExecutionEventsResponse> AddExecutionEventsAsync(AddExecutionEventsRequest request, CancellationToken cancellationToken)

Parameters
Name	Description
`request`	`AddExecutionEventsRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<AddExecutionEventsResponse>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
AddExecutionEventsRequest request = new AddExecutionEventsRequest
{
    ExecutionAsExecutionName = ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]"),
    Events = { new Event(), },
};
// Make the request
AddExecutionEventsResponse response = await metadataServiceClient.AddExecutionEventsAsync(request);

AddExecutionEventsAsync(ExecutionName, IEnumerable<Event>, CallSettings)

public virtual Task<AddExecutionEventsResponse> AddExecutionEventsAsync(ExecutionName execution, IEnumerable<Event> events, CallSettings callSettings = null)

Parameters
Name	Description
`execution`	`ExecutionName` Required. The resource name of the Execution that the Events connect Artifacts with. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`events`	`IEnumerable<Event>` The Events to create and add.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<AddExecutionEventsResponse>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ExecutionName execution = ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]");
IEnumerable<Event> events = new Event[] { new Event(), };
// Make the request
AddExecutionEventsResponse response = await metadataServiceClient.AddExecutionEventsAsync(execution, events);

AddExecutionEventsAsync(ExecutionName, IEnumerable<Event>, CancellationToken)

public virtual Task<AddExecutionEventsResponse> AddExecutionEventsAsync(ExecutionName execution, IEnumerable<Event> events, CancellationToken cancellationToken)

Parameters
Name	Description
`execution`	`ExecutionName` Required. The resource name of the Execution that the Events connect Artifacts with. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`events`	`IEnumerable<Event>` The Events to create and add.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<AddExecutionEventsResponse>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ExecutionName execution = ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]");
IEnumerable<Event> events = new Event[] { new Event(), };
// Make the request
AddExecutionEventsResponse response = await metadataServiceClient.AddExecutionEventsAsync(execution, events);

AddExecutionEventsAsync(String, IEnumerable<Event>, CallSettings)

public virtual Task<AddExecutionEventsResponse> AddExecutionEventsAsync(string execution, IEnumerable<Event> events, CallSettings callSettings = null)

Parameters
Name	Description
`execution`	`String` Required. The resource name of the Execution that the Events connect Artifacts with. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`events`	`IEnumerable<Event>` The Events to create and add.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<AddExecutionEventsResponse>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string execution = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/executions/[EXECUTION]";
IEnumerable<Event> events = new Event[] { new Event(), };
// Make the request
AddExecutionEventsResponse response = await metadataServiceClient.AddExecutionEventsAsync(execution, events);

AddExecutionEventsAsync(String, IEnumerable<Event>, CancellationToken)

public virtual Task<AddExecutionEventsResponse> AddExecutionEventsAsync(string execution, IEnumerable<Event> events, CancellationToken cancellationToken)

Parameters
Name	Description
`execution`	`String` Required. The resource name of the Execution that the Events connect Artifacts with. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`events`	`IEnumerable<Event>` The Events to create and add.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<AddExecutionEventsResponse>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string execution = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/executions/[EXECUTION]";
IEnumerable<Event> events = new Event[] { new Event(), };
// Make the request
AddExecutionEventsResponse response = await metadataServiceClient.AddExecutionEventsAsync(execution, events);

Create()

public static MetadataServiceClient Create()

Synchronously creates a MetadataServiceClient using the default credentials, endpoint and settings. To specify custom credentials or other settings, use MetadataServiceClientBuilder.

Returns
Type	Description
`MetadataServiceClient`	The created MetadataServiceClient.

CreateArtifact(CreateArtifactRequest, CallSettings)

public virtual Artifact CreateArtifact(CreateArtifactRequest request, CallSettings callSettings = null)

Creates an Artifact associated with a MetadataStore.

Parameters
Name	Description
`request`	`CreateArtifactRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Artifact`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
CreateArtifactRequest request = new CreateArtifactRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    Artifact = new Artifact(),
    ArtifactId = "",
};
// Make the request
Artifact response = metadataServiceClient.CreateArtifact(request);

CreateArtifact(MetadataStoreName, Artifact, String, CallSettings)

public virtual Artifact CreateArtifact(MetadataStoreName parent, Artifact artifact, string artifactId, CallSettings callSettings = null)

Creates an Artifact associated with a MetadataStore.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The resource name of the MetadataStore where the Artifact should be created. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`artifact`	`Artifact` Required. The Artifact to create.
`artifactId`	`String` The {artifact} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}` If not provided, the Artifact's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all Artifacts in the parent MetadataStore. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting Artifact.)
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Artifact`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
Artifact artifact = new Artifact();
string artifactId = "";
// Make the request
Artifact response = metadataServiceClient.CreateArtifact(parent, artifact, artifactId);

CreateArtifact(String, Artifact, String, CallSettings)

public virtual Artifact CreateArtifact(string parent, Artifact artifact, string artifactId, CallSettings callSettings = null)

Creates an Artifact associated with a MetadataStore.

Parameters
Name	Description
`parent`	`String` Required. The resource name of the MetadataStore where the Artifact should be created. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`artifact`	`Artifact` Required. The Artifact to create.
`artifactId`	`String` The {artifact} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}` If not provided, the Artifact's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all Artifacts in the parent MetadataStore. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting Artifact.)
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Artifact`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
Artifact artifact = new Artifact();
string artifactId = "";
// Make the request
Artifact response = metadataServiceClient.CreateArtifact(parent, artifact, artifactId);

CreateArtifactAsync(CreateArtifactRequest, CallSettings)

public virtual Task<Artifact> CreateArtifactAsync(CreateArtifactRequest request, CallSettings callSettings = null)

Creates an Artifact associated with a MetadataStore.

Parameters
Name	Description
`request`	`CreateArtifactRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Artifact>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
CreateArtifactRequest request = new CreateArtifactRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    Artifact = new Artifact(),
    ArtifactId = "",
};
// Make the request
Artifact response = await metadataServiceClient.CreateArtifactAsync(request);

CreateArtifactAsync(CreateArtifactRequest, CancellationToken)

public virtual Task<Artifact> CreateArtifactAsync(CreateArtifactRequest request, CancellationToken cancellationToken)

Creates an Artifact associated with a MetadataStore.

Parameters
Name	Description
`request`	`CreateArtifactRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Artifact>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
CreateArtifactRequest request = new CreateArtifactRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    Artifact = new Artifact(),
    ArtifactId = "",
};
// Make the request
Artifact response = await metadataServiceClient.CreateArtifactAsync(request);

CreateArtifactAsync(MetadataStoreName, Artifact, String, CallSettings)

public virtual Task<Artifact> CreateArtifactAsync(MetadataStoreName parent, Artifact artifact, string artifactId, CallSettings callSettings = null)

Creates an Artifact associated with a MetadataStore.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The resource name of the MetadataStore where the Artifact should be created. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`artifact`	`Artifact` Required. The Artifact to create.
`artifactId`	`String` The {artifact} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}` If not provided, the Artifact's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all Artifacts in the parent MetadataStore. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting Artifact.)
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Artifact>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
Artifact artifact = new Artifact();
string artifactId = "";
// Make the request
Artifact response = await metadataServiceClient.CreateArtifactAsync(parent, artifact, artifactId);

CreateArtifactAsync(MetadataStoreName, Artifact, String, CancellationToken)

public virtual Task<Artifact> CreateArtifactAsync(MetadataStoreName parent, Artifact artifact, string artifactId, CancellationToken cancellationToken)

Creates an Artifact associated with a MetadataStore.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The resource name of the MetadataStore where the Artifact should be created. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`artifact`	`Artifact` Required. The Artifact to create.
`artifactId`	`String` The {artifact} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}` If not provided, the Artifact's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all Artifacts in the parent MetadataStore. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting Artifact.)
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Artifact>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
Artifact artifact = new Artifact();
string artifactId = "";
// Make the request
Artifact response = await metadataServiceClient.CreateArtifactAsync(parent, artifact, artifactId);

CreateArtifactAsync(String, Artifact, String, CallSettings)

public virtual Task<Artifact> CreateArtifactAsync(string parent, Artifact artifact, string artifactId, CallSettings callSettings = null)

Creates an Artifact associated with a MetadataStore.

Parameters
Name	Description
`parent`	`String` Required. The resource name of the MetadataStore where the Artifact should be created. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`artifact`	`Artifact` Required. The Artifact to create.
`artifactId`	`String` The {artifact} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}` If not provided, the Artifact's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all Artifacts in the parent MetadataStore. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting Artifact.)
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Artifact>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
Artifact artifact = new Artifact();
string artifactId = "";
// Make the request
Artifact response = await metadataServiceClient.CreateArtifactAsync(parent, artifact, artifactId);

CreateArtifactAsync(String, Artifact, String, CancellationToken)

public virtual Task<Artifact> CreateArtifactAsync(string parent, Artifact artifact, string artifactId, CancellationToken cancellationToken)

Creates an Artifact associated with a MetadataStore.

Parameters
Name	Description
`parent`	`String` Required. The resource name of the MetadataStore where the Artifact should be created. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`artifact`	`Artifact` Required. The Artifact to create.
`artifactId`	`String` The {artifact} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}` If not provided, the Artifact's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all Artifacts in the parent MetadataStore. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting Artifact.)
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Artifact>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
Artifact artifact = new Artifact();
string artifactId = "";
// Make the request
Artifact response = await metadataServiceClient.CreateArtifactAsync(parent, artifact, artifactId);

CreateAsync(CancellationToken)

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

Asynchronously creates a MetadataServiceClient using the default credentials, endpoint and settings. To specify custom credentials or other settings, use MetadataServiceClientBuilder.

Parameter
Name	Description
`cancellationToken`	`CancellationToken` The CancellationToken to use while creating the client.

Returns
Type	Description
`Task<MetadataServiceClient>`	The task representing the created MetadataServiceClient.

CreateContext(CreateContextRequest, CallSettings)

public virtual Context CreateContext(CreateContextRequest request, CallSettings callSettings = null)

Creates a Context associated with a MetadataStore.

Parameters
Name	Description
`request`	`CreateContextRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Context`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
CreateContextRequest request = new CreateContextRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    Context = new Context(),
    ContextId = "",
};
// Make the request
Context response = metadataServiceClient.CreateContext(request);

CreateContext(MetadataStoreName, Context, String, CallSettings)

public virtual Context CreateContext(MetadataStoreName parent, Context context, string contextId, CallSettings callSettings = null)

Creates a Context associated with a MetadataStore.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The resource name of the MetadataStore where the Context should be created. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`context`	`Context` Required. The Context to create.
`contextId`	`String` The {context} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`. If not provided, the Context's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all Contexts in the parent MetadataStore. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting Context.)
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Context`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
Context context = new Context();
string contextId = "";
// Make the request
Context response = metadataServiceClient.CreateContext(parent, context, contextId);

CreateContext(String, Context, String, CallSettings)

public virtual Context CreateContext(string parent, Context context, string contextId, CallSettings callSettings = null)

Creates a Context associated with a MetadataStore.

Parameters
Name	Description
`parent`	`String` Required. The resource name of the MetadataStore where the Context should be created. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`context`	`Context` Required. The Context to create.
`contextId`	`String` The {context} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`. If not provided, the Context's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all Contexts in the parent MetadataStore. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting Context.)
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Context`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
Context context = new Context();
string contextId = "";
// Make the request
Context response = metadataServiceClient.CreateContext(parent, context, contextId);

CreateContextAsync(CreateContextRequest, CallSettings)

public virtual Task<Context> CreateContextAsync(CreateContextRequest request, CallSettings callSettings = null)

Creates a Context associated with a MetadataStore.

Parameters
Name	Description
`request`	`CreateContextRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Context>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
CreateContextRequest request = new CreateContextRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    Context = new Context(),
    ContextId = "",
};
// Make the request
Context response = await metadataServiceClient.CreateContextAsync(request);

CreateContextAsync(CreateContextRequest, CancellationToken)

public virtual Task<Context> CreateContextAsync(CreateContextRequest request, CancellationToken cancellationToken)

Creates a Context associated with a MetadataStore.

Parameters
Name	Description
`request`	`CreateContextRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Context>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
CreateContextRequest request = new CreateContextRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    Context = new Context(),
    ContextId = "",
};
// Make the request
Context response = await metadataServiceClient.CreateContextAsync(request);

CreateContextAsync(MetadataStoreName, Context, String, CallSettings)

public virtual Task<Context> CreateContextAsync(MetadataStoreName parent, Context context, string contextId, CallSettings callSettings = null)

Creates a Context associated with a MetadataStore.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The resource name of the MetadataStore where the Context should be created. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`context`	`Context` Required. The Context to create.
`contextId`	`String` The {context} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`. If not provided, the Context's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all Contexts in the parent MetadataStore. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting Context.)
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Context>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
Context context = new Context();
string contextId = "";
// Make the request
Context response = await metadataServiceClient.CreateContextAsync(parent, context, contextId);

CreateContextAsync(MetadataStoreName, Context, String, CancellationToken)

public virtual Task<Context> CreateContextAsync(MetadataStoreName parent, Context context, string contextId, CancellationToken cancellationToken)

Creates a Context associated with a MetadataStore.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The resource name of the MetadataStore where the Context should be created. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`context`	`Context` Required. The Context to create.
`contextId`	`String` The {context} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`. If not provided, the Context's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all Contexts in the parent MetadataStore. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting Context.)
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Context>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
Context context = new Context();
string contextId = "";
// Make the request
Context response = await metadataServiceClient.CreateContextAsync(parent, context, contextId);

CreateContextAsync(String, Context, String, CallSettings)

public virtual Task<Context> CreateContextAsync(string parent, Context context, string contextId, CallSettings callSettings = null)

Creates a Context associated with a MetadataStore.

Parameters
Name	Description
`parent`	`String` Required. The resource name of the MetadataStore where the Context should be created. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`context`	`Context` Required. The Context to create.
`contextId`	`String` The {context} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`. If not provided, the Context's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all Contexts in the parent MetadataStore. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting Context.)
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Context>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
Context context = new Context();
string contextId = "";
// Make the request
Context response = await metadataServiceClient.CreateContextAsync(parent, context, contextId);

CreateContextAsync(String, Context, String, CancellationToken)

public virtual Task<Context> CreateContextAsync(string parent, Context context, string contextId, CancellationToken cancellationToken)

Creates a Context associated with a MetadataStore.

Parameters
Name	Description
`parent`	`String` Required. The resource name of the MetadataStore where the Context should be created. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`context`	`Context` Required. The Context to create.
`contextId`	`String` The {context} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`. If not provided, the Context's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all Contexts in the parent MetadataStore. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting Context.)
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Context>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
Context context = new Context();
string contextId = "";
// Make the request
Context response = await metadataServiceClient.CreateContextAsync(parent, context, contextId);

CreateExecution(CreateExecutionRequest, CallSettings)

public virtual Execution CreateExecution(CreateExecutionRequest request, CallSettings callSettings = null)

Creates an Execution associated with a MetadataStore.

Parameters
Name	Description
`request`	`CreateExecutionRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Execution`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
CreateExecutionRequest request = new CreateExecutionRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    Execution = new Execution(),
    ExecutionId = "",
};
// Make the request
Execution response = metadataServiceClient.CreateExecution(request);

CreateExecution(MetadataStoreName, Execution, String, CallSettings)

public virtual Execution CreateExecution(MetadataStoreName parent, Execution execution, string executionId, CallSettings callSettings = null)

Creates an Execution associated with a MetadataStore.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The resource name of the MetadataStore where the Execution should be created. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`execution`	`Execution` Required. The Execution to create.
`executionId`	`String` The {execution} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}` If not provided, the Execution's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all Executions in the parent MetadataStore. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting Execution.)
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Execution`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
Execution execution = new Execution();
string executionId = "";
// Make the request
Execution response = metadataServiceClient.CreateExecution(parent, execution, executionId);

CreateExecution(String, Execution, String, CallSettings)

public virtual Execution CreateExecution(string parent, Execution execution, string executionId, CallSettings callSettings = null)

Creates an Execution associated with a MetadataStore.

Parameters
Name	Description
`parent`	`String` Required. The resource name of the MetadataStore where the Execution should be created. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`execution`	`Execution` Required. The Execution to create.
`executionId`	`String` The {execution} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}` If not provided, the Execution's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all Executions in the parent MetadataStore. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting Execution.)
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Execution`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
Execution execution = new Execution();
string executionId = "";
// Make the request
Execution response = metadataServiceClient.CreateExecution(parent, execution, executionId);

CreateExecutionAsync(CreateExecutionRequest, CallSettings)

public virtual Task<Execution> CreateExecutionAsync(CreateExecutionRequest request, CallSettings callSettings = null)

Creates an Execution associated with a MetadataStore.

Parameters
Name	Description
`request`	`CreateExecutionRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Execution>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
CreateExecutionRequest request = new CreateExecutionRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    Execution = new Execution(),
    ExecutionId = "",
};
// Make the request
Execution response = await metadataServiceClient.CreateExecutionAsync(request);

CreateExecutionAsync(CreateExecutionRequest, CancellationToken)

public virtual Task<Execution> CreateExecutionAsync(CreateExecutionRequest request, CancellationToken cancellationToken)

Creates an Execution associated with a MetadataStore.

Parameters
Name	Description
`request`	`CreateExecutionRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Execution>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
CreateExecutionRequest request = new CreateExecutionRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    Execution = new Execution(),
    ExecutionId = "",
};
// Make the request
Execution response = await metadataServiceClient.CreateExecutionAsync(request);

CreateExecutionAsync(MetadataStoreName, Execution, String, CallSettings)

public virtual Task<Execution> CreateExecutionAsync(MetadataStoreName parent, Execution execution, string executionId, CallSettings callSettings = null)

Creates an Execution associated with a MetadataStore.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The resource name of the MetadataStore where the Execution should be created. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`execution`	`Execution` Required. The Execution to create.
`executionId`	`String` The {execution} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}` If not provided, the Execution's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all Executions in the parent MetadataStore. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting Execution.)
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Execution>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
Execution execution = new Execution();
string executionId = "";
// Make the request
Execution response = await metadataServiceClient.CreateExecutionAsync(parent, execution, executionId);

CreateExecutionAsync(MetadataStoreName, Execution, String, CancellationToken)

public virtual Task<Execution> CreateExecutionAsync(MetadataStoreName parent, Execution execution, string executionId, CancellationToken cancellationToken)

Creates an Execution associated with a MetadataStore.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The resource name of the MetadataStore where the Execution should be created. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`execution`	`Execution` Required. The Execution to create.
`executionId`	`String` The {execution} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}` If not provided, the Execution's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all Executions in the parent MetadataStore. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting Execution.)
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Execution>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
Execution execution = new Execution();
string executionId = "";
// Make the request
Execution response = await metadataServiceClient.CreateExecutionAsync(parent, execution, executionId);

CreateExecutionAsync(String, Execution, String, CallSettings)

public virtual Task<Execution> CreateExecutionAsync(string parent, Execution execution, string executionId, CallSettings callSettings = null)

Creates an Execution associated with a MetadataStore.

Parameters
Name	Description
`parent`	`String` Required. The resource name of the MetadataStore where the Execution should be created. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`execution`	`Execution` Required. The Execution to create.
`executionId`	`String` The {execution} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}` If not provided, the Execution's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all Executions in the parent MetadataStore. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting Execution.)
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Execution>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
Execution execution = new Execution();
string executionId = "";
// Make the request
Execution response = await metadataServiceClient.CreateExecutionAsync(parent, execution, executionId);

CreateExecutionAsync(String, Execution, String, CancellationToken)

public virtual Task<Execution> CreateExecutionAsync(string parent, Execution execution, string executionId, CancellationToken cancellationToken)

Creates an Execution associated with a MetadataStore.

Parameters
Name	Description
`parent`	`String` Required. The resource name of the MetadataStore where the Execution should be created. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`execution`	`Execution` Required. The Execution to create.
`executionId`	`String` The {execution} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}` If not provided, the Execution's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all Executions in the parent MetadataStore. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting Execution.)
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Execution>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
Execution execution = new Execution();
string executionId = "";
// Make the request
Execution response = await metadataServiceClient.CreateExecutionAsync(parent, execution, executionId);

CreateMetadataSchema(CreateMetadataSchemaRequest, CallSettings)

public virtual MetadataSchema CreateMetadataSchema(CreateMetadataSchemaRequest request, CallSettings callSettings = null)

Creates a MetadataSchema.

Parameters
Name	Description
`request`	`CreateMetadataSchemaRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`MetadataSchema`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
CreateMetadataSchemaRequest request = new CreateMetadataSchemaRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    MetadataSchema = new MetadataSchema(),
    MetadataSchemaId = "",
};
// Make the request
MetadataSchema response = metadataServiceClient.CreateMetadataSchema(request);

CreateMetadataSchema(MetadataStoreName, MetadataSchema, String, CallSettings)

public virtual MetadataSchema CreateMetadataSchema(MetadataStoreName parent, MetadataSchema metadataSchema, string metadataSchemaId, CallSettings callSettings = null)

Creates a MetadataSchema.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The resource name of the MetadataStore where the MetadataSchema should be created. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`metadataSchema`	`MetadataSchema` Required. The MetadataSchema to create.
`metadataSchemaId`	`String` The {metadata_schema} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/metadataSchemas/{metadataschema}` If not provided, the MetadataStore's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all MetadataSchemas in the parent Location. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting MetadataSchema.)
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`MetadataSchema`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
MetadataSchema metadataSchema = new MetadataSchema();
string metadataSchemaId = "";
// Make the request
MetadataSchema response = metadataServiceClient.CreateMetadataSchema(parent, metadataSchema, metadataSchemaId);

CreateMetadataSchema(String, MetadataSchema, String, CallSettings)

public virtual MetadataSchema CreateMetadataSchema(string parent, MetadataSchema metadataSchema, string metadataSchemaId, CallSettings callSettings = null)

Creates a MetadataSchema.

Parameters
Name	Description
`parent`	`String` Required. The resource name of the MetadataStore where the MetadataSchema should be created. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`metadataSchema`	`MetadataSchema` Required. The MetadataSchema to create.
`metadataSchemaId`	`String` The {metadata_schema} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/metadataSchemas/{metadataschema}` If not provided, the MetadataStore's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all MetadataSchemas in the parent Location. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting MetadataSchema.)
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`MetadataSchema`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
MetadataSchema metadataSchema = new MetadataSchema();
string metadataSchemaId = "";
// Make the request
MetadataSchema response = metadataServiceClient.CreateMetadataSchema(parent, metadataSchema, metadataSchemaId);

CreateMetadataSchemaAsync(CreateMetadataSchemaRequest, CallSettings)

public virtual Task<MetadataSchema> CreateMetadataSchemaAsync(CreateMetadataSchemaRequest request, CallSettings callSettings = null)

Creates a MetadataSchema.

Parameters
Name	Description
`request`	`CreateMetadataSchemaRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<MetadataSchema>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
CreateMetadataSchemaRequest request = new CreateMetadataSchemaRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    MetadataSchema = new MetadataSchema(),
    MetadataSchemaId = "",
};
// Make the request
MetadataSchema response = await metadataServiceClient.CreateMetadataSchemaAsync(request);

CreateMetadataSchemaAsync(CreateMetadataSchemaRequest, CancellationToken)

public virtual Task<MetadataSchema> CreateMetadataSchemaAsync(CreateMetadataSchemaRequest request, CancellationToken cancellationToken)

Creates a MetadataSchema.

Parameters
Name	Description
`request`	`CreateMetadataSchemaRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<MetadataSchema>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
CreateMetadataSchemaRequest request = new CreateMetadataSchemaRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    MetadataSchema = new MetadataSchema(),
    MetadataSchemaId = "",
};
// Make the request
MetadataSchema response = await metadataServiceClient.CreateMetadataSchemaAsync(request);

CreateMetadataSchemaAsync(MetadataStoreName, MetadataSchema, String, CallSettings)

public virtual Task<MetadataSchema> CreateMetadataSchemaAsync(MetadataStoreName parent, MetadataSchema metadataSchema, string metadataSchemaId, CallSettings callSettings = null)

Creates a MetadataSchema.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The resource name of the MetadataStore where the MetadataSchema should be created. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`metadataSchema`	`MetadataSchema` Required. The MetadataSchema to create.
`metadataSchemaId`	`String` The {metadata_schema} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/metadataSchemas/{metadataschema}` If not provided, the MetadataStore's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all MetadataSchemas in the parent Location. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting MetadataSchema.)
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<MetadataSchema>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
MetadataSchema metadataSchema = new MetadataSchema();
string metadataSchemaId = "";
// Make the request
MetadataSchema response = await metadataServiceClient.CreateMetadataSchemaAsync(parent, metadataSchema, metadataSchemaId);

CreateMetadataSchemaAsync(MetadataStoreName, MetadataSchema, String, CancellationToken)

public virtual Task<MetadataSchema> CreateMetadataSchemaAsync(MetadataStoreName parent, MetadataSchema metadataSchema, string metadataSchemaId, CancellationToken cancellationToken)

Creates a MetadataSchema.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The resource name of the MetadataStore where the MetadataSchema should be created. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`metadataSchema`	`MetadataSchema` Required. The MetadataSchema to create.
`metadataSchemaId`	`String` The {metadata_schema} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/metadataSchemas/{metadataschema}` If not provided, the MetadataStore's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all MetadataSchemas in the parent Location. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting MetadataSchema.)
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<MetadataSchema>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
MetadataSchema metadataSchema = new MetadataSchema();
string metadataSchemaId = "";
// Make the request
MetadataSchema response = await metadataServiceClient.CreateMetadataSchemaAsync(parent, metadataSchema, metadataSchemaId);

CreateMetadataSchemaAsync(String, MetadataSchema, String, CallSettings)

public virtual Task<MetadataSchema> CreateMetadataSchemaAsync(string parent, MetadataSchema metadataSchema, string metadataSchemaId, CallSettings callSettings = null)

Creates a MetadataSchema.

Parameters
Name	Description
`parent`	`String` Required. The resource name of the MetadataStore where the MetadataSchema should be created. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`metadataSchema`	`MetadataSchema` Required. The MetadataSchema to create.
`metadataSchemaId`	`String` The {metadata_schema} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/metadataSchemas/{metadataschema}` If not provided, the MetadataStore's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all MetadataSchemas in the parent Location. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting MetadataSchema.)
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<MetadataSchema>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
MetadataSchema metadataSchema = new MetadataSchema();
string metadataSchemaId = "";
// Make the request
MetadataSchema response = await metadataServiceClient.CreateMetadataSchemaAsync(parent, metadataSchema, metadataSchemaId);

CreateMetadataSchemaAsync(String, MetadataSchema, String, CancellationToken)

public virtual Task<MetadataSchema> CreateMetadataSchemaAsync(string parent, MetadataSchema metadataSchema, string metadataSchemaId, CancellationToken cancellationToken)

Creates a MetadataSchema.

Parameters
Name	Description
`parent`	`String` Required. The resource name of the MetadataStore where the MetadataSchema should be created. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`metadataSchema`	`MetadataSchema` Required. The MetadataSchema to create.
`metadataSchemaId`	`String` The {metadata_schema} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/metadataSchemas/{metadataschema}` If not provided, the MetadataStore's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all MetadataSchemas in the parent Location. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting MetadataSchema.)
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<MetadataSchema>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
MetadataSchema metadataSchema = new MetadataSchema();
string metadataSchemaId = "";
// Make the request
MetadataSchema response = await metadataServiceClient.CreateMetadataSchemaAsync(parent, metadataSchema, metadataSchemaId);

CreateMetadataStore(LocationName, MetadataStore, String, CallSettings)

public virtual Operation<MetadataStore, CreateMetadataStoreOperationMetadata> CreateMetadataStore(LocationName parent, MetadataStore metadataStore, string metadataStoreId, CallSettings callSettings = null)

Initializes a MetadataStore, including allocation of resources.

Parameters
Name	Description
`parent`	`LocationName` Required. The resource name of the Location where the MetadataStore should be created. Format: `projects/{project}/locations/{location}/`
`metadataStore`	`MetadataStore` Required. The MetadataStore to create.
`metadataStoreId`	`String` The {metadatastore} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}` If not provided, the MetadataStore's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all MetadataStores in the parent Location. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting MetadataStore.)
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<MetadataStore, CreateMetadataStoreOperationMetadata>`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
MetadataStore metadataStore = new MetadataStore();
string metadataStoreId = "";
// Make the request
Operation<MetadataStore, CreateMetadataStoreOperationMetadata> response = metadataServiceClient.CreateMetadataStore(parent, metadataStore, metadataStoreId);

// Poll until the returned long-running operation is complete
Operation<MetadataStore, CreateMetadataStoreOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
MetadataStore 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<MetadataStore, CreateMetadataStoreOperationMetadata> retrievedResponse = metadataServiceClient.PollOnceCreateMetadataStore(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    MetadataStore retrievedResult = retrievedResponse.Result;
}

CreateMetadataStore(CreateMetadataStoreRequest, CallSettings)

public virtual Operation<MetadataStore, CreateMetadataStoreOperationMetadata> CreateMetadataStore(CreateMetadataStoreRequest request, CallSettings callSettings = null)

Initializes a MetadataStore, including allocation of resources.

Parameters
Name	Description
`request`	`CreateMetadataStoreRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<MetadataStore, CreateMetadataStoreOperationMetadata>`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
CreateMetadataStoreRequest request = new CreateMetadataStoreRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    MetadataStore = new MetadataStore(),
    MetadataStoreId = "",
};
// Make the request
Operation<MetadataStore, CreateMetadataStoreOperationMetadata> response = metadataServiceClient.CreateMetadataStore(request);

// Poll until the returned long-running operation is complete
Operation<MetadataStore, CreateMetadataStoreOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
MetadataStore 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<MetadataStore, CreateMetadataStoreOperationMetadata> retrievedResponse = metadataServiceClient.PollOnceCreateMetadataStore(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    MetadataStore retrievedResult = retrievedResponse.Result;
}

CreateMetadataStore(String, MetadataStore, String, CallSettings)

public virtual Operation<MetadataStore, CreateMetadataStoreOperationMetadata> CreateMetadataStore(string parent, MetadataStore metadataStore, string metadataStoreId, CallSettings callSettings = null)

Initializes a MetadataStore, including allocation of resources.

Parameters
Name	Description
`parent`	`String` Required. The resource name of the Location where the MetadataStore should be created. Format: `projects/{project}/locations/{location}/`
`metadataStore`	`MetadataStore` Required. The MetadataStore to create.
`metadataStoreId`	`String` The {metadatastore} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}` If not provided, the MetadataStore's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all MetadataStores in the parent Location. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting MetadataStore.)
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<MetadataStore, CreateMetadataStoreOperationMetadata>`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
MetadataStore metadataStore = new MetadataStore();
string metadataStoreId = "";
// Make the request
Operation<MetadataStore, CreateMetadataStoreOperationMetadata> response = metadataServiceClient.CreateMetadataStore(parent, metadataStore, metadataStoreId);

// Poll until the returned long-running operation is complete
Operation<MetadataStore, CreateMetadataStoreOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
MetadataStore 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<MetadataStore, CreateMetadataStoreOperationMetadata> retrievedResponse = metadataServiceClient.PollOnceCreateMetadataStore(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    MetadataStore retrievedResult = retrievedResponse.Result;
}

CreateMetadataStoreAsync(LocationName, MetadataStore, String, CallSettings)

public virtual Task<Operation<MetadataStore, CreateMetadataStoreOperationMetadata>> CreateMetadataStoreAsync(LocationName parent, MetadataStore metadataStore, string metadataStoreId, CallSettings callSettings = null)

Initializes a MetadataStore, including allocation of resources.

Parameters
Name	Description
`parent`	`LocationName` Required. The resource name of the Location where the MetadataStore should be created. Format: `projects/{project}/locations/{location}/`
`metadataStore`	`MetadataStore` Required. The MetadataStore to create.
`metadataStoreId`	`String` The {metadatastore} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}` If not provided, the MetadataStore's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all MetadataStores in the parent Location. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting MetadataStore.)
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<MetadataStore, CreateMetadataStoreOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
MetadataStore metadataStore = new MetadataStore();
string metadataStoreId = "";
// Make the request
Operation<MetadataStore, CreateMetadataStoreOperationMetadata> response = await metadataServiceClient.CreateMetadataStoreAsync(parent, metadataStore, metadataStoreId);

// Poll until the returned long-running operation is complete
Operation<MetadataStore, CreateMetadataStoreOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
MetadataStore 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<MetadataStore, CreateMetadataStoreOperationMetadata> retrievedResponse = await metadataServiceClient.PollOnceCreateMetadataStoreAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    MetadataStore retrievedResult = retrievedResponse.Result;
}

CreateMetadataStoreAsync(LocationName, MetadataStore, String, CancellationToken)

public virtual Task<Operation<MetadataStore, CreateMetadataStoreOperationMetadata>> CreateMetadataStoreAsync(LocationName parent, MetadataStore metadataStore, string metadataStoreId, CancellationToken cancellationToken)

Initializes a MetadataStore, including allocation of resources.

Parameters
Name	Description
`parent`	`LocationName` Required. The resource name of the Location where the MetadataStore should be created. Format: `projects/{project}/locations/{location}/`
`metadataStore`	`MetadataStore` Required. The MetadataStore to create.
`metadataStoreId`	`String` The {metadatastore} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}` If not provided, the MetadataStore's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all MetadataStores in the parent Location. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting MetadataStore.)
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<MetadataStore, CreateMetadataStoreOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
MetadataStore metadataStore = new MetadataStore();
string metadataStoreId = "";
// Make the request
Operation<MetadataStore, CreateMetadataStoreOperationMetadata> response = await metadataServiceClient.CreateMetadataStoreAsync(parent, metadataStore, metadataStoreId);

// Poll until the returned long-running operation is complete
Operation<MetadataStore, CreateMetadataStoreOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
MetadataStore 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<MetadataStore, CreateMetadataStoreOperationMetadata> retrievedResponse = await metadataServiceClient.PollOnceCreateMetadataStoreAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    MetadataStore retrievedResult = retrievedResponse.Result;
}

CreateMetadataStoreAsync(CreateMetadataStoreRequest, CallSettings)

public virtual Task<Operation<MetadataStore, CreateMetadataStoreOperationMetadata>> CreateMetadataStoreAsync(CreateMetadataStoreRequest request, CallSettings callSettings = null)

Initializes a MetadataStore, including allocation of resources.

Parameters
Name	Description
`request`	`CreateMetadataStoreRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<MetadataStore, CreateMetadataStoreOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
CreateMetadataStoreRequest request = new CreateMetadataStoreRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    MetadataStore = new MetadataStore(),
    MetadataStoreId = "",
};
// Make the request
Operation<MetadataStore, CreateMetadataStoreOperationMetadata> response = await metadataServiceClient.CreateMetadataStoreAsync(request);

// Poll until the returned long-running operation is complete
Operation<MetadataStore, CreateMetadataStoreOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
MetadataStore 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<MetadataStore, CreateMetadataStoreOperationMetadata> retrievedResponse = await metadataServiceClient.PollOnceCreateMetadataStoreAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    MetadataStore retrievedResult = retrievedResponse.Result;
}

CreateMetadataStoreAsync(CreateMetadataStoreRequest, CancellationToken)

public virtual Task<Operation<MetadataStore, CreateMetadataStoreOperationMetadata>> CreateMetadataStoreAsync(CreateMetadataStoreRequest request, CancellationToken cancellationToken)

Initializes a MetadataStore, including allocation of resources.

Parameters
Name	Description
`request`	`CreateMetadataStoreRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<MetadataStore, CreateMetadataStoreOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
CreateMetadataStoreRequest request = new CreateMetadataStoreRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    MetadataStore = new MetadataStore(),
    MetadataStoreId = "",
};
// Make the request
Operation<MetadataStore, CreateMetadataStoreOperationMetadata> response = await metadataServiceClient.CreateMetadataStoreAsync(request);

// Poll until the returned long-running operation is complete
Operation<MetadataStore, CreateMetadataStoreOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
MetadataStore 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<MetadataStore, CreateMetadataStoreOperationMetadata> retrievedResponse = await metadataServiceClient.PollOnceCreateMetadataStoreAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    MetadataStore retrievedResult = retrievedResponse.Result;
}

CreateMetadataStoreAsync(String, MetadataStore, String, CallSettings)

public virtual Task<Operation<MetadataStore, CreateMetadataStoreOperationMetadata>> CreateMetadataStoreAsync(string parent, MetadataStore metadataStore, string metadataStoreId, CallSettings callSettings = null)

Initializes a MetadataStore, including allocation of resources.

Parameters
Name	Description
`parent`	`String` Required. The resource name of the Location where the MetadataStore should be created. Format: `projects/{project}/locations/{location}/`
`metadataStore`	`MetadataStore` Required. The MetadataStore to create.
`metadataStoreId`	`String` The {metadatastore} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}` If not provided, the MetadataStore's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all MetadataStores in the parent Location. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting MetadataStore.)
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<MetadataStore, CreateMetadataStoreOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
MetadataStore metadataStore = new MetadataStore();
string metadataStoreId = "";
// Make the request
Operation<MetadataStore, CreateMetadataStoreOperationMetadata> response = await metadataServiceClient.CreateMetadataStoreAsync(parent, metadataStore, metadataStoreId);

// Poll until the returned long-running operation is complete
Operation<MetadataStore, CreateMetadataStoreOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
MetadataStore 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<MetadataStore, CreateMetadataStoreOperationMetadata> retrievedResponse = await metadataServiceClient.PollOnceCreateMetadataStoreAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    MetadataStore retrievedResult = retrievedResponse.Result;
}

CreateMetadataStoreAsync(String, MetadataStore, String, CancellationToken)

public virtual Task<Operation<MetadataStore, CreateMetadataStoreOperationMetadata>> CreateMetadataStoreAsync(string parent, MetadataStore metadataStore, string metadataStoreId, CancellationToken cancellationToken)

Initializes a MetadataStore, including allocation of resources.

Parameters
Name	Description
`parent`	`String` Required. The resource name of the Location where the MetadataStore should be created. Format: `projects/{project}/locations/{location}/`
`metadataStore`	`MetadataStore` Required. The MetadataStore to create.
`metadataStoreId`	`String` The {metadatastore} portion of the resource name with the format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}` If not provided, the MetadataStore's ID will be a UUID generated by the service. Must be 4-128 characters in length. Valid characters are `/[a-z][0-9]-/`. Must be unique across all MetadataStores in the parent Location. (Otherwise the request will fail with ALREADY_EXISTS, or PERMISSION_DENIED if the caller can't view the preexisting MetadataStore.)
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<MetadataStore, CreateMetadataStoreOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
MetadataStore metadataStore = new MetadataStore();
string metadataStoreId = "";
// Make the request
Operation<MetadataStore, CreateMetadataStoreOperationMetadata> response = await metadataServiceClient.CreateMetadataStoreAsync(parent, metadataStore, metadataStoreId);

// Poll until the returned long-running operation is complete
Operation<MetadataStore, CreateMetadataStoreOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
MetadataStore 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<MetadataStore, CreateMetadataStoreOperationMetadata> retrievedResponse = await metadataServiceClient.PollOnceCreateMetadataStoreAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    MetadataStore retrievedResult = retrievedResponse.Result;
}

DeleteArtifact(ArtifactName, CallSettings)

public virtual Operation<Empty, DeleteOperationMetadata> DeleteArtifact(ArtifactName name, CallSettings callSettings = null)

Deletes an Artifact.

Parameters
Name	Description
`name`	`ArtifactName` Required. The resource name of the Artifact to delete. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<Empty, DeleteOperationMetadata>`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
ArtifactName name = ArtifactName.FromProjectLocationMetadataStoreArtifact("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = metadataServiceClient.DeleteArtifact(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 = metadataServiceClient.PollOnceDeleteArtifact(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;
}

DeleteArtifact(DeleteArtifactRequest, CallSettings)

public virtual Operation<Empty, DeleteOperationMetadata> DeleteArtifact(DeleteArtifactRequest request, CallSettings callSettings = null)

Deletes an Artifact.

Parameters
Name	Description
`request`	`DeleteArtifactRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<Empty, DeleteOperationMetadata>`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
DeleteArtifactRequest request = new DeleteArtifactRequest
{
    ArtifactName = ArtifactName.FromProjectLocationMetadataStoreArtifact("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]"),
    Etag = "",
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = metadataServiceClient.DeleteArtifact(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 = metadataServiceClient.PollOnceDeleteArtifact(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;
}

DeleteArtifact(String, CallSettings)

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

Deletes an Artifact.

Parameters
Name	Description
`name`	`String` Required. The resource name of the Artifact to delete. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<Empty, DeleteOperationMetadata>`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/artifacts/[ARTIFACT]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = metadataServiceClient.DeleteArtifact(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 = metadataServiceClient.PollOnceDeleteArtifact(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;
}

DeleteArtifactAsync(ArtifactName, CallSettings)

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

Deletes an Artifact.

Parameters
Name	Description
`name`	`ArtifactName` Required. The resource name of the Artifact to delete. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<Empty, DeleteOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ArtifactName name = ArtifactName.FromProjectLocationMetadataStoreArtifact("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await metadataServiceClient.DeleteArtifactAsync(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 metadataServiceClient.PollOnceDeleteArtifactAsync(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;
}

DeleteArtifactAsync(ArtifactName, CancellationToken)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteArtifactAsync(ArtifactName name, CancellationToken cancellationToken)

Deletes an Artifact.

Parameters
Name	Description
`name`	`ArtifactName` Required. The resource name of the Artifact to delete. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<Empty, DeleteOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ArtifactName name = ArtifactName.FromProjectLocationMetadataStoreArtifact("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await metadataServiceClient.DeleteArtifactAsync(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 metadataServiceClient.PollOnceDeleteArtifactAsync(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;
}

DeleteArtifactAsync(DeleteArtifactRequest, CallSettings)

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

Deletes an Artifact.

Parameters
Name	Description
`request`	`DeleteArtifactRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<Empty, DeleteOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteArtifactRequest request = new DeleteArtifactRequest
{
    ArtifactName = ArtifactName.FromProjectLocationMetadataStoreArtifact("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]"),
    Etag = "",
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await metadataServiceClient.DeleteArtifactAsync(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 metadataServiceClient.PollOnceDeleteArtifactAsync(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;
}

DeleteArtifactAsync(DeleteArtifactRequest, CancellationToken)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteArtifactAsync(DeleteArtifactRequest request, CancellationToken cancellationToken)

Deletes an Artifact.

Parameters
Name	Description
`request`	`DeleteArtifactRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<Empty, DeleteOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteArtifactRequest request = new DeleteArtifactRequest
{
    ArtifactName = ArtifactName.FromProjectLocationMetadataStoreArtifact("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]"),
    Etag = "",
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await metadataServiceClient.DeleteArtifactAsync(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 metadataServiceClient.PollOnceDeleteArtifactAsync(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;
}

DeleteArtifactAsync(String, CallSettings)

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

Deletes an Artifact.

Parameters
Name	Description
`name`	`String` Required. The resource name of the Artifact to delete. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<Empty, DeleteOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/artifacts/[ARTIFACT]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await metadataServiceClient.DeleteArtifactAsync(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 metadataServiceClient.PollOnceDeleteArtifactAsync(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;
}

DeleteArtifactAsync(String, CancellationToken)

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

Deletes an Artifact.

Parameters
Name	Description
`name`	`String` Required. The resource name of the Artifact to delete. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<Empty, DeleteOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/artifacts/[ARTIFACT]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await metadataServiceClient.DeleteArtifactAsync(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 metadataServiceClient.PollOnceDeleteArtifactAsync(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;
}

DeleteContext(ContextName, CallSettings)

public virtual Operation<Empty, DeleteOperationMetadata> DeleteContext(ContextName name, CallSettings callSettings = null)

Deletes a stored Context.

Parameters
Name	Description
`name`	`ContextName` Required. The resource name of the Context to delete. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<Empty, DeleteOperationMetadata>`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
ContextName name = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = metadataServiceClient.DeleteContext(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 = metadataServiceClient.PollOnceDeleteContext(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;
}

DeleteContext(DeleteContextRequest, CallSettings)

public virtual Operation<Empty, DeleteOperationMetadata> DeleteContext(DeleteContextRequest request, CallSettings callSettings = null)

Deletes a stored Context.

Parameters
Name	Description
`request`	`DeleteContextRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<Empty, DeleteOperationMetadata>`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
DeleteContextRequest request = new DeleteContextRequest
{
    ContextName = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]"),
    Force = false,
    Etag = "",
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = metadataServiceClient.DeleteContext(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 = metadataServiceClient.PollOnceDeleteContext(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;
}

DeleteContext(String, CallSettings)

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

Deletes a stored Context.

Parameters
Name	Description
`name`	`String` Required. The resource name of the Context to delete. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<Empty, DeleteOperationMetadata>`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/contexts/[CONTEXT]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = metadataServiceClient.DeleteContext(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 = metadataServiceClient.PollOnceDeleteContext(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;
}

DeleteContextAsync(ContextName, CallSettings)

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

Deletes a stored Context.

Parameters
Name	Description
`name`	`ContextName` Required. The resource name of the Context to delete. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<Empty, DeleteOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ContextName name = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await metadataServiceClient.DeleteContextAsync(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 metadataServiceClient.PollOnceDeleteContextAsync(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;
}

DeleteContextAsync(ContextName, CancellationToken)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteContextAsync(ContextName name, CancellationToken cancellationToken)

Deletes a stored Context.

Parameters
Name	Description
`name`	`ContextName` Required. The resource name of the Context to delete. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<Empty, DeleteOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ContextName name = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await metadataServiceClient.DeleteContextAsync(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 metadataServiceClient.PollOnceDeleteContextAsync(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;
}

DeleteContextAsync(DeleteContextRequest, CallSettings)

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

Deletes a stored Context.

Parameters
Name	Description
`request`	`DeleteContextRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<Empty, DeleteOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteContextRequest request = new DeleteContextRequest
{
    ContextName = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]"),
    Force = false,
    Etag = "",
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await metadataServiceClient.DeleteContextAsync(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 metadataServiceClient.PollOnceDeleteContextAsync(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;
}

DeleteContextAsync(DeleteContextRequest, CancellationToken)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteContextAsync(DeleteContextRequest request, CancellationToken cancellationToken)

Deletes a stored Context.

Parameters
Name	Description
`request`	`DeleteContextRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<Empty, DeleteOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteContextRequest request = new DeleteContextRequest
{
    ContextName = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]"),
    Force = false,
    Etag = "",
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await metadataServiceClient.DeleteContextAsync(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 metadataServiceClient.PollOnceDeleteContextAsync(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;
}

DeleteContextAsync(String, CallSettings)

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

Deletes a stored Context.

Parameters
Name	Description
`name`	`String` Required. The resource name of the Context to delete. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<Empty, DeleteOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/contexts/[CONTEXT]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await metadataServiceClient.DeleteContextAsync(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 metadataServiceClient.PollOnceDeleteContextAsync(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;
}

DeleteContextAsync(String, CancellationToken)

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

Deletes a stored Context.

Parameters
Name	Description
`name`	`String` Required. The resource name of the Context to delete. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<Empty, DeleteOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/contexts/[CONTEXT]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await metadataServiceClient.DeleteContextAsync(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 metadataServiceClient.PollOnceDeleteContextAsync(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;
}

DeleteExecution(DeleteExecutionRequest, CallSettings)

public virtual Operation<Empty, DeleteOperationMetadata> DeleteExecution(DeleteExecutionRequest request, CallSettings callSettings = null)

Deletes an Execution.

Parameters
Name	Description
`request`	`DeleteExecutionRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<Empty, DeleteOperationMetadata>`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
DeleteExecutionRequest request = new DeleteExecutionRequest
{
    ExecutionName = ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]"),
    Etag = "",
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = metadataServiceClient.DeleteExecution(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 = metadataServiceClient.PollOnceDeleteExecution(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;
}

DeleteExecution(ExecutionName, CallSettings)

public virtual Operation<Empty, DeleteOperationMetadata> DeleteExecution(ExecutionName name, CallSettings callSettings = null)

Deletes an Execution.

Parameters
Name	Description
`name`	`ExecutionName` Required. The resource name of the Execution to delete. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<Empty, DeleteOperationMetadata>`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
ExecutionName name = ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = metadataServiceClient.DeleteExecution(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 = metadataServiceClient.PollOnceDeleteExecution(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;
}

DeleteExecution(String, CallSettings)

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

Deletes an Execution.

Parameters
Name	Description
`name`	`String` Required. The resource name of the Execution to delete. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<Empty, DeleteOperationMetadata>`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/executions/[EXECUTION]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = metadataServiceClient.DeleteExecution(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 = metadataServiceClient.PollOnceDeleteExecution(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;
}

DeleteExecutionAsync(DeleteExecutionRequest, CallSettings)

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

Deletes an Execution.

Parameters
Name	Description
`request`	`DeleteExecutionRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<Empty, DeleteOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteExecutionRequest request = new DeleteExecutionRequest
{
    ExecutionName = ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]"),
    Etag = "",
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await metadataServiceClient.DeleteExecutionAsync(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 metadataServiceClient.PollOnceDeleteExecutionAsync(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;
}

DeleteExecutionAsync(DeleteExecutionRequest, CancellationToken)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteExecutionAsync(DeleteExecutionRequest request, CancellationToken cancellationToken)

Deletes an Execution.

Parameters
Name	Description
`request`	`DeleteExecutionRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<Empty, DeleteOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteExecutionRequest request = new DeleteExecutionRequest
{
    ExecutionName = ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]"),
    Etag = "",
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await metadataServiceClient.DeleteExecutionAsync(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 metadataServiceClient.PollOnceDeleteExecutionAsync(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;
}

DeleteExecutionAsync(ExecutionName, CallSettings)

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

Deletes an Execution.

Parameters
Name	Description
`name`	`ExecutionName` Required. The resource name of the Execution to delete. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<Empty, DeleteOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ExecutionName name = ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await metadataServiceClient.DeleteExecutionAsync(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 metadataServiceClient.PollOnceDeleteExecutionAsync(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;
}

DeleteExecutionAsync(ExecutionName, CancellationToken)

public virtual Task<Operation<Empty, DeleteOperationMetadata>> DeleteExecutionAsync(ExecutionName name, CancellationToken cancellationToken)

Deletes an Execution.

Parameters
Name	Description
`name`	`ExecutionName` Required. The resource name of the Execution to delete. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<Empty, DeleteOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ExecutionName name = ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await metadataServiceClient.DeleteExecutionAsync(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 metadataServiceClient.PollOnceDeleteExecutionAsync(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;
}

DeleteExecutionAsync(String, CallSettings)

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

Deletes an Execution.

Parameters
Name	Description
`name`	`String` Required. The resource name of the Execution to delete. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<Empty, DeleteOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/executions/[EXECUTION]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await metadataServiceClient.DeleteExecutionAsync(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 metadataServiceClient.PollOnceDeleteExecutionAsync(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;
}

DeleteExecutionAsync(String, CancellationToken)

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

Deletes an Execution.

Parameters
Name	Description
`name`	`String` Required. The resource name of the Execution to delete. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<Empty, DeleteOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/executions/[EXECUTION]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await metadataServiceClient.DeleteExecutionAsync(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 metadataServiceClient.PollOnceDeleteExecutionAsync(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;
}

DeleteMetadataStore(DeleteMetadataStoreRequest, CallSettings)

public virtual Operation<Empty, DeleteMetadataStoreOperationMetadata> DeleteMetadataStore(DeleteMetadataStoreRequest request, CallSettings callSettings = null)

Deletes a single MetadataStore and all its child resources (Artifacts, Executions, and Contexts).

Parameters
Name	Description
`request`	`DeleteMetadataStoreRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<Empty, DeleteMetadataStoreOperationMetadata>`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
DeleteMetadataStoreRequest request = new DeleteMetadataStoreRequest
{
    MetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
};
// Make the request
Operation<Empty, DeleteMetadataStoreOperationMetadata> response = metadataServiceClient.DeleteMetadataStore(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteMetadataStoreOperationMetadata> 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, DeleteMetadataStoreOperationMetadata> retrievedResponse = metadataServiceClient.PollOnceDeleteMetadataStore(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;
}

DeleteMetadataStore(MetadataStoreName, CallSettings)

public virtual Operation<Empty, DeleteMetadataStoreOperationMetadata> DeleteMetadataStore(MetadataStoreName name, CallSettings callSettings = null)

Deletes a single MetadataStore and all its child resources (Artifacts, Executions, and Contexts).

Parameters
Name	Description
`name`	`MetadataStoreName` Required. The resource name of the MetadataStore to delete. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<Empty, DeleteMetadataStoreOperationMetadata>`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
MetadataStoreName name = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
// Make the request
Operation<Empty, DeleteMetadataStoreOperationMetadata> response = metadataServiceClient.DeleteMetadataStore(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteMetadataStoreOperationMetadata> 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, DeleteMetadataStoreOperationMetadata> retrievedResponse = metadataServiceClient.PollOnceDeleteMetadataStore(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;
}

DeleteMetadataStore(String, CallSettings)

public virtual Operation<Empty, DeleteMetadataStoreOperationMetadata> DeleteMetadataStore(string name, CallSettings callSettings = null)

Deletes a single MetadataStore and all its child resources (Artifacts, Executions, and Contexts).

Parameters
Name	Description
`name`	`String` Required. The resource name of the MetadataStore to delete. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<Empty, DeleteMetadataStoreOperationMetadata>`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
// Make the request
Operation<Empty, DeleteMetadataStoreOperationMetadata> response = metadataServiceClient.DeleteMetadataStore(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteMetadataStoreOperationMetadata> 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, DeleteMetadataStoreOperationMetadata> retrievedResponse = metadataServiceClient.PollOnceDeleteMetadataStore(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;
}

DeleteMetadataStoreAsync(DeleteMetadataStoreRequest, CallSettings)

public virtual Task<Operation<Empty, DeleteMetadataStoreOperationMetadata>> DeleteMetadataStoreAsync(DeleteMetadataStoreRequest request, CallSettings callSettings = null)

Deletes a single MetadataStore and all its child resources (Artifacts, Executions, and Contexts).

Parameters
Name	Description
`request`	`DeleteMetadataStoreRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<Empty, DeleteMetadataStoreOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteMetadataStoreRequest request = new DeleteMetadataStoreRequest
{
    MetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
};
// Make the request
Operation<Empty, DeleteMetadataStoreOperationMetadata> response = await metadataServiceClient.DeleteMetadataStoreAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteMetadataStoreOperationMetadata> 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, DeleteMetadataStoreOperationMetadata> retrievedResponse = await metadataServiceClient.PollOnceDeleteMetadataStoreAsync(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;
}

DeleteMetadataStoreAsync(DeleteMetadataStoreRequest, CancellationToken)

public virtual Task<Operation<Empty, DeleteMetadataStoreOperationMetadata>> DeleteMetadataStoreAsync(DeleteMetadataStoreRequest request, CancellationToken cancellationToken)

Deletes a single MetadataStore and all its child resources (Artifacts, Executions, and Contexts).

Parameters
Name	Description
`request`	`DeleteMetadataStoreRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<Empty, DeleteMetadataStoreOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteMetadataStoreRequest request = new DeleteMetadataStoreRequest
{
    MetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
};
// Make the request
Operation<Empty, DeleteMetadataStoreOperationMetadata> response = await metadataServiceClient.DeleteMetadataStoreAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteMetadataStoreOperationMetadata> 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, DeleteMetadataStoreOperationMetadata> retrievedResponse = await metadataServiceClient.PollOnceDeleteMetadataStoreAsync(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;
}

DeleteMetadataStoreAsync(MetadataStoreName, CallSettings)

public virtual Task<Operation<Empty, DeleteMetadataStoreOperationMetadata>> DeleteMetadataStoreAsync(MetadataStoreName name, CallSettings callSettings = null)

Deletes a single MetadataStore and all its child resources (Artifacts, Executions, and Contexts).

Parameters
Name	Description
`name`	`MetadataStoreName` Required. The resource name of the MetadataStore to delete. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<Empty, DeleteMetadataStoreOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
MetadataStoreName name = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
// Make the request
Operation<Empty, DeleteMetadataStoreOperationMetadata> response = await metadataServiceClient.DeleteMetadataStoreAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteMetadataStoreOperationMetadata> 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, DeleteMetadataStoreOperationMetadata> retrievedResponse = await metadataServiceClient.PollOnceDeleteMetadataStoreAsync(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;
}

DeleteMetadataStoreAsync(MetadataStoreName, CancellationToken)

public virtual Task<Operation<Empty, DeleteMetadataStoreOperationMetadata>> DeleteMetadataStoreAsync(MetadataStoreName name, CancellationToken cancellationToken)

Deletes a single MetadataStore and all its child resources (Artifacts, Executions, and Contexts).

Parameters
Name	Description
`name`	`MetadataStoreName` Required. The resource name of the MetadataStore to delete. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<Empty, DeleteMetadataStoreOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
MetadataStoreName name = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
// Make the request
Operation<Empty, DeleteMetadataStoreOperationMetadata> response = await metadataServiceClient.DeleteMetadataStoreAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteMetadataStoreOperationMetadata> 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, DeleteMetadataStoreOperationMetadata> retrievedResponse = await metadataServiceClient.PollOnceDeleteMetadataStoreAsync(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;
}

DeleteMetadataStoreAsync(String, CallSettings)

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

Deletes a single MetadataStore and all its child resources (Artifacts, Executions, and Contexts).

Parameters
Name	Description
`name`	`String` Required. The resource name of the MetadataStore to delete. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<Empty, DeleteMetadataStoreOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
// Make the request
Operation<Empty, DeleteMetadataStoreOperationMetadata> response = await metadataServiceClient.DeleteMetadataStoreAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteMetadataStoreOperationMetadata> 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, DeleteMetadataStoreOperationMetadata> retrievedResponse = await metadataServiceClient.PollOnceDeleteMetadataStoreAsync(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;
}

DeleteMetadataStoreAsync(String, CancellationToken)

public virtual Task<Operation<Empty, DeleteMetadataStoreOperationMetadata>> DeleteMetadataStoreAsync(string name, CancellationToken cancellationToken)

Deletes a single MetadataStore and all its child resources (Artifacts, Executions, and Contexts).

Parameters
Name	Description
`name`	`String` Required. The resource name of the MetadataStore to delete. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<Empty, DeleteMetadataStoreOperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
// Make the request
Operation<Empty, DeleteMetadataStoreOperationMetadata> response = await metadataServiceClient.DeleteMetadataStoreAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteMetadataStoreOperationMetadata> 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, DeleteMetadataStoreOperationMetadata> retrievedResponse = await metadataServiceClient.PollOnceDeleteMetadataStoreAsync(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;
}

GetArtifact(ArtifactName, CallSettings)

public virtual Artifact GetArtifact(ArtifactName name, CallSettings callSettings = null)

Retrieves a specific Artifact.

Parameters
Name	Description
`name`	`ArtifactName` Required. The resource name of the Artifact to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Artifact`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
ArtifactName name = ArtifactName.FromProjectLocationMetadataStoreArtifact("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]");
// Make the request
Artifact response = metadataServiceClient.GetArtifact(name);

GetArtifact(GetArtifactRequest, CallSettings)

public virtual Artifact GetArtifact(GetArtifactRequest request, CallSettings callSettings = null)

Retrieves a specific Artifact.

Parameters
Name	Description
`request`	`GetArtifactRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Artifact`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
GetArtifactRequest request = new GetArtifactRequest
{
    ArtifactName = ArtifactName.FromProjectLocationMetadataStoreArtifact("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]"),
};
// Make the request
Artifact response = metadataServiceClient.GetArtifact(request);

GetArtifact(String, CallSettings)

public virtual Artifact GetArtifact(string name, CallSettings callSettings = null)

Retrieves a specific Artifact.

Parameters
Name	Description
`name`	`String` Required. The resource name of the Artifact to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Artifact`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/artifacts/[ARTIFACT]";
// Make the request
Artifact response = metadataServiceClient.GetArtifact(name);

GetArtifactAsync(ArtifactName, CallSettings)

public virtual Task<Artifact> GetArtifactAsync(ArtifactName name, CallSettings callSettings = null)

Retrieves a specific Artifact.

Parameters
Name	Description
`name`	`ArtifactName` Required. The resource name of the Artifact to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Artifact>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ArtifactName name = ArtifactName.FromProjectLocationMetadataStoreArtifact("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]");
// Make the request
Artifact response = await metadataServiceClient.GetArtifactAsync(name);

GetArtifactAsync(ArtifactName, CancellationToken)

public virtual Task<Artifact> GetArtifactAsync(ArtifactName name, CancellationToken cancellationToken)

Retrieves a specific Artifact.

Parameters
Name	Description
`name`	`ArtifactName` Required. The resource name of the Artifact to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Artifact>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ArtifactName name = ArtifactName.FromProjectLocationMetadataStoreArtifact("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]");
// Make the request
Artifact response = await metadataServiceClient.GetArtifactAsync(name);

GetArtifactAsync(GetArtifactRequest, CallSettings)

public virtual Task<Artifact> GetArtifactAsync(GetArtifactRequest request, CallSettings callSettings = null)

Retrieves a specific Artifact.

Parameters
Name	Description
`request`	`GetArtifactRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Artifact>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
GetArtifactRequest request = new GetArtifactRequest
{
    ArtifactName = ArtifactName.FromProjectLocationMetadataStoreArtifact("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]"),
};
// Make the request
Artifact response = await metadataServiceClient.GetArtifactAsync(request);

GetArtifactAsync(GetArtifactRequest, CancellationToken)

public virtual Task<Artifact> GetArtifactAsync(GetArtifactRequest request, CancellationToken cancellationToken)

Retrieves a specific Artifact.

Parameters
Name	Description
`request`	`GetArtifactRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Artifact>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
GetArtifactRequest request = new GetArtifactRequest
{
    ArtifactName = ArtifactName.FromProjectLocationMetadataStoreArtifact("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]"),
};
// Make the request
Artifact response = await metadataServiceClient.GetArtifactAsync(request);

GetArtifactAsync(String, CallSettings)

public virtual Task<Artifact> GetArtifactAsync(string name, CallSettings callSettings = null)

Retrieves a specific Artifact.

Parameters
Name	Description
`name`	`String` Required. The resource name of the Artifact to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Artifact>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/artifacts/[ARTIFACT]";
// Make the request
Artifact response = await metadataServiceClient.GetArtifactAsync(name);

GetArtifactAsync(String, CancellationToken)

public virtual Task<Artifact> GetArtifactAsync(string name, CancellationToken cancellationToken)

Retrieves a specific Artifact.

Parameters
Name	Description
`name`	`String` Required. The resource name of the Artifact to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Artifact>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/artifacts/[ARTIFACT]";
// Make the request
Artifact response = await metadataServiceClient.GetArtifactAsync(name);

GetContext(ContextName, CallSettings)

public virtual Context GetContext(ContextName name, CallSettings callSettings = null)

Retrieves a specific Context.

Parameters
Name	Description
`name`	`ContextName` Required. The resource name of the Context to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Context`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
ContextName name = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]");
// Make the request
Context response = metadataServiceClient.GetContext(name);

GetContext(GetContextRequest, CallSettings)

public virtual Context GetContext(GetContextRequest request, CallSettings callSettings = null)

Retrieves a specific Context.

Parameters
Name	Description
`request`	`GetContextRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Context`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
GetContextRequest request = new GetContextRequest
{
    ContextName = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]"),
};
// Make the request
Context response = metadataServiceClient.GetContext(request);

GetContext(String, CallSettings)

public virtual Context GetContext(string name, CallSettings callSettings = null)

Retrieves a specific Context.

Parameters
Name	Description
`name`	`String` Required. The resource name of the Context to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Context`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/contexts/[CONTEXT]";
// Make the request
Context response = metadataServiceClient.GetContext(name);

GetContextAsync(ContextName, CallSettings)

public virtual Task<Context> GetContextAsync(ContextName name, CallSettings callSettings = null)

Retrieves a specific Context.

Parameters
Name	Description
`name`	`ContextName` Required. The resource name of the Context to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Context>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ContextName name = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]");
// Make the request
Context response = await metadataServiceClient.GetContextAsync(name);

GetContextAsync(ContextName, CancellationToken)

public virtual Task<Context> GetContextAsync(ContextName name, CancellationToken cancellationToken)

Retrieves a specific Context.

Parameters
Name	Description
`name`	`ContextName` Required. The resource name of the Context to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Context>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ContextName name = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]");
// Make the request
Context response = await metadataServiceClient.GetContextAsync(name);

GetContextAsync(GetContextRequest, CallSettings)

public virtual Task<Context> GetContextAsync(GetContextRequest request, CallSettings callSettings = null)

Retrieves a specific Context.

Parameters
Name	Description
`request`	`GetContextRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Context>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
GetContextRequest request = new GetContextRequest
{
    ContextName = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]"),
};
// Make the request
Context response = await metadataServiceClient.GetContextAsync(request);

GetContextAsync(GetContextRequest, CancellationToken)

public virtual Task<Context> GetContextAsync(GetContextRequest request, CancellationToken cancellationToken)

Retrieves a specific Context.

Parameters
Name	Description
`request`	`GetContextRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Context>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
GetContextRequest request = new GetContextRequest
{
    ContextName = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]"),
};
// Make the request
Context response = await metadataServiceClient.GetContextAsync(request);

GetContextAsync(String, CallSettings)

public virtual Task<Context> GetContextAsync(string name, CallSettings callSettings = null)

Retrieves a specific Context.

Parameters
Name	Description
`name`	`String` Required. The resource name of the Context to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Context>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/contexts/[CONTEXT]";
// Make the request
Context response = await metadataServiceClient.GetContextAsync(name);

GetContextAsync(String, CancellationToken)

public virtual Task<Context> GetContextAsync(string name, CancellationToken cancellationToken)

Retrieves a specific Context.

Parameters
Name	Description
`name`	`String` Required. The resource name of the Context to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Context>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/contexts/[CONTEXT]";
// Make the request
Context response = await metadataServiceClient.GetContextAsync(name);

GetExecution(ExecutionName, CallSettings)

public virtual Execution GetExecution(ExecutionName name, CallSettings callSettings = null)

Retrieves a specific Execution.

Parameters
Name	Description
`name`	`ExecutionName` Required. The resource name of the Execution to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Execution`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
ExecutionName name = ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]");
// Make the request
Execution response = metadataServiceClient.GetExecution(name);

GetExecution(GetExecutionRequest, CallSettings)

public virtual Execution GetExecution(GetExecutionRequest request, CallSettings callSettings = null)

Retrieves a specific Execution.

Parameters
Name	Description
`request`	`GetExecutionRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Execution`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
GetExecutionRequest request = new GetExecutionRequest
{
    ExecutionName = ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]"),
};
// Make the request
Execution response = metadataServiceClient.GetExecution(request);

GetExecution(String, CallSettings)

public virtual Execution GetExecution(string name, CallSettings callSettings = null)

Retrieves a specific Execution.

Parameters
Name	Description
`name`	`String` Required. The resource name of the Execution to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Execution`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/executions/[EXECUTION]";
// Make the request
Execution response = metadataServiceClient.GetExecution(name);

GetExecutionAsync(ExecutionName, CallSettings)

public virtual Task<Execution> GetExecutionAsync(ExecutionName name, CallSettings callSettings = null)

Retrieves a specific Execution.

Parameters
Name	Description
`name`	`ExecutionName` Required. The resource name of the Execution to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Execution>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ExecutionName name = ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]");
// Make the request
Execution response = await metadataServiceClient.GetExecutionAsync(name);

GetExecutionAsync(ExecutionName, CancellationToken)

public virtual Task<Execution> GetExecutionAsync(ExecutionName name, CancellationToken cancellationToken)

Retrieves a specific Execution.

Parameters
Name	Description
`name`	`ExecutionName` Required. The resource name of the Execution to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Execution>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ExecutionName name = ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]");
// Make the request
Execution response = await metadataServiceClient.GetExecutionAsync(name);

GetExecutionAsync(GetExecutionRequest, CallSettings)

public virtual Task<Execution> GetExecutionAsync(GetExecutionRequest request, CallSettings callSettings = null)

Retrieves a specific Execution.

Parameters
Name	Description
`request`	`GetExecutionRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Execution>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
GetExecutionRequest request = new GetExecutionRequest
{
    ExecutionName = ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]"),
};
// Make the request
Execution response = await metadataServiceClient.GetExecutionAsync(request);

GetExecutionAsync(GetExecutionRequest, CancellationToken)

public virtual Task<Execution> GetExecutionAsync(GetExecutionRequest request, CancellationToken cancellationToken)

Retrieves a specific Execution.

Parameters
Name	Description
`request`	`GetExecutionRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Execution>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
GetExecutionRequest request = new GetExecutionRequest
{
    ExecutionName = ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]"),
};
// Make the request
Execution response = await metadataServiceClient.GetExecutionAsync(request);

GetExecutionAsync(String, CallSettings)

public virtual Task<Execution> GetExecutionAsync(string name, CallSettings callSettings = null)

Retrieves a specific Execution.

Parameters
Name	Description
`name`	`String` Required. The resource name of the Execution to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Execution>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/executions/[EXECUTION]";
// Make the request
Execution response = await metadataServiceClient.GetExecutionAsync(name);

GetExecutionAsync(String, CancellationToken)

public virtual Task<Execution> GetExecutionAsync(string name, CancellationToken cancellationToken)

Retrieves a specific Execution.

Parameters
Name	Description
`name`	`String` Required. The resource name of the Execution to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Execution>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/executions/[EXECUTION]";
// Make the request
Execution response = await metadataServiceClient.GetExecutionAsync(name);

GetMetadataSchema(GetMetadataSchemaRequest, CallSettings)

public virtual MetadataSchema GetMetadataSchema(GetMetadataSchemaRequest request, CallSettings callSettings = null)

Retrieves a specific MetadataSchema.

Parameters
Name	Description
`request`	`GetMetadataSchemaRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`MetadataSchema`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
GetMetadataSchemaRequest request = new GetMetadataSchemaRequest
{
    MetadataSchemaName = MetadataSchemaName.FromProjectLocationMetadataStoreMetadataSchema("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[METADATA_SCHEMA]"),
};
// Make the request
MetadataSchema response = metadataServiceClient.GetMetadataSchema(request);

GetMetadataSchema(MetadataSchemaName, CallSettings)

public virtual MetadataSchema GetMetadataSchema(MetadataSchemaName name, CallSettings callSettings = null)

Retrieves a specific MetadataSchema.

Parameters
Name	Description
`name`	`MetadataSchemaName` Required. The resource name of the MetadataSchema to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/metadataSchemas/{metadataschema}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`MetadataSchema`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
MetadataSchemaName name = MetadataSchemaName.FromProjectLocationMetadataStoreMetadataSchema("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[METADATA_SCHEMA]");
// Make the request
MetadataSchema response = metadataServiceClient.GetMetadataSchema(name);

GetMetadataSchema(String, CallSettings)

public virtual MetadataSchema GetMetadataSchema(string name, CallSettings callSettings = null)

Retrieves a specific MetadataSchema.

Parameters
Name	Description
`name`	`String` Required. The resource name of the MetadataSchema to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/metadataSchemas/{metadataschema}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`MetadataSchema`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/metadataSchemas/[METADATA_SCHEMA]";
// Make the request
MetadataSchema response = metadataServiceClient.GetMetadataSchema(name);

GetMetadataSchemaAsync(GetMetadataSchemaRequest, CallSettings)

public virtual Task<MetadataSchema> GetMetadataSchemaAsync(GetMetadataSchemaRequest request, CallSettings callSettings = null)

Retrieves a specific MetadataSchema.

Parameters
Name	Description
`request`	`GetMetadataSchemaRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<MetadataSchema>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
GetMetadataSchemaRequest request = new GetMetadataSchemaRequest
{
    MetadataSchemaName = MetadataSchemaName.FromProjectLocationMetadataStoreMetadataSchema("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[METADATA_SCHEMA]"),
};
// Make the request
MetadataSchema response = await metadataServiceClient.GetMetadataSchemaAsync(request);

GetMetadataSchemaAsync(GetMetadataSchemaRequest, CancellationToken)

public virtual Task<MetadataSchema> GetMetadataSchemaAsync(GetMetadataSchemaRequest request, CancellationToken cancellationToken)

Retrieves a specific MetadataSchema.

Parameters
Name	Description
`request`	`GetMetadataSchemaRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<MetadataSchema>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
GetMetadataSchemaRequest request = new GetMetadataSchemaRequest
{
    MetadataSchemaName = MetadataSchemaName.FromProjectLocationMetadataStoreMetadataSchema("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[METADATA_SCHEMA]"),
};
// Make the request
MetadataSchema response = await metadataServiceClient.GetMetadataSchemaAsync(request);

GetMetadataSchemaAsync(MetadataSchemaName, CallSettings)

public virtual Task<MetadataSchema> GetMetadataSchemaAsync(MetadataSchemaName name, CallSettings callSettings = null)

Retrieves a specific MetadataSchema.

Parameters
Name	Description
`name`	`MetadataSchemaName` Required. The resource name of the MetadataSchema to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/metadataSchemas/{metadataschema}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<MetadataSchema>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
MetadataSchemaName name = MetadataSchemaName.FromProjectLocationMetadataStoreMetadataSchema("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[METADATA_SCHEMA]");
// Make the request
MetadataSchema response = await metadataServiceClient.GetMetadataSchemaAsync(name);

GetMetadataSchemaAsync(MetadataSchemaName, CancellationToken)

public virtual Task<MetadataSchema> GetMetadataSchemaAsync(MetadataSchemaName name, CancellationToken cancellationToken)

Retrieves a specific MetadataSchema.

Parameters
Name	Description
`name`	`MetadataSchemaName` Required. The resource name of the MetadataSchema to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/metadataSchemas/{metadataschema}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<MetadataSchema>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
MetadataSchemaName name = MetadataSchemaName.FromProjectLocationMetadataStoreMetadataSchema("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[METADATA_SCHEMA]");
// Make the request
MetadataSchema response = await metadataServiceClient.GetMetadataSchemaAsync(name);

GetMetadataSchemaAsync(String, CallSettings)

public virtual Task<MetadataSchema> GetMetadataSchemaAsync(string name, CallSettings callSettings = null)

Retrieves a specific MetadataSchema.

Parameters
Name	Description
`name`	`String` Required. The resource name of the MetadataSchema to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/metadataSchemas/{metadataschema}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<MetadataSchema>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/metadataSchemas/[METADATA_SCHEMA]";
// Make the request
MetadataSchema response = await metadataServiceClient.GetMetadataSchemaAsync(name);

GetMetadataSchemaAsync(String, CancellationToken)

public virtual Task<MetadataSchema> GetMetadataSchemaAsync(string name, CancellationToken cancellationToken)

Retrieves a specific MetadataSchema.

Parameters
Name	Description
`name`	`String` Required. The resource name of the MetadataSchema to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/metadataSchemas/{metadataschema}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<MetadataSchema>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/metadataSchemas/[METADATA_SCHEMA]";
// Make the request
MetadataSchema response = await metadataServiceClient.GetMetadataSchemaAsync(name);

GetMetadataStore(GetMetadataStoreRequest, CallSettings)

public virtual MetadataStore GetMetadataStore(GetMetadataStoreRequest request, CallSettings callSettings = null)

Retrieves a specific MetadataStore.

Parameters
Name	Description
`request`	`GetMetadataStoreRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`MetadataStore`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
GetMetadataStoreRequest request = new GetMetadataStoreRequest
{
    MetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
};
// Make the request
MetadataStore response = metadataServiceClient.GetMetadataStore(request);

GetMetadataStore(MetadataStoreName, CallSettings)

public virtual MetadataStore GetMetadataStore(MetadataStoreName name, CallSettings callSettings = null)

Retrieves a specific MetadataStore.

Parameters
Name	Description
`name`	`MetadataStoreName` Required. The resource name of the MetadataStore to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`MetadataStore`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
MetadataStoreName name = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
// Make the request
MetadataStore response = metadataServiceClient.GetMetadataStore(name);

GetMetadataStore(String, CallSettings)

public virtual MetadataStore GetMetadataStore(string name, CallSettings callSettings = null)

Retrieves a specific MetadataStore.

Parameters
Name	Description
`name`	`String` Required. The resource name of the MetadataStore to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`MetadataStore`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
// Make the request
MetadataStore response = metadataServiceClient.GetMetadataStore(name);

GetMetadataStoreAsync(GetMetadataStoreRequest, CallSettings)

public virtual Task<MetadataStore> GetMetadataStoreAsync(GetMetadataStoreRequest request, CallSettings callSettings = null)

Retrieves a specific MetadataStore.

Parameters
Name	Description
`request`	`GetMetadataStoreRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<MetadataStore>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
GetMetadataStoreRequest request = new GetMetadataStoreRequest
{
    MetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
};
// Make the request
MetadataStore response = await metadataServiceClient.GetMetadataStoreAsync(request);

GetMetadataStoreAsync(GetMetadataStoreRequest, CancellationToken)

public virtual Task<MetadataStore> GetMetadataStoreAsync(GetMetadataStoreRequest request, CancellationToken cancellationToken)

Retrieves a specific MetadataStore.

Parameters
Name	Description
`request`	`GetMetadataStoreRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<MetadataStore>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
GetMetadataStoreRequest request = new GetMetadataStoreRequest
{
    MetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
};
// Make the request
MetadataStore response = await metadataServiceClient.GetMetadataStoreAsync(request);

GetMetadataStoreAsync(MetadataStoreName, CallSettings)

public virtual Task<MetadataStore> GetMetadataStoreAsync(MetadataStoreName name, CallSettings callSettings = null)

Retrieves a specific MetadataStore.

Parameters
Name	Description
`name`	`MetadataStoreName` Required. The resource name of the MetadataStore to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<MetadataStore>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
MetadataStoreName name = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
// Make the request
MetadataStore response = await metadataServiceClient.GetMetadataStoreAsync(name);

GetMetadataStoreAsync(MetadataStoreName, CancellationToken)

public virtual Task<MetadataStore> GetMetadataStoreAsync(MetadataStoreName name, CancellationToken cancellationToken)

Retrieves a specific MetadataStore.

Parameters
Name	Description
`name`	`MetadataStoreName` Required. The resource name of the MetadataStore to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<MetadataStore>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
MetadataStoreName name = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
// Make the request
MetadataStore response = await metadataServiceClient.GetMetadataStoreAsync(name);

GetMetadataStoreAsync(String, CallSettings)

public virtual Task<MetadataStore> GetMetadataStoreAsync(string name, CallSettings callSettings = null)

Retrieves a specific MetadataStore.

Parameters
Name	Description
`name`	`String` Required. The resource name of the MetadataStore to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<MetadataStore>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
// Make the request
MetadataStore response = await metadataServiceClient.GetMetadataStoreAsync(name);

GetMetadataStoreAsync(String, CancellationToken)

public virtual Task<MetadataStore> GetMetadataStoreAsync(string name, CancellationToken cancellationToken)

Retrieves a specific MetadataStore.

Parameters
Name	Description
`name`	`String` Required. The resource name of the MetadataStore to retrieve. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<MetadataStore>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
// Make the request
MetadataStore response = await metadataServiceClient.GetMetadataStoreAsync(name);

ListArtifacts(ListArtifactsRequest, CallSettings)

public virtual PagedEnumerable<ListArtifactsResponse, Artifact> ListArtifacts(ListArtifactsRequest request, CallSettings callSettings = null)

Lists Artifacts in the MetadataStore.

Parameters
Name	Description
`request`	`ListArtifactsRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedEnumerable<ListArtifactsResponse, Artifact>`	A pageable sequence of Artifact resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
ListArtifactsRequest request = new ListArtifactsRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    Filter = "",
};
// Make the request
PagedEnumerable<ListArtifactsResponse, Artifact> response = metadataServiceClient.ListArtifacts(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (Artifact 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 (ListArtifactsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Artifact 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<Artifact> 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 (Artifact 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;

ListArtifacts(MetadataStoreName, String, Nullable<Int32>, CallSettings)

public virtual PagedEnumerable<ListArtifactsResponse, Artifact> ListArtifacts(MetadataStoreName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists Artifacts in the MetadataStore.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The MetadataStore whose Artifacts should be listed. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`pageToken`	`String` The token returned from the previous request. A value of `null` or an empty string retrieves the first page.
`pageSize`	`Nullable<Int32>` The size of page to request. The response will not be larger than this, but may be smaller. A value of `null` or `0` uses a server-defined page size.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedEnumerable<ListArtifactsResponse, Artifact>`	A pageable sequence of Artifact resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
// Make the request
PagedEnumerable<ListArtifactsResponse, Artifact> response = metadataServiceClient.ListArtifacts(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Artifact 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 (ListArtifactsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Artifact 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<Artifact> 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 (Artifact 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;

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

public virtual PagedEnumerable<ListArtifactsResponse, Artifact> ListArtifacts(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists Artifacts in the MetadataStore.

Parameters
Name	Description
`parent`	`String` Required. The MetadataStore whose Artifacts should be listed. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`pageToken`	`String` The token returned from the previous request. A value of `null` or an empty string retrieves the first page.
`pageSize`	`Nullable<Int32>` The size of page to request. The response will not be larger than this, but may be smaller. A value of `null` or `0` uses a server-defined page size.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedEnumerable<ListArtifactsResponse, Artifact>`	A pageable sequence of Artifact resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
// Make the request
PagedEnumerable<ListArtifactsResponse, Artifact> response = metadataServiceClient.ListArtifacts(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Artifact 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 (ListArtifactsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Artifact 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<Artifact> 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 (Artifact 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;

ListArtifactsAsync(ListArtifactsRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListArtifactsResponse, Artifact> ListArtifactsAsync(ListArtifactsRequest request, CallSettings callSettings = null)

Lists Artifacts in the MetadataStore.

Parameters
Name	Description
`request`	`ListArtifactsRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedAsyncEnumerable<ListArtifactsResponse, Artifact>`	A pageable asynchronous sequence of Artifact resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ListArtifactsRequest request = new ListArtifactsRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    Filter = "",
};
// Make the request
PagedAsyncEnumerable<ListArtifactsResponse, Artifact> response = metadataServiceClient.ListArtifactsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Artifact 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((ListArtifactsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Artifact 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<Artifact> 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 (Artifact 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;

ListArtifactsAsync(MetadataStoreName, String, Nullable<Int32>, CallSettings)

public virtual PagedAsyncEnumerable<ListArtifactsResponse, Artifact> ListArtifactsAsync(MetadataStoreName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists Artifacts in the MetadataStore.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The MetadataStore whose Artifacts should be listed. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`pageToken`	`String` The token returned from the previous request. A value of `null` or an empty string retrieves the first page.
`pageSize`	`Nullable<Int32>` The size of page to request. The response will not be larger than this, but may be smaller. A value of `null` or `0` uses a server-defined page size.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedAsyncEnumerable<ListArtifactsResponse, Artifact>`	A pageable asynchronous sequence of Artifact resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
// Make the request
PagedAsyncEnumerable<ListArtifactsResponse, Artifact> response = metadataServiceClient.ListArtifactsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Artifact 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((ListArtifactsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Artifact 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<Artifact> 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 (Artifact 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;

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

public virtual PagedAsyncEnumerable<ListArtifactsResponse, Artifact> ListArtifactsAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists Artifacts in the MetadataStore.

Parameters
Name	Description
`parent`	`String` Required. The MetadataStore whose Artifacts should be listed. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`pageToken`	`String` The token returned from the previous request. A value of `null` or an empty string retrieves the first page.
`pageSize`	`Nullable<Int32>` The size of page to request. The response will not be larger than this, but may be smaller. A value of `null` or `0` uses a server-defined page size.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedAsyncEnumerable<ListArtifactsResponse, Artifact>`	A pageable asynchronous sequence of Artifact resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
// Make the request
PagedAsyncEnumerable<ListArtifactsResponse, Artifact> response = metadataServiceClient.ListArtifactsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Artifact 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((ListArtifactsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Artifact 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<Artifact> 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 (Artifact 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;

ListContexts(ListContextsRequest, CallSettings)

public virtual PagedEnumerable<ListContextsResponse, Context> ListContexts(ListContextsRequest request, CallSettings callSettings = null)

Lists Contexts on the MetadataStore.

Parameters
Name	Description
`request`	`ListContextsRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedEnumerable<ListContextsResponse, Context>`	A pageable sequence of Context resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
ListContextsRequest request = new ListContextsRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    Filter = "",
};
// Make the request
PagedEnumerable<ListContextsResponse, Context> response = metadataServiceClient.ListContexts(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (Context 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 (ListContextsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Context 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<Context> 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 (Context 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;

ListContexts(MetadataStoreName, String, Nullable<Int32>, CallSettings)

public virtual PagedEnumerable<ListContextsResponse, Context> ListContexts(MetadataStoreName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists Contexts on the MetadataStore.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The MetadataStore whose Contexts should be listed. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`pageToken`	`String` The token returned from the previous request. A value of `null` or an empty string retrieves the first page.
`pageSize`	`Nullable<Int32>` The size of page to request. The response will not be larger than this, but may be smaller. A value of `null` or `0` uses a server-defined page size.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedEnumerable<ListContextsResponse, Context>`	A pageable sequence of Context resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
// Make the request
PagedEnumerable<ListContextsResponse, Context> response = metadataServiceClient.ListContexts(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Context 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 (ListContextsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Context 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<Context> 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 (Context 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;

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

public virtual PagedEnumerable<ListContextsResponse, Context> ListContexts(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists Contexts on the MetadataStore.

Parameters
Name	Description
`parent`	`String` Required. The MetadataStore whose Contexts should be listed. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`pageToken`	`String` The token returned from the previous request. A value of `null` or an empty string retrieves the first page.
`pageSize`	`Nullable<Int32>` The size of page to request. The response will not be larger than this, but may be smaller. A value of `null` or `0` uses a server-defined page size.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedEnumerable<ListContextsResponse, Context>`	A pageable sequence of Context resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
// Make the request
PagedEnumerable<ListContextsResponse, Context> response = metadataServiceClient.ListContexts(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Context 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 (ListContextsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Context 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<Context> 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 (Context 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;

ListContextsAsync(ListContextsRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListContextsResponse, Context> ListContextsAsync(ListContextsRequest request, CallSettings callSettings = null)

Lists Contexts on the MetadataStore.

Parameters
Name	Description
`request`	`ListContextsRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedAsyncEnumerable<ListContextsResponse, Context>`	A pageable asynchronous sequence of Context resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ListContextsRequest request = new ListContextsRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    Filter = "",
};
// Make the request
PagedAsyncEnumerable<ListContextsResponse, Context> response = metadataServiceClient.ListContextsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Context 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((ListContextsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Context 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<Context> 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 (Context 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;

ListContextsAsync(MetadataStoreName, String, Nullable<Int32>, CallSettings)

public virtual PagedAsyncEnumerable<ListContextsResponse, Context> ListContextsAsync(MetadataStoreName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists Contexts on the MetadataStore.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The MetadataStore whose Contexts should be listed. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`pageToken`	`String` The token returned from the previous request. A value of `null` or an empty string retrieves the first page.
`pageSize`	`Nullable<Int32>` The size of page to request. The response will not be larger than this, but may be smaller. A value of `null` or `0` uses a server-defined page size.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedAsyncEnumerable<ListContextsResponse, Context>`	A pageable asynchronous sequence of Context resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
// Make the request
PagedAsyncEnumerable<ListContextsResponse, Context> response = metadataServiceClient.ListContextsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Context 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((ListContextsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Context 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<Context> 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 (Context 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;

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

public virtual PagedAsyncEnumerable<ListContextsResponse, Context> ListContextsAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists Contexts on the MetadataStore.

Parameters
Name	Description
`parent`	`String` Required. The MetadataStore whose Contexts should be listed. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`pageToken`	`String` The token returned from the previous request. A value of `null` or an empty string retrieves the first page.
`pageSize`	`Nullable<Int32>` The size of page to request. The response will not be larger than this, but may be smaller. A value of `null` or `0` uses a server-defined page size.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedAsyncEnumerable<ListContextsResponse, Context>`	A pageable asynchronous sequence of Context resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
// Make the request
PagedAsyncEnumerable<ListContextsResponse, Context> response = metadataServiceClient.ListContextsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Context 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((ListContextsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Context 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<Context> 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 (Context 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;

ListExecutions(ListExecutionsRequest, CallSettings)

public virtual PagedEnumerable<ListExecutionsResponse, Execution> ListExecutions(ListExecutionsRequest request, CallSettings callSettings = null)

Lists Executions in the MetadataStore.

Parameters
Name	Description
`request`	`ListExecutionsRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedEnumerable<ListExecutionsResponse, Execution>`	A pageable sequence of Execution resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
ListExecutionsRequest request = new ListExecutionsRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    Filter = "",
};
// Make the request
PagedEnumerable<ListExecutionsResponse, Execution> response = metadataServiceClient.ListExecutions(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (Execution 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 (ListExecutionsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Execution 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<Execution> 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 (Execution 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;

ListExecutions(MetadataStoreName, String, Nullable<Int32>, CallSettings)

public virtual PagedEnumerable<ListExecutionsResponse, Execution> ListExecutions(MetadataStoreName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists Executions in the MetadataStore.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The MetadataStore whose Executions should be listed. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`pageToken`	`String` The token returned from the previous request. A value of `null` or an empty string retrieves the first page.
`pageSize`	`Nullable<Int32>` The size of page to request. The response will not be larger than this, but may be smaller. A value of `null` or `0` uses a server-defined page size.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedEnumerable<ListExecutionsResponse, Execution>`	A pageable sequence of Execution resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
// Make the request
PagedEnumerable<ListExecutionsResponse, Execution> response = metadataServiceClient.ListExecutions(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Execution 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 (ListExecutionsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Execution 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<Execution> 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 (Execution 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;

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

public virtual PagedEnumerable<ListExecutionsResponse, Execution> ListExecutions(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists Executions in the MetadataStore.

Parameters
Name	Description
`parent`	`String` Required. The MetadataStore whose Executions should be listed. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`pageToken`	`String` The token returned from the previous request. A value of `null` or an empty string retrieves the first page.
`pageSize`	`Nullable<Int32>` The size of page to request. The response will not be larger than this, but may be smaller. A value of `null` or `0` uses a server-defined page size.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedEnumerable<ListExecutionsResponse, Execution>`	A pageable sequence of Execution resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
// Make the request
PagedEnumerable<ListExecutionsResponse, Execution> response = metadataServiceClient.ListExecutions(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Execution 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 (ListExecutionsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Execution 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<Execution> 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 (Execution 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;

ListExecutionsAsync(ListExecutionsRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListExecutionsResponse, Execution> ListExecutionsAsync(ListExecutionsRequest request, CallSettings callSettings = null)

Lists Executions in the MetadataStore.

Parameters
Name	Description
`request`	`ListExecutionsRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedAsyncEnumerable<ListExecutionsResponse, Execution>`	A pageable asynchronous sequence of Execution resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ListExecutionsRequest request = new ListExecutionsRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    Filter = "",
};
// Make the request
PagedAsyncEnumerable<ListExecutionsResponse, Execution> response = metadataServiceClient.ListExecutionsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Execution 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((ListExecutionsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Execution 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<Execution> 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 (Execution 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;

ListExecutionsAsync(MetadataStoreName, String, Nullable<Int32>, CallSettings)

public virtual PagedAsyncEnumerable<ListExecutionsResponse, Execution> ListExecutionsAsync(MetadataStoreName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists Executions in the MetadataStore.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The MetadataStore whose Executions should be listed. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`pageToken`	`String` The token returned from the previous request. A value of `null` or an empty string retrieves the first page.
`pageSize`	`Nullable<Int32>` The size of page to request. The response will not be larger than this, but may be smaller. A value of `null` or `0` uses a server-defined page size.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedAsyncEnumerable<ListExecutionsResponse, Execution>`	A pageable asynchronous sequence of Execution resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
// Make the request
PagedAsyncEnumerable<ListExecutionsResponse, Execution> response = metadataServiceClient.ListExecutionsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Execution 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((ListExecutionsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Execution 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<Execution> 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 (Execution 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;

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

public virtual PagedAsyncEnumerable<ListExecutionsResponse, Execution> ListExecutionsAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists Executions in the MetadataStore.

Parameters
Name	Description
`parent`	`String` Required. The MetadataStore whose Executions should be listed. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`pageToken`	`String` The token returned from the previous request. A value of `null` or an empty string retrieves the first page.
`pageSize`	`Nullable<Int32>` The size of page to request. The response will not be larger than this, but may be smaller. A value of `null` or `0` uses a server-defined page size.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedAsyncEnumerable<ListExecutionsResponse, Execution>`	A pageable asynchronous sequence of Execution resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
// Make the request
PagedAsyncEnumerable<ListExecutionsResponse, Execution> response = metadataServiceClient.ListExecutionsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Execution 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((ListExecutionsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Execution 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<Execution> 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 (Execution 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;

ListMetadataSchemas(ListMetadataSchemasRequest, CallSettings)

public virtual PagedEnumerable<ListMetadataSchemasResponse, MetadataSchema> ListMetadataSchemas(ListMetadataSchemasRequest request, CallSettings callSettings = null)

Lists MetadataSchemas.

Parameters
Name	Description
`request`	`ListMetadataSchemasRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedEnumerable<ListMetadataSchemasResponse, MetadataSchema>`	A pageable sequence of MetadataSchema resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
ListMetadataSchemasRequest request = new ListMetadataSchemasRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    Filter = "",
};
// Make the request
PagedEnumerable<ListMetadataSchemasResponse, MetadataSchema> response = metadataServiceClient.ListMetadataSchemas(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (MetadataSchema 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 (ListMetadataSchemasResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (MetadataSchema 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<MetadataSchema> 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 (MetadataSchema 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;

ListMetadataSchemas(MetadataStoreName, String, Nullable<Int32>, CallSettings)

public virtual PagedEnumerable<ListMetadataSchemasResponse, MetadataSchema> ListMetadataSchemas(MetadataStoreName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists MetadataSchemas.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The MetadataStore whose MetadataSchemas should be listed. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`pageToken`	`String` The token returned from the previous request. A value of `null` or an empty string retrieves the first page.
`pageSize`	`Nullable<Int32>` The size of page to request. The response will not be larger than this, but may be smaller. A value of `null` or `0` uses a server-defined page size.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedEnumerable<ListMetadataSchemasResponse, MetadataSchema>`	A pageable sequence of MetadataSchema resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
// Make the request
PagedEnumerable<ListMetadataSchemasResponse, MetadataSchema> response = metadataServiceClient.ListMetadataSchemas(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (MetadataSchema 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 (ListMetadataSchemasResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (MetadataSchema 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<MetadataSchema> 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 (MetadataSchema 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;

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

public virtual PagedEnumerable<ListMetadataSchemasResponse, MetadataSchema> ListMetadataSchemas(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists MetadataSchemas.

Parameters
Name	Description
`parent`	`String` Required. The MetadataStore whose MetadataSchemas should be listed. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`pageToken`	`String` The token returned from the previous request. A value of `null` or an empty string retrieves the first page.
`pageSize`	`Nullable<Int32>` The size of page to request. The response will not be larger than this, but may be smaller. A value of `null` or `0` uses a server-defined page size.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedEnumerable<ListMetadataSchemasResponse, MetadataSchema>`	A pageable sequence of MetadataSchema resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
// Make the request
PagedEnumerable<ListMetadataSchemasResponse, MetadataSchema> response = metadataServiceClient.ListMetadataSchemas(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (MetadataSchema 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 (ListMetadataSchemasResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (MetadataSchema 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<MetadataSchema> 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 (MetadataSchema 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;

ListMetadataSchemasAsync(ListMetadataSchemasRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListMetadataSchemasResponse, MetadataSchema> ListMetadataSchemasAsync(ListMetadataSchemasRequest request, CallSettings callSettings = null)

Lists MetadataSchemas.

Parameters
Name	Description
`request`	`ListMetadataSchemasRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedAsyncEnumerable<ListMetadataSchemasResponse, MetadataSchema>`	A pageable asynchronous sequence of MetadataSchema resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ListMetadataSchemasRequest request = new ListMetadataSchemasRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    Filter = "",
};
// Make the request
PagedAsyncEnumerable<ListMetadataSchemasResponse, MetadataSchema> response = metadataServiceClient.ListMetadataSchemasAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((MetadataSchema 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((ListMetadataSchemasResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (MetadataSchema 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<MetadataSchema> 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 (MetadataSchema 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;

ListMetadataSchemasAsync(MetadataStoreName, String, Nullable<Int32>, CallSettings)

public virtual PagedAsyncEnumerable<ListMetadataSchemasResponse, MetadataSchema> ListMetadataSchemasAsync(MetadataStoreName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists MetadataSchemas.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The MetadataStore whose MetadataSchemas should be listed. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`pageToken`	`String` The token returned from the previous request. A value of `null` or an empty string retrieves the first page.
`pageSize`	`Nullable<Int32>` The size of page to request. The response will not be larger than this, but may be smaller. A value of `null` or `0` uses a server-defined page size.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedAsyncEnumerable<ListMetadataSchemasResponse, MetadataSchema>`	A pageable asynchronous sequence of MetadataSchema resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
// Make the request
PagedAsyncEnumerable<ListMetadataSchemasResponse, MetadataSchema> response = metadataServiceClient.ListMetadataSchemasAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((MetadataSchema 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((ListMetadataSchemasResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (MetadataSchema 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<MetadataSchema> 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 (MetadataSchema 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;

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

public virtual PagedAsyncEnumerable<ListMetadataSchemasResponse, MetadataSchema> ListMetadataSchemasAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists MetadataSchemas.

Parameters
Name	Description
`parent`	`String` Required. The MetadataStore whose MetadataSchemas should be listed. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`pageToken`	`String` The token returned from the previous request. A value of `null` or an empty string retrieves the first page.
`pageSize`	`Nullable<Int32>` The size of page to request. The response will not be larger than this, but may be smaller. A value of `null` or `0` uses a server-defined page size.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedAsyncEnumerable<ListMetadataSchemasResponse, MetadataSchema>`	A pageable asynchronous sequence of MetadataSchema resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
// Make the request
PagedAsyncEnumerable<ListMetadataSchemasResponse, MetadataSchema> response = metadataServiceClient.ListMetadataSchemasAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((MetadataSchema 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((ListMetadataSchemasResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (MetadataSchema 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<MetadataSchema> 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 (MetadataSchema 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;

ListMetadataStores(LocationName, String, Nullable<Int32>, CallSettings)

public virtual PagedEnumerable<ListMetadataStoresResponse, MetadataStore> ListMetadataStores(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists MetadataStores for a Location.

Parameters
Name	Description
`parent`	`LocationName` Required. The Location whose MetadataStores should be listed. Format: `projects/{project}/locations/{location}`
`pageToken`	`String` The token returned from the previous request. A value of `null` or an empty string retrieves the first page.
`pageSize`	`Nullable<Int32>` The size of page to request. The response will not be larger than this, but may be smaller. A value of `null` or `0` uses a server-defined page size.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedEnumerable<ListMetadataStoresResponse, MetadataStore>`	A pageable sequence of MetadataStore resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListMetadataStoresResponse, MetadataStore> response = metadataServiceClient.ListMetadataStores(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (MetadataStore 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 (ListMetadataStoresResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (MetadataStore 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<MetadataStore> 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 (MetadataStore 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;

ListMetadataStores(ListMetadataStoresRequest, CallSettings)

public virtual PagedEnumerable<ListMetadataStoresResponse, MetadataStore> ListMetadataStores(ListMetadataStoresRequest request, CallSettings callSettings = null)

Lists MetadataStores for a Location.

Parameters
Name	Description
`request`	`ListMetadataStoresRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedEnumerable<ListMetadataStoresResponse, MetadataStore>`	A pageable sequence of MetadataStore resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
ListMetadataStoresRequest request = new ListMetadataStoresRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
PagedEnumerable<ListMetadataStoresResponse, MetadataStore> response = metadataServiceClient.ListMetadataStores(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (MetadataStore 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 (ListMetadataStoresResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (MetadataStore 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<MetadataStore> 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 (MetadataStore 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;

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

public virtual PagedEnumerable<ListMetadataStoresResponse, MetadataStore> ListMetadataStores(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists MetadataStores for a Location.

Parameters
Name	Description
`parent`	`String` Required. The Location whose MetadataStores should be listed. Format: `projects/{project}/locations/{location}`
`pageToken`	`String` The token returned from the previous request. A value of `null` or an empty string retrieves the first page.
`pageSize`	`Nullable<Int32>` The size of page to request. The response will not be larger than this, but may be smaller. A value of `null` or `0` uses a server-defined page size.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedEnumerable<ListMetadataStoresResponse, MetadataStore>`	A pageable sequence of MetadataStore resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<ListMetadataStoresResponse, MetadataStore> response = metadataServiceClient.ListMetadataStores(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (MetadataStore 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 (ListMetadataStoresResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (MetadataStore 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<MetadataStore> 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 (MetadataStore 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;

ListMetadataStoresAsync(LocationName, String, Nullable<Int32>, CallSettings)

public virtual PagedAsyncEnumerable<ListMetadataStoresResponse, MetadataStore> ListMetadataStoresAsync(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists MetadataStores for a Location.

Parameters
Name	Description
`parent`	`LocationName` Required. The Location whose MetadataStores should be listed. Format: `projects/{project}/locations/{location}`
`pageToken`	`String` The token returned from the previous request. A value of `null` or an empty string retrieves the first page.
`pageSize`	`Nullable<Int32>` The size of page to request. The response will not be larger than this, but may be smaller. A value of `null` or `0` uses a server-defined page size.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedAsyncEnumerable<ListMetadataStoresResponse, MetadataStore>`	A pageable asynchronous sequence of MetadataStore resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListMetadataStoresResponse, MetadataStore> response = metadataServiceClient.ListMetadataStoresAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((MetadataStore 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((ListMetadataStoresResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (MetadataStore 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<MetadataStore> 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 (MetadataStore 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;

ListMetadataStoresAsync(ListMetadataStoresRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListMetadataStoresResponse, MetadataStore> ListMetadataStoresAsync(ListMetadataStoresRequest request, CallSettings callSettings = null)

Lists MetadataStores for a Location.

Parameters
Name	Description
`request`	`ListMetadataStoresRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedAsyncEnumerable<ListMetadataStoresResponse, MetadataStore>`	A pageable asynchronous sequence of MetadataStore resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ListMetadataStoresRequest request = new ListMetadataStoresRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
PagedAsyncEnumerable<ListMetadataStoresResponse, MetadataStore> response = metadataServiceClient.ListMetadataStoresAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((MetadataStore 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((ListMetadataStoresResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (MetadataStore 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<MetadataStore> 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 (MetadataStore 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;

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

public virtual PagedAsyncEnumerable<ListMetadataStoresResponse, MetadataStore> ListMetadataStoresAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists MetadataStores for a Location.

Parameters
Name	Description
`parent`	`String` Required. The Location whose MetadataStores should be listed. Format: `projects/{project}/locations/{location}`
`pageToken`	`String` The token returned from the previous request. A value of `null` or an empty string retrieves the first page.
`pageSize`	`Nullable<Int32>` The size of page to request. The response will not be larger than this, but may be smaller. A value of `null` or `0` uses a server-defined page size.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedAsyncEnumerable<ListMetadataStoresResponse, MetadataStore>`	A pageable asynchronous sequence of MetadataStore resources.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<ListMetadataStoresResponse, MetadataStore> response = metadataServiceClient.ListMetadataStoresAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((MetadataStore 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((ListMetadataStoresResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (MetadataStore 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<MetadataStore> 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 (MetadataStore 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;

PollOnceCreateMetadataStore(String, CallSettings)

public virtual Operation<MetadataStore, CreateMetadataStoreOperationMetadata> PollOnceCreateMetadataStore(string operationName, CallSettings callSettings = null)

Poll an operation once, using an operationName from a previous invocation of CreateMetadataStore .

Parameters
Name	Description
`operationName`	`String` The name of a previously invoked operation. Must not be `null` or empty.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<MetadataStore, CreateMetadataStoreOperationMetadata>`	The result of polling the operation.

PollOnceCreateMetadataStoreAsync(String, CallSettings)

public virtual Task<Operation<MetadataStore, CreateMetadataStoreOperationMetadata>> PollOnceCreateMetadataStoreAsync(string operationName, CallSettings callSettings = null)

Asynchronously poll an operation once, using an operationName from a previous invocation of CreateMetadataStore.

Parameters
Name	Description
`operationName`	`String` The name of a previously invoked operation. Must not be `null` or empty.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<MetadataStore, CreateMetadataStoreOperationMetadata>>`	A task representing the result of polling the operation.

PollOnceDeleteArtifact(String, CallSettings)

public virtual Operation<Empty, DeleteOperationMetadata> PollOnceDeleteArtifact(string operationName, CallSettings callSettings = null)

Poll an operation once, using an operationName from a previous invocation of DeleteArtifact.

Parameters
Name	Description
`operationName`	`String` The name of a previously invoked operation. Must not be `null` or empty.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<Empty, DeleteOperationMetadata>`	The result of polling the operation.

PollOnceDeleteArtifactAsync(String, CallSettings)

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

Asynchronously poll an operation once, using an operationName from a previous invocation of DeleteArtifact.

Parameters
Name	Description
`operationName`	`String` The name of a previously invoked operation. Must not be `null` or empty.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<Empty, DeleteOperationMetadata>>`	A task representing the result of polling the operation.

PollOnceDeleteContext(String, CallSettings)

public virtual Operation<Empty, DeleteOperationMetadata> PollOnceDeleteContext(string operationName, CallSettings callSettings = null)

Poll an operation once, using an operationName from a previous invocation of DeleteContext.

Parameters
Name	Description
`operationName`	`String` The name of a previously invoked operation. Must not be `null` or empty.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<Empty, DeleteOperationMetadata>`	The result of polling the operation.

PollOnceDeleteContextAsync(String, CallSettings)

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

Asynchronously poll an operation once, using an operationName from a previous invocation of DeleteContext.

Parameters
Name	Description
`operationName`	`String` The name of a previously invoked operation. Must not be `null` or empty.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<Empty, DeleteOperationMetadata>>`	A task representing the result of polling the operation.

PollOnceDeleteExecution(String, CallSettings)

public virtual Operation<Empty, DeleteOperationMetadata> PollOnceDeleteExecution(string operationName, CallSettings callSettings = null)

Poll an operation once, using an operationName from a previous invocation of DeleteExecution.

Parameters
Name	Description
`operationName`	`String` The name of a previously invoked operation. Must not be `null` or empty.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<Empty, DeleteOperationMetadata>`	The result of polling the operation.

PollOnceDeleteExecutionAsync(String, CallSettings)

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

Asynchronously poll an operation once, using an operationName from a previous invocation of DeleteExecution.

Parameters
Name	Description
`operationName`	`String` The name of a previously invoked operation. Must not be `null` or empty.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<Empty, DeleteOperationMetadata>>`	A task representing the result of polling the operation.

PollOnceDeleteMetadataStore(String, CallSettings)

public virtual Operation<Empty, DeleteMetadataStoreOperationMetadata> PollOnceDeleteMetadataStore(string operationName, CallSettings callSettings = null)

Poll an operation once, using an operationName from a previous invocation of DeleteMetadataStore .

Parameters
Name	Description
`operationName`	`String` The name of a previously invoked operation. Must not be `null` or empty.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<Empty, DeleteMetadataStoreOperationMetadata>`	The result of polling the operation.

PollOnceDeleteMetadataStoreAsync(String, CallSettings)

public virtual Task<Operation<Empty, DeleteMetadataStoreOperationMetadata>> PollOnceDeleteMetadataStoreAsync(string operationName, CallSettings callSettings = null)

Asynchronously poll an operation once, using an operationName from a previous invocation of DeleteMetadataStore.

Parameters
Name	Description
`operationName`	`String` The name of a previously invoked operation. Must not be `null` or empty.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<Empty, DeleteMetadataStoreOperationMetadata>>`	A task representing the result of polling the operation.

PollOncePurgeArtifacts(String, CallSettings)

public virtual Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata> PollOncePurgeArtifacts(string operationName, CallSettings callSettings = null)

Poll an operation once, using an operationName from a previous invocation of PurgeArtifacts.

Parameters
Name	Description
`operationName`	`String` The name of a previously invoked operation. Must not be `null` or empty.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata>`	The result of polling the operation.

PollOncePurgeArtifactsAsync(String, CallSettings)

public virtual Task<Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata>> PollOncePurgeArtifactsAsync(string operationName, CallSettings callSettings = null)

Asynchronously poll an operation once, using an operationName from a previous invocation of PurgeArtifacts.

Parameters
Name	Description
`operationName`	`String` The name of a previously invoked operation. Must not be `null` or empty.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata>>`	A task representing the result of polling the operation.

PollOncePurgeContexts(String, CallSettings)

public virtual Operation<PurgeContextsResponse, PurgeContextsMetadata> PollOncePurgeContexts(string operationName, CallSettings callSettings = null)

Poll an operation once, using an operationName from a previous invocation of PurgeContexts.

Parameters
Name	Description
`operationName`	`String` The name of a previously invoked operation. Must not be `null` or empty.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<PurgeContextsResponse, PurgeContextsMetadata>`	The result of polling the operation.

PollOncePurgeContextsAsync(String, CallSettings)

public virtual Task<Operation<PurgeContextsResponse, PurgeContextsMetadata>> PollOncePurgeContextsAsync(string operationName, CallSettings callSettings = null)

Asynchronously poll an operation once, using an operationName from a previous invocation of PurgeContexts.

Parameters
Name	Description
`operationName`	`String` The name of a previously invoked operation. Must not be `null` or empty.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<PurgeContextsResponse, PurgeContextsMetadata>>`	A task representing the result of polling the operation.

PollOncePurgeExecutions(String, CallSettings)

public virtual Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata> PollOncePurgeExecutions(string operationName, CallSettings callSettings = null)

Poll an operation once, using an operationName from a previous invocation of PurgeExecutions.

Parameters
Name	Description
`operationName`	`String` The name of a previously invoked operation. Must not be `null` or empty.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata>`	The result of polling the operation.

PollOncePurgeExecutionsAsync(String, CallSettings)

public virtual Task<Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata>> PollOncePurgeExecutionsAsync(string operationName, CallSettings callSettings = null)

Asynchronously poll an operation once, using an operationName from a previous invocation of PurgeExecutions.

Parameters
Name	Description
`operationName`	`String` The name of a previously invoked operation. Must not be `null` or empty.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata>>`	A task representing the result of polling the operation.

PurgeArtifacts(MetadataStoreName, CallSettings)

public virtual Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata> PurgeArtifacts(MetadataStoreName parent, CallSettings callSettings = null)

Purges Artifacts.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The metadata store to purge Artifacts from. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata>`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
// Make the request
Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata> response = metadataServiceClient.PurgeArtifacts(parent);

// Poll until the returned long-running operation is complete
Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
PurgeArtifactsResponse 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<PurgeArtifactsResponse, PurgeArtifactsMetadata> retrievedResponse = metadataServiceClient.PollOncePurgeArtifacts(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    PurgeArtifactsResponse retrievedResult = retrievedResponse.Result;
}

PurgeArtifacts(PurgeArtifactsRequest, CallSettings)

public virtual Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata> PurgeArtifacts(PurgeArtifactsRequest request, CallSettings callSettings = null)

Purges Artifacts.

Parameters
Name	Description
`request`	`PurgeArtifactsRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata>`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
PurgeArtifactsRequest request = new PurgeArtifactsRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    Filter = "",
    Force = false,
};
// Make the request
Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata> response = metadataServiceClient.PurgeArtifacts(request);

// Poll until the returned long-running operation is complete
Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
PurgeArtifactsResponse 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<PurgeArtifactsResponse, PurgeArtifactsMetadata> retrievedResponse = metadataServiceClient.PollOncePurgeArtifacts(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    PurgeArtifactsResponse retrievedResult = retrievedResponse.Result;
}

PurgeArtifacts(String, CallSettings)

public virtual Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata> PurgeArtifacts(string parent, CallSettings callSettings = null)

Purges Artifacts.

Parameters
Name	Description
`parent`	`String` Required. The metadata store to purge Artifacts from. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata>`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
// Make the request
Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata> response = metadataServiceClient.PurgeArtifacts(parent);

// Poll until the returned long-running operation is complete
Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
PurgeArtifactsResponse 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<PurgeArtifactsResponse, PurgeArtifactsMetadata> retrievedResponse = metadataServiceClient.PollOncePurgeArtifacts(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    PurgeArtifactsResponse retrievedResult = retrievedResponse.Result;
}

PurgeArtifactsAsync(MetadataStoreName, CallSettings)

public virtual Task<Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata>> PurgeArtifactsAsync(MetadataStoreName parent, CallSettings callSettings = null)

Purges Artifacts.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The metadata store to purge Artifacts from. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
// Make the request
Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata> response = await metadataServiceClient.PurgeArtifactsAsync(parent);

// Poll until the returned long-running operation is complete
Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
PurgeArtifactsResponse 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<PurgeArtifactsResponse, PurgeArtifactsMetadata> retrievedResponse = await metadataServiceClient.PollOncePurgeArtifactsAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    PurgeArtifactsResponse retrievedResult = retrievedResponse.Result;
}

PurgeArtifactsAsync(MetadataStoreName, CancellationToken)

public virtual Task<Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata>> PurgeArtifactsAsync(MetadataStoreName parent, CancellationToken cancellationToken)

Purges Artifacts.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The metadata store to purge Artifacts from. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
// Make the request
Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata> response = await metadataServiceClient.PurgeArtifactsAsync(parent);

// Poll until the returned long-running operation is complete
Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
PurgeArtifactsResponse 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<PurgeArtifactsResponse, PurgeArtifactsMetadata> retrievedResponse = await metadataServiceClient.PollOncePurgeArtifactsAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    PurgeArtifactsResponse retrievedResult = retrievedResponse.Result;
}

PurgeArtifactsAsync(PurgeArtifactsRequest, CallSettings)

public virtual Task<Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata>> PurgeArtifactsAsync(PurgeArtifactsRequest request, CallSettings callSettings = null)

Purges Artifacts.

Parameters
Name	Description
`request`	`PurgeArtifactsRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
PurgeArtifactsRequest request = new PurgeArtifactsRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    Filter = "",
    Force = false,
};
// Make the request
Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata> response = await metadataServiceClient.PurgeArtifactsAsync(request);

// Poll until the returned long-running operation is complete
Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
PurgeArtifactsResponse 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<PurgeArtifactsResponse, PurgeArtifactsMetadata> retrievedResponse = await metadataServiceClient.PollOncePurgeArtifactsAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    PurgeArtifactsResponse retrievedResult = retrievedResponse.Result;
}

PurgeArtifactsAsync(PurgeArtifactsRequest, CancellationToken)

public virtual Task<Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata>> PurgeArtifactsAsync(PurgeArtifactsRequest request, CancellationToken cancellationToken)

Purges Artifacts.

Parameters
Name	Description
`request`	`PurgeArtifactsRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
PurgeArtifactsRequest request = new PurgeArtifactsRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    Filter = "",
    Force = false,
};
// Make the request
Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata> response = await metadataServiceClient.PurgeArtifactsAsync(request);

// Poll until the returned long-running operation is complete
Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
PurgeArtifactsResponse 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<PurgeArtifactsResponse, PurgeArtifactsMetadata> retrievedResponse = await metadataServiceClient.PollOncePurgeArtifactsAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    PurgeArtifactsResponse retrievedResult = retrievedResponse.Result;
}

PurgeArtifactsAsync(String, CallSettings)

public virtual Task<Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata>> PurgeArtifactsAsync(string parent, CallSettings callSettings = null)

Purges Artifacts.

Parameters
Name	Description
`parent`	`String` Required. The metadata store to purge Artifacts from. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
// Make the request
Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata> response = await metadataServiceClient.PurgeArtifactsAsync(parent);

// Poll until the returned long-running operation is complete
Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
PurgeArtifactsResponse 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<PurgeArtifactsResponse, PurgeArtifactsMetadata> retrievedResponse = await metadataServiceClient.PollOncePurgeArtifactsAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    PurgeArtifactsResponse retrievedResult = retrievedResponse.Result;
}

PurgeArtifactsAsync(String, CancellationToken)

public virtual Task<Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata>> PurgeArtifactsAsync(string parent, CancellationToken cancellationToken)

Purges Artifacts.

Parameters
Name	Description
`parent`	`String` Required. The metadata store to purge Artifacts from. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
// Make the request
Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata> response = await metadataServiceClient.PurgeArtifactsAsync(parent);

// Poll until the returned long-running operation is complete
Operation<PurgeArtifactsResponse, PurgeArtifactsMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
PurgeArtifactsResponse 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<PurgeArtifactsResponse, PurgeArtifactsMetadata> retrievedResponse = await metadataServiceClient.PollOncePurgeArtifactsAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    PurgeArtifactsResponse retrievedResult = retrievedResponse.Result;
}

PurgeContexts(MetadataStoreName, CallSettings)

public virtual Operation<PurgeContextsResponse, PurgeContextsMetadata> PurgeContexts(MetadataStoreName parent, CallSettings callSettings = null)

Purges Contexts.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The metadata store to purge Contexts from. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<PurgeContextsResponse, PurgeContextsMetadata>`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
// Make the request
Operation<PurgeContextsResponse, PurgeContextsMetadata> response = metadataServiceClient.PurgeContexts(parent);

// Poll until the returned long-running operation is complete
Operation<PurgeContextsResponse, PurgeContextsMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
PurgeContextsResponse 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<PurgeContextsResponse, PurgeContextsMetadata> retrievedResponse = metadataServiceClient.PollOncePurgeContexts(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    PurgeContextsResponse retrievedResult = retrievedResponse.Result;
}

PurgeContexts(PurgeContextsRequest, CallSettings)

public virtual Operation<PurgeContextsResponse, PurgeContextsMetadata> PurgeContexts(PurgeContextsRequest request, CallSettings callSettings = null)

Purges Contexts.

Parameters
Name	Description
`request`	`PurgeContextsRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<PurgeContextsResponse, PurgeContextsMetadata>`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
PurgeContextsRequest request = new PurgeContextsRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    Filter = "",
    Force = false,
};
// Make the request
Operation<PurgeContextsResponse, PurgeContextsMetadata> response = metadataServiceClient.PurgeContexts(request);

// Poll until the returned long-running operation is complete
Operation<PurgeContextsResponse, PurgeContextsMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
PurgeContextsResponse 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<PurgeContextsResponse, PurgeContextsMetadata> retrievedResponse = metadataServiceClient.PollOncePurgeContexts(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    PurgeContextsResponse retrievedResult = retrievedResponse.Result;
}

PurgeContexts(String, CallSettings)

public virtual Operation<PurgeContextsResponse, PurgeContextsMetadata> PurgeContexts(string parent, CallSettings callSettings = null)

Purges Contexts.

Parameters
Name	Description
`parent`	`String` Required. The metadata store to purge Contexts from. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<PurgeContextsResponse, PurgeContextsMetadata>`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
// Make the request
Operation<PurgeContextsResponse, PurgeContextsMetadata> response = metadataServiceClient.PurgeContexts(parent);

// Poll until the returned long-running operation is complete
Operation<PurgeContextsResponse, PurgeContextsMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
PurgeContextsResponse 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<PurgeContextsResponse, PurgeContextsMetadata> retrievedResponse = metadataServiceClient.PollOncePurgeContexts(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    PurgeContextsResponse retrievedResult = retrievedResponse.Result;
}

PurgeContextsAsync(MetadataStoreName, CallSettings)

public virtual Task<Operation<PurgeContextsResponse, PurgeContextsMetadata>> PurgeContextsAsync(MetadataStoreName parent, CallSettings callSettings = null)

Purges Contexts.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The metadata store to purge Contexts from. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<PurgeContextsResponse, PurgeContextsMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
// Make the request
Operation<PurgeContextsResponse, PurgeContextsMetadata> response = await metadataServiceClient.PurgeContextsAsync(parent);

// Poll until the returned long-running operation is complete
Operation<PurgeContextsResponse, PurgeContextsMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
PurgeContextsResponse 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<PurgeContextsResponse, PurgeContextsMetadata> retrievedResponse = await metadataServiceClient.PollOncePurgeContextsAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    PurgeContextsResponse retrievedResult = retrievedResponse.Result;
}

PurgeContextsAsync(MetadataStoreName, CancellationToken)

public virtual Task<Operation<PurgeContextsResponse, PurgeContextsMetadata>> PurgeContextsAsync(MetadataStoreName parent, CancellationToken cancellationToken)

Purges Contexts.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The metadata store to purge Contexts from. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<PurgeContextsResponse, PurgeContextsMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
// Make the request
Operation<PurgeContextsResponse, PurgeContextsMetadata> response = await metadataServiceClient.PurgeContextsAsync(parent);

// Poll until the returned long-running operation is complete
Operation<PurgeContextsResponse, PurgeContextsMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
PurgeContextsResponse 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<PurgeContextsResponse, PurgeContextsMetadata> retrievedResponse = await metadataServiceClient.PollOncePurgeContextsAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    PurgeContextsResponse retrievedResult = retrievedResponse.Result;
}

PurgeContextsAsync(PurgeContextsRequest, CallSettings)

public virtual Task<Operation<PurgeContextsResponse, PurgeContextsMetadata>> PurgeContextsAsync(PurgeContextsRequest request, CallSettings callSettings = null)

Purges Contexts.

Parameters
Name	Description
`request`	`PurgeContextsRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<PurgeContextsResponse, PurgeContextsMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
PurgeContextsRequest request = new PurgeContextsRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    Filter = "",
    Force = false,
};
// Make the request
Operation<PurgeContextsResponse, PurgeContextsMetadata> response = await metadataServiceClient.PurgeContextsAsync(request);

// Poll until the returned long-running operation is complete
Operation<PurgeContextsResponse, PurgeContextsMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
PurgeContextsResponse 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<PurgeContextsResponse, PurgeContextsMetadata> retrievedResponse = await metadataServiceClient.PollOncePurgeContextsAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    PurgeContextsResponse retrievedResult = retrievedResponse.Result;
}

PurgeContextsAsync(PurgeContextsRequest, CancellationToken)

public virtual Task<Operation<PurgeContextsResponse, PurgeContextsMetadata>> PurgeContextsAsync(PurgeContextsRequest request, CancellationToken cancellationToken)

Purges Contexts.

Parameters
Name	Description
`request`	`PurgeContextsRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<PurgeContextsResponse, PurgeContextsMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
PurgeContextsRequest request = new PurgeContextsRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    Filter = "",
    Force = false,
};
// Make the request
Operation<PurgeContextsResponse, PurgeContextsMetadata> response = await metadataServiceClient.PurgeContextsAsync(request);

// Poll until the returned long-running operation is complete
Operation<PurgeContextsResponse, PurgeContextsMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
PurgeContextsResponse 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<PurgeContextsResponse, PurgeContextsMetadata> retrievedResponse = await metadataServiceClient.PollOncePurgeContextsAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    PurgeContextsResponse retrievedResult = retrievedResponse.Result;
}

PurgeContextsAsync(String, CallSettings)

public virtual Task<Operation<PurgeContextsResponse, PurgeContextsMetadata>> PurgeContextsAsync(string parent, CallSettings callSettings = null)

Purges Contexts.

Parameters
Name	Description
`parent`	`String` Required. The metadata store to purge Contexts from. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<PurgeContextsResponse, PurgeContextsMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
// Make the request
Operation<PurgeContextsResponse, PurgeContextsMetadata> response = await metadataServiceClient.PurgeContextsAsync(parent);

// Poll until the returned long-running operation is complete
Operation<PurgeContextsResponse, PurgeContextsMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
PurgeContextsResponse 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<PurgeContextsResponse, PurgeContextsMetadata> retrievedResponse = await metadataServiceClient.PollOncePurgeContextsAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    PurgeContextsResponse retrievedResult = retrievedResponse.Result;
}

PurgeContextsAsync(String, CancellationToken)

public virtual Task<Operation<PurgeContextsResponse, PurgeContextsMetadata>> PurgeContextsAsync(string parent, CancellationToken cancellationToken)

Purges Contexts.

Parameters
Name	Description
`parent`	`String` Required. The metadata store to purge Contexts from. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<PurgeContextsResponse, PurgeContextsMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
// Make the request
Operation<PurgeContextsResponse, PurgeContextsMetadata> response = await metadataServiceClient.PurgeContextsAsync(parent);

// Poll until the returned long-running operation is complete
Operation<PurgeContextsResponse, PurgeContextsMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
PurgeContextsResponse 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<PurgeContextsResponse, PurgeContextsMetadata> retrievedResponse = await metadataServiceClient.PollOncePurgeContextsAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    PurgeContextsResponse retrievedResult = retrievedResponse.Result;
}

PurgeExecutions(MetadataStoreName, CallSettings)

public virtual Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata> PurgeExecutions(MetadataStoreName parent, CallSettings callSettings = null)

Purges Executions.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The metadata store to purge Executions from. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata>`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
// Make the request
Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata> response = metadataServiceClient.PurgeExecutions(parent);

// Poll until the returned long-running operation is complete
Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
PurgeExecutionsResponse 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<PurgeExecutionsResponse, PurgeExecutionsMetadata> retrievedResponse = metadataServiceClient.PollOncePurgeExecutions(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    PurgeExecutionsResponse retrievedResult = retrievedResponse.Result;
}

PurgeExecutions(PurgeExecutionsRequest, CallSettings)

public virtual Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata> PurgeExecutions(PurgeExecutionsRequest request, CallSettings callSettings = null)

Purges Executions.

Parameters
Name	Description
`request`	`PurgeExecutionsRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata>`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
PurgeExecutionsRequest request = new PurgeExecutionsRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    Filter = "",
    Force = false,
};
// Make the request
Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata> response = metadataServiceClient.PurgeExecutions(request);

// Poll until the returned long-running operation is complete
Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
PurgeExecutionsResponse 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<PurgeExecutionsResponse, PurgeExecutionsMetadata> retrievedResponse = metadataServiceClient.PollOncePurgeExecutions(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    PurgeExecutionsResponse retrievedResult = retrievedResponse.Result;
}

PurgeExecutions(String, CallSettings)

public virtual Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata> PurgeExecutions(string parent, CallSettings callSettings = null)

Purges Executions.

Parameters
Name	Description
`parent`	`String` Required. The metadata store to purge Executions from. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata>`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
// Make the request
Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata> response = metadataServiceClient.PurgeExecutions(parent);

// Poll until the returned long-running operation is complete
Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
PurgeExecutionsResponse 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<PurgeExecutionsResponse, PurgeExecutionsMetadata> retrievedResponse = metadataServiceClient.PollOncePurgeExecutions(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    PurgeExecutionsResponse retrievedResult = retrievedResponse.Result;
}

PurgeExecutionsAsync(MetadataStoreName, CallSettings)

public virtual Task<Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata>> PurgeExecutionsAsync(MetadataStoreName parent, CallSettings callSettings = null)

Purges Executions.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The metadata store to purge Executions from. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
// Make the request
Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata> response = await metadataServiceClient.PurgeExecutionsAsync(parent);

// Poll until the returned long-running operation is complete
Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
PurgeExecutionsResponse 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<PurgeExecutionsResponse, PurgeExecutionsMetadata> retrievedResponse = await metadataServiceClient.PollOncePurgeExecutionsAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    PurgeExecutionsResponse retrievedResult = retrievedResponse.Result;
}

PurgeExecutionsAsync(MetadataStoreName, CancellationToken)

public virtual Task<Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata>> PurgeExecutionsAsync(MetadataStoreName parent, CancellationToken cancellationToken)

Purges Executions.

Parameters
Name	Description
`parent`	`MetadataStoreName` Required. The metadata store to purge Executions from. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
MetadataStoreName parent = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
// Make the request
Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata> response = await metadataServiceClient.PurgeExecutionsAsync(parent);

// Poll until the returned long-running operation is complete
Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
PurgeExecutionsResponse 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<PurgeExecutionsResponse, PurgeExecutionsMetadata> retrievedResponse = await metadataServiceClient.PollOncePurgeExecutionsAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    PurgeExecutionsResponse retrievedResult = retrievedResponse.Result;
}

PurgeExecutionsAsync(PurgeExecutionsRequest, CallSettings)

public virtual Task<Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata>> PurgeExecutionsAsync(PurgeExecutionsRequest request, CallSettings callSettings = null)

Purges Executions.

Parameters
Name	Description
`request`	`PurgeExecutionsRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
PurgeExecutionsRequest request = new PurgeExecutionsRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    Filter = "",
    Force = false,
};
// Make the request
Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata> response = await metadataServiceClient.PurgeExecutionsAsync(request);

// Poll until the returned long-running operation is complete
Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
PurgeExecutionsResponse 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<PurgeExecutionsResponse, PurgeExecutionsMetadata> retrievedResponse = await metadataServiceClient.PollOncePurgeExecutionsAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    PurgeExecutionsResponse retrievedResult = retrievedResponse.Result;
}

PurgeExecutionsAsync(PurgeExecutionsRequest, CancellationToken)

public virtual Task<Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata>> PurgeExecutionsAsync(PurgeExecutionsRequest request, CancellationToken cancellationToken)

Purges Executions.

Parameters
Name	Description
`request`	`PurgeExecutionsRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
PurgeExecutionsRequest request = new PurgeExecutionsRequest
{
    ParentAsMetadataStoreName = MetadataStoreName.FromProjectLocationMetadataStore("[PROJECT]", "[LOCATION]", "[METADATA_STORE]"),
    Filter = "",
    Force = false,
};
// Make the request
Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata> response = await metadataServiceClient.PurgeExecutionsAsync(request);

// Poll until the returned long-running operation is complete
Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
PurgeExecutionsResponse 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<PurgeExecutionsResponse, PurgeExecutionsMetadata> retrievedResponse = await metadataServiceClient.PollOncePurgeExecutionsAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    PurgeExecutionsResponse retrievedResult = retrievedResponse.Result;
}

PurgeExecutionsAsync(String, CallSettings)

public virtual Task<Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata>> PurgeExecutionsAsync(string parent, CallSettings callSettings = null)

Purges Executions.

Parameters
Name	Description
`parent`	`String` Required. The metadata store to purge Executions from. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
// Make the request
Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata> response = await metadataServiceClient.PurgeExecutionsAsync(parent);

// Poll until the returned long-running operation is complete
Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
PurgeExecutionsResponse 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<PurgeExecutionsResponse, PurgeExecutionsMetadata> retrievedResponse = await metadataServiceClient.PollOncePurgeExecutionsAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    PurgeExecutionsResponse retrievedResult = retrievedResponse.Result;
}

PurgeExecutionsAsync(String, CancellationToken)

public virtual Task<Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata>> PurgeExecutionsAsync(string parent, CancellationToken cancellationToken)

Purges Executions.

Parameters
Name	Description
`parent`	`String` Required. The metadata store to purge Executions from. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata>>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]";
// Make the request
Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata> response = await metadataServiceClient.PurgeExecutionsAsync(parent);

// Poll until the returned long-running operation is complete
Operation<PurgeExecutionsResponse, PurgeExecutionsMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
PurgeExecutionsResponse 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<PurgeExecutionsResponse, PurgeExecutionsMetadata> retrievedResponse = await metadataServiceClient.PollOncePurgeExecutionsAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    PurgeExecutionsResponse retrievedResult = retrievedResponse.Result;
}

QueryArtifactLineageSubgraph(ArtifactName, CallSettings)

public virtual LineageSubgraph QueryArtifactLineageSubgraph(ArtifactName artifact, CallSettings callSettings = null)

Retrieves lineage of an Artifact represented through Artifacts and Executions connected by Event edges and returned as a LineageSubgraph.

Parameters

Name Description

artifact

ArtifactName

Required. The resource name of the Artifact whose Lineage needs to be retrieved as a LineageSubgraph. Format: projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}

The request may error with FAILED_PRECONDITION if the number of Artifacts, the number of Executions, or the number of Events that would be returned for the Context exceeds 1000.

callSettings

CallSettings

If not null, applies overrides to this RPC call.

Returns
Type	Description
`LineageSubgraph`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
ArtifactName artifact = ArtifactName.FromProjectLocationMetadataStoreArtifact("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]");
// Make the request
LineageSubgraph response = metadataServiceClient.QueryArtifactLineageSubgraph(artifact);

QueryArtifactLineageSubgraph(QueryArtifactLineageSubgraphRequest, CallSettings)

public virtual LineageSubgraph QueryArtifactLineageSubgraph(QueryArtifactLineageSubgraphRequest request, CallSettings callSettings = null)

Retrieves lineage of an Artifact represented through Artifacts and Executions connected by Event edges and returned as a LineageSubgraph.

Parameters
Name	Description
`request`	`QueryArtifactLineageSubgraphRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`LineageSubgraph`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
QueryArtifactLineageSubgraphRequest request = new QueryArtifactLineageSubgraphRequest
{
    ArtifactAsArtifactName = ArtifactName.FromProjectLocationMetadataStoreArtifact("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]"),
    MaxHops = 0,
    Filter = "",
};
// Make the request
LineageSubgraph response = metadataServiceClient.QueryArtifactLineageSubgraph(request);

QueryArtifactLineageSubgraph(String, CallSettings)

public virtual LineageSubgraph QueryArtifactLineageSubgraph(string artifact, CallSettings callSettings = null)

Retrieves lineage of an Artifact represented through Artifacts and Executions connected by Event edges and returned as a LineageSubgraph.

Parameters

Name Description

artifact

String

The request may error with FAILED_PRECONDITION if the number of Artifacts, the number of Executions, or the number of Events that would be returned for the Context exceeds 1000.

callSettings

CallSettings

If not null, applies overrides to this RPC call.

Returns
Type	Description
`LineageSubgraph`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string artifact = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/artifacts/[ARTIFACT]";
// Make the request
LineageSubgraph response = metadataServiceClient.QueryArtifactLineageSubgraph(artifact);

QueryArtifactLineageSubgraphAsync(ArtifactName, CallSettings)

public virtual Task<LineageSubgraph> QueryArtifactLineageSubgraphAsync(ArtifactName artifact, CallSettings callSettings = null)

Retrieves lineage of an Artifact represented through Artifacts and Executions connected by Event edges and returned as a LineageSubgraph.

Parameters

Name Description

artifact

ArtifactName

The request may error with FAILED_PRECONDITION if the number of Artifacts, the number of Executions, or the number of Events that would be returned for the Context exceeds 1000.

callSettings

CallSettings

If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<LineageSubgraph>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ArtifactName artifact = ArtifactName.FromProjectLocationMetadataStoreArtifact("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]");
// Make the request
LineageSubgraph response = await metadataServiceClient.QueryArtifactLineageSubgraphAsync(artifact);

QueryArtifactLineageSubgraphAsync(ArtifactName, CancellationToken)

public virtual Task<LineageSubgraph> QueryArtifactLineageSubgraphAsync(ArtifactName artifact, CancellationToken cancellationToken)

Retrieves lineage of an Artifact represented through Artifacts and Executions connected by Event edges and returned as a LineageSubgraph.

Parameters

Name Description

artifact

ArtifactName

The request may error with FAILED_PRECONDITION if the number of Artifacts, the number of Executions, or the number of Events that would be returned for the Context exceeds 1000.

cancellationToken

CancellationToken

A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<LineageSubgraph>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ArtifactName artifact = ArtifactName.FromProjectLocationMetadataStoreArtifact("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]");
// Make the request
LineageSubgraph response = await metadataServiceClient.QueryArtifactLineageSubgraphAsync(artifact);

QueryArtifactLineageSubgraphAsync(QueryArtifactLineageSubgraphRequest, CallSettings)

public virtual Task<LineageSubgraph> QueryArtifactLineageSubgraphAsync(QueryArtifactLineageSubgraphRequest request, CallSettings callSettings = null)

Retrieves lineage of an Artifact represented through Artifacts and Executions connected by Event edges and returned as a LineageSubgraph.

Parameters
Name	Description
`request`	`QueryArtifactLineageSubgraphRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<LineageSubgraph>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
QueryArtifactLineageSubgraphRequest request = new QueryArtifactLineageSubgraphRequest
{
    ArtifactAsArtifactName = ArtifactName.FromProjectLocationMetadataStoreArtifact("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]"),
    MaxHops = 0,
    Filter = "",
};
// Make the request
LineageSubgraph response = await metadataServiceClient.QueryArtifactLineageSubgraphAsync(request);

QueryArtifactLineageSubgraphAsync(QueryArtifactLineageSubgraphRequest, CancellationToken)

public virtual Task<LineageSubgraph> QueryArtifactLineageSubgraphAsync(QueryArtifactLineageSubgraphRequest request, CancellationToken cancellationToken)

Retrieves lineage of an Artifact represented through Artifacts and Executions connected by Event edges and returned as a LineageSubgraph.

Parameters
Name	Description
`request`	`QueryArtifactLineageSubgraphRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<LineageSubgraph>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
QueryArtifactLineageSubgraphRequest request = new QueryArtifactLineageSubgraphRequest
{
    ArtifactAsArtifactName = ArtifactName.FromProjectLocationMetadataStoreArtifact("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]"),
    MaxHops = 0,
    Filter = "",
};
// Make the request
LineageSubgraph response = await metadataServiceClient.QueryArtifactLineageSubgraphAsync(request);

QueryArtifactLineageSubgraphAsync(String, CallSettings)

public virtual Task<LineageSubgraph> QueryArtifactLineageSubgraphAsync(string artifact, CallSettings callSettings = null)

Retrieves lineage of an Artifact represented through Artifacts and Executions connected by Event edges and returned as a LineageSubgraph.

Parameters

Name Description

artifact

String

The request may error with FAILED_PRECONDITION if the number of Artifacts, the number of Executions, or the number of Events that would be returned for the Context exceeds 1000.

callSettings

CallSettings

If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<LineageSubgraph>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string artifact = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/artifacts/[ARTIFACT]";
// Make the request
LineageSubgraph response = await metadataServiceClient.QueryArtifactLineageSubgraphAsync(artifact);

QueryArtifactLineageSubgraphAsync(String, CancellationToken)

public virtual Task<LineageSubgraph> QueryArtifactLineageSubgraphAsync(string artifact, CancellationToken cancellationToken)

Retrieves lineage of an Artifact represented through Artifacts and Executions connected by Event edges and returned as a LineageSubgraph.

Parameters

Name Description

artifact

String

The request may error with FAILED_PRECONDITION if the number of Artifacts, the number of Executions, or the number of Events that would be returned for the Context exceeds 1000.

cancellationToken

CancellationToken

A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<LineageSubgraph>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string artifact = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/artifacts/[ARTIFACT]";
// Make the request
LineageSubgraph response = await metadataServiceClient.QueryArtifactLineageSubgraphAsync(artifact);

QueryContextLineageSubgraph(ContextName, CallSettings)

public virtual LineageSubgraph QueryContextLineageSubgraph(ContextName context, CallSettings callSettings = null)

Retrieves Artifacts and Executions within the specified Context, connected by Event edges and returned as a LineageSubgraph.

Parameters

Name Description

context

ContextName

Required. The resource name of the Context whose Artifacts and Executions should be retrieved as a LineageSubgraph. Format: projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}

The request may error with FAILED_PRECONDITION if the number of Artifacts, the number of Executions, or the number of Events that would be returned for the Context exceeds 1000.

callSettings

CallSettings

If not null, applies overrides to this RPC call.

Returns
Type	Description
`LineageSubgraph`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
ContextName context = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]");
// Make the request
LineageSubgraph response = metadataServiceClient.QueryContextLineageSubgraph(context);

QueryContextLineageSubgraph(QueryContextLineageSubgraphRequest, CallSettings)

public virtual LineageSubgraph QueryContextLineageSubgraph(QueryContextLineageSubgraphRequest request, CallSettings callSettings = null)

Retrieves Artifacts and Executions within the specified Context, connected by Event edges and returned as a LineageSubgraph.

Parameters
Name	Description
`request`	`QueryContextLineageSubgraphRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`LineageSubgraph`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
QueryContextLineageSubgraphRequest request = new QueryContextLineageSubgraphRequest
{
    ContextAsContextName = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]"),
};
// Make the request
LineageSubgraph response = metadataServiceClient.QueryContextLineageSubgraph(request);

QueryContextLineageSubgraph(String, CallSettings)

public virtual LineageSubgraph QueryContextLineageSubgraph(string context, CallSettings callSettings = null)

Retrieves Artifacts and Executions within the specified Context, connected by Event edges and returned as a LineageSubgraph.

Parameters

Name Description

context

String

The request may error with FAILED_PRECONDITION if the number of Artifacts, the number of Executions, or the number of Events that would be returned for the Context exceeds 1000.

callSettings

CallSettings

If not null, applies overrides to this RPC call.

Returns
Type	Description
`LineageSubgraph`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string context = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/contexts/[CONTEXT]";
// Make the request
LineageSubgraph response = metadataServiceClient.QueryContextLineageSubgraph(context);

QueryContextLineageSubgraphAsync(ContextName, CallSettings)

public virtual Task<LineageSubgraph> QueryContextLineageSubgraphAsync(ContextName context, CallSettings callSettings = null)

Retrieves Artifacts and Executions within the specified Context, connected by Event edges and returned as a LineageSubgraph.

Parameters

Name Description

context

ContextName

The request may error with FAILED_PRECONDITION if the number of Artifacts, the number of Executions, or the number of Events that would be returned for the Context exceeds 1000.

callSettings

CallSettings

If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<LineageSubgraph>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ContextName context = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]");
// Make the request
LineageSubgraph response = await metadataServiceClient.QueryContextLineageSubgraphAsync(context);

QueryContextLineageSubgraphAsync(ContextName, CancellationToken)

public virtual Task<LineageSubgraph> QueryContextLineageSubgraphAsync(ContextName context, CancellationToken cancellationToken)

Retrieves Artifacts and Executions within the specified Context, connected by Event edges and returned as a LineageSubgraph.

Parameters

Name Description

context

ContextName

The request may error with FAILED_PRECONDITION if the number of Artifacts, the number of Executions, or the number of Events that would be returned for the Context exceeds 1000.

cancellationToken

CancellationToken

A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<LineageSubgraph>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ContextName context = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]");
// Make the request
LineageSubgraph response = await metadataServiceClient.QueryContextLineageSubgraphAsync(context);

QueryContextLineageSubgraphAsync(QueryContextLineageSubgraphRequest, CallSettings)

public virtual Task<LineageSubgraph> QueryContextLineageSubgraphAsync(QueryContextLineageSubgraphRequest request, CallSettings callSettings = null)

Retrieves Artifacts and Executions within the specified Context, connected by Event edges and returned as a LineageSubgraph.

Parameters
Name	Description
`request`	`QueryContextLineageSubgraphRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<LineageSubgraph>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
QueryContextLineageSubgraphRequest request = new QueryContextLineageSubgraphRequest
{
    ContextAsContextName = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]"),
};
// Make the request
LineageSubgraph response = await metadataServiceClient.QueryContextLineageSubgraphAsync(request);

QueryContextLineageSubgraphAsync(QueryContextLineageSubgraphRequest, CancellationToken)

public virtual Task<LineageSubgraph> QueryContextLineageSubgraphAsync(QueryContextLineageSubgraphRequest request, CancellationToken cancellationToken)

Retrieves Artifacts and Executions within the specified Context, connected by Event edges and returned as a LineageSubgraph.

Parameters
Name	Description
`request`	`QueryContextLineageSubgraphRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<LineageSubgraph>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
QueryContextLineageSubgraphRequest request = new QueryContextLineageSubgraphRequest
{
    ContextAsContextName = ContextName.FromProjectLocationMetadataStoreContext("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]"),
};
// Make the request
LineageSubgraph response = await metadataServiceClient.QueryContextLineageSubgraphAsync(request);

QueryContextLineageSubgraphAsync(String, CallSettings)

public virtual Task<LineageSubgraph> QueryContextLineageSubgraphAsync(string context, CallSettings callSettings = null)

Retrieves Artifacts and Executions within the specified Context, connected by Event edges and returned as a LineageSubgraph.

Parameters

Name Description

context

String

The request may error with FAILED_PRECONDITION if the number of Artifacts, the number of Executions, or the number of Events that would be returned for the Context exceeds 1000.

callSettings

CallSettings

If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<LineageSubgraph>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string context = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/contexts/[CONTEXT]";
// Make the request
LineageSubgraph response = await metadataServiceClient.QueryContextLineageSubgraphAsync(context);

QueryContextLineageSubgraphAsync(String, CancellationToken)

public virtual Task<LineageSubgraph> QueryContextLineageSubgraphAsync(string context, CancellationToken cancellationToken)

Retrieves Artifacts and Executions within the specified Context, connected by Event edges and returned as a LineageSubgraph.

Parameters

Name Description

context

String

The request may error with FAILED_PRECONDITION if the number of Artifacts, the number of Executions, or the number of Events that would be returned for the Context exceeds 1000.

cancellationToken

CancellationToken

A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<LineageSubgraph>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string context = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/contexts/[CONTEXT]";
// Make the request
LineageSubgraph response = await metadataServiceClient.QueryContextLineageSubgraphAsync(context);

QueryExecutionInputsAndOutputs(ExecutionName, CallSettings)

public virtual LineageSubgraph QueryExecutionInputsAndOutputs(ExecutionName execution, CallSettings callSettings = null)

Obtains the set of input and output Artifacts for this Execution, in the form of LineageSubgraph that also contains the Execution and connecting Events.

Parameters
Name	Description
`execution`	`ExecutionName` Required. The resource name of the Execution whose input and output Artifacts should be retrieved as a LineageSubgraph. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`LineageSubgraph`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
ExecutionName execution = ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]");
// Make the request
LineageSubgraph response = metadataServiceClient.QueryExecutionInputsAndOutputs(execution);

QueryExecutionInputsAndOutputs(QueryExecutionInputsAndOutputsRequest, CallSettings)

public virtual LineageSubgraph QueryExecutionInputsAndOutputs(QueryExecutionInputsAndOutputsRequest request, CallSettings callSettings = null)

Obtains the set of input and output Artifacts for this Execution, in the form of LineageSubgraph that also contains the Execution and connecting Events.

Parameters
Name	Description
`request`	`QueryExecutionInputsAndOutputsRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`LineageSubgraph`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
QueryExecutionInputsAndOutputsRequest request = new QueryExecutionInputsAndOutputsRequest
{
    ExecutionAsExecutionName = ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]"),
};
// Make the request
LineageSubgraph response = metadataServiceClient.QueryExecutionInputsAndOutputs(request);

QueryExecutionInputsAndOutputs(String, CallSettings)

public virtual LineageSubgraph QueryExecutionInputsAndOutputs(string execution, CallSettings callSettings = null)

Obtains the set of input and output Artifacts for this Execution, in the form of LineageSubgraph that also contains the Execution and connecting Events.

Parameters
Name	Description
`execution`	`String` Required. The resource name of the Execution whose input and output Artifacts should be retrieved as a LineageSubgraph. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`LineageSubgraph`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
string execution = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/executions/[EXECUTION]";
// Make the request
LineageSubgraph response = metadataServiceClient.QueryExecutionInputsAndOutputs(execution);

QueryExecutionInputsAndOutputsAsync(ExecutionName, CallSettings)

public virtual Task<LineageSubgraph> QueryExecutionInputsAndOutputsAsync(ExecutionName execution, CallSettings callSettings = null)

Obtains the set of input and output Artifacts for this Execution, in the form of LineageSubgraph that also contains the Execution and connecting Events.

Parameters
Name	Description
`execution`	`ExecutionName` Required. The resource name of the Execution whose input and output Artifacts should be retrieved as a LineageSubgraph. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<LineageSubgraph>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ExecutionName execution = ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]");
// Make the request
LineageSubgraph response = await metadataServiceClient.QueryExecutionInputsAndOutputsAsync(execution);

QueryExecutionInputsAndOutputsAsync(ExecutionName, CancellationToken)

public virtual Task<LineageSubgraph> QueryExecutionInputsAndOutputsAsync(ExecutionName execution, CancellationToken cancellationToken)

Obtains the set of input and output Artifacts for this Execution, in the form of LineageSubgraph that also contains the Execution and connecting Events.

Parameters
Name	Description
`execution`	`ExecutionName` Required. The resource name of the Execution whose input and output Artifacts should be retrieved as a LineageSubgraph. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<LineageSubgraph>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
ExecutionName execution = ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]");
// Make the request
LineageSubgraph response = await metadataServiceClient.QueryExecutionInputsAndOutputsAsync(execution);

QueryExecutionInputsAndOutputsAsync(QueryExecutionInputsAndOutputsRequest, CallSettings)

public virtual Task<LineageSubgraph> QueryExecutionInputsAndOutputsAsync(QueryExecutionInputsAndOutputsRequest request, CallSettings callSettings = null)

Obtains the set of input and output Artifacts for this Execution, in the form of LineageSubgraph that also contains the Execution and connecting Events.

Parameters
Name	Description
`request`	`QueryExecutionInputsAndOutputsRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<LineageSubgraph>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
QueryExecutionInputsAndOutputsRequest request = new QueryExecutionInputsAndOutputsRequest
{
    ExecutionAsExecutionName = ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]"),
};
// Make the request
LineageSubgraph response = await metadataServiceClient.QueryExecutionInputsAndOutputsAsync(request);

QueryExecutionInputsAndOutputsAsync(QueryExecutionInputsAndOutputsRequest, CancellationToken)

public virtual Task<LineageSubgraph> QueryExecutionInputsAndOutputsAsync(QueryExecutionInputsAndOutputsRequest request, CancellationToken cancellationToken)

Obtains the set of input and output Artifacts for this Execution, in the form of LineageSubgraph that also contains the Execution and connecting Events.

Parameters
Name	Description
`request`	`QueryExecutionInputsAndOutputsRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<LineageSubgraph>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
QueryExecutionInputsAndOutputsRequest request = new QueryExecutionInputsAndOutputsRequest
{
    ExecutionAsExecutionName = ExecutionName.FromProjectLocationMetadataStoreExecution("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]"),
};
// Make the request
LineageSubgraph response = await metadataServiceClient.QueryExecutionInputsAndOutputsAsync(request);

QueryExecutionInputsAndOutputsAsync(String, CallSettings)

public virtual Task<LineageSubgraph> QueryExecutionInputsAndOutputsAsync(string execution, CallSettings callSettings = null)

Obtains the set of input and output Artifacts for this Execution, in the form of LineageSubgraph that also contains the Execution and connecting Events.

Parameters
Name	Description
`execution`	`String` Required. The resource name of the Execution whose input and output Artifacts should be retrieved as a LineageSubgraph. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<LineageSubgraph>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string execution = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/executions/[EXECUTION]";
// Make the request
LineageSubgraph response = await metadataServiceClient.QueryExecutionInputsAndOutputsAsync(execution);

QueryExecutionInputsAndOutputsAsync(String, CancellationToken)

public virtual Task<LineageSubgraph> QueryExecutionInputsAndOutputsAsync(string execution, CancellationToken cancellationToken)

Obtains the set of input and output Artifacts for this Execution, in the form of LineageSubgraph that also contains the Execution and connecting Events.

Parameters
Name	Description
`execution`	`String` Required. The resource name of the Execution whose input and output Artifacts should be retrieved as a LineageSubgraph. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<LineageSubgraph>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
string execution = "projects/[PROJECT]/locations/[LOCATION]/metadataStores/[METADATA_STORE]/executions/[EXECUTION]";
// Make the request
LineageSubgraph response = await metadataServiceClient.QueryExecutionInputsAndOutputsAsync(execution);

ShutdownDefaultChannelsAsync()

public static Task ShutdownDefaultChannelsAsync()

Shuts down any channels automatically created by Create() and CreateAsync(CancellationToken). Channels which weren't automatically created are not affected.

Returns
Type	Description
`Task`	A task representing the asynchronous shutdown operation.

Remarks

After calling this method, further calls to Create() and CreateAsync(CancellationToken) will create new channels, which could in turn be shut down by another call to this method.

UpdateArtifact(Artifact, FieldMask, CallSettings)

public virtual Artifact UpdateArtifact(Artifact artifact, FieldMask updateMask, CallSettings callSettings = null)

Updates a stored Artifact.

Parameters
Name	Description
`artifact`	`Artifact` Required. The Artifact containing updates. The Artifact's [Artifact.name][google.cloud.aiplatform.v1.Artifact.name] field is used to identify the Artifact to be updated. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}`
`updateMask`	`FieldMask` Optional. A FieldMask indicating which fields should be updated. Functionality of this field is not yet supported.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Artifact`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
Artifact artifact = new Artifact();
FieldMask updateMask = new FieldMask();
// Make the request
Artifact response = metadataServiceClient.UpdateArtifact(artifact, updateMask);

UpdateArtifact(UpdateArtifactRequest, CallSettings)

public virtual Artifact UpdateArtifact(UpdateArtifactRequest request, CallSettings callSettings = null)

Updates a stored Artifact.

Parameters
Name	Description
`request`	`UpdateArtifactRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Artifact`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
UpdateArtifactRequest request = new UpdateArtifactRequest
{
    Artifact = new Artifact(),
    UpdateMask = new FieldMask(),
    AllowMissing = false,
};
// Make the request
Artifact response = metadataServiceClient.UpdateArtifact(request);

UpdateArtifactAsync(Artifact, FieldMask, CallSettings)

public virtual Task<Artifact> UpdateArtifactAsync(Artifact artifact, FieldMask updateMask, CallSettings callSettings = null)

Updates a stored Artifact.

Parameters
Name	Description
`artifact`	`Artifact` Required. The Artifact containing updates. The Artifact's [Artifact.name][google.cloud.aiplatform.v1.Artifact.name] field is used to identify the Artifact to be updated. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}`
`updateMask`	`FieldMask` Optional. A FieldMask indicating which fields should be updated. Functionality of this field is not yet supported.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Artifact>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
Artifact artifact = new Artifact();
FieldMask updateMask = new FieldMask();
// Make the request
Artifact response = await metadataServiceClient.UpdateArtifactAsync(artifact, updateMask);

UpdateArtifactAsync(Artifact, FieldMask, CancellationToken)

public virtual Task<Artifact> UpdateArtifactAsync(Artifact artifact, FieldMask updateMask, CancellationToken cancellationToken)

Updates a stored Artifact.

Parameters
Name	Description
`artifact`	`Artifact` Required. The Artifact containing updates. The Artifact's [Artifact.name][google.cloud.aiplatform.v1.Artifact.name] field is used to identify the Artifact to be updated. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/artifacts/{artifact}`
`updateMask`	`FieldMask` Optional. A FieldMask indicating which fields should be updated. Functionality of this field is not yet supported.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Artifact>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
Artifact artifact = new Artifact();
FieldMask updateMask = new FieldMask();
// Make the request
Artifact response = await metadataServiceClient.UpdateArtifactAsync(artifact, updateMask);

UpdateArtifactAsync(UpdateArtifactRequest, CallSettings)

public virtual Task<Artifact> UpdateArtifactAsync(UpdateArtifactRequest request, CallSettings callSettings = null)

Updates a stored Artifact.

Parameters
Name	Description
`request`	`UpdateArtifactRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Artifact>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateArtifactRequest request = new UpdateArtifactRequest
{
    Artifact = new Artifact(),
    UpdateMask = new FieldMask(),
    AllowMissing = false,
};
// Make the request
Artifact response = await metadataServiceClient.UpdateArtifactAsync(request);

UpdateArtifactAsync(UpdateArtifactRequest, CancellationToken)

public virtual Task<Artifact> UpdateArtifactAsync(UpdateArtifactRequest request, CancellationToken cancellationToken)

Updates a stored Artifact.

Parameters
Name	Description
`request`	`UpdateArtifactRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Artifact>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateArtifactRequest request = new UpdateArtifactRequest
{
    Artifact = new Artifact(),
    UpdateMask = new FieldMask(),
    AllowMissing = false,
};
// Make the request
Artifact response = await metadataServiceClient.UpdateArtifactAsync(request);

UpdateContext(Context, FieldMask, CallSettings)

public virtual Context UpdateContext(Context context, FieldMask updateMask, CallSettings callSettings = null)

Updates a stored Context.

Parameters
Name	Description
`context`	`Context` Required. The Context containing updates. The Context's [Context.name][google.cloud.aiplatform.v1.Context.name] field is used to identify the Context to be updated. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`
`updateMask`	`FieldMask` Optional. A FieldMask indicating which fields should be updated. Functionality of this field is not yet supported.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Context`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
Context context = new Context();
FieldMask updateMask = new FieldMask();
// Make the request
Context response = metadataServiceClient.UpdateContext(context, updateMask);

UpdateContext(UpdateContextRequest, CallSettings)

public virtual Context UpdateContext(UpdateContextRequest request, CallSettings callSettings = null)

Updates a stored Context.

Parameters
Name	Description
`request`	`UpdateContextRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Context`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
UpdateContextRequest request = new UpdateContextRequest
{
    Context = new Context(),
    UpdateMask = new FieldMask(),
    AllowMissing = false,
};
// Make the request
Context response = metadataServiceClient.UpdateContext(request);

UpdateContextAsync(Context, FieldMask, CallSettings)

public virtual Task<Context> UpdateContextAsync(Context context, FieldMask updateMask, CallSettings callSettings = null)

Updates a stored Context.

Parameters
Name	Description
`context`	`Context` Required. The Context containing updates. The Context's [Context.name][google.cloud.aiplatform.v1.Context.name] field is used to identify the Context to be updated. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`
`updateMask`	`FieldMask` Optional. A FieldMask indicating which fields should be updated. Functionality of this field is not yet supported.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Context>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
Context context = new Context();
FieldMask updateMask = new FieldMask();
// Make the request
Context response = await metadataServiceClient.UpdateContextAsync(context, updateMask);

UpdateContextAsync(Context, FieldMask, CancellationToken)

public virtual Task<Context> UpdateContextAsync(Context context, FieldMask updateMask, CancellationToken cancellationToken)

Updates a stored Context.

Parameters
Name	Description
`context`	`Context` Required. The Context containing updates. The Context's [Context.name][google.cloud.aiplatform.v1.Context.name] field is used to identify the Context to be updated. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/contexts/{context}`
`updateMask`	`FieldMask` Optional. A FieldMask indicating which fields should be updated. Functionality of this field is not yet supported.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Context>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
Context context = new Context();
FieldMask updateMask = new FieldMask();
// Make the request
Context response = await metadataServiceClient.UpdateContextAsync(context, updateMask);

UpdateContextAsync(UpdateContextRequest, CallSettings)

public virtual Task<Context> UpdateContextAsync(UpdateContextRequest request, CallSettings callSettings = null)

Updates a stored Context.

Parameters
Name	Description
`request`	`UpdateContextRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Context>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateContextRequest request = new UpdateContextRequest
{
    Context = new Context(),
    UpdateMask = new FieldMask(),
    AllowMissing = false,
};
// Make the request
Context response = await metadataServiceClient.UpdateContextAsync(request);

UpdateContextAsync(UpdateContextRequest, CancellationToken)

public virtual Task<Context> UpdateContextAsync(UpdateContextRequest request, CancellationToken cancellationToken)

Updates a stored Context.

Parameters
Name	Description
`request`	`UpdateContextRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Context>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateContextRequest request = new UpdateContextRequest
{
    Context = new Context(),
    UpdateMask = new FieldMask(),
    AllowMissing = false,
};
// Make the request
Context response = await metadataServiceClient.UpdateContextAsync(request);

UpdateExecution(Execution, FieldMask, CallSettings)

public virtual Execution UpdateExecution(Execution execution, FieldMask updateMask, CallSettings callSettings = null)

Updates a stored Execution.

Parameters
Name	Description
`execution`	`Execution` Required. The Execution containing updates. The Execution's [Execution.name][google.cloud.aiplatform.v1.Execution.name] field is used to identify the Execution to be updated. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`updateMask`	`FieldMask` Optional. A FieldMask indicating which fields should be updated. Functionality of this field is not yet supported.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Execution`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
Execution execution = new Execution();
FieldMask updateMask = new FieldMask();
// Make the request
Execution response = metadataServiceClient.UpdateExecution(execution, updateMask);

UpdateExecution(UpdateExecutionRequest, CallSettings)

public virtual Execution UpdateExecution(UpdateExecutionRequest request, CallSettings callSettings = null)

Updates a stored Execution.

Parameters
Name	Description
`request`	`UpdateExecutionRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Execution`	The RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = MetadataServiceClient.Create();
// Initialize request argument(s)
UpdateExecutionRequest request = new UpdateExecutionRequest
{
    Execution = new Execution(),
    UpdateMask = new FieldMask(),
    AllowMissing = false,
};
// Make the request
Execution response = metadataServiceClient.UpdateExecution(request);

UpdateExecutionAsync(Execution, FieldMask, CallSettings)

public virtual Task<Execution> UpdateExecutionAsync(Execution execution, FieldMask updateMask, CallSettings callSettings = null)

Updates a stored Execution.

Parameters
Name	Description
`execution`	`Execution` Required. The Execution containing updates. The Execution's [Execution.name][google.cloud.aiplatform.v1.Execution.name] field is used to identify the Execution to be updated. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`updateMask`	`FieldMask` Optional. A FieldMask indicating which fields should be updated. Functionality of this field is not yet supported.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Execution>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
Execution execution = new Execution();
FieldMask updateMask = new FieldMask();
// Make the request
Execution response = await metadataServiceClient.UpdateExecutionAsync(execution, updateMask);

UpdateExecutionAsync(Execution, FieldMask, CancellationToken)

public virtual Task<Execution> UpdateExecutionAsync(Execution execution, FieldMask updateMask, CancellationToken cancellationToken)

Updates a stored Execution.

Parameters
Name	Description
`execution`	`Execution` Required. The Execution containing updates. The Execution's [Execution.name][google.cloud.aiplatform.v1.Execution.name] field is used to identify the Execution to be updated. Format: `projects/{project}/locations/{location}/metadataStores/{metadatastore}/executions/{execution}`
`updateMask`	`FieldMask` Optional. A FieldMask indicating which fields should be updated. Functionality of this field is not yet supported.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Execution>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
Execution execution = new Execution();
FieldMask updateMask = new FieldMask();
// Make the request
Execution response = await metadataServiceClient.UpdateExecutionAsync(execution, updateMask);

UpdateExecutionAsync(UpdateExecutionRequest, CallSettings)

public virtual Task<Execution> UpdateExecutionAsync(UpdateExecutionRequest request, CallSettings callSettings = null)

Updates a stored Execution.

Parameters
Name	Description
`request`	`UpdateExecutionRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Execution>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateExecutionRequest request = new UpdateExecutionRequest
{
    Execution = new Execution(),
    UpdateMask = new FieldMask(),
    AllowMissing = false,
};
// Make the request
Execution response = await metadataServiceClient.UpdateExecutionAsync(request);

UpdateExecutionAsync(UpdateExecutionRequest, CancellationToken)

public virtual Task<Execution> UpdateExecutionAsync(UpdateExecutionRequest request, CancellationToken cancellationToken)

Updates a stored Execution.

Parameters
Name	Description
`request`	`UpdateExecutionRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Execution>`	A Task containing the RPC response.

Example

// Create client
MetadataServiceClient metadataServiceClient = await MetadataServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateExecutionRequest request = new UpdateExecutionRequest
{
    Execution = new Execution(),
    UpdateMask = new FieldMask(),
    AllowMissing = false,
};
// Make the request
Execution response = await metadataServiceClient.UpdateExecutionAsync(request);