Cloud Pub/Sub v1 API - Class SchemaServiceClient (3.19.0)

Version latest

• 3.19.0 (latest)
• 3.18.0
• 3.17.0
• 3.16.0
• 3.15.0
• 3.14.0
• 3.13.0
• 3.12.0
• 3.11.0
• 3.10.1
• 3.9.1
• 3.8.0
• 3.7.0
• 3.6.0
• 3.5.1
• 3.4.0
• 3.3.0
• 3.2.0
• 3.1.0
• 3.0.0
• 2.10.0
• 2.9.0
• 2.8.0
• 2.7.0
• 2.6.0
• 2.5.0
• 2.4.0
• 2.3.0

public abstract class SchemaServiceClient

Reference documentation and code samples for the Cloud Pub/Sub v1 API class SchemaServiceClient.

SchemaService client wrapper, for convenient use.

Inheritance

object > SchemaServiceClient

Inherited Members

object.GetHashCode()

object.GetType()

object.MemberwiseClone()

object.ToString()

Derived Types

SchemaServiceClientImpl

Namespace

Google.Cloud.PubSub.V1

Assembly

Google.Cloud.PubSub.V1.dll

Remarks

Service for doing schema-related operations.

Properties

DefaultEndpoint

public static string DefaultEndpoint { get; }

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

Property Value
Type	Description
string

DefaultScopes

public static IReadOnlyList<string> DefaultScopes { get; }

The default SchemaService scopes.

Property Value
Type	Description
IReadOnlyListstring

Remarks

The default SchemaService scopes are:

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

GrpcClient

public virtual SchemaService.SchemaServiceClient GrpcClient { get; }

The underlying gRPC SchemaService client

Property Value
Type	Description
SchemaServiceSchemaServiceClient

IAMPolicyClient

public virtual IAMPolicyClient IAMPolicyClient { get; }

The IAMPolicyClient associated with this client.

Property Value
Type	Description
IAMPolicyClient

ServiceMetadata

public static ServiceMetadata ServiceMetadata { get; }

The service metadata associated with this client type.

Property Value
Type	Description
ServiceMetadata

Methods

CommitSchema(CommitSchemaRequest, CallSettings)

public virtual Schema CommitSchema(CommitSchemaRequest request, CallSettings callSettings = null)

Commits a new schema revision to an existing schema.

Parameters
Name	Description
request	CommitSchemaRequest 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
Schema	The RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
// Initialize request argument(s)
CommitSchemaRequest request = new CommitSchemaRequest
{
    SchemaName = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]"),
    Schema = new Schema(),
};
// Make the request
Schema response = schemaServiceClient.CommitSchema(request);

CommitSchema(SchemaName, Schema, CallSettings)

public virtual Schema CommitSchema(SchemaName name, Schema schema, CallSettings callSettings = null)

Commits a new schema revision to an existing schema.

Parameters
Name	Description
name	SchemaName Required. The name of the schema we are revising. Format is projects/{project}/schemas/{schema}.
schema	Schema Required. The schema revision to commit.
callSettings	CallSettings If not null, applies overrides to this RPC call.

Returns
Type	Description
Schema	The RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
// Initialize request argument(s)
SchemaName name = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]");
Schema schema = new Schema();
// Make the request
Schema response = schemaServiceClient.CommitSchema(name, schema);

CommitSchema(string, Schema, CallSettings)

public virtual Schema CommitSchema(string name, Schema schema, CallSettings callSettings = null)

Commits a new schema revision to an existing schema.

Parameters
Name	Description
name	string Required. The name of the schema we are revising. Format is projects/{project}/schemas/{schema}.
schema	Schema Required. The schema revision to commit.
callSettings	CallSettings If not null, applies overrides to this RPC call.

Returns
Type	Description
Schema	The RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/schemas/[SCHEMA]";
Schema schema = new Schema();
// Make the request
Schema response = schemaServiceClient.CommitSchema(name, schema);

CommitSchemaAsync(CommitSchemaRequest, CallSettings)

public virtual Task<Schema> CommitSchemaAsync(CommitSchemaRequest request, CallSettings callSettings = null)

Commits a new schema revision to an existing schema.

Parameters
Name	Description
request	CommitSchemaRequest 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
TaskSchema	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
CommitSchemaRequest request = new CommitSchemaRequest
{
    SchemaName = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]"),
    Schema = new Schema(),
};
// Make the request
Schema response = await schemaServiceClient.CommitSchemaAsync(request);

CommitSchemaAsync(CommitSchemaRequest, CancellationToken)

public virtual Task<Schema> CommitSchemaAsync(CommitSchemaRequest request, CancellationToken cancellationToken)

Commits a new schema revision to an existing schema.

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

Returns
Type	Description
TaskSchema	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
CommitSchemaRequest request = new CommitSchemaRequest
{
    SchemaName = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]"),
    Schema = new Schema(),
};
// Make the request
Schema response = await schemaServiceClient.CommitSchemaAsync(request);

CommitSchemaAsync(SchemaName, Schema, CallSettings)

public virtual Task<Schema> CommitSchemaAsync(SchemaName name, Schema schema, CallSettings callSettings = null)

Commits a new schema revision to an existing schema.

Parameters
Name	Description
name	SchemaName Required. The name of the schema we are revising. Format is projects/{project}/schemas/{schema}.
schema	Schema Required. The schema revision to commit.
callSettings	CallSettings If not null, applies overrides to this RPC call.

Returns
Type	Description
TaskSchema	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
SchemaName name = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]");
Schema schema = new Schema();
// Make the request
Schema response = await schemaServiceClient.CommitSchemaAsync(name, schema);

CommitSchemaAsync(SchemaName, Schema, CancellationToken)

public virtual Task<Schema> CommitSchemaAsync(SchemaName name, Schema schema, CancellationToken cancellationToken)

Commits a new schema revision to an existing schema.

Parameters
Name	Description
name	SchemaName Required. The name of the schema we are revising. Format is projects/{project}/schemas/{schema}.
schema	Schema Required. The schema revision to commit.
cancellationToken	CancellationToken A CancellationToken to use for this RPC.

Returns
Type	Description
TaskSchema	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
SchemaName name = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]");
Schema schema = new Schema();
// Make the request
Schema response = await schemaServiceClient.CommitSchemaAsync(name, schema);

CommitSchemaAsync(string, Schema, CallSettings)

public virtual Task<Schema> CommitSchemaAsync(string name, Schema schema, CallSettings callSettings = null)

Commits a new schema revision to an existing schema.

Parameters
Name	Description
name	string Required. The name of the schema we are revising. Format is projects/{project}/schemas/{schema}.
schema	Schema Required. The schema revision to commit.
callSettings	CallSettings If not null, applies overrides to this RPC call.

