Class ExecutionsClient (2.0.0)

public abstract class ExecutionsClient

Namespace

Assembly

Google.Cloud.Workflows.Executions.V1.dll

Remarks

Properties

DefaultEndpoint

public static string DefaultEndpoint { get; }

DefaultScopes

public static IReadOnlyList<string> DefaultScopes { get; }

GrpcClient

public virtual Executions.ExecutionsClient GrpcClient { get; }

ServiceMetadata

public static ServiceMetadata ServiceMetadata { get; }

Methods

CancelExecution(CancelExecutionRequest, CallSettings)

public virtual Execution CancelExecution(CancelExecutionRequest request, CallSettings callSettings = null)

// Create client
ExecutionsClient executionsClient = ExecutionsClient.Create();
// Initialize request argument(s)
CancelExecutionRequest request = new CancelExecutionRequest
{
    ExecutionName = ExecutionName.FromProjectLocationWorkflowExecution("[PROJECT]", "[LOCATION]", "[WORKFLOW]", "[EXECUTION]"),
};
// Make the request
Execution response = executionsClient.CancelExecution(request);

CancelExecution(ExecutionName, CallSettings)

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

// Create client
ExecutionsClient executionsClient = ExecutionsClient.Create();
// Initialize request argument(s)
ExecutionName name = ExecutionName.FromProjectLocationWorkflowExecution("[PROJECT]", "[LOCATION]", "[WORKFLOW]", "[EXECUTION]");
// Make the request
Execution response = executionsClient.CancelExecution(name);

CancelExecution(String, CallSettings)

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

// Create client
ExecutionsClient executionsClient = ExecutionsClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/workflows/[WORKFLOW]/executions/[EXECUTION]";
// Make the request
Execution response = executionsClient.CancelExecution(name);

CancelExecutionAsync(CancelExecutionRequest, CallSettings)

public virtual Task<Execution> CancelExecutionAsync(CancelExecutionRequest request, CallSettings callSettings = null)

// Create client
ExecutionsClient executionsClient = await ExecutionsClient.CreateAsync();
// Initialize request argument(s)
CancelExecutionRequest request = new CancelExecutionRequest
{
    ExecutionName = ExecutionName.FromProjectLocationWorkflowExecution("[PROJECT]", "[LOCATION]", "[WORKFLOW]", "[EXECUTION]"),
};
// Make the request
Execution response = await executionsClient.CancelExecutionAsync(request);

CancelExecutionAsync(CancelExecutionRequest, CancellationToken)

public virtual Task<Execution> CancelExecutionAsync(CancelExecutionRequest request, CancellationToken cancellationToken)

// Create client
ExecutionsClient executionsClient = await ExecutionsClient.CreateAsync();
// Initialize request argument(s)
CancelExecutionRequest request = new CancelExecutionRequest
{
    ExecutionName = ExecutionName.FromProjectLocationWorkflowExecution("[PROJECT]", "[LOCATION]", "[WORKFLOW]", "[EXECUTION]"),
};
// Make the request
Execution response = await executionsClient.CancelExecutionAsync(request);

CancelExecutionAsync(ExecutionName, CallSettings)

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

// Create client
ExecutionsClient executionsClient = await ExecutionsClient.CreateAsync();
// Initialize request argument(s)
ExecutionName name = ExecutionName.FromProjectLocationWorkflowExecution("[PROJECT]", "[LOCATION]", "[WORKFLOW]", "[EXECUTION]");
// Make the request
Execution response = await executionsClient.CancelExecutionAsync(name);

CancelExecutionAsync(ExecutionName, CancellationToken)

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

// Create client
ExecutionsClient executionsClient = await ExecutionsClient.CreateAsync();
// Initialize request argument(s)
ExecutionName name = ExecutionName.FromProjectLocationWorkflowExecution("[PROJECT]", "[LOCATION]", "[WORKFLOW]", "[EXECUTION]");
// Make the request
Execution response = await executionsClient.CancelExecutionAsync(name);

CancelExecutionAsync(String, CallSettings)

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

// Create client
ExecutionsClient executionsClient = await ExecutionsClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/workflows/[WORKFLOW]/executions/[EXECUTION]";
// Make the request
Execution response = await executionsClient.CancelExecutionAsync(name);

CancelExecutionAsync(String, CancellationToken)

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

// Create client
ExecutionsClient executionsClient = await ExecutionsClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/workflows/[WORKFLOW]/executions/[EXECUTION]";
// Make the request
Execution response = await executionsClient.CancelExecutionAsync(name);

Create()

public static ExecutionsClient Create()

CreateAsync(CancellationToken)

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

CreateExecution(WorkflowName, Execution, CallSettings)

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

// Create client
ExecutionsClient executionsClient = ExecutionsClient.Create();
// Initialize request argument(s)
WorkflowName parent = WorkflowName.FromProjectLocationWorkflow("[PROJECT]", "[LOCATION]", "[WORKFLOW]");
Execution execution = new Execution();
// Make the request
Execution response = executionsClient.CreateExecution(parent, execution);

