Google BigQuery Data Transfer v1 API - Class DataTransferServiceClient (4.1.0)

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
CheckValidCredsRequest request = new CheckValidCredsRequest
{
    DataSourceName = DataSourceName.FromProjectDataSource("[PROJECT]", "[DATA_SOURCE]"),
};
// Make the request
CheckValidCredsResponse response = dataTransferServiceClient.CheckValidCreds(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
DataSourceName name = DataSourceName.FromProjectDataSource("[PROJECT]", "[DATA_SOURCE]");
// Make the request
CheckValidCredsResponse response = dataTransferServiceClient.CheckValidCreds(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/dataSources/[DATA_SOURCE]";
// Make the request
CheckValidCredsResponse response = dataTransferServiceClient.CheckValidCreds(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
CheckValidCredsRequest request = new CheckValidCredsRequest
{
    DataSourceName = DataSourceName.FromProjectDataSource("[PROJECT]", "[DATA_SOURCE]"),
};
// Make the request
CheckValidCredsResponse response = await dataTransferServiceClient.CheckValidCredsAsync(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
CheckValidCredsRequest request = new CheckValidCredsRequest
{
    DataSourceName = DataSourceName.FromProjectDataSource("[PROJECT]", "[DATA_SOURCE]"),
};
// Make the request
CheckValidCredsResponse response = await dataTransferServiceClient.CheckValidCredsAsync(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
DataSourceName name = DataSourceName.FromProjectDataSource("[PROJECT]", "[DATA_SOURCE]");
// Make the request
CheckValidCredsResponse response = await dataTransferServiceClient.CheckValidCredsAsync(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
DataSourceName name = DataSourceName.FromProjectDataSource("[PROJECT]", "[DATA_SOURCE]");
// Make the request
CheckValidCredsResponse response = await dataTransferServiceClient.CheckValidCredsAsync(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/dataSources/[DATA_SOURCE]";
// Make the request
CheckValidCredsResponse response = await dataTransferServiceClient.CheckValidCredsAsync(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/dataSources/[DATA_SOURCE]";
// Make the request
CheckValidCredsResponse response = await dataTransferServiceClient.CheckValidCredsAsync(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
TransferConfig transferConfig = new TransferConfig();
// Make the request
TransferConfig response = dataTransferServiceClient.CreateTransferConfig(parent, transferConfig);

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
ProjectName parent = ProjectName.FromProject("[PROJECT]");
TransferConfig transferConfig = new TransferConfig();
// Make the request
TransferConfig response = dataTransferServiceClient.CreateTransferConfig(parent, transferConfig);

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
CreateTransferConfigRequest request = new CreateTransferConfigRequest
{
    ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
    TransferConfig = new TransferConfig(),
    AuthorizationCode = "",
    VersionInfo = "",
    ServiceAccountName = "",
};
// Make the request
TransferConfig response = dataTransferServiceClient.CreateTransferConfig(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]";
TransferConfig transferConfig = new TransferConfig();
// Make the request
TransferConfig response = dataTransferServiceClient.CreateTransferConfig(parent, transferConfig);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
TransferConfig transferConfig = new TransferConfig();
// Make the request
TransferConfig response = await dataTransferServiceClient.CreateTransferConfigAsync(parent, transferConfig);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
TransferConfig transferConfig = new TransferConfig();
// Make the request
TransferConfig response = await dataTransferServiceClient.CreateTransferConfigAsync(parent, transferConfig);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
ProjectName parent = ProjectName.FromProject("[PROJECT]");
TransferConfig transferConfig = new TransferConfig();
// Make the request
TransferConfig response = await dataTransferServiceClient.CreateTransferConfigAsync(parent, transferConfig);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
ProjectName parent = ProjectName.FromProject("[PROJECT]");
TransferConfig transferConfig = new TransferConfig();
// Make the request
TransferConfig response = await dataTransferServiceClient.CreateTransferConfigAsync(parent, transferConfig);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
CreateTransferConfigRequest request = new CreateTransferConfigRequest
{
    ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
    TransferConfig = new TransferConfig(),
    AuthorizationCode = "",
    VersionInfo = "",
    ServiceAccountName = "",
};
// Make the request
TransferConfig response = await dataTransferServiceClient.CreateTransferConfigAsync(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
CreateTransferConfigRequest request = new CreateTransferConfigRequest
{
    ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
    TransferConfig = new TransferConfig(),
    AuthorizationCode = "",
    VersionInfo = "",
    ServiceAccountName = "",
};
// Make the request
TransferConfig response = await dataTransferServiceClient.CreateTransferConfigAsync(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]";
TransferConfig transferConfig = new TransferConfig();
// Make the request
TransferConfig response = await dataTransferServiceClient.CreateTransferConfigAsync(parent, transferConfig);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]";
TransferConfig transferConfig = new TransferConfig();
// Make the request
TransferConfig response = await dataTransferServiceClient.CreateTransferConfigAsync(parent, transferConfig);

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
DeleteTransferConfigRequest request = new DeleteTransferConfigRequest
{
    TransferConfigName = TransferConfigName.FromProjectTransferConfig("[PROJECT]", "[TRANSFER_CONFIG]"),
};
// Make the request
dataTransferServiceClient.DeleteTransferConfig(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
TransferConfigName name = TransferConfigName.FromProjectTransferConfig("[PROJECT]", "[TRANSFER_CONFIG]");
// Make the request
dataTransferServiceClient.DeleteTransferConfig(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/transferConfigs/[TRANSFER_CONFIG]";
// Make the request
dataTransferServiceClient.DeleteTransferConfig(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteTransferConfigRequest request = new DeleteTransferConfigRequest
{
    TransferConfigName = TransferConfigName.FromProjectTransferConfig("[PROJECT]", "[TRANSFER_CONFIG]"),
};
// Make the request
await dataTransferServiceClient.DeleteTransferConfigAsync(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteTransferConfigRequest request = new DeleteTransferConfigRequest
{
    TransferConfigName = TransferConfigName.FromProjectTransferConfig("[PROJECT]", "[TRANSFER_CONFIG]"),
};
// Make the request
await dataTransferServiceClient.DeleteTransferConfigAsync(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
TransferConfigName name = TransferConfigName.FromProjectTransferConfig("[PROJECT]", "[TRANSFER_CONFIG]");
// Make the request
await dataTransferServiceClient.DeleteTransferConfigAsync(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
TransferConfigName name = TransferConfigName.FromProjectTransferConfig("[PROJECT]", "[TRANSFER_CONFIG]");
// Make the request
await dataTransferServiceClient.DeleteTransferConfigAsync(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/transferConfigs/[TRANSFER_CONFIG]";
// Make the request
await dataTransferServiceClient.DeleteTransferConfigAsync(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/transferConfigs/[TRANSFER_CONFIG]";
// Make the request
await dataTransferServiceClient.DeleteTransferConfigAsync(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
DeleteTransferRunRequest request = new DeleteTransferRunRequest
{
    RunName = RunName.FromProjectTransferConfigRun("[PROJECT]", "[TRANSFER_CONFIG]", "[RUN]"),
};
// Make the request
dataTransferServiceClient.DeleteTransferRun(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
RunName name = RunName.FromProjectTransferConfigRun("[PROJECT]", "[TRANSFER_CONFIG]", "[RUN]");
// Make the request
dataTransferServiceClient.DeleteTransferRun(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/transferConfigs/[TRANSFER_CONFIG]/runs/[RUN]";
// Make the request
dataTransferServiceClient.DeleteTransferRun(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteTransferRunRequest request = new DeleteTransferRunRequest
{
    RunName = RunName.FromProjectTransferConfigRun("[PROJECT]", "[TRANSFER_CONFIG]", "[RUN]"),
};
// Make the request
await dataTransferServiceClient.DeleteTransferRunAsync(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteTransferRunRequest request = new DeleteTransferRunRequest
{
    RunName = RunName.FromProjectTransferConfigRun("[PROJECT]", "[TRANSFER_CONFIG]", "[RUN]"),
};
// Make the request
await dataTransferServiceClient.DeleteTransferRunAsync(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
RunName name = RunName.FromProjectTransferConfigRun("[PROJECT]", "[TRANSFER_CONFIG]", "[RUN]");
// Make the request
await dataTransferServiceClient.DeleteTransferRunAsync(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
RunName name = RunName.FromProjectTransferConfigRun("[PROJECT]", "[TRANSFER_CONFIG]", "[RUN]");
// Make the request
await dataTransferServiceClient.DeleteTransferRunAsync(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/transferConfigs/[TRANSFER_CONFIG]/runs/[RUN]";
// Make the request
await dataTransferServiceClient.DeleteTransferRunAsync(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/transferConfigs/[TRANSFER_CONFIG]/runs/[RUN]";
// Make the request
await dataTransferServiceClient.DeleteTransferRunAsync(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
EnrollDataSourcesRequest request = new EnrollDataSourcesRequest
{
    Name = "",
    DataSourceIds = { "", },
};
// Make the request
dataTransferServiceClient.EnrollDataSources(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
EnrollDataSourcesRequest request = new EnrollDataSourcesRequest
{
    Name = "",
    DataSourceIds = { "", },
};
// Make the request
await dataTransferServiceClient.EnrollDataSourcesAsync(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
EnrollDataSourcesRequest request = new EnrollDataSourcesRequest
{
    Name = "",
    DataSourceIds = { "", },
};
// Make the request
await dataTransferServiceClient.EnrollDataSourcesAsync(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
DataSourceName name = DataSourceName.FromProjectDataSource("[PROJECT]", "[DATA_SOURCE]");
// Make the request
DataSource response = dataTransferServiceClient.GetDataSource(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
GetDataSourceRequest request = new GetDataSourceRequest
{
    DataSourceName = DataSourceName.FromProjectDataSource("[PROJECT]", "[DATA_SOURCE]"),
};
// Make the request
DataSource response = dataTransferServiceClient.GetDataSource(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/dataSources/[DATA_SOURCE]";
// Make the request
DataSource response = dataTransferServiceClient.GetDataSource(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
DataSourceName name = DataSourceName.FromProjectDataSource("[PROJECT]", "[DATA_SOURCE]");
// Make the request
DataSource response = await dataTransferServiceClient.GetDataSourceAsync(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
DataSourceName name = DataSourceName.FromProjectDataSource("[PROJECT]", "[DATA_SOURCE]");
// Make the request
DataSource response = await dataTransferServiceClient.GetDataSourceAsync(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
GetDataSourceRequest request = new GetDataSourceRequest
{
    DataSourceName = DataSourceName.FromProjectDataSource("[PROJECT]", "[DATA_SOURCE]"),
};
// Make the request
DataSource response = await dataTransferServiceClient.GetDataSourceAsync(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
GetDataSourceRequest request = new GetDataSourceRequest
{
    DataSourceName = DataSourceName.FromProjectDataSource("[PROJECT]", "[DATA_SOURCE]"),
};
// Make the request
DataSource response = await dataTransferServiceClient.GetDataSourceAsync(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/dataSources/[DATA_SOURCE]";
// Make the request
DataSource response = await dataTransferServiceClient.GetDataSourceAsync(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/dataSources/[DATA_SOURCE]";
// Make the request
DataSource response = await dataTransferServiceClient.GetDataSourceAsync(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
GetTransferConfigRequest request = new GetTransferConfigRequest
{
    TransferConfigName = TransferConfigName.FromProjectTransferConfig("[PROJECT]", "[TRANSFER_CONFIG]"),
};
// Make the request
TransferConfig response = dataTransferServiceClient.GetTransferConfig(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
TransferConfigName name = TransferConfigName.FromProjectTransferConfig("[PROJECT]", "[TRANSFER_CONFIG]");
// Make the request
TransferConfig response = dataTransferServiceClient.GetTransferConfig(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/transferConfigs/[TRANSFER_CONFIG]";
// Make the request
TransferConfig response = dataTransferServiceClient.GetTransferConfig(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
GetTransferConfigRequest request = new GetTransferConfigRequest
{
    TransferConfigName = TransferConfigName.FromProjectTransferConfig("[PROJECT]", "[TRANSFER_CONFIG]"),
};
// Make the request
TransferConfig response = await dataTransferServiceClient.GetTransferConfigAsync(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
GetTransferConfigRequest request = new GetTransferConfigRequest
{
    TransferConfigName = TransferConfigName.FromProjectTransferConfig("[PROJECT]", "[TRANSFER_CONFIG]"),
};
// Make the request
TransferConfig response = await dataTransferServiceClient.GetTransferConfigAsync(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
TransferConfigName name = TransferConfigName.FromProjectTransferConfig("[PROJECT]", "[TRANSFER_CONFIG]");
// Make the request
TransferConfig response = await dataTransferServiceClient.GetTransferConfigAsync(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
TransferConfigName name = TransferConfigName.FromProjectTransferConfig("[PROJECT]", "[TRANSFER_CONFIG]");
// Make the request
TransferConfig response = await dataTransferServiceClient.GetTransferConfigAsync(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/transferConfigs/[TRANSFER_CONFIG]";
// Make the request
TransferConfig response = await dataTransferServiceClient.GetTransferConfigAsync(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/transferConfigs/[TRANSFER_CONFIG]";
// Make the request
TransferConfig response = await dataTransferServiceClient.GetTransferConfigAsync(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
GetTransferRunRequest request = new GetTransferRunRequest
{
    RunName = RunName.FromProjectTransferConfigRun("[PROJECT]", "[TRANSFER_CONFIG]", "[RUN]"),
};
// Make the request
TransferRun response = dataTransferServiceClient.GetTransferRun(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
RunName name = RunName.FromProjectTransferConfigRun("[PROJECT]", "[TRANSFER_CONFIG]", "[RUN]");
// Make the request
TransferRun response = dataTransferServiceClient.GetTransferRun(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/transferConfigs/[TRANSFER_CONFIG]/runs/[RUN]";
// Make the request
TransferRun response = dataTransferServiceClient.GetTransferRun(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
GetTransferRunRequest request = new GetTransferRunRequest
{
    RunName = RunName.FromProjectTransferConfigRun("[PROJECT]", "[TRANSFER_CONFIG]", "[RUN]"),
};
// Make the request
TransferRun response = await dataTransferServiceClient.GetTransferRunAsync(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
GetTransferRunRequest request = new GetTransferRunRequest
{
    RunName = RunName.FromProjectTransferConfigRun("[PROJECT]", "[TRANSFER_CONFIG]", "[RUN]"),
};
// Make the request
TransferRun response = await dataTransferServiceClient.GetTransferRunAsync(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
RunName name = RunName.FromProjectTransferConfigRun("[PROJECT]", "[TRANSFER_CONFIG]", "[RUN]");
// Make the request
TransferRun response = await dataTransferServiceClient.GetTransferRunAsync(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
RunName name = RunName.FromProjectTransferConfigRun("[PROJECT]", "[TRANSFER_CONFIG]", "[RUN]");
// Make the request
TransferRun response = await dataTransferServiceClient.GetTransferRunAsync(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/transferConfigs/[TRANSFER_CONFIG]/runs/[RUN]";
// Make the request
TransferRun response = await dataTransferServiceClient.GetTransferRunAsync(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/transferConfigs/[TRANSFER_CONFIG]/runs/[RUN]";
// Make the request
TransferRun response = await dataTransferServiceClient.GetTransferRunAsync(name);

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListDataSourcesResponse, DataSource> response = dataTransferServiceClient.ListDataSources(parent);

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

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
ProjectName parent = ProjectName.FromProject("[PROJECT]");
// Make the request
PagedEnumerable<ListDataSourcesResponse, DataSource> response = dataTransferServiceClient.ListDataSources(parent);

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

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
ListDataSourcesRequest request = new ListDataSourcesRequest
{
    ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
};
// Make the request
PagedEnumerable<ListDataSourcesResponse, DataSource> response = dataTransferServiceClient.ListDataSources(request);

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

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]";
// Make the request
PagedEnumerable<ListDataSourcesResponse, DataSource> response = dataTransferServiceClient.ListDataSources(parent);

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

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListDataSourcesResponse, DataSource> response = dataTransferServiceClient.ListDataSourcesAsync(parent);

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

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
ProjectName parent = ProjectName.FromProject("[PROJECT]");
// Make the request
PagedAsyncEnumerable<ListDataSourcesResponse, DataSource> response = dataTransferServiceClient.ListDataSourcesAsync(parent);

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

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
ListDataSourcesRequest request = new ListDataSourcesRequest
{
    ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
};
// Make the request
PagedAsyncEnumerable<ListDataSourcesResponse, DataSource> response = dataTransferServiceClient.ListDataSourcesAsync(request);

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

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]";
// Make the request
PagedAsyncEnumerable<ListDataSourcesResponse, DataSource> response = dataTransferServiceClient.ListDataSourcesAsync(parent);

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

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListTransferConfigsResponse, TransferConfig> response = dataTransferServiceClient.ListTransferConfigs(parent);

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

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
ProjectName parent = ProjectName.FromProject("[PROJECT]");
// Make the request
PagedEnumerable<ListTransferConfigsResponse, TransferConfig> response = dataTransferServiceClient.ListTransferConfigs(parent);

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

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
ListTransferConfigsRequest request = new ListTransferConfigsRequest
{
    ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
    DataSourceIds = { "", },
};
// Make the request
PagedEnumerable<ListTransferConfigsResponse, TransferConfig> response = dataTransferServiceClient.ListTransferConfigs(request);

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

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]";
// Make the request
PagedEnumerable<ListTransferConfigsResponse, TransferConfig> response = dataTransferServiceClient.ListTransferConfigs(parent);

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

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListTransferConfigsResponse, TransferConfig> response = dataTransferServiceClient.ListTransferConfigsAsync(parent);

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

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
ProjectName parent = ProjectName.FromProject("[PROJECT]");
// Make the request
PagedAsyncEnumerable<ListTransferConfigsResponse, TransferConfig> response = dataTransferServiceClient.ListTransferConfigsAsync(parent);

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

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
ListTransferConfigsRequest request = new ListTransferConfigsRequest
{
    ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
    DataSourceIds = { "", },
};
// Make the request
PagedAsyncEnumerable<ListTransferConfigsResponse, TransferConfig> response = dataTransferServiceClient.ListTransferConfigsAsync(request);

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

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]";
// Make the request
PagedAsyncEnumerable<ListTransferConfigsResponse, TransferConfig> response = dataTransferServiceClient.ListTransferConfigsAsync(parent);

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

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
ListTransferLogsRequest request = new ListTransferLogsRequest
{
    ParentAsRunName = RunName.FromProjectTransferConfigRun("[PROJECT]", "[TRANSFER_CONFIG]", "[RUN]"),
    MessageTypes =
    {
        TransferMessage.Types.MessageSeverity.Unspecified,
    },
};
// Make the request
PagedEnumerable<ListTransferLogsResponse, TransferMessage> response = dataTransferServiceClient.ListTransferLogs(request);

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

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
RunName parent = RunName.FromProjectTransferConfigRun("[PROJECT]", "[TRANSFER_CONFIG]", "[RUN]");
// Make the request
PagedEnumerable<ListTransferLogsResponse, TransferMessage> response = dataTransferServiceClient.ListTransferLogs(parent);

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

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/transferConfigs/[TRANSFER_CONFIG]/runs/[RUN]";
// Make the request
PagedEnumerable<ListTransferLogsResponse, TransferMessage> response = dataTransferServiceClient.ListTransferLogs(parent);

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

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
ListTransferLogsRequest request = new ListTransferLogsRequest
{
    ParentAsRunName = RunName.FromProjectTransferConfigRun("[PROJECT]", "[TRANSFER_CONFIG]", "[RUN]"),
    MessageTypes =
    {
        TransferMessage.Types.MessageSeverity.Unspecified,
    },
};
// Make the request
PagedAsyncEnumerable<ListTransferLogsResponse, TransferMessage> response = dataTransferServiceClient.ListTransferLogsAsync(request);

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

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
RunName parent = RunName.FromProjectTransferConfigRun("[PROJECT]", "[TRANSFER_CONFIG]", "[RUN]");
// Make the request
PagedAsyncEnumerable<ListTransferLogsResponse, TransferMessage> response = dataTransferServiceClient.ListTransferLogsAsync(parent);

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

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/transferConfigs/[TRANSFER_CONFIG]/runs/[RUN]";
// Make the request
PagedAsyncEnumerable<ListTransferLogsResponse, TransferMessage> response = dataTransferServiceClient.ListTransferLogsAsync(parent);

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

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
ListTransferRunsRequest request = new ListTransferRunsRequest
{
    ParentAsTransferConfigName = TransferConfigName.FromProjectTransferConfig("[PROJECT]", "[TRANSFER_CONFIG]"),
    States =
    {
        TransferState.Unspecified,
    },
    RunAttempt = ListTransferRunsRequest.Types.RunAttempt.Unspecified,
};
// Make the request
PagedEnumerable<ListTransferRunsResponse, TransferRun> response = dataTransferServiceClient.ListTransferRuns(request);

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

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
TransferConfigName parent = TransferConfigName.FromProjectTransferConfig("[PROJECT]", "[TRANSFER_CONFIG]");
// Make the request
PagedEnumerable<ListTransferRunsResponse, TransferRun> response = dataTransferServiceClient.ListTransferRuns(parent);

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

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/transferConfigs/[TRANSFER_CONFIG]";
// Make the request
PagedEnumerable<ListTransferRunsResponse, TransferRun> response = dataTransferServiceClient.ListTransferRuns(parent);

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

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
ListTransferRunsRequest request = new ListTransferRunsRequest
{
    ParentAsTransferConfigName = TransferConfigName.FromProjectTransferConfig("[PROJECT]", "[TRANSFER_CONFIG]"),
    States =
    {
        TransferState.Unspecified,
    },
    RunAttempt = ListTransferRunsRequest.Types.RunAttempt.Unspecified,
};
// Make the request
PagedAsyncEnumerable<ListTransferRunsResponse, TransferRun> response = dataTransferServiceClient.ListTransferRunsAsync(request);

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

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
TransferConfigName parent = TransferConfigName.FromProjectTransferConfig("[PROJECT]", "[TRANSFER_CONFIG]");
// Make the request
PagedAsyncEnumerable<ListTransferRunsResponse, TransferRun> response = dataTransferServiceClient.ListTransferRunsAsync(parent);

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

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/transferConfigs/[TRANSFER_CONFIG]";
// Make the request
PagedAsyncEnumerable<ListTransferRunsResponse, TransferRun> response = dataTransferServiceClient.ListTransferRunsAsync(parent);

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

            // Create client
            DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
            // Initialize request argument(s)
            ScheduleTransferRunsRequest request = new ScheduleTransferRunsRequest
            {
                ParentAsTransferConfigName = TransferConfigName.FromProjectTransferConfig("[PROJECT]", "[TRANSFER_CONFIG]"),
                StartTime = new Timestamp(),
                EndTime = new Timestamp(),
            };
            // Make the request
#pragma warning disable CS0612
            ScheduleTransferRunsResponse response = dataTransferServiceClient.ScheduleTransferRuns(request);
#pragma warning restore CS0612

            // Create client
            DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
            // Initialize request argument(s)
            TransferConfigName parent = TransferConfigName.FromProjectTransferConfig("[PROJECT]", "[TRANSFER_CONFIG]");
            Timestamp startTime = new Timestamp();
            Timestamp endTime = new Timestamp();
            // Make the request
#pragma warning disable CS0612
            ScheduleTransferRunsResponse response = dataTransferServiceClient.ScheduleTransferRuns(parent, startTime, endTime);
#pragma warning restore CS0612

            // Create client
            DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
            // Initialize request argument(s)
            string parent = "projects/[PROJECT]/transferConfigs/[TRANSFER_CONFIG]";
            Timestamp startTime = new Timestamp();
            Timestamp endTime = new Timestamp();
            // Make the request
#pragma warning disable CS0612
            ScheduleTransferRunsResponse response = dataTransferServiceClient.ScheduleTransferRuns(parent, startTime, endTime);
#pragma warning restore CS0612

            // Create client
            DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
            // Initialize request argument(s)
            ScheduleTransferRunsRequest request = new ScheduleTransferRunsRequest
            {
                ParentAsTransferConfigName = TransferConfigName.FromProjectTransferConfig("[PROJECT]", "[TRANSFER_CONFIG]"),
                StartTime = new Timestamp(),
                EndTime = new Timestamp(),
            };
            // Make the request
#pragma warning disable CS0612
            ScheduleTransferRunsResponse response = await dataTransferServiceClient.ScheduleTransferRunsAsync(request);
#pragma warning restore CS0612

            // Create client
            DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
            // Initialize request argument(s)
            ScheduleTransferRunsRequest request = new ScheduleTransferRunsRequest
            {
                ParentAsTransferConfigName = TransferConfigName.FromProjectTransferConfig("[PROJECT]", "[TRANSFER_CONFIG]"),
                StartTime = new Timestamp(),
                EndTime = new Timestamp(),
            };
            // Make the request
#pragma warning disable CS0612
            ScheduleTransferRunsResponse response = await dataTransferServiceClient.ScheduleTransferRunsAsync(request);
#pragma warning restore CS0612

            // Create client
            DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
            // Initialize request argument(s)
            TransferConfigName parent = TransferConfigName.FromProjectTransferConfig("[PROJECT]", "[TRANSFER_CONFIG]");
            Timestamp startTime = new Timestamp();
            Timestamp endTime = new Timestamp();
            // Make the request
#pragma warning disable CS0612
            ScheduleTransferRunsResponse response = await dataTransferServiceClient.ScheduleTransferRunsAsync(parent, startTime, endTime);
#pragma warning restore CS0612

            // Create client
            DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
            // Initialize request argument(s)
            TransferConfigName parent = TransferConfigName.FromProjectTransferConfig("[PROJECT]", "[TRANSFER_CONFIG]");
            Timestamp startTime = new Timestamp();
            Timestamp endTime = new Timestamp();
            // Make the request
#pragma warning disable CS0612
            ScheduleTransferRunsResponse response = await dataTransferServiceClient.ScheduleTransferRunsAsync(parent, startTime, endTime);
#pragma warning restore CS0612

            // Create client
            DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
            // Initialize request argument(s)
            string parent = "projects/[PROJECT]/transferConfigs/[TRANSFER_CONFIG]";
            Timestamp startTime = new Timestamp();
            Timestamp endTime = new Timestamp();
            // Make the request
#pragma warning disable CS0612
            ScheduleTransferRunsResponse response = await dataTransferServiceClient.ScheduleTransferRunsAsync(parent, startTime, endTime);
#pragma warning restore CS0612

            // Create client
            DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
            // Initialize request argument(s)
            string parent = "projects/[PROJECT]/transferConfigs/[TRANSFER_CONFIG]";
            Timestamp startTime = new Timestamp();
            Timestamp endTime = new Timestamp();
            // Make the request
#pragma warning disable CS0612
            ScheduleTransferRunsResponse response = await dataTransferServiceClient.ScheduleTransferRunsAsync(parent, startTime, endTime);
#pragma warning restore CS0612

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
StartManualTransferRunsRequest request = new StartManualTransferRunsRequest
{
    ParentAsTransferConfigName = TransferConfigName.FromProjectTransferConfig("[PROJECT]", "[TRANSFER_CONFIG]"),
    RequestedTimeRange = new StartManualTransferRunsRequest.Types.TimeRange(),
};
// Make the request
StartManualTransferRunsResponse response = dataTransferServiceClient.StartManualTransferRuns(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
StartManualTransferRunsRequest request = new StartManualTransferRunsRequest
{
    ParentAsTransferConfigName = TransferConfigName.FromProjectTransferConfig("[PROJECT]", "[TRANSFER_CONFIG]"),
    RequestedTimeRange = new StartManualTransferRunsRequest.Types.TimeRange(),
};
// Make the request
StartManualTransferRunsResponse response = await dataTransferServiceClient.StartManualTransferRunsAsync(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
StartManualTransferRunsRequest request = new StartManualTransferRunsRequest
{
    ParentAsTransferConfigName = TransferConfigName.FromProjectTransferConfig("[PROJECT]", "[TRANSFER_CONFIG]"),
    RequestedTimeRange = new StartManualTransferRunsRequest.Types.TimeRange(),
};
// Make the request
StartManualTransferRunsResponse response = await dataTransferServiceClient.StartManualTransferRunsAsync(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
TransferConfig transferConfig = new TransferConfig();
FieldMask updateMask = new FieldMask();
// Make the request
TransferConfig response = dataTransferServiceClient.UpdateTransferConfig(transferConfig, updateMask);

// Create client
DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.Create();
// Initialize request argument(s)
UpdateTransferConfigRequest request = new UpdateTransferConfigRequest
{
    TransferConfig = new TransferConfig(),
    AuthorizationCode = "",
    UpdateMask = new FieldMask(),
    VersionInfo = "",
    ServiceAccountName = "",
};
// Make the request
TransferConfig response = dataTransferServiceClient.UpdateTransferConfig(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
TransferConfig transferConfig = new TransferConfig();
FieldMask updateMask = new FieldMask();
// Make the request
TransferConfig response = await dataTransferServiceClient.UpdateTransferConfigAsync(transferConfig, updateMask);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
TransferConfig transferConfig = new TransferConfig();
FieldMask updateMask = new FieldMask();
// Make the request
TransferConfig response = await dataTransferServiceClient.UpdateTransferConfigAsync(transferConfig, updateMask);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateTransferConfigRequest request = new UpdateTransferConfigRequest
{
    TransferConfig = new TransferConfig(),
    AuthorizationCode = "",
    UpdateMask = new FieldMask(),
    VersionInfo = "",
    ServiceAccountName = "",
};
// Make the request
TransferConfig response = await dataTransferServiceClient.UpdateTransferConfigAsync(request);

// Create client
DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateTransferConfigRequest request = new UpdateTransferConfigRequest
{
    TransferConfig = new TransferConfig(),
    AuthorizationCode = "",
    UpdateMask = new FieldMask(),
    VersionInfo = "",
    ServiceAccountName = "",
};
// Make the request
TransferConfig response = await dataTransferServiceClient.UpdateTransferConfigAsync(request);