Returns
Type	Description
TaskSchema	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/schemas/[SCHEMA]";
Schema schema = new Schema();
// Make the request
Schema response = await schemaServiceClient.CommitSchemaAsync(name, schema);

CommitSchemaAsync(string, Schema, CancellationToken)

public virtual Task<Schema> CommitSchemaAsync(string name, Schema schema, CancellationToken cancellationToken)

Commits a new schema revision to an existing schema.

Parameters
Name	Description
name	string Required. The name of the schema we are revising. Format is projects/{project}/schemas/{schema}.
schema	Schema Required. The schema revision to commit.
cancellationToken	CancellationToken A CancellationToken to use for this RPC.

Returns
Type	Description
TaskSchema	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/schemas/[SCHEMA]";
Schema schema = new Schema();
// Make the request
Schema response = await schemaServiceClient.CommitSchemaAsync(name, schema);

Create()

public static SchemaServiceClient Create()

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

Returns
Type	Description
SchemaServiceClient	The created SchemaServiceClient.

CreateAsync(CancellationToken)

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

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

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

Returns
Type	Description
TaskSchemaServiceClient	The task representing the created SchemaServiceClient.

CreateSchema(ProjectName, Schema, string, CallSettings)

public virtual Schema CreateSchema(ProjectName parent, Schema schema, string schemaId, CallSettings callSettings = null)

Creates a schema.

Parameters
Name	Description
parent	ProjectName Required. The name of the project in which to create the schema. Format is projects/{project-id}.
schema	Schema Required. The schema object to create. This schema's name parameter is ignored. The schema object returned by CreateSchema will have a name made using the given parent and schema_id.
schemaId	string The ID to use for the schema, which will become the final component of the schema's resource name. See https://cloud.google.com/pubsub/docs/pubsub-basics#resource_names for resource name constraints.
callSettings	CallSettings If not null, applies overrides to this RPC call.

Returns
Type	Description
Schema	The RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
// Initialize request argument(s)
ProjectName parent = ProjectName.FromProject("[PROJECT]");
Schema schema = new Schema();
string schemaId = "";
// Make the request
Schema response = schemaServiceClient.CreateSchema(parent, schema, schemaId);

CreateSchema(CreateSchemaRequest, CallSettings)

public virtual Schema CreateSchema(CreateSchemaRequest request, CallSettings callSettings = null)

Creates a schema.

Parameters
Name	Description
request	CreateSchemaRequest 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
Schema	The RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
// Initialize request argument(s)
CreateSchemaRequest request = new CreateSchemaRequest
{
    ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
    Schema = new Schema(),
    SchemaId = "",
};
// Make the request
Schema response = schemaServiceClient.CreateSchema(request);

CreateSchema(string, Schema, string, CallSettings)

public virtual Schema CreateSchema(string parent, Schema schema, string schemaId, CallSettings callSettings = null)

Creates a schema.

Parameters
Name	Description
parent	string Required. The name of the project in which to create the schema. Format is projects/{project-id}.
schema	Schema Required. The schema object to create. This schema's name parameter is ignored. The schema object returned by CreateSchema will have a name made using the given parent and schema_id.
schemaId	string The ID to use for the schema, which will become the final component of the schema's resource name. See https://cloud.google.com/pubsub/docs/pubsub-basics#resource_names for resource name constraints.
callSettings	CallSettings If not null, applies overrides to this RPC call.

Returns
Type	Description
Schema	The RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]";
Schema schema = new Schema();
string schemaId = "";
// Make the request
Schema response = schemaServiceClient.CreateSchema(parent, schema, schemaId);

CreateSchemaAsync(ProjectName, Schema, string, CallSettings)

public virtual Task<Schema> CreateSchemaAsync(ProjectName parent, Schema schema, string schemaId, CallSettings callSettings = null)

Creates a schema.

Parameters
Name	Description
parent	ProjectName Required. The name of the project in which to create the schema. Format is projects/{project-id}.
schema	Schema Required. The schema object to create. This schema's name parameter is ignored. The schema object returned by CreateSchema will have a name made using the given parent and schema_id.
schemaId	string The ID to use for the schema, which will become the final component of the schema's resource name. See https://cloud.google.com/pubsub/docs/pubsub-basics#resource_names for resource name constraints.
callSettings	CallSettings If not null, applies overrides to this RPC call.

Returns
Type	Description
TaskSchema	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
ProjectName parent = ProjectName.FromProject("[PROJECT]");
Schema schema = new Schema();
string schemaId = "";
// Make the request
Schema response = await schemaServiceClient.CreateSchemaAsync(parent, schema, schemaId);

CreateSchemaAsync(ProjectName, Schema, string, CancellationToken)

public virtual Task<Schema> CreateSchemaAsync(ProjectName parent, Schema schema, string schemaId, CancellationToken cancellationToken)

Creates a schema.

Parameters
Name	Description
parent	ProjectName Required. The name of the project in which to create the schema. Format is projects/{project-id}.
schema	Schema Required. The schema object to create. This schema's name parameter is ignored. The schema object returned by CreateSchema will have a name made using the given parent and schema_id.
schemaId	string The ID to use for the schema, which will become the final component of the schema's resource name. See https://cloud.google.com/pubsub/docs/pubsub-basics#resource_names for resource name constraints.
cancellationToken	CancellationToken A CancellationToken to use for this RPC.

Returns
Type	Description
TaskSchema	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
ProjectName parent = ProjectName.FromProject("[PROJECT]");
Schema schema = new Schema();
string schemaId = "";
// Make the request
Schema response = await schemaServiceClient.CreateSchemaAsync(parent, schema, schemaId);

CreateSchemaAsync(CreateSchemaRequest, CallSettings)

public virtual Task<Schema> CreateSchemaAsync(CreateSchemaRequest request, CallSettings callSettings = null)

Creates a schema.

Parameters
Name	Description
request	CreateSchemaRequest 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
TaskSchema	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
CreateSchemaRequest request = new CreateSchemaRequest
{
    ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
    Schema = new Schema(),
    SchemaId = "",
};
// Make the request
Schema response = await schemaServiceClient.CreateSchemaAsync(request);

CreateSchemaAsync(CreateSchemaRequest, CancellationToken)

public virtual Task<Schema> CreateSchemaAsync(CreateSchemaRequest request, CancellationToken cancellationToken)

Creates a schema.

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

Returns
Type	Description
TaskSchema	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
CreateSchemaRequest request = new CreateSchemaRequest
{
    ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
    Schema = new Schema(),
    SchemaId = "",
};
// Make the request
Schema response = await schemaServiceClient.CreateSchemaAsync(request);

CreateSchemaAsync(string, Schema, string, CallSettings)

public virtual Task<Schema> CreateSchemaAsync(string parent, Schema schema, string schemaId, CallSettings callSettings = null)