CreateExecution(CreateExecutionRequest, CallSettings)

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

// Create client
ExecutionsClient executionsClient = ExecutionsClient.Create();
// Initialize request argument(s)
CreateExecutionRequest request = new CreateExecutionRequest
{
    ParentAsWorkflowName = WorkflowName.FromProjectLocationWorkflow("[PROJECT]", "[LOCATION]", "[WORKFLOW]"),
    Execution = new Execution(),
};
// Make the request
Execution response = executionsClient.CreateExecution(request);

CreateExecution(String, Execution, CallSettings)

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

// Create client
ExecutionsClient executionsClient = ExecutionsClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/workflows/[WORKFLOW]";
Execution execution = new Execution();
// Make the request
Execution response = executionsClient.CreateExecution(parent, execution);

CreateExecutionAsync(WorkflowName, Execution, CallSettings)

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

// Create client
ExecutionsClient executionsClient = await ExecutionsClient.CreateAsync();
// Initialize request argument(s)
WorkflowName parent = WorkflowName.FromProjectLocationWorkflow("[PROJECT]", "[LOCATION]", "[WORKFLOW]");
Execution execution = new Execution();
// Make the request
Execution response = await executionsClient.CreateExecutionAsync(parent, execution);

CreateExecutionAsync(WorkflowName, Execution, CancellationToken)

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

// Create client
ExecutionsClient executionsClient = await ExecutionsClient.CreateAsync();
// Initialize request argument(s)
WorkflowName parent = WorkflowName.FromProjectLocationWorkflow("[PROJECT]", "[LOCATION]", "[WORKFLOW]");
Execution execution = new Execution();
// Make the request
Execution response = await executionsClient.CreateExecutionAsync(parent, execution);

CreateExecutionAsync(CreateExecutionRequest, CallSettings)

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

// Create client
ExecutionsClient executionsClient = await ExecutionsClient.CreateAsync();
// Initialize request argument(s)
CreateExecutionRequest request = new CreateExecutionRequest
{
    ParentAsWorkflowName = WorkflowName.FromProjectLocationWorkflow("[PROJECT]", "[LOCATION]", "[WORKFLOW]"),
    Execution = new Execution(),
};
// Make the request
Execution response = await executionsClient.CreateExecutionAsync(request);

CreateExecutionAsync(CreateExecutionRequest, CancellationToken)

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

// Create client
ExecutionsClient executionsClient = await ExecutionsClient.CreateAsync();
// Initialize request argument(s)
CreateExecutionRequest request = new CreateExecutionRequest
{
    ParentAsWorkflowName = WorkflowName.FromProjectLocationWorkflow("[PROJECT]", "[LOCATION]", "[WORKFLOW]"),
    Execution = new Execution(),
};
// Make the request
Execution response = await executionsClient.CreateExecutionAsync(request);

CreateExecutionAsync(String, Execution, CallSettings)

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

// Create client
ExecutionsClient executionsClient = await ExecutionsClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/workflows/[WORKFLOW]";
Execution execution = new Execution();
// Make the request
Execution response = await executionsClient.CreateExecutionAsync(parent, execution);

CreateExecutionAsync(String, Execution, CancellationToken)

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

// Create client
ExecutionsClient executionsClient = await ExecutionsClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/workflows/[WORKFLOW]";
Execution execution = new Execution();
// Make the request
Execution response = await executionsClient.CreateExecutionAsync(parent, execution);

GetExecution(ExecutionName, CallSettings)

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

// Create client
ExecutionsClient executionsClient = ExecutionsClient.Create();
// Initialize request argument(s)
ExecutionName name = ExecutionName.FromProjectLocationWorkflowExecution("[PROJECT]", "[LOCATION]", "[WORKFLOW]", "[EXECUTION]");
// Make the request
Execution response = executionsClient.GetExecution(name);

GetExecution(GetExecutionRequest, CallSettings)

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

// Create client
ExecutionsClient executionsClient = ExecutionsClient.Create();
// Initialize request argument(s)
GetExecutionRequest request = new GetExecutionRequest
{
    ExecutionName = ExecutionName.FromProjectLocationWorkflowExecution("[PROJECT]", "[LOCATION]", "[WORKFLOW]", "[EXECUTION]"),
    View = ExecutionView.Unspecified,
};
// Make the request
Execution response = executionsClient.GetExecution(request);

GetExecution(String, CallSettings)

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

// Create client
ExecutionsClient executionsClient = ExecutionsClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/workflows/[WORKFLOW]/executions/[EXECUTION]";
// Make the request
Execution response = executionsClient.GetExecution(name);

GetExecutionAsync(ExecutionName, CallSettings)

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

