DataStream v1alpha1 API - Class DatastreamClient (2.0.0-alpha04)

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ConnectionProfile connectionProfile = new ConnectionProfile();
string connectionProfileId = "";
// Make the request
Operation<ConnectionProfile, OperationMetadata> response = datastreamClient.CreateConnectionProfile(parent, connectionProfile, connectionProfileId);

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

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

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
CreateConnectionProfileRequest request = new CreateConnectionProfileRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ConnectionProfileId = "",
    ConnectionProfile = new ConnectionProfile(),
    RequestId = "",
};
// Make the request
Operation<ConnectionProfile, OperationMetadata> response = datastreamClient.CreateConnectionProfile(request);

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

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

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ConnectionProfile connectionProfile = new ConnectionProfile();
string connectionProfileId = "";
// Make the request
Operation<ConnectionProfile, OperationMetadata> response = datastreamClient.CreateConnectionProfile(parent, connectionProfile, connectionProfileId);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ConnectionProfile connectionProfile = new ConnectionProfile();
string connectionProfileId = "";
// Make the request
Operation<ConnectionProfile, OperationMetadata> response = await datastreamClient.CreateConnectionProfileAsync(parent, connectionProfile, connectionProfileId);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ConnectionProfile connectionProfile = new ConnectionProfile();
string connectionProfileId = "";
// Make the request
Operation<ConnectionProfile, OperationMetadata> response = await datastreamClient.CreateConnectionProfileAsync(parent, connectionProfile, connectionProfileId);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
CreateConnectionProfileRequest request = new CreateConnectionProfileRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ConnectionProfileId = "",
    ConnectionProfile = new ConnectionProfile(),
    RequestId = "",
};
// Make the request
Operation<ConnectionProfile, OperationMetadata> response = await datastreamClient.CreateConnectionProfileAsync(request);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
CreateConnectionProfileRequest request = new CreateConnectionProfileRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ConnectionProfileId = "",
    ConnectionProfile = new ConnectionProfile(),
    RequestId = "",
};
// Make the request
Operation<ConnectionProfile, OperationMetadata> response = await datastreamClient.CreateConnectionProfileAsync(request);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ConnectionProfile connectionProfile = new ConnectionProfile();
string connectionProfileId = "";
// Make the request
Operation<ConnectionProfile, OperationMetadata> response = await datastreamClient.CreateConnectionProfileAsync(parent, connectionProfile, connectionProfileId);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ConnectionProfile connectionProfile = new ConnectionProfile();
string connectionProfileId = "";
// Make the request
Operation<ConnectionProfile, OperationMetadata> response = await datastreamClient.CreateConnectionProfileAsync(parent, connectionProfile, connectionProfileId);

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

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

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
PrivateConnection privateConnection = new PrivateConnection();
string privateConnectionId = "";
// Make the request
Operation<PrivateConnection, OperationMetadata> response = datastreamClient.CreatePrivateConnection(parent, privateConnection, privateConnectionId);

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

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

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
CreatePrivateConnectionRequest request = new CreatePrivateConnectionRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    PrivateConnectionId = "",
    PrivateConnection = new PrivateConnection(),
    RequestId = "",
};
// Make the request
Operation<PrivateConnection, OperationMetadata> response = datastreamClient.CreatePrivateConnection(request);

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

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

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
PrivateConnection privateConnection = new PrivateConnection();
string privateConnectionId = "";
// Make the request
Operation<PrivateConnection, OperationMetadata> response = datastreamClient.CreatePrivateConnection(parent, privateConnection, privateConnectionId);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
PrivateConnection privateConnection = new PrivateConnection();
string privateConnectionId = "";
// Make the request
Operation<PrivateConnection, OperationMetadata> response = await datastreamClient.CreatePrivateConnectionAsync(parent, privateConnection, privateConnectionId);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
PrivateConnection privateConnection = new PrivateConnection();
string privateConnectionId = "";
// Make the request
Operation<PrivateConnection, OperationMetadata> response = await datastreamClient.CreatePrivateConnectionAsync(parent, privateConnection, privateConnectionId);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
CreatePrivateConnectionRequest request = new CreatePrivateConnectionRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    PrivateConnectionId = "",
    PrivateConnection = new PrivateConnection(),
    RequestId = "",
};
// Make the request
Operation<PrivateConnection, OperationMetadata> response = await datastreamClient.CreatePrivateConnectionAsync(request);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
CreatePrivateConnectionRequest request = new CreatePrivateConnectionRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    PrivateConnectionId = "",
    PrivateConnection = new PrivateConnection(),
    RequestId = "",
};
// Make the request
Operation<PrivateConnection, OperationMetadata> response = await datastreamClient.CreatePrivateConnectionAsync(request);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
PrivateConnection privateConnection = new PrivateConnection();
string privateConnectionId = "";
// Make the request
Operation<PrivateConnection, OperationMetadata> response = await datastreamClient.CreatePrivateConnectionAsync(parent, privateConnection, privateConnectionId);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
PrivateConnection privateConnection = new PrivateConnection();
string privateConnectionId = "";
// Make the request
Operation<PrivateConnection, OperationMetadata> response = await datastreamClient.CreatePrivateConnectionAsync(parent, privateConnection, privateConnectionId);

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

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

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
CreateRouteRequest request = new CreateRouteRequest
{
    ParentAsPrivateConnectionName = PrivateConnectionName.FromProjectLocationPrivateConnection("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]"),
    RouteId = "",
    Route = new Route(),
    RequestId = "",
};
// Make the request
Operation<Route, OperationMetadata> response = datastreamClient.CreateRoute(request);

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

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

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
PrivateConnectionName parent = PrivateConnectionName.FromProjectLocationPrivateConnection("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]");
Route route = new Route();
string routeId = "";
// Make the request
Operation<Route, OperationMetadata> response = datastreamClient.CreateRoute(parent, route, routeId);

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

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

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/privateConnections/[PRIVATE_CONNECTION]";
Route route = new Route();
string routeId = "";
// Make the request
Operation<Route, OperationMetadata> response = datastreamClient.CreateRoute(parent, route, routeId);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
CreateRouteRequest request = new CreateRouteRequest
{
    ParentAsPrivateConnectionName = PrivateConnectionName.FromProjectLocationPrivateConnection("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]"),
    RouteId = "",
    Route = new Route(),
    RequestId = "",
};
// Make the request
Operation<Route, OperationMetadata> response = await datastreamClient.CreateRouteAsync(request);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
CreateRouteRequest request = new CreateRouteRequest
{
    ParentAsPrivateConnectionName = PrivateConnectionName.FromProjectLocationPrivateConnection("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]"),
    RouteId = "",
    Route = new Route(),
    RequestId = "",
};
// Make the request
Operation<Route, OperationMetadata> response = await datastreamClient.CreateRouteAsync(request);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
PrivateConnectionName parent = PrivateConnectionName.FromProjectLocationPrivateConnection("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]");
Route route = new Route();
string routeId = "";
// Make the request
Operation<Route, OperationMetadata> response = await datastreamClient.CreateRouteAsync(parent, route, routeId);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
PrivateConnectionName parent = PrivateConnectionName.FromProjectLocationPrivateConnection("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]");
Route route = new Route();
string routeId = "";
// Make the request
Operation<Route, OperationMetadata> response = await datastreamClient.CreateRouteAsync(parent, route, routeId);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/privateConnections/[PRIVATE_CONNECTION]";
Route route = new Route();
string routeId = "";
// Make the request
Operation<Route, OperationMetadata> response = await datastreamClient.CreateRouteAsync(parent, route, routeId);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/privateConnections/[PRIVATE_CONNECTION]";
Route route = new Route();
string routeId = "";
// Make the request
Operation<Route, OperationMetadata> response = await datastreamClient.CreateRouteAsync(parent, route, routeId);

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

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

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Stream stream = new Stream();
string streamId = "";
// Make the request
Operation<Stream, OperationMetadata> response = datastreamClient.CreateStream(parent, stream, streamId);

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

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

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
CreateStreamRequest request = new CreateStreamRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    StreamId = "",
    Stream = new Stream(),
    RequestId = "",
    ValidateOnly = false,
    Force = false,
};
// Make the request
Operation<Stream, OperationMetadata> response = datastreamClient.CreateStream(request);

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

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

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Stream stream = new Stream();
string streamId = "";
// Make the request
Operation<Stream, OperationMetadata> response = datastreamClient.CreateStream(parent, stream, streamId);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Stream stream = new Stream();
string streamId = "";
// Make the request
Operation<Stream, OperationMetadata> response = await datastreamClient.CreateStreamAsync(parent, stream, streamId);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Stream stream = new Stream();
string streamId = "";
// Make the request
Operation<Stream, OperationMetadata> response = await datastreamClient.CreateStreamAsync(parent, stream, streamId);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
CreateStreamRequest request = new CreateStreamRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    StreamId = "",
    Stream = new Stream(),
    RequestId = "",
    ValidateOnly = false,
    Force = false,
};
// Make the request
Operation<Stream, OperationMetadata> response = await datastreamClient.CreateStreamAsync(request);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
CreateStreamRequest request = new CreateStreamRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    StreamId = "",
    Stream = new Stream(),
    RequestId = "",
    ValidateOnly = false,
    Force = false,
};
// Make the request
Operation<Stream, OperationMetadata> response = await datastreamClient.CreateStreamAsync(request);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Stream stream = new Stream();
string streamId = "";
// Make the request
Operation<Stream, OperationMetadata> response = await datastreamClient.CreateStreamAsync(parent, stream, streamId);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Stream stream = new Stream();
string streamId = "";
// Make the request
Operation<Stream, OperationMetadata> response = await datastreamClient.CreateStreamAsync(parent, stream, streamId);

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

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

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
ConnectionProfileName name = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]");
// Make the request
Operation<Empty, OperationMetadata> response = datastreamClient.DeleteConnectionProfile(name);

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

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

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
DeleteConnectionProfileRequest request = new DeleteConnectionProfileRequest
{
    ConnectionProfileName = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = datastreamClient.DeleteConnectionProfile(request);

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

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

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectionProfiles/[CONNECTION_PROFILE]";
// Make the request
Operation<Empty, OperationMetadata> response = datastreamClient.DeleteConnectionProfile(name);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
ConnectionProfileName name = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]");
// Make the request
Operation<Empty, OperationMetadata> response = await datastreamClient.DeleteConnectionProfileAsync(name);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
ConnectionProfileName name = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]");
// Make the request
Operation<Empty, OperationMetadata> response = await datastreamClient.DeleteConnectionProfileAsync(name);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
DeleteConnectionProfileRequest request = new DeleteConnectionProfileRequest
{
    ConnectionProfileName = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await datastreamClient.DeleteConnectionProfileAsync(request);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
DeleteConnectionProfileRequest request = new DeleteConnectionProfileRequest
{
    ConnectionProfileName = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await datastreamClient.DeleteConnectionProfileAsync(request);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectionProfiles/[CONNECTION_PROFILE]";
// Make the request
Operation<Empty, OperationMetadata> response = await datastreamClient.DeleteConnectionProfileAsync(name);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectionProfiles/[CONNECTION_PROFILE]";
// Make the request
Operation<Empty, OperationMetadata> response = await datastreamClient.DeleteConnectionProfileAsync(name);

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

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

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
DeletePrivateConnectionRequest request = new DeletePrivateConnectionRequest
{
    PrivateConnectionName = PrivateConnectionName.FromProjectLocationPrivateConnection("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = datastreamClient.DeletePrivateConnection(request);

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

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

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
PrivateConnectionName name = PrivateConnectionName.FromProjectLocationPrivateConnection("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]");
// Make the request
Operation<Empty, OperationMetadata> response = datastreamClient.DeletePrivateConnection(name);

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

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

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/privateConnections/[PRIVATE_CONNECTION]";
// Make the request
Operation<Empty, OperationMetadata> response = datastreamClient.DeletePrivateConnection(name);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
DeletePrivateConnectionRequest request = new DeletePrivateConnectionRequest
{
    PrivateConnectionName = PrivateConnectionName.FromProjectLocationPrivateConnection("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await datastreamClient.DeletePrivateConnectionAsync(request);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
DeletePrivateConnectionRequest request = new DeletePrivateConnectionRequest
{
    PrivateConnectionName = PrivateConnectionName.FromProjectLocationPrivateConnection("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await datastreamClient.DeletePrivateConnectionAsync(request);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
PrivateConnectionName name = PrivateConnectionName.FromProjectLocationPrivateConnection("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]");
// Make the request
Operation<Empty, OperationMetadata> response = await datastreamClient.DeletePrivateConnectionAsync(name);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
PrivateConnectionName name = PrivateConnectionName.FromProjectLocationPrivateConnection("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]");
// Make the request
Operation<Empty, OperationMetadata> response = await datastreamClient.DeletePrivateConnectionAsync(name);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/privateConnections/[PRIVATE_CONNECTION]";
// Make the request
Operation<Empty, OperationMetadata> response = await datastreamClient.DeletePrivateConnectionAsync(name);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/privateConnections/[PRIVATE_CONNECTION]";
// Make the request
Operation<Empty, OperationMetadata> response = await datastreamClient.DeletePrivateConnectionAsync(name);

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

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

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
DeleteRouteRequest request = new DeleteRouteRequest
{
    RouteName = RouteName.FromProjectLocationPrivateConnectionRoute("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]", "[ROUTE]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = datastreamClient.DeleteRoute(request);

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

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

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
RouteName name = RouteName.FromProjectLocationPrivateConnectionRoute("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]", "[ROUTE]");
// Make the request
Operation<Empty, OperationMetadata> response = datastreamClient.DeleteRoute(name);

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

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

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/privateConnections/[PRIVATE_CONNECTION]/routes/[ROUTE]";
// Make the request
Operation<Empty, OperationMetadata> response = datastreamClient.DeleteRoute(name);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
DeleteRouteRequest request = new DeleteRouteRequest
{
    RouteName = RouteName.FromProjectLocationPrivateConnectionRoute("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]", "[ROUTE]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await datastreamClient.DeleteRouteAsync(request);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
DeleteRouteRequest request = new DeleteRouteRequest
{
    RouteName = RouteName.FromProjectLocationPrivateConnectionRoute("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]", "[ROUTE]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await datastreamClient.DeleteRouteAsync(request);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
RouteName name = RouteName.FromProjectLocationPrivateConnectionRoute("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]", "[ROUTE]");
// Make the request
Operation<Empty, OperationMetadata> response = await datastreamClient.DeleteRouteAsync(name);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
RouteName name = RouteName.FromProjectLocationPrivateConnectionRoute("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]", "[ROUTE]");
// Make the request
Operation<Empty, OperationMetadata> response = await datastreamClient.DeleteRouteAsync(name);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/privateConnections/[PRIVATE_CONNECTION]/routes/[ROUTE]";
// Make the request
Operation<Empty, OperationMetadata> response = await datastreamClient.DeleteRouteAsync(name);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/privateConnections/[PRIVATE_CONNECTION]/routes/[ROUTE]";
// Make the request
Operation<Empty, OperationMetadata> response = await datastreamClient.DeleteRouteAsync(name);

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

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

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
DeleteStreamRequest request = new DeleteStreamRequest
{
    StreamName = StreamName.FromProjectLocationStream("[PROJECT]", "[LOCATION]", "[STREAM]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = datastreamClient.DeleteStream(request);

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

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

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
StreamName name = StreamName.FromProjectLocationStream("[PROJECT]", "[LOCATION]", "[STREAM]");
// Make the request
Operation<Empty, OperationMetadata> response = datastreamClient.DeleteStream(name);

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

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

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/streams/[STREAM]";
// Make the request
Operation<Empty, OperationMetadata> response = datastreamClient.DeleteStream(name);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
DeleteStreamRequest request = new DeleteStreamRequest
{
    StreamName = StreamName.FromProjectLocationStream("[PROJECT]", "[LOCATION]", "[STREAM]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await datastreamClient.DeleteStreamAsync(request);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
DeleteStreamRequest request = new DeleteStreamRequest
{
    StreamName = StreamName.FromProjectLocationStream("[PROJECT]", "[LOCATION]", "[STREAM]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await datastreamClient.DeleteStreamAsync(request);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
StreamName name = StreamName.FromProjectLocationStream("[PROJECT]", "[LOCATION]", "[STREAM]");
// Make the request
Operation<Empty, OperationMetadata> response = await datastreamClient.DeleteStreamAsync(name);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
StreamName name = StreamName.FromProjectLocationStream("[PROJECT]", "[LOCATION]", "[STREAM]");
// Make the request
Operation<Empty, OperationMetadata> response = await datastreamClient.DeleteStreamAsync(name);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/streams/[STREAM]";
// Make the request
Operation<Empty, OperationMetadata> response = await datastreamClient.DeleteStreamAsync(name);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/streams/[STREAM]";
// Make the request
Operation<Empty, OperationMetadata> response = await datastreamClient.DeleteStreamAsync(name);

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

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

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
DiscoverConnectionProfileRequest request = new DiscoverConnectionProfileRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Recursive = false,
    OracleRdbms = new OracleRdbms(),
    ConnectionProfile = new ConnectionProfile(),
};
// Make the request
DiscoverConnectionProfileResponse response = datastreamClient.DiscoverConnectionProfile(request);

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
DiscoverConnectionProfileRequest request = new DiscoverConnectionProfileRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Recursive = false,
    OracleRdbms = new OracleRdbms(),
    ConnectionProfile = new ConnectionProfile(),
};
// Make the request
DiscoverConnectionProfileResponse response = await datastreamClient.DiscoverConnectionProfileAsync(request);

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
DiscoverConnectionProfileRequest request = new DiscoverConnectionProfileRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Recursive = false,
    OracleRdbms = new OracleRdbms(),
    ConnectionProfile = new ConnectionProfile(),
};
// Make the request
DiscoverConnectionProfileResponse response = await datastreamClient.DiscoverConnectionProfileAsync(request);

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
FetchErrorsRequest request = new FetchErrorsRequest
{
    StreamAsStreamName = StreamName.FromProjectLocationStream("[PROJECT]", "[LOCATION]", "[STREAM]"),
};
// Make the request
Operation<FetchErrorsResponse, OperationMetadata> response = datastreamClient.FetchErrors(request);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
FetchErrorsRequest request = new FetchErrorsRequest
{
    StreamAsStreamName = StreamName.FromProjectLocationStream("[PROJECT]", "[LOCATION]", "[STREAM]"),
};
// Make the request
Operation<FetchErrorsResponse, OperationMetadata> response = await datastreamClient.FetchErrorsAsync(request);

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

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

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
FetchErrorsRequest request = new FetchErrorsRequest
{
    StreamAsStreamName = StreamName.FromProjectLocationStream("[PROJECT]", "[LOCATION]", "[STREAM]"),
};
// Make the request
Operation<FetchErrorsResponse, OperationMetadata> response = await datastreamClient.FetchErrorsAsync(request);

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

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

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
LocationName name = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<FetchStaticIpsResponse, string> response = datastreamClient.FetchStaticIps(name);

// Iterate over all response items, lazily performing RPCs as required
foreach (string 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 (FetchStaticIpsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (string 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<string> 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 (string 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
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
FetchStaticIpsRequest request = new FetchStaticIpsRequest
{
    LocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
PagedEnumerable<FetchStaticIpsResponse, string> response = datastreamClient.FetchStaticIps(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (string 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 (FetchStaticIpsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (string 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<string> 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 (string 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
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<FetchStaticIpsResponse, string> response = datastreamClient.FetchStaticIps(name);

// Iterate over all response items, lazily performing RPCs as required
foreach (string 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 (FetchStaticIpsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (string 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<string> 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 (string 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
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
LocationName name = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<FetchStaticIpsResponse, string> response = datastreamClient.FetchStaticIpsAsync(name);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((string 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((FetchStaticIpsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (string 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<string> 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 (string 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
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
FetchStaticIpsRequest request = new FetchStaticIpsRequest
{
    LocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
PagedAsyncEnumerable<FetchStaticIpsResponse, string> response = datastreamClient.FetchStaticIpsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((string 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((FetchStaticIpsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (string 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<string> 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 (string 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
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<FetchStaticIpsResponse, string> response = datastreamClient.FetchStaticIpsAsync(name);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((string 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((FetchStaticIpsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (string 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<string> 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 (string 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
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
ConnectionProfileName name = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]");
// Make the request
ConnectionProfile response = datastreamClient.GetConnectionProfile(name);

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
GetConnectionProfileRequest request = new GetConnectionProfileRequest
{
    ConnectionProfileName = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]"),
};
// Make the request
ConnectionProfile response = datastreamClient.GetConnectionProfile(request);

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectionProfiles/[CONNECTION_PROFILE]";
// Make the request
ConnectionProfile response = datastreamClient.GetConnectionProfile(name);

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
ConnectionProfileName name = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]");
// Make the request
ConnectionProfile response = await datastreamClient.GetConnectionProfileAsync(name);

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
ConnectionProfileName name = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]");
// Make the request
ConnectionProfile response = await datastreamClient.GetConnectionProfileAsync(name);

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
GetConnectionProfileRequest request = new GetConnectionProfileRequest
{
    ConnectionProfileName = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]"),
};
// Make the request
ConnectionProfile response = await datastreamClient.GetConnectionProfileAsync(request);

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
GetConnectionProfileRequest request = new GetConnectionProfileRequest
{
    ConnectionProfileName = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]"),
};
// Make the request
ConnectionProfile response = await datastreamClient.GetConnectionProfileAsync(request);

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectionProfiles/[CONNECTION_PROFILE]";
// Make the request
ConnectionProfile response = await datastreamClient.GetConnectionProfileAsync(name);

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectionProfiles/[CONNECTION_PROFILE]";
// Make the request
ConnectionProfile response = await datastreamClient.GetConnectionProfileAsync(name);

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
GetPrivateConnectionRequest request = new GetPrivateConnectionRequest
{
    PrivateConnectionName = PrivateConnectionName.FromProjectLocationPrivateConnection("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]"),
};
// Make the request
PrivateConnection response = datastreamClient.GetPrivateConnection(request);

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
PrivateConnectionName name = PrivateConnectionName.FromProjectLocationPrivateConnection("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]");
// Make the request
PrivateConnection response = datastreamClient.GetPrivateConnection(name);

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/privateConnections/[PRIVATE_CONNECTION]";
// Make the request
PrivateConnection response = datastreamClient.GetPrivateConnection(name);

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
GetPrivateConnectionRequest request = new GetPrivateConnectionRequest
{
    PrivateConnectionName = PrivateConnectionName.FromProjectLocationPrivateConnection("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]"),
};
// Make the request
PrivateConnection response = await datastreamClient.GetPrivateConnectionAsync(request);

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
GetPrivateConnectionRequest request = new GetPrivateConnectionRequest
{
    PrivateConnectionName = PrivateConnectionName.FromProjectLocationPrivateConnection("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]"),
};
// Make the request
PrivateConnection response = await datastreamClient.GetPrivateConnectionAsync(request);

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
PrivateConnectionName name = PrivateConnectionName.FromProjectLocationPrivateConnection("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]");
// Make the request
PrivateConnection response = await datastreamClient.GetPrivateConnectionAsync(name);

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
PrivateConnectionName name = PrivateConnectionName.FromProjectLocationPrivateConnection("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]");
// Make the request
PrivateConnection response = await datastreamClient.GetPrivateConnectionAsync(name);

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/privateConnections/[PRIVATE_CONNECTION]";
// Make the request
PrivateConnection response = await datastreamClient.GetPrivateConnectionAsync(name);

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/privateConnections/[PRIVATE_CONNECTION]";
// Make the request
PrivateConnection response = await datastreamClient.GetPrivateConnectionAsync(name);

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
GetRouteRequest request = new GetRouteRequest
{
    RouteName = RouteName.FromProjectLocationPrivateConnectionRoute("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]", "[ROUTE]"),
};
// Make the request
Route response = datastreamClient.GetRoute(request);

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
RouteName name = RouteName.FromProjectLocationPrivateConnectionRoute("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]", "[ROUTE]");
// Make the request
Route response = datastreamClient.GetRoute(name);

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/privateConnections/[PRIVATE_CONNECTION]/routes/[ROUTE]";
// Make the request
Route response = datastreamClient.GetRoute(name);

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
GetRouteRequest request = new GetRouteRequest
{
    RouteName = RouteName.FromProjectLocationPrivateConnectionRoute("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]", "[ROUTE]"),
};
// Make the request
Route response = await datastreamClient.GetRouteAsync(request);

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
GetRouteRequest request = new GetRouteRequest
{
    RouteName = RouteName.FromProjectLocationPrivateConnectionRoute("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]", "[ROUTE]"),
};
// Make the request
Route response = await datastreamClient.GetRouteAsync(request);

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
RouteName name = RouteName.FromProjectLocationPrivateConnectionRoute("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]", "[ROUTE]");
// Make the request
Route response = await datastreamClient.GetRouteAsync(name);

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
RouteName name = RouteName.FromProjectLocationPrivateConnectionRoute("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]", "[ROUTE]");
// Make the request
Route response = await datastreamClient.GetRouteAsync(name);

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/privateConnections/[PRIVATE_CONNECTION]/routes/[ROUTE]";
// Make the request
Route response = await datastreamClient.GetRouteAsync(name);

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/privateConnections/[PRIVATE_CONNECTION]/routes/[ROUTE]";
// Make the request
Route response = await datastreamClient.GetRouteAsync(name);

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
GetStreamRequest request = new GetStreamRequest
{
    StreamName = StreamName.FromProjectLocationStream("[PROJECT]", "[LOCATION]", "[STREAM]"),
};
// Make the request
Stream response = datastreamClient.GetStream(request);

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
StreamName name = StreamName.FromProjectLocationStream("[PROJECT]", "[LOCATION]", "[STREAM]");
// Make the request
Stream response = datastreamClient.GetStream(name);

// Create client
DatastreamClient datastreamClient = DatastreamClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/streams/[STREAM]";
// Make the request
Stream response = datastreamClient.GetStream(name);

// Create client
DatastreamClient datastreamClient = await DatastreamClient.CreateAsync();
// Initialize request argument(s)
GetStreamRequest request = new GetStreamRequest
{
    StreamName = StreamName.FromProjectLocationStream("[PROJECT]", "[LOCATION]", "[STREAM]"),
};
// Make the request
Stream response = await datastreamClient.GetStreamAsync(request);