Creates a schema.

Parameters
Name	Description
parent	string Required. The name of the project in which to create the schema. Format is projects/{project-id}.
schema	Schema Required. The schema object to create. This schema's name parameter is ignored. The schema object returned by CreateSchema will have a name made using the given parent and schema_id.
schemaId	string The ID to use for the schema, which will become the final component of the schema's resource name. See https://cloud.google.com/pubsub/docs/pubsub-basics#resource_names for resource name constraints.
callSettings	CallSettings If not null, applies overrides to this RPC call.

Returns
Type	Description
TaskSchema	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]";
Schema schema = new Schema();
string schemaId = "";
// Make the request
Schema response = await schemaServiceClient.CreateSchemaAsync(parent, schema, schemaId);

CreateSchemaAsync(string, Schema, string, CancellationToken)

public virtual Task<Schema> CreateSchemaAsync(string parent, Schema schema, string schemaId, CancellationToken cancellationToken)

Creates a schema.

Parameters
Name	Description
parent	string Required. The name of the project in which to create the schema. Format is projects/{project-id}.
schema	Schema Required. The schema object to create. This schema's name parameter is ignored. The schema object returned by CreateSchema will have a name made using the given parent and schema_id.
schemaId	string The ID to use for the schema, which will become the final component of the schema's resource name. See https://cloud.google.com/pubsub/docs/pubsub-basics#resource_names for resource name constraints.
cancellationToken	CancellationToken A CancellationToken to use for this RPC.

Returns
Type	Description
TaskSchema	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]";
Schema schema = new Schema();
string schemaId = "";
// Make the request
Schema response = await schemaServiceClient.CreateSchemaAsync(parent, schema, schemaId);

DeleteSchema(DeleteSchemaRequest, CallSettings)

public virtual void DeleteSchema(DeleteSchemaRequest request, CallSettings callSettings = null)

Deletes a schema.

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

Example

// Create client
SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
// Initialize request argument(s)
DeleteSchemaRequest request = new DeleteSchemaRequest
{
    SchemaName = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]"),
};
// Make the request
schemaServiceClient.DeleteSchema(request);

DeleteSchema(SchemaName, CallSettings)

public virtual void DeleteSchema(SchemaName name, CallSettings callSettings = null)

Deletes a schema.

Parameters
Name	Description
name	SchemaName Required. Name of the schema to delete. Format is projects/{project}/schemas/{schema}.
callSettings	CallSettings If not null, applies overrides to this RPC call.

Example

// Create client
SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
// Initialize request argument(s)
SchemaName name = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]");
// Make the request
schemaServiceClient.DeleteSchema(name);

DeleteSchema(string, CallSettings)

public virtual void DeleteSchema(string name, CallSettings callSettings = null)

Deletes a schema.

Parameters
Name	Description
name	string Required. Name of the schema to delete. Format is projects/{project}/schemas/{schema}.
callSettings	CallSettings If not null, applies overrides to this RPC call.

Example

// Create client
SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/schemas/[SCHEMA]";
// Make the request
schemaServiceClient.DeleteSchema(name);

DeleteSchemaAsync(DeleteSchemaRequest, CallSettings)

public virtual Task DeleteSchemaAsync(DeleteSchemaRequest request, CallSettings callSettings = null)

Deletes a schema.

Parameters
Name	Description
request	DeleteSchemaRequest 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	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteSchemaRequest request = new DeleteSchemaRequest
{
    SchemaName = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]"),
};
// Make the request
await schemaServiceClient.DeleteSchemaAsync(request);

DeleteSchemaAsync(DeleteSchemaRequest, CancellationToken)

public virtual Task DeleteSchemaAsync(DeleteSchemaRequest request, CancellationToken cancellationToken)

Deletes a schema.

Parameters
Name	Description
request	DeleteSchemaRequest 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	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteSchemaRequest request = new DeleteSchemaRequest
{
    SchemaName = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]"),
};
// Make the request
await schemaServiceClient.DeleteSchemaAsync(request);

DeleteSchemaAsync(SchemaName, CallSettings)

public virtual Task DeleteSchemaAsync(SchemaName name, CallSettings callSettings = null)

Deletes a schema.

Parameters
Name	Description
name	SchemaName Required. Name of the schema to delete. Format is projects/{project}/schemas/{schema}.
callSettings	CallSettings If not null, applies overrides to this RPC call.

Returns
Type	Description
Task	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
SchemaName name = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]");
// Make the request
await schemaServiceClient.DeleteSchemaAsync(name);

DeleteSchemaAsync(SchemaName, CancellationToken)

public virtual Task DeleteSchemaAsync(SchemaName name, CancellationToken cancellationToken)

Deletes a schema.

Parameters
Name	Description
name	SchemaName Required. Name of the schema to delete. Format is projects/{project}/schemas/{schema}.
cancellationToken	CancellationToken A CancellationToken to use for this RPC.

Returns
Type	Description
Task	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
SchemaName name = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]");
// Make the request
await schemaServiceClient.DeleteSchemaAsync(name);

DeleteSchemaAsync(string, CallSettings)

public virtual Task DeleteSchemaAsync(string name, CallSettings callSettings = null)

Deletes a schema.

Parameters
Name	Description
name	string Required. Name of the schema to delete. Format is projects/{project}/schemas/{schema}.
callSettings	CallSettings If not null, applies overrides to this RPC call.

Returns
Type	Description
Task	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/schemas/[SCHEMA]";
// Make the request
await schemaServiceClient.DeleteSchemaAsync(name);

DeleteSchemaAsync(string, CancellationToken)

public virtual Task DeleteSchemaAsync(string name, CancellationToken cancellationToken)

Deletes a schema.

Parameters
Name	Description
name	string Required. Name of the schema to delete. Format is projects/{project}/schemas/{schema}.
cancellationToken	CancellationToken A CancellationToken to use for this RPC.

Returns
Type	Description
Task	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/schemas/[SCHEMA]";
// Make the request
await schemaServiceClient.DeleteSchemaAsync(name);

DeleteSchemaRevision(DeleteSchemaRevisionRequest, CallSettings)

public virtual Schema DeleteSchemaRevision(DeleteSchemaRevisionRequest request, CallSettings callSettings = null)

Deletes a specific schema revision.

Parameters
Name	Description
request	DeleteSchemaRevisionRequest 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
Schema	The RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
// Initialize request argument(s)
DeleteSchemaRevisionRequest request = new DeleteSchemaRevisionRequest
{
    SchemaName = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]"),
};
// Make the request
Schema response = schemaServiceClient.DeleteSchemaRevision(request);

DeleteSchemaRevision(SchemaName, string, CallSettings)