// Create client
ExecutionsClient executionsClient = await ExecutionsClient.CreateAsync();
// Initialize request argument(s)
ExecutionName name = ExecutionName.FromProjectLocationWorkflowExecution("[PROJECT]", "[LOCATION]", "[WORKFLOW]", "[EXECUTION]");
// Make the request
Execution response = await executionsClient.GetExecutionAsync(name);

GetExecutionAsync(ExecutionName, CancellationToken)

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

// Create client
ExecutionsClient executionsClient = await ExecutionsClient.CreateAsync();
// Initialize request argument(s)
ExecutionName name = ExecutionName.FromProjectLocationWorkflowExecution("[PROJECT]", "[LOCATION]", "[WORKFLOW]", "[EXECUTION]");
// Make the request
Execution response = await executionsClient.GetExecutionAsync(name);

GetExecutionAsync(GetExecutionRequest, CallSettings)

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

// Create client
ExecutionsClient executionsClient = await ExecutionsClient.CreateAsync();
// Initialize request argument(s)
GetExecutionRequest request = new GetExecutionRequest
{
    ExecutionName = ExecutionName.FromProjectLocationWorkflowExecution("[PROJECT]", "[LOCATION]", "[WORKFLOW]", "[EXECUTION]"),
    View = ExecutionView.Unspecified,
};
// Make the request
Execution response = await executionsClient.GetExecutionAsync(request);

GetExecutionAsync(GetExecutionRequest, CancellationToken)

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

// Create client
ExecutionsClient executionsClient = await ExecutionsClient.CreateAsync();
// Initialize request argument(s)
GetExecutionRequest request = new GetExecutionRequest
{
    ExecutionName = ExecutionName.FromProjectLocationWorkflowExecution("[PROJECT]", "[LOCATION]", "[WORKFLOW]", "[EXECUTION]"),
    View = ExecutionView.Unspecified,
};
// Make the request
Execution response = await executionsClient.GetExecutionAsync(request);

GetExecutionAsync(String, CallSettings)

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

// Create client
ExecutionsClient executionsClient = await ExecutionsClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/workflows/[WORKFLOW]/executions/[EXECUTION]";
// Make the request
Execution response = await executionsClient.GetExecutionAsync(name);

GetExecutionAsync(String, CancellationToken)

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

// Create client
ExecutionsClient executionsClient = await ExecutionsClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/workflows/[WORKFLOW]/executions/[EXECUTION]";
// Make the request
Execution response = await executionsClient.GetExecutionAsync(name);

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

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

// Create client
ExecutionsClient executionsClient = ExecutionsClient.Create();
// Initialize request argument(s)
WorkflowName parent = WorkflowName.FromProjectLocationWorkflow("[PROJECT]", "[LOCATION]", "[WORKFLOW]");
// Make the request
PagedEnumerable<ListExecutionsResponse, Execution> response = executionsClient.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(ListExecutionsRequest, CallSettings)

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

// Create client
ExecutionsClient executionsClient = ExecutionsClient.Create();
// Initialize request argument(s)
ListExecutionsRequest request = new ListExecutionsRequest
{
    ParentAsWorkflowName = WorkflowName.FromProjectLocationWorkflow("[PROJECT]", "[LOCATION]", "[WORKFLOW]"),
    View = ExecutionView.Unspecified,
};
// Make the request
PagedEnumerable<ListExecutionsResponse, Execution> response = executionsClient.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(String, String, Nullable<Int32>, CallSettings)

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

// Create client
ExecutionsClient executionsClient = ExecutionsClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/workflows/[WORKFLOW]";
// Make the request
PagedEnumerable<ListExecutionsResponse, Execution> response = executionsClient.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(WorkflowName, String, Nullable<Int32>, CallSettings)

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

// Create client
ExecutionsClient executionsClient = await ExecutionsClient.CreateAsync();
// Initialize request argument(s)
WorkflowName parent = WorkflowName.FromProjectLocationWorkflow("[PROJECT]", "[LOCATION]", "[WORKFLOW]");
// Make the request
PagedAsyncEnumerable<ListExecutionsResponse, Execution> response = executionsClient.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(ListExecutionsRequest, CallSettings)

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

// Create client
ExecutionsClient executionsClient = await ExecutionsClient.CreateAsync();
// Initialize request argument(s)
ListExecutionsRequest request = new ListExecutionsRequest
{
    ParentAsWorkflowName = WorkflowName.FromProjectLocationWorkflow("[PROJECT]", "[LOCATION]", "[WORKFLOW]"),
    View = ExecutionView.Unspecified,
};
// Make the request
PagedAsyncEnumerable<ListExecutionsResponse, Execution> response = executionsClient.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(String, String, Nullable<Int32>, CallSettings)

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

// Create client
ExecutionsClient executionsClient = await ExecutionsClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/workflows/[WORKFLOW]";
// Make the request
PagedAsyncEnumerable<ListExecutionsResponse, Execution> response = executionsClient.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;

ShutdownDefaultChannelsAsync()

public static Task ShutdownDefaultChannelsAsync()