[Obsolete]
public virtual Schema DeleteSchemaRevision(SchemaName name, string revisionId, CallSettings callSettings = null)

Deletes a specific schema revision.

Parameters
Name	Description
name	SchemaName Required. The name of the schema revision to be deleted, with a revision ID explicitly included. Example: projects/123/schemas/my-schema@c7cfa2a8
revisionId	string Optional. This field is deprecated and should not be used for specifying the revision ID. The revision ID should be specified via the name parameter.
callSettings	CallSettings If not null, applies overrides to this RPC call.

Returns
Type	Description
Schema	The RPC response.

Example

            // Create client
            SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
            // Initialize request argument(s)
            SchemaName name = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]");
            string revisionId = "";
            // Make the request
#pragma warning disable CS0612
            Schema response = schemaServiceClient.DeleteSchemaRevision(name, revisionId);
#pragma warning restore CS0612

DeleteSchemaRevision(string, string, CallSettings)

[Obsolete]
public virtual Schema DeleteSchemaRevision(string name, string revisionId, CallSettings callSettings = null)

Deletes a specific schema revision.

Parameters
Name	Description
name	string Required. The name of the schema revision to be deleted, with a revision ID explicitly included. Example: projects/123/schemas/my-schema@c7cfa2a8
revisionId	string Optional. This field is deprecated and should not be used for specifying the revision ID. The revision ID should be specified via the name parameter.
callSettings	CallSettings If not null, applies overrides to this RPC call.

Returns
Type	Description
Schema	The RPC response.

Example

            // Create client
            SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
            // Initialize request argument(s)
            string name = "projects/[PROJECT]/schemas/[SCHEMA]";
            string revisionId = "";
            // Make the request
#pragma warning disable CS0612
            Schema response = schemaServiceClient.DeleteSchemaRevision(name, revisionId);
#pragma warning restore CS0612

DeleteSchemaRevisionAsync(DeleteSchemaRevisionRequest, CallSettings)

public virtual Task<Schema> DeleteSchemaRevisionAsync(DeleteSchemaRevisionRequest request, CallSettings callSettings = null)

Deletes a specific schema revision.

Parameters
Name	Description
request	DeleteSchemaRevisionRequest 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
TaskSchema	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteSchemaRevisionRequest request = new DeleteSchemaRevisionRequest
{
    SchemaName = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]"),
};
// Make the request
Schema response = await schemaServiceClient.DeleteSchemaRevisionAsync(request);

DeleteSchemaRevisionAsync(DeleteSchemaRevisionRequest, CancellationToken)

public virtual Task<Schema> DeleteSchemaRevisionAsync(DeleteSchemaRevisionRequest request, CancellationToken cancellationToken)

Deletes a specific schema revision.

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

Returns
Type	Description
TaskSchema	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteSchemaRevisionRequest request = new DeleteSchemaRevisionRequest
{
    SchemaName = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]"),
};
// Make the request
Schema response = await schemaServiceClient.DeleteSchemaRevisionAsync(request);

DeleteSchemaRevisionAsync(SchemaName, string, CallSettings)

[Obsolete]
public virtual Task<Schema> DeleteSchemaRevisionAsync(SchemaName name, string revisionId, CallSettings callSettings = null)

Deletes a specific schema revision.

Parameters
Name	Description
name	SchemaName Required. The name of the schema revision to be deleted, with a revision ID explicitly included. Example: projects/123/schemas/my-schema@c7cfa2a8
revisionId	string Optional. This field is deprecated and should not be used for specifying the revision ID. The revision ID should be specified via the name parameter.
callSettings	CallSettings If not null, applies overrides to this RPC call.

Returns
Type	Description
TaskSchema	A Task containing the RPC response.

Example

            // Create client
            SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
            // Initialize request argument(s)
            SchemaName name = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]");
            string revisionId = "";
            // Make the request
#pragma warning disable CS0612
            Schema response = await schemaServiceClient.DeleteSchemaRevisionAsync(name, revisionId);
#pragma warning restore CS0612

DeleteSchemaRevisionAsync(SchemaName, string, CancellationToken)

[Obsolete]
public virtual Task<Schema> DeleteSchemaRevisionAsync(SchemaName name, string revisionId, CancellationToken cancellationToken)

Deletes a specific schema revision.

Parameters
Name	Description
name	SchemaName Required. The name of the schema revision to be deleted, with a revision ID explicitly included. Example: projects/123/schemas/my-schema@c7cfa2a8
revisionId	string Optional. This field is deprecated and should not be used for specifying the revision ID. The revision ID should be specified via the name parameter.
cancellationToken	CancellationToken A CancellationToken to use for this RPC.

Returns
Type	Description
TaskSchema	A Task containing the RPC response.

Example

            // Create client
            SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
            // Initialize request argument(s)
            SchemaName name = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]");
            string revisionId = "";
            // Make the request
#pragma warning disable CS0612
            Schema response = await schemaServiceClient.DeleteSchemaRevisionAsync(name, revisionId);
#pragma warning restore CS0612

DeleteSchemaRevisionAsync(string, string, CallSettings)

[Obsolete]
public virtual Task<Schema> DeleteSchemaRevisionAsync(string name, string revisionId, CallSettings callSettings = null)

Deletes a specific schema revision.

Parameters
Name	Description
name	string Required. The name of the schema revision to be deleted, with a revision ID explicitly included. Example: projects/123/schemas/my-schema@c7cfa2a8
revisionId	string Optional. This field is deprecated and should not be used for specifying the revision ID. The revision ID should be specified via the name parameter.
callSettings	CallSettings If not null, applies overrides to this RPC call.

Returns
Type	Description
TaskSchema	A Task containing the RPC response.

Example

            // Create client
            SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
            // Initialize request argument(s)
            string name = "projects/[PROJECT]/schemas/[SCHEMA]";
            string revisionId = "";
            // Make the request
#pragma warning disable CS0612
            Schema response = await schemaServiceClient.DeleteSchemaRevisionAsync(name, revisionId);
#pragma warning restore CS0612

DeleteSchemaRevisionAsync(string, string, CancellationToken)

[Obsolete]
public virtual Task<Schema> DeleteSchemaRevisionAsync(string name, string revisionId, CancellationToken cancellationToken)

Deletes a specific schema revision.

Parameters
Name	Description
name	string Required. The name of the schema revision to be deleted, with a revision ID explicitly included. Example: projects/123/schemas/my-schema@c7cfa2a8
revisionId	string Optional. This field is deprecated and should not be used for specifying the revision ID. The revision ID should be specified via the name parameter.
cancellationToken	CancellationToken A CancellationToken to use for this RPC.

Returns
Type	Description
TaskSchema	A Task containing the RPC response.

Example

            // Create client
            SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
            // Initialize request argument(s)
            string name = "projects/[PROJECT]/schemas/[SCHEMA]";
            string revisionId = "";
            // Make the request
#pragma warning disable CS0612
            Schema response = await schemaServiceClient.DeleteSchemaRevisionAsync(name, revisionId);
#pragma warning restore CS0612

GetSchema(GetSchemaRequest, CallSettings)

public virtual Schema GetSchema(GetSchemaRequest request, CallSettings callSettings = null)

Gets a schema.

Parameters
Name	Description
request	GetSchemaRequest 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
Schema	The RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
// Initialize request argument(s)
GetSchemaRequest request = new GetSchemaRequest
{
    SchemaName = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]"),
    View = SchemaView.Unspecified,
};
// Make the request
Schema response = schemaServiceClient.GetSchema(request);

GetSchema(SchemaName, CallSettings)

public virtual Schema GetSchema(SchemaName name, CallSettings callSettings = null)

Gets a schema.

Parameters
Name	Description
name	SchemaName Required. The name of the schema to get. Format is projects/{project}/schemas/{schema}.
callSettings	CallSettings If not null, applies overrides to this RPC call.

Returns
Type	Description
Schema	The RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
// Initialize request argument(s)
SchemaName name = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]");
// Make the request
Schema response = schemaServiceClient.GetSchema(name);

GetSchema(string, CallSettings)

public virtual Schema GetSchema(string name, CallSettings callSettings = null)

Gets a schema.

Parameters
Name	Description
name	string Required. The name of the schema to get. Format is projects/{project}/schemas/{schema}.
callSettings	CallSettings If not null, applies overrides to this RPC call.

Returns
Type	Description
Schema	The RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/schemas/[SCHEMA]";
// Make the request
Schema response = schemaServiceClient.GetSchema(name);

GetSchemaAsync(GetSchemaRequest, CallSettings)

public virtual Task<Schema> GetSchemaAsync(GetSchemaRequest request, CallSettings callSettings = null)

Gets a schema.

Parameters
Name	Description
request	GetSchemaRequest 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
TaskSchema	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
GetSchemaRequest request = new GetSchemaRequest
{
    SchemaName = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]"),
    View = SchemaView.Unspecified,
};
// Make the request
Schema response = await schemaServiceClient.GetSchemaAsync(request);

GetSchemaAsync(GetSchemaRequest, CancellationToken)

public virtual Task<Schema> GetSchemaAsync(GetSchemaRequest request, CancellationToken cancellationToken)

Gets a schema.

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

Returns
Type	Description
TaskSchema	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
GetSchemaRequest request = new GetSchemaRequest
{
    SchemaName = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]"),
    View = SchemaView.Unspecified,
};
// Make the request
Schema response = await schemaServiceClient.GetSchemaAsync(request);

GetSchemaAsync(SchemaName, CallSettings)

public virtual Task<Schema> GetSchemaAsync(SchemaName name, CallSettings callSettings = null)

Gets a schema.

Parameters
Name	Description
name	SchemaName Required. The name of the schema to get. Format is projects/{project}/schemas/{schema}.
callSettings	CallSettings If not null, applies overrides to this RPC call.

Returns
Type	Description
TaskSchema	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
SchemaName name = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]");
// Make the request
Schema response = await schemaServiceClient.GetSchemaAsync(name);

GetSchemaAsync(SchemaName, CancellationToken)

public virtual Task<Schema> GetSchemaAsync(SchemaName name, CancellationToken cancellationToken)

Gets a schema.

Parameters
Name	Description
name	SchemaName Required. The name of the schema to get. Format is projects/{project}/schemas/{schema}.
cancellationToken	CancellationToken A CancellationToken to use for this RPC.

Returns
Type	Description
TaskSchema	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
SchemaName name = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]");
// Make the request
Schema response = await schemaServiceClient.GetSchemaAsync(name);

GetSchemaAsync(string, CallSettings)

public virtual Task<Schema> GetSchemaAsync(string name, CallSettings callSettings = null)

Gets a schema.

Parameters
Name	Description
name	string Required. The name of the schema to get. Format is projects/{project}/schemas/{schema}.
callSettings	CallSettings If not null, applies overrides to this RPC call.

Returns
Type	Description
TaskSchema	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/schemas/[SCHEMA]";
// Make the request
Schema response = await schemaServiceClient.GetSchemaAsync(name);

GetSchemaAsync(string, CancellationToken)

public virtual Task<Schema> GetSchemaAsync(string name, CancellationToken cancellationToken)

Gets a schema.

Parameters
Name	Description
name	string Required. The name of the schema to get. Format is projects/{project}/schemas/{schema}.
cancellationToken	CancellationToken A CancellationToken to use for this RPC.

Returns
Type	Description
TaskSchema	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/schemas/[SCHEMA]";
// Make the request
Schema response = await schemaServiceClient.GetSchemaAsync(name);

ListSchemaRevisions(ListSchemaRevisionsRequest, CallSettings)

public virtual PagedEnumerable<ListSchemaRevisionsResponse, Schema> ListSchemaRevisions(ListSchemaRevisionsRequest request, CallSettings callSettings = null)

Lists all schema revisions for the named schema.

Parameters
Name	Description
request	ListSchemaRevisionsRequest 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
PagedEnumerableListSchemaRevisionsResponseSchema	A pageable sequence of Schema resources.

Example

// Create client
SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
// Initialize request argument(s)
ListSchemaRevisionsRequest request = new ListSchemaRevisionsRequest
{
    SchemaName = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]"),
    View = SchemaView.Unspecified,
};
// Make the request
PagedEnumerable<ListSchemaRevisionsResponse, Schema> response = schemaServiceClient.ListSchemaRevisions(request);

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

ListSchemaRevisions(SchemaName, string, int?, CallSettings)

public virtual PagedEnumerable<ListSchemaRevisionsResponse, Schema> ListSchemaRevisions(SchemaName name, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists all schema revisions for the named schema.

Parameters
Name	Description
name	SchemaName Required. The name of the schema to list revisions for.
pageToken	string The token returned from the previous request. A value of null or an empty string retrieves the first page.
pageSize	int 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
PagedEnumerableListSchemaRevisionsResponseSchema	A pageable sequence of Schema resources.

Example

// Create client
SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
// Initialize request argument(s)
SchemaName name = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]");
// Make the request
PagedEnumerable<ListSchemaRevisionsResponse, Schema> response = schemaServiceClient.ListSchemaRevisions(name);

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

ListSchemaRevisions(string, string, int?, CallSettings)

public virtual PagedEnumerable<ListSchemaRevisionsResponse, Schema> ListSchemaRevisions(string name, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists all schema revisions for the named schema.

Parameters
Name	Description
name	string Required. The name of the schema to list revisions for.
pageToken	string The token returned from the previous request. A value of null or an empty string retrieves the first page.
pageSize	int 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
PagedEnumerableListSchemaRevisionsResponseSchema	A pageable sequence of Schema resources.

Example

// Create client
SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/schemas/[SCHEMA]";
// Make the request
PagedEnumerable<ListSchemaRevisionsResponse, Schema> response = schemaServiceClient.ListSchemaRevisions(name);

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

ListSchemaRevisionsAsync(ListSchemaRevisionsRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListSchemaRevisionsResponse, Schema> ListSchemaRevisionsAsync(ListSchemaRevisionsRequest request, CallSettings callSettings = null)

Lists all schema revisions for the named schema.

Parameters
Name	Description
request	ListSchemaRevisionsRequest 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
PagedAsyncEnumerableListSchemaRevisionsResponseSchema	A pageable asynchronous sequence of Schema resources.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
ListSchemaRevisionsRequest request = new ListSchemaRevisionsRequest
{
    SchemaName = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]"),
    View = SchemaView.Unspecified,
};
// Make the request
PagedAsyncEnumerable<ListSchemaRevisionsResponse, Schema> response = schemaServiceClient.ListSchemaRevisionsAsync(request);

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

ListSchemaRevisionsAsync(SchemaName, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListSchemaRevisionsResponse, Schema> ListSchemaRevisionsAsync(SchemaName name, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists all schema revisions for the named schema.

Parameters
Name	Description
name	SchemaName Required. The name of the schema to list revisions for.
pageToken	string The token returned from the previous request. A value of null or an empty string retrieves the first page.
pageSize	int 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
PagedAsyncEnumerableListSchemaRevisionsResponseSchema	A pageable asynchronous sequence of Schema resources.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
SchemaName name = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]");
// Make the request
PagedAsyncEnumerable<ListSchemaRevisionsResponse, Schema> response = schemaServiceClient.ListSchemaRevisionsAsync(name);

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

ListSchemaRevisionsAsync(string, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListSchemaRevisionsResponse, Schema> ListSchemaRevisionsAsync(string name, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists all schema revisions for the named schema.

Parameters
Name	Description
name	string Required. The name of the schema to list revisions for.
pageToken	string The token returned from the previous request. A value of null or an empty string retrieves the first page.
pageSize	int 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
PagedAsyncEnumerableListSchemaRevisionsResponseSchema	A pageable asynchronous sequence of Schema resources.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/schemas/[SCHEMA]";
// Make the request
PagedAsyncEnumerable<ListSchemaRevisionsResponse, Schema> response = schemaServiceClient.ListSchemaRevisionsAsync(name);

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

ListSchemas(ProjectName, string, int?, CallSettings)

public virtual PagedEnumerable<ListSchemasResponse, Schema> ListSchemas(ProjectName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists schemas in a project.

Parameters
Name	Description
parent	ProjectName Required. The name of the project in which to list schemas. Format is projects/{project-id}.
pageToken	string The token returned from the previous request. A value of null or an empty string retrieves the first page.
pageSize	int 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
PagedEnumerableListSchemasResponseSchema	A pageable sequence of Schema resources.

Example

// Create client
SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
// Initialize request argument(s)
ProjectName parent = ProjectName.FromProject("[PROJECT]");
// Make the request
PagedEnumerable<ListSchemasResponse, Schema> response = schemaServiceClient.ListSchemas(parent);

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

ListSchemas(ListSchemasRequest, CallSettings)

public virtual PagedEnumerable<ListSchemasResponse, Schema> ListSchemas(ListSchemasRequest request, CallSettings callSettings = null)

Lists schemas in a project.

Parameters
Name	Description
request	ListSchemasRequest 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
PagedEnumerableListSchemasResponseSchema	A pageable sequence of Schema resources.

Example

// Create client
SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
// Initialize request argument(s)
ListSchemasRequest request = new ListSchemasRequest
{
    ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
    View = SchemaView.Unspecified,
};
// Make the request
PagedEnumerable<ListSchemasResponse, Schema> response = schemaServiceClient.ListSchemas(request);

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

ListSchemas(string, string, int?, CallSettings)

public virtual PagedEnumerable<ListSchemasResponse, Schema> ListSchemas(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists schemas in a project.

Parameters
Name	Description
parent	string Required. The name of the project in which to list schemas. Format is projects/{project-id}.
pageToken	string The token returned from the previous request. A value of null or an empty string retrieves the first page.
pageSize	int 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
PagedEnumerableListSchemasResponseSchema	A pageable sequence of Schema resources.

Example

// Create client
SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]";
// Make the request
PagedEnumerable<ListSchemasResponse, Schema> response = schemaServiceClient.ListSchemas(parent);

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

ListSchemasAsync(ProjectName, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListSchemasResponse, Schema> ListSchemasAsync(ProjectName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists schemas in a project.

Parameters
Name	Description
parent	ProjectName Required. The name of the project in which to list schemas. Format is projects/{project-id}.
pageToken	string The token returned from the previous request. A value of null or an empty string retrieves the first page.
pageSize	int 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
PagedAsyncEnumerableListSchemasResponseSchema	A pageable asynchronous sequence of Schema resources.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
ProjectName parent = ProjectName.FromProject("[PROJECT]");
// Make the request
PagedAsyncEnumerable<ListSchemasResponse, Schema> response = schemaServiceClient.ListSchemasAsync(parent);

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

ListSchemasAsync(ListSchemasRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListSchemasResponse, Schema> ListSchemasAsync(ListSchemasRequest request, CallSettings callSettings = null)

Lists schemas in a project.

Parameters
Name	Description
request	ListSchemasRequest 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
PagedAsyncEnumerableListSchemasResponseSchema	A pageable asynchronous sequence of Schema resources.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
ListSchemasRequest request = new ListSchemasRequest
{
    ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
    View = SchemaView.Unspecified,
};
// Make the request
PagedAsyncEnumerable<ListSchemasResponse, Schema> response = schemaServiceClient.ListSchemasAsync(request);

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

ListSchemasAsync(string, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListSchemasResponse, Schema> ListSchemasAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists schemas in a project.

Parameters
Name	Description
parent	string Required. The name of the project in which to list schemas. Format is projects/{project-id}.
pageToken	string The token returned from the previous request. A value of null or an empty string retrieves the first page.
pageSize	int 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
PagedAsyncEnumerableListSchemasResponseSchema	A pageable asynchronous sequence of Schema resources.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]";
// Make the request
PagedAsyncEnumerable<ListSchemasResponse, Schema> response = schemaServiceClient.ListSchemasAsync(parent);

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

RollbackSchema(RollbackSchemaRequest, CallSettings)

public virtual Schema RollbackSchema(RollbackSchemaRequest request, CallSettings callSettings = null)

Creates a new schema revision that is a copy of the provided revision_id.

Parameters
Name	Description
request	RollbackSchemaRequest 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
Schema	The RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
// Initialize request argument(s)
RollbackSchemaRequest request = new RollbackSchemaRequest
{
    SchemaName = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]"),
    RevisionId = "",
};
// Make the request
Schema response = schemaServiceClient.RollbackSchema(request);

RollbackSchema(SchemaName, string, CallSettings)

public virtual Schema RollbackSchema(SchemaName name, string revisionId, CallSettings callSettings = null)

Creates a new schema revision that is a copy of the provided revision_id.

Parameters
Name	Description
name	SchemaName Required. The schema being rolled back with revision id.
revisionId	string Required. The revision ID to roll back to. It must be a revision of the same schema. Example: c7cfa2a8
callSettings	CallSettings If not null, applies overrides to this RPC call.

Returns
Type	Description
Schema	The RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
// Initialize request argument(s)
SchemaName name = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]");
string revisionId = "";
// Make the request
Schema response = schemaServiceClient.RollbackSchema(name, revisionId);

RollbackSchema(string, string, CallSettings)

public virtual Schema RollbackSchema(string name, string revisionId, CallSettings callSettings = null)

Creates a new schema revision that is a copy of the provided revision_id.

Parameters
Name	Description
name	string Required. The schema being rolled back with revision id.
revisionId	string Required. The revision ID to roll back to. It must be a revision of the same schema. Example: c7cfa2a8
callSettings	CallSettings If not null, applies overrides to this RPC call.

Returns
Type	Description
Schema	The RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/schemas/[SCHEMA]";
string revisionId = "";
// Make the request
Schema response = schemaServiceClient.RollbackSchema(name, revisionId);

RollbackSchemaAsync(RollbackSchemaRequest, CallSettings)

public virtual Task<Schema> RollbackSchemaAsync(RollbackSchemaRequest request, CallSettings callSettings = null)

Creates a new schema revision that is a copy of the provided revision_id.

Parameters
Name	Description
request	RollbackSchemaRequest 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
TaskSchema	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
RollbackSchemaRequest request = new RollbackSchemaRequest
{
    SchemaName = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]"),
    RevisionId = "",
};
// Make the request
Schema response = await schemaServiceClient.RollbackSchemaAsync(request);

RollbackSchemaAsync(RollbackSchemaRequest, CancellationToken)

public virtual Task<Schema> RollbackSchemaAsync(RollbackSchemaRequest request, CancellationToken cancellationToken)

Creates a new schema revision that is a copy of the provided revision_id.

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

Returns
Type	Description
TaskSchema	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
RollbackSchemaRequest request = new RollbackSchemaRequest
{
    SchemaName = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]"),
    RevisionId = "",
};
// Make the request
Schema response = await schemaServiceClient.RollbackSchemaAsync(request);

RollbackSchemaAsync(SchemaName, string, CallSettings)

public virtual Task<Schema> RollbackSchemaAsync(SchemaName name, string revisionId, CallSettings callSettings = null)

Creates a new schema revision that is a copy of the provided revision_id.

Parameters
Name	Description
name	SchemaName Required. The schema being rolled back with revision id.
revisionId	string Required. The revision ID to roll back to. It must be a revision of the same schema. Example: c7cfa2a8
callSettings	CallSettings If not null, applies overrides to this RPC call.

Returns
Type	Description
TaskSchema	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
SchemaName name = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]");
string revisionId = "";
// Make the request
Schema response = await schemaServiceClient.RollbackSchemaAsync(name, revisionId);

RollbackSchemaAsync(SchemaName, string, CancellationToken)

public virtual Task<Schema> RollbackSchemaAsync(SchemaName name, string revisionId, CancellationToken cancellationToken)

Creates a new schema revision that is a copy of the provided revision_id.

Parameters
Name	Description
name	SchemaName Required. The schema being rolled back with revision id.
revisionId	string Required. The revision ID to roll back to. It must be a revision of the same schema. Example: c7cfa2a8
cancellationToken	CancellationToken A CancellationToken to use for this RPC.

Returns
Type	Description
TaskSchema	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
SchemaName name = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]");
string revisionId = "";
// Make the request
Schema response = await schemaServiceClient.RollbackSchemaAsync(name, revisionId);

RollbackSchemaAsync(string, string, CallSettings)

public virtual Task<Schema> RollbackSchemaAsync(string name, string revisionId, CallSettings callSettings = null)

Creates a new schema revision that is a copy of the provided revision_id.

Parameters
Name	Description
name	string Required. The schema being rolled back with revision id.
revisionId	string Required. The revision ID to roll back to. It must be a revision of the same schema. Example: c7cfa2a8
callSettings	CallSettings If not null, applies overrides to this RPC call.

Returns
Type	Description
TaskSchema	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/schemas/[SCHEMA]";
string revisionId = "";
// Make the request
Schema response = await schemaServiceClient.RollbackSchemaAsync(name, revisionId);

RollbackSchemaAsync(string, string, CancellationToken)

public virtual Task<Schema> RollbackSchemaAsync(string name, string revisionId, CancellationToken cancellationToken)

Creates a new schema revision that is a copy of the provided revision_id.

Parameters
Name	Description
name	string Required. The schema being rolled back with revision id.
revisionId	string Required. The revision ID to roll back to. It must be a revision of the same schema. Example: c7cfa2a8
cancellationToken	CancellationToken A CancellationToken to use for this RPC.

Returns
Type	Description
TaskSchema	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/schemas/[SCHEMA]";
string revisionId = "";
// Make the request
Schema response = await schemaServiceClient.RollbackSchemaAsync(name, revisionId);

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.

ValidateMessage(ValidateMessageRequest, CallSettings)

public virtual ValidateMessageResponse ValidateMessage(ValidateMessageRequest request, CallSettings callSettings = null)

Validates a message against a schema.

Parameters
Name	Description
request	ValidateMessageRequest 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
ValidateMessageResponse	The RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
// Initialize request argument(s)
ValidateMessageRequest request = new ValidateMessageRequest
{
    ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
    SchemaName = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]"),
    Message = ByteString.Empty,
    Encoding = Encoding.Unspecified,
};
// Make the request
ValidateMessageResponse response = schemaServiceClient.ValidateMessage(request);

ValidateMessageAsync(ValidateMessageRequest, CallSettings)

public virtual Task<ValidateMessageResponse> ValidateMessageAsync(ValidateMessageRequest request, CallSettings callSettings = null)

Validates a message against a schema.

Parameters
Name	Description
request	ValidateMessageRequest 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
TaskValidateMessageResponse	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
ValidateMessageRequest request = new ValidateMessageRequest
{
    ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
    SchemaName = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]"),
    Message = ByteString.Empty,
    Encoding = Encoding.Unspecified,
};
// Make the request
ValidateMessageResponse response = await schemaServiceClient.ValidateMessageAsync(request);

ValidateMessageAsync(ValidateMessageRequest, CancellationToken)

public virtual Task<ValidateMessageResponse> ValidateMessageAsync(ValidateMessageRequest request, CancellationToken cancellationToken)

Validates a message against a schema.

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

Returns
Type	Description
TaskValidateMessageResponse	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
ValidateMessageRequest request = new ValidateMessageRequest
{
    ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
    SchemaName = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]"),
    Message = ByteString.Empty,
    Encoding = Encoding.Unspecified,
};
// Make the request
ValidateMessageResponse response = await schemaServiceClient.ValidateMessageAsync(request);

ValidateSchema(ProjectName, Schema, CallSettings)

public virtual ValidateSchemaResponse ValidateSchema(ProjectName parent, Schema schema, CallSettings callSettings = null)

Validates a schema.

Parameters
Name	Description
parent	ProjectName Required. The name of the project in which to validate schemas. Format is projects/{project-id}.
schema	Schema Required. The schema object to validate.
callSettings	CallSettings If not null, applies overrides to this RPC call.

Returns
Type	Description
ValidateSchemaResponse	The RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
// Initialize request argument(s)
ProjectName parent = ProjectName.FromProject("[PROJECT]");
Schema schema = new Schema();
// Make the request
ValidateSchemaResponse response = schemaServiceClient.ValidateSchema(parent, schema);

ValidateSchema(ValidateSchemaRequest, CallSettings)

public virtual ValidateSchemaResponse ValidateSchema(ValidateSchemaRequest request, CallSettings callSettings = null)

Validates a schema.

Parameters
Name	Description
request	ValidateSchemaRequest 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
ValidateSchemaResponse	The RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
// Initialize request argument(s)
ValidateSchemaRequest request = new ValidateSchemaRequest
{
    ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
    Schema = new Schema(),
};
// Make the request
ValidateSchemaResponse response = schemaServiceClient.ValidateSchema(request);

ValidateSchema(string, Schema, CallSettings)

public virtual ValidateSchemaResponse ValidateSchema(string parent, Schema schema, CallSettings callSettings = null)

Validates a schema.

Parameters
Name	Description
parent	string Required. The name of the project in which to validate schemas. Format is projects/{project-id}.
schema	Schema Required. The schema object to validate.
callSettings	CallSettings If not null, applies overrides to this RPC call.

Returns
Type	Description
ValidateSchemaResponse	The RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = SchemaServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]";
Schema schema = new Schema();
// Make the request
ValidateSchemaResponse response = schemaServiceClient.ValidateSchema(parent, schema);

ValidateSchemaAsync(ProjectName, Schema, CallSettings)

public virtual Task<ValidateSchemaResponse> ValidateSchemaAsync(ProjectName parent, Schema schema, CallSettings callSettings = null)

Validates a schema.

Parameters
Name	Description
parent	ProjectName Required. The name of the project in which to validate schemas. Format is projects/{project-id}.
schema	Schema Required. The schema object to validate.
callSettings	CallSettings If not null, applies overrides to this RPC call.

Returns
Type	Description
TaskValidateSchemaResponse	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
ProjectName parent = ProjectName.FromProject("[PROJECT]");
Schema schema = new Schema();
// Make the request
ValidateSchemaResponse response = await schemaServiceClient.ValidateSchemaAsync(parent, schema);

ValidateSchemaAsync(ProjectName, Schema, CancellationToken)

public virtual Task<ValidateSchemaResponse> ValidateSchemaAsync(ProjectName parent, Schema schema, CancellationToken cancellationToken)

Validates a schema.

Parameters
Name	Description
parent	ProjectName Required. The name of the project in which to validate schemas. Format is projects/{project-id}.
schema	Schema Required. The schema object to validate.
cancellationToken	CancellationToken A CancellationToken to use for this RPC.

Returns
Type	Description
TaskValidateSchemaResponse	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
ProjectName parent = ProjectName.FromProject("[PROJECT]");
Schema schema = new Schema();
// Make the request
ValidateSchemaResponse response = await schemaServiceClient.ValidateSchemaAsync(parent, schema);

ValidateSchemaAsync(ValidateSchemaRequest, CallSettings)

public virtual Task<ValidateSchemaResponse> ValidateSchemaAsync(ValidateSchemaRequest request, CallSettings callSettings = null)

Validates a schema.

Parameters
Name	Description
request	ValidateSchemaRequest 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
TaskValidateSchemaResponse	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
ValidateSchemaRequest request = new ValidateSchemaRequest
{
    ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
    Schema = new Schema(),
};
// Make the request
ValidateSchemaResponse response = await schemaServiceClient.ValidateSchemaAsync(request);

ValidateSchemaAsync(ValidateSchemaRequest, CancellationToken)

public virtual Task<ValidateSchemaResponse> ValidateSchemaAsync(ValidateSchemaRequest request, CancellationToken cancellationToken)

Validates a schema.

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

Returns
Type	Description
TaskValidateSchemaResponse	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
ValidateSchemaRequest request = new ValidateSchemaRequest
{
    ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
    Schema = new Schema(),
};
// Make the request
ValidateSchemaResponse response = await schemaServiceClient.ValidateSchemaAsync(request);

ValidateSchemaAsync(string, Schema, CallSettings)

public virtual Task<ValidateSchemaResponse> ValidateSchemaAsync(string parent, Schema schema, CallSettings callSettings = null)

Validates a schema.

Parameters
Name	Description
parent	string Required. The name of the project in which to validate schemas. Format is projects/{project-id}.
schema	Schema Required. The schema object to validate.
callSettings	CallSettings If not null, applies overrides to this RPC call.

Returns
Type	Description
TaskValidateSchemaResponse	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]";
Schema schema = new Schema();
// Make the request
ValidateSchemaResponse response = await schemaServiceClient.ValidateSchemaAsync(parent, schema);

ValidateSchemaAsync(string, Schema, CancellationToken)

public virtual Task<ValidateSchemaResponse> ValidateSchemaAsync(string parent, Schema schema, CancellationToken cancellationToken)

Validates a schema.

Parameters
Name	Description
parent	string Required. The name of the project in which to validate schemas. Format is projects/{project-id}.
schema	Schema Required. The schema object to validate.
cancellationToken	CancellationToken A CancellationToken to use for this RPC.

Returns
Type	Description
TaskValidateSchemaResponse	A Task containing the RPC response.

Example

// Create client
SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]";
Schema schema = new Schema();
// Make the request
ValidateSchemaResponse response = await schemaServiceClient.ValidateSchemaAsync(parent, schema);