Cloud Storage v2 API - Class StorageControlClient (1.3.0)

Stay organized with collections Save and categorize content based on your preferences.

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
BucketName parent = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]");
AnywhereCache anywhereCache = new AnywhereCache();
// Make the request
Operation<AnywhereCache, CreateAnywhereCacheMetadata> response = storageControlClient.CreateAnywhereCache(parent, anywhereCache);

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

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
CreateAnywhereCacheRequest request = new CreateAnywhereCacheRequest
{
    ParentAsBucketName = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]"),
    AnywhereCache = new AnywhereCache(),
};
// Make the request
Operation<AnywhereCache, CreateAnywhereCacheMetadata> response = storageControlClient.CreateAnywhereCache(request);

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

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/buckets/[BUCKET]";
AnywhereCache anywhereCache = new AnywhereCache();
// Make the request
Operation<AnywhereCache, CreateAnywhereCacheMetadata> response = storageControlClient.CreateAnywhereCache(parent, anywhereCache);

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

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
BucketName parent = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]");
AnywhereCache anywhereCache = new AnywhereCache();
// Make the request
Operation<AnywhereCache, CreateAnywhereCacheMetadata> response = await storageControlClient.CreateAnywhereCacheAsync(parent, anywhereCache);

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

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
BucketName parent = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]");
AnywhereCache anywhereCache = new AnywhereCache();
// Make the request
Operation<AnywhereCache, CreateAnywhereCacheMetadata> response = await storageControlClient.CreateAnywhereCacheAsync(parent, anywhereCache);

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

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
CreateAnywhereCacheRequest request = new CreateAnywhereCacheRequest
{
    ParentAsBucketName = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]"),
    AnywhereCache = new AnywhereCache(),
};
// Make the request
Operation<AnywhereCache, CreateAnywhereCacheMetadata> response = await storageControlClient.CreateAnywhereCacheAsync(request);

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

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
CreateAnywhereCacheRequest request = new CreateAnywhereCacheRequest
{
    ParentAsBucketName = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]"),
    AnywhereCache = new AnywhereCache(),
};
// Make the request
Operation<AnywhereCache, CreateAnywhereCacheMetadata> response = await storageControlClient.CreateAnywhereCacheAsync(request);

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

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/buckets/[BUCKET]";
AnywhereCache anywhereCache = new AnywhereCache();
// Make the request
Operation<AnywhereCache, CreateAnywhereCacheMetadata> response = await storageControlClient.CreateAnywhereCacheAsync(parent, anywhereCache);

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

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/buckets/[BUCKET]";
AnywhereCache anywhereCache = new AnywhereCache();
// Make the request
Operation<AnywhereCache, CreateAnywhereCacheMetadata> response = await storageControlClient.CreateAnywhereCacheAsync(parent, anywhereCache);

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

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
BucketName parent = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]");
Folder folder = new Folder();
string folderId = "";
// Make the request
Folder response = storageControlClient.CreateFolder(parent, folder, folderId);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
CreateFolderRequest request = new CreateFolderRequest
{
    ParentAsBucketName = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]"),
    Folder = new Folder(),
    FolderId = "",
    Recursive = false,
};
// Make the request
Folder response = storageControlClient.CreateFolder(request);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/buckets/[BUCKET]";
Folder folder = new Folder();
string folderId = "";
// Make the request
Folder response = storageControlClient.CreateFolder(parent, folder, folderId);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
BucketName parent = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]");
Folder folder = new Folder();
string folderId = "";
// Make the request
Folder response = await storageControlClient.CreateFolderAsync(parent, folder, folderId);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
BucketName parent = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]");
Folder folder = new Folder();
string folderId = "";
// Make the request
Folder response = await storageControlClient.CreateFolderAsync(parent, folder, folderId);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
CreateFolderRequest request = new CreateFolderRequest
{
    ParentAsBucketName = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]"),
    Folder = new Folder(),
    FolderId = "",
    Recursive = false,
};
// Make the request
Folder response = await storageControlClient.CreateFolderAsync(request);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
CreateFolderRequest request = new CreateFolderRequest
{
    ParentAsBucketName = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]"),
    Folder = new Folder(),
    FolderId = "",
    Recursive = false,
};
// Make the request
Folder response = await storageControlClient.CreateFolderAsync(request);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/buckets/[BUCKET]";
Folder folder = new Folder();
string folderId = "";
// Make the request
Folder response = await storageControlClient.CreateFolderAsync(parent, folder, folderId);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/buckets/[BUCKET]";
Folder folder = new Folder();
string folderId = "";
// Make the request
Folder response = await storageControlClient.CreateFolderAsync(parent, folder, folderId);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
BucketName parent = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]");
ManagedFolder managedFolder = new ManagedFolder();
string managedFolderId = "";
// Make the request
ManagedFolder response = storageControlClient.CreateManagedFolder(parent, managedFolder, managedFolderId);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
CreateManagedFolderRequest request = new CreateManagedFolderRequest
{
    ParentAsBucketName = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]"),
    ManagedFolder = new ManagedFolder(),
    ManagedFolderId = "",
};
// Make the request
ManagedFolder response = storageControlClient.CreateManagedFolder(request);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/buckets/[BUCKET]";
ManagedFolder managedFolder = new ManagedFolder();
string managedFolderId = "";
// Make the request
ManagedFolder response = storageControlClient.CreateManagedFolder(parent, managedFolder, managedFolderId);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
BucketName parent = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]");
ManagedFolder managedFolder = new ManagedFolder();
string managedFolderId = "";
// Make the request
ManagedFolder response = await storageControlClient.CreateManagedFolderAsync(parent, managedFolder, managedFolderId);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
BucketName parent = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]");
ManagedFolder managedFolder = new ManagedFolder();
string managedFolderId = "";
// Make the request
ManagedFolder response = await storageControlClient.CreateManagedFolderAsync(parent, managedFolder, managedFolderId);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
CreateManagedFolderRequest request = new CreateManagedFolderRequest
{
    ParentAsBucketName = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]"),
    ManagedFolder = new ManagedFolder(),
    ManagedFolderId = "",
};
// Make the request
ManagedFolder response = await storageControlClient.CreateManagedFolderAsync(request);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
CreateManagedFolderRequest request = new CreateManagedFolderRequest
{
    ParentAsBucketName = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]"),
    ManagedFolder = new ManagedFolder(),
    ManagedFolderId = "",
};
// Make the request
ManagedFolder response = await storageControlClient.CreateManagedFolderAsync(request);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/buckets/[BUCKET]";
ManagedFolder managedFolder = new ManagedFolder();
string managedFolderId = "";
// Make the request
ManagedFolder response = await storageControlClient.CreateManagedFolderAsync(parent, managedFolder, managedFolderId);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/buckets/[BUCKET]";
ManagedFolder managedFolder = new ManagedFolder();
string managedFolderId = "";
// Make the request
ManagedFolder response = await storageControlClient.CreateManagedFolderAsync(parent, managedFolder, managedFolderId);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
DeleteFolderRequest request = new DeleteFolderRequest
{
    IfMetagenerationMatch = 0L,
    IfMetagenerationNotMatch = 0L,
    FolderName = FolderName.FromProjectBucketFolder("[PROJECT]", "[BUCKET]", "[FOLDER]"),
};
// Make the request
storageControlClient.DeleteFolder(request);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
FolderName name = FolderName.FromProjectBucketFolder("[PROJECT]", "[BUCKET]", "[FOLDER]");
// Make the request
storageControlClient.DeleteFolder(name);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/buckets/[BUCKET]/folders/[FOLDER]";
// Make the request
storageControlClient.DeleteFolder(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
DeleteFolderRequest request = new DeleteFolderRequest
{
    IfMetagenerationMatch = 0L,
    IfMetagenerationNotMatch = 0L,
    FolderName = FolderName.FromProjectBucketFolder("[PROJECT]", "[BUCKET]", "[FOLDER]"),
};
// Make the request
await storageControlClient.DeleteFolderAsync(request);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
DeleteFolderRequest request = new DeleteFolderRequest
{
    IfMetagenerationMatch = 0L,
    IfMetagenerationNotMatch = 0L,
    FolderName = FolderName.FromProjectBucketFolder("[PROJECT]", "[BUCKET]", "[FOLDER]"),
};
// Make the request
await storageControlClient.DeleteFolderAsync(request);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
FolderName name = FolderName.FromProjectBucketFolder("[PROJECT]", "[BUCKET]", "[FOLDER]");
// Make the request
await storageControlClient.DeleteFolderAsync(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
FolderName name = FolderName.FromProjectBucketFolder("[PROJECT]", "[BUCKET]", "[FOLDER]");
// Make the request
await storageControlClient.DeleteFolderAsync(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/buckets/[BUCKET]/folders/[FOLDER]";
// Make the request
await storageControlClient.DeleteFolderAsync(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/buckets/[BUCKET]/folders/[FOLDER]";
// Make the request
await storageControlClient.DeleteFolderAsync(name);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
DeleteManagedFolderRequest request = new DeleteManagedFolderRequest
{
    IfMetagenerationMatch = 0L,
    IfMetagenerationNotMatch = 0L,
    AllowNonEmpty = false,
    ManagedFolderName = ManagedFolderName.FromProjectBucketManagedFolder("[PROJECT]", "[BUCKET]", "[MANAGED_FOLDER]"),
};
// Make the request
storageControlClient.DeleteManagedFolder(request);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
ManagedFolderName name = ManagedFolderName.FromProjectBucketManagedFolder("[PROJECT]", "[BUCKET]", "[MANAGED_FOLDER]");
// Make the request
storageControlClient.DeleteManagedFolder(name);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/buckets/[BUCKET]/managedFolders/[MANAGED_FOLDER]";
// Make the request
storageControlClient.DeleteManagedFolder(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
DeleteManagedFolderRequest request = new DeleteManagedFolderRequest
{
    IfMetagenerationMatch = 0L,
    IfMetagenerationNotMatch = 0L,
    AllowNonEmpty = false,
    ManagedFolderName = ManagedFolderName.FromProjectBucketManagedFolder("[PROJECT]", "[BUCKET]", "[MANAGED_FOLDER]"),
};
// Make the request
await storageControlClient.DeleteManagedFolderAsync(request);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
DeleteManagedFolderRequest request = new DeleteManagedFolderRequest
{
    IfMetagenerationMatch = 0L,
    IfMetagenerationNotMatch = 0L,
    AllowNonEmpty = false,
    ManagedFolderName = ManagedFolderName.FromProjectBucketManagedFolder("[PROJECT]", "[BUCKET]", "[MANAGED_FOLDER]"),
};
// Make the request
await storageControlClient.DeleteManagedFolderAsync(request);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
ManagedFolderName name = ManagedFolderName.FromProjectBucketManagedFolder("[PROJECT]", "[BUCKET]", "[MANAGED_FOLDER]");
// Make the request
await storageControlClient.DeleteManagedFolderAsync(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
ManagedFolderName name = ManagedFolderName.FromProjectBucketManagedFolder("[PROJECT]", "[BUCKET]", "[MANAGED_FOLDER]");
// Make the request
await storageControlClient.DeleteManagedFolderAsync(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/buckets/[BUCKET]/managedFolders/[MANAGED_FOLDER]";
// Make the request
await storageControlClient.DeleteManagedFolderAsync(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/buckets/[BUCKET]/managedFolders/[MANAGED_FOLDER]";
// Make the request
await storageControlClient.DeleteManagedFolderAsync(name);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
AnywhereCacheName name = AnywhereCacheName.FromProjectBucketAnywhereCache("[PROJECT]", "[BUCKET]", "[ANYWHERE_CACHE]");
// Make the request
AnywhereCache response = storageControlClient.DisableAnywhereCache(name);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
DisableAnywhereCacheRequest request = new DisableAnywhereCacheRequest
{
    AnywhereCacheName = AnywhereCacheName.FromProjectBucketAnywhereCache("[PROJECT]", "[BUCKET]", "[ANYWHERE_CACHE]"),
};
// Make the request
AnywhereCache response = storageControlClient.DisableAnywhereCache(request);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/buckets/[BUCKET]/anywhereCaches/[ANYWHERE_CACHE]";
// Make the request
AnywhereCache response = storageControlClient.DisableAnywhereCache(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
AnywhereCacheName name = AnywhereCacheName.FromProjectBucketAnywhereCache("[PROJECT]", "[BUCKET]", "[ANYWHERE_CACHE]");
// Make the request
AnywhereCache response = await storageControlClient.DisableAnywhereCacheAsync(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
AnywhereCacheName name = AnywhereCacheName.FromProjectBucketAnywhereCache("[PROJECT]", "[BUCKET]", "[ANYWHERE_CACHE]");
// Make the request
AnywhereCache response = await storageControlClient.DisableAnywhereCacheAsync(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
DisableAnywhereCacheRequest request = new DisableAnywhereCacheRequest
{
    AnywhereCacheName = AnywhereCacheName.FromProjectBucketAnywhereCache("[PROJECT]", "[BUCKET]", "[ANYWHERE_CACHE]"),
};
// Make the request
AnywhereCache response = await storageControlClient.DisableAnywhereCacheAsync(request);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
DisableAnywhereCacheRequest request = new DisableAnywhereCacheRequest
{
    AnywhereCacheName = AnywhereCacheName.FromProjectBucketAnywhereCache("[PROJECT]", "[BUCKET]", "[ANYWHERE_CACHE]"),
};
// Make the request
AnywhereCache response = await storageControlClient.DisableAnywhereCacheAsync(request);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/buckets/[BUCKET]/anywhereCaches/[ANYWHERE_CACHE]";
// Make the request
AnywhereCache response = await storageControlClient.DisableAnywhereCacheAsync(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/buckets/[BUCKET]/anywhereCaches/[ANYWHERE_CACHE]";
// Make the request
AnywhereCache response = await storageControlClient.DisableAnywhereCacheAsync(name);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
AnywhereCacheName name = AnywhereCacheName.FromProjectBucketAnywhereCache("[PROJECT]", "[BUCKET]", "[ANYWHERE_CACHE]");
// Make the request
AnywhereCache response = storageControlClient.GetAnywhereCache(name);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
GetAnywhereCacheRequest request = new GetAnywhereCacheRequest
{
    AnywhereCacheName = AnywhereCacheName.FromProjectBucketAnywhereCache("[PROJECT]", "[BUCKET]", "[ANYWHERE_CACHE]"),
};
// Make the request
AnywhereCache response = storageControlClient.GetAnywhereCache(request);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/buckets/[BUCKET]/anywhereCaches/[ANYWHERE_CACHE]";
// Make the request
AnywhereCache response = storageControlClient.GetAnywhereCache(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
AnywhereCacheName name = AnywhereCacheName.FromProjectBucketAnywhereCache("[PROJECT]", "[BUCKET]", "[ANYWHERE_CACHE]");
// Make the request
AnywhereCache response = await storageControlClient.GetAnywhereCacheAsync(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
AnywhereCacheName name = AnywhereCacheName.FromProjectBucketAnywhereCache("[PROJECT]", "[BUCKET]", "[ANYWHERE_CACHE]");
// Make the request
AnywhereCache response = await storageControlClient.GetAnywhereCacheAsync(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
GetAnywhereCacheRequest request = new GetAnywhereCacheRequest
{
    AnywhereCacheName = AnywhereCacheName.FromProjectBucketAnywhereCache("[PROJECT]", "[BUCKET]", "[ANYWHERE_CACHE]"),
};
// Make the request
AnywhereCache response = await storageControlClient.GetAnywhereCacheAsync(request);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
GetAnywhereCacheRequest request = new GetAnywhereCacheRequest
{
    AnywhereCacheName = AnywhereCacheName.FromProjectBucketAnywhereCache("[PROJECT]", "[BUCKET]", "[ANYWHERE_CACHE]"),
};
// Make the request
AnywhereCache response = await storageControlClient.GetAnywhereCacheAsync(request);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/buckets/[BUCKET]/anywhereCaches/[ANYWHERE_CACHE]";
// Make the request
AnywhereCache response = await storageControlClient.GetAnywhereCacheAsync(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/buckets/[BUCKET]/anywhereCaches/[ANYWHERE_CACHE]";
// Make the request
AnywhereCache response = await storageControlClient.GetAnywhereCacheAsync(name);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
FolderName name = FolderName.FromProjectBucketFolder("[PROJECT]", "[BUCKET]", "[FOLDER]");
// Make the request
Folder response = storageControlClient.GetFolder(name);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
GetFolderRequest request = new GetFolderRequest
{
    IfMetagenerationMatch = 0L,
    IfMetagenerationNotMatch = 0L,
    FolderName = FolderName.FromProjectBucketFolder("[PROJECT]", "[BUCKET]", "[FOLDER]"),
};
// Make the request
Folder response = storageControlClient.GetFolder(request);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/buckets/[BUCKET]/folders/[FOLDER]";
// Make the request
Folder response = storageControlClient.GetFolder(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
FolderName name = FolderName.FromProjectBucketFolder("[PROJECT]", "[BUCKET]", "[FOLDER]");
// Make the request
Folder response = await storageControlClient.GetFolderAsync(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
FolderName name = FolderName.FromProjectBucketFolder("[PROJECT]", "[BUCKET]", "[FOLDER]");
// Make the request
Folder response = await storageControlClient.GetFolderAsync(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
GetFolderRequest request = new GetFolderRequest
{
    IfMetagenerationMatch = 0L,
    IfMetagenerationNotMatch = 0L,
    FolderName = FolderName.FromProjectBucketFolder("[PROJECT]", "[BUCKET]", "[FOLDER]"),
};
// Make the request
Folder response = await storageControlClient.GetFolderAsync(request);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
GetFolderRequest request = new GetFolderRequest
{
    IfMetagenerationMatch = 0L,
    IfMetagenerationNotMatch = 0L,
    FolderName = FolderName.FromProjectBucketFolder("[PROJECT]", "[BUCKET]", "[FOLDER]"),
};
// Make the request
Folder response = await storageControlClient.GetFolderAsync(request);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/buckets/[BUCKET]/folders/[FOLDER]";
// Make the request
Folder response = await storageControlClient.GetFolderAsync(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/buckets/[BUCKET]/folders/[FOLDER]";
// Make the request
Folder response = await storageControlClient.GetFolderAsync(name);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
GetManagedFolderRequest request = new GetManagedFolderRequest
{
    IfMetagenerationMatch = 0L,
    IfMetagenerationNotMatch = 0L,
    ManagedFolderName = ManagedFolderName.FromProjectBucketManagedFolder("[PROJECT]", "[BUCKET]", "[MANAGED_FOLDER]"),
};
// Make the request
ManagedFolder response = storageControlClient.GetManagedFolder(request);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
ManagedFolderName name = ManagedFolderName.FromProjectBucketManagedFolder("[PROJECT]", "[BUCKET]", "[MANAGED_FOLDER]");
// Make the request
ManagedFolder response = storageControlClient.GetManagedFolder(name);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/buckets/[BUCKET]/managedFolders/[MANAGED_FOLDER]";
// Make the request
ManagedFolder response = storageControlClient.GetManagedFolder(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
GetManagedFolderRequest request = new GetManagedFolderRequest
{
    IfMetagenerationMatch = 0L,
    IfMetagenerationNotMatch = 0L,
    ManagedFolderName = ManagedFolderName.FromProjectBucketManagedFolder("[PROJECT]", "[BUCKET]", "[MANAGED_FOLDER]"),
};
// Make the request
ManagedFolder response = await storageControlClient.GetManagedFolderAsync(request);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
GetManagedFolderRequest request = new GetManagedFolderRequest
{
    IfMetagenerationMatch = 0L,
    IfMetagenerationNotMatch = 0L,
    ManagedFolderName = ManagedFolderName.FromProjectBucketManagedFolder("[PROJECT]", "[BUCKET]", "[MANAGED_FOLDER]"),
};
// Make the request
ManagedFolder response = await storageControlClient.GetManagedFolderAsync(request);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
ManagedFolderName name = ManagedFolderName.FromProjectBucketManagedFolder("[PROJECT]", "[BUCKET]", "[MANAGED_FOLDER]");
// Make the request
ManagedFolder response = await storageControlClient.GetManagedFolderAsync(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
ManagedFolderName name = ManagedFolderName.FromProjectBucketManagedFolder("[PROJECT]", "[BUCKET]", "[MANAGED_FOLDER]");
// Make the request
ManagedFolder response = await storageControlClient.GetManagedFolderAsync(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/buckets/[BUCKET]/managedFolders/[MANAGED_FOLDER]";
// Make the request
ManagedFolder response = await storageControlClient.GetManagedFolderAsync(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/buckets/[BUCKET]/managedFolders/[MANAGED_FOLDER]";
// Make the request
ManagedFolder response = await storageControlClient.GetManagedFolderAsync(name);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
GetStorageLayoutRequest request = new GetStorageLayoutRequest
{
    StorageLayoutName = StorageLayoutName.FromProjectBucket("[PROJECT]", "[BUCKET]"),
    Prefix = "",
};
// Make the request
StorageLayout response = storageControlClient.GetStorageLayout(request);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
StorageLayoutName name = StorageLayoutName.FromProjectBucket("[PROJECT]", "[BUCKET]");
// Make the request
StorageLayout response = storageControlClient.GetStorageLayout(name);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/buckets/[BUCKET]/storageLayout";
// Make the request
StorageLayout response = storageControlClient.GetStorageLayout(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
GetStorageLayoutRequest request = new GetStorageLayoutRequest
{
    StorageLayoutName = StorageLayoutName.FromProjectBucket("[PROJECT]", "[BUCKET]"),
    Prefix = "",
};
// Make the request
StorageLayout response = await storageControlClient.GetStorageLayoutAsync(request);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
GetStorageLayoutRequest request = new GetStorageLayoutRequest
{
    StorageLayoutName = StorageLayoutName.FromProjectBucket("[PROJECT]", "[BUCKET]"),
    Prefix = "",
};
// Make the request
StorageLayout response = await storageControlClient.GetStorageLayoutAsync(request);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
StorageLayoutName name = StorageLayoutName.FromProjectBucket("[PROJECT]", "[BUCKET]");
// Make the request
StorageLayout response = await storageControlClient.GetStorageLayoutAsync(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
StorageLayoutName name = StorageLayoutName.FromProjectBucket("[PROJECT]", "[BUCKET]");
// Make the request
StorageLayout response = await storageControlClient.GetStorageLayoutAsync(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/buckets/[BUCKET]/storageLayout";
// Make the request
StorageLayout response = await storageControlClient.GetStorageLayoutAsync(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/buckets/[BUCKET]/storageLayout";
// Make the request
StorageLayout response = await storageControlClient.GetStorageLayoutAsync(name);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
BucketName parent = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]");
// Make the request
PagedEnumerable<ListAnywhereCachesResponse, AnywhereCache> response = storageControlClient.ListAnywhereCaches(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (AnywhereCache 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 (ListAnywhereCachesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AnywhereCache 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<AnywhereCache> 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 (AnywhereCache 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
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
ListAnywhereCachesRequest request = new ListAnywhereCachesRequest
{
    ParentAsBucketName = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]"),
};
// Make the request
PagedEnumerable<ListAnywhereCachesResponse, AnywhereCache> response = storageControlClient.ListAnywhereCaches(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (AnywhereCache 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 (ListAnywhereCachesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AnywhereCache 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<AnywhereCache> 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 (AnywhereCache 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
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/buckets/[BUCKET]";
// Make the request
PagedEnumerable<ListAnywhereCachesResponse, AnywhereCache> response = storageControlClient.ListAnywhereCaches(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (AnywhereCache 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 (ListAnywhereCachesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AnywhereCache 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<AnywhereCache> 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 (AnywhereCache 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
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
BucketName parent = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]");
// Make the request
PagedAsyncEnumerable<ListAnywhereCachesResponse, AnywhereCache> response = storageControlClient.ListAnywhereCachesAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((AnywhereCache 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((ListAnywhereCachesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AnywhereCache 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<AnywhereCache> 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 (AnywhereCache 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
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
ListAnywhereCachesRequest request = new ListAnywhereCachesRequest
{
    ParentAsBucketName = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]"),
};
// Make the request
PagedAsyncEnumerable<ListAnywhereCachesResponse, AnywhereCache> response = storageControlClient.ListAnywhereCachesAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((AnywhereCache 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((ListAnywhereCachesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AnywhereCache 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<AnywhereCache> 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 (AnywhereCache 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
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/buckets/[BUCKET]";
// Make the request
PagedAsyncEnumerable<ListAnywhereCachesResponse, AnywhereCache> response = storageControlClient.ListAnywhereCachesAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((AnywhereCache 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((ListAnywhereCachesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AnywhereCache 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<AnywhereCache> 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 (AnywhereCache 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
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
BucketName parent = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]");
// Make the request
PagedEnumerable<ListFoldersResponse, Folder> response = storageControlClient.ListFolders(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Folder 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 (ListFoldersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Folder 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<Folder> 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 (Folder 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
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
ListFoldersRequest request = new ListFoldersRequest
{
    ParentAsBucketName = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]"),
    Prefix = "",
    LexicographicStart = "",
    LexicographicEnd = "",
    Delimiter = "",
    RequestId = "",
};
// Make the request
PagedEnumerable<ListFoldersResponse, Folder> response = storageControlClient.ListFolders(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (Folder 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 (ListFoldersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Folder 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<Folder> 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 (Folder 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
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/buckets/[BUCKET]";
// Make the request
PagedEnumerable<ListFoldersResponse, Folder> response = storageControlClient.ListFolders(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Folder 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 (ListFoldersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Folder 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<Folder> 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 (Folder 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
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
BucketName parent = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]");
// Make the request
PagedAsyncEnumerable<ListFoldersResponse, Folder> response = storageControlClient.ListFoldersAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Folder 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((ListFoldersResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Folder 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<Folder> 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 (Folder 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
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
ListFoldersRequest request = new ListFoldersRequest
{
    ParentAsBucketName = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]"),
    Prefix = "",
    LexicographicStart = "",
    LexicographicEnd = "",
    Delimiter = "",
    RequestId = "",
};
// Make the request
PagedAsyncEnumerable<ListFoldersResponse, Folder> response = storageControlClient.ListFoldersAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Folder 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((ListFoldersResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Folder 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<Folder> 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 (Folder 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
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/buckets/[BUCKET]";
// Make the request
PagedAsyncEnumerable<ListFoldersResponse, Folder> response = storageControlClient.ListFoldersAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Folder 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((ListFoldersResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Folder 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<Folder> 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 (Folder 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
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
BucketName parent = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]");
// Make the request
PagedEnumerable<ListManagedFoldersResponse, ManagedFolder> response = storageControlClient.ListManagedFolders(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (ManagedFolder 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 (ListManagedFoldersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ManagedFolder 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<ManagedFolder> 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 (ManagedFolder 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
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
ListManagedFoldersRequest request = new ListManagedFoldersRequest
{
    ParentAsBucketName = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]"),
    Prefix = "",
};
// Make the request
PagedEnumerable<ListManagedFoldersResponse, ManagedFolder> response = storageControlClient.ListManagedFolders(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (ManagedFolder 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 (ListManagedFoldersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ManagedFolder 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<ManagedFolder> 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 (ManagedFolder 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
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/buckets/[BUCKET]";
// Make the request
PagedEnumerable<ListManagedFoldersResponse, ManagedFolder> response = storageControlClient.ListManagedFolders(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (ManagedFolder 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 (ListManagedFoldersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ManagedFolder 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<ManagedFolder> 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 (ManagedFolder 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
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
BucketName parent = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]");
// Make the request
PagedAsyncEnumerable<ListManagedFoldersResponse, ManagedFolder> response = storageControlClient.ListManagedFoldersAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((ManagedFolder 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((ListManagedFoldersResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ManagedFolder 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<ManagedFolder> 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 (ManagedFolder 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
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
ListManagedFoldersRequest request = new ListManagedFoldersRequest
{
    ParentAsBucketName = BucketName.FromProjectBucket("[PROJECT]", "[BUCKET]"),
    Prefix = "",
};
// Make the request
PagedAsyncEnumerable<ListManagedFoldersResponse, ManagedFolder> response = storageControlClient.ListManagedFoldersAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((ManagedFolder 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((ListManagedFoldersResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ManagedFolder 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<ManagedFolder> 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 (ManagedFolder 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
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/buckets/[BUCKET]";
// Make the request
PagedAsyncEnumerable<ListManagedFoldersResponse, ManagedFolder> response = storageControlClient.ListManagedFoldersAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((ManagedFolder 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((ListManagedFoldersResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ManagedFolder 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<ManagedFolder> 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 (ManagedFolder 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
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
AnywhereCacheName name = AnywhereCacheName.FromProjectBucketAnywhereCache("[PROJECT]", "[BUCKET]", "[ANYWHERE_CACHE]");
// Make the request
AnywhereCache response = storageControlClient.PauseAnywhereCache(name);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
PauseAnywhereCacheRequest request = new PauseAnywhereCacheRequest
{
    AnywhereCacheName = AnywhereCacheName.FromProjectBucketAnywhereCache("[PROJECT]", "[BUCKET]", "[ANYWHERE_CACHE]"),
};
// Make the request
AnywhereCache response = storageControlClient.PauseAnywhereCache(request);

// Create client
StorageControlClient storageControlClient = StorageControlClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/buckets/[BUCKET]/anywhereCaches/[ANYWHERE_CACHE]";
// Make the request
AnywhereCache response = storageControlClient.PauseAnywhereCache(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
AnywhereCacheName name = AnywhereCacheName.FromProjectBucketAnywhereCache("[PROJECT]", "[BUCKET]", "[ANYWHERE_CACHE]");
// Make the request
AnywhereCache response = await storageControlClient.PauseAnywhereCacheAsync(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
AnywhereCacheName name = AnywhereCacheName.FromProjectBucketAnywhereCache("[PROJECT]", "[BUCKET]", "[ANYWHERE_CACHE]");
// Make the request
AnywhereCache response = await storageControlClient.PauseAnywhereCacheAsync(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
PauseAnywhereCacheRequest request = new PauseAnywhereCacheRequest
{
    AnywhereCacheName = AnywhereCacheName.FromProjectBucketAnywhereCache("[PROJECT]", "[BUCKET]", "[ANYWHERE_CACHE]"),
};
// Make the request
AnywhereCache response = await storageControlClient.PauseAnywhereCacheAsync(request);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
PauseAnywhereCacheRequest request = new PauseAnywhereCacheRequest
{
    AnywhereCacheName = AnywhereCacheName.FromProjectBucketAnywhereCache("[PROJECT]", "[BUCKET]", "[ANYWHERE_CACHE]"),
};
// Make the request
AnywhereCache response = await storageControlClient.PauseAnywhereCacheAsync(request);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/buckets/[BUCKET]/anywhereCaches/[ANYWHERE_CACHE]";
// Make the request
AnywhereCache response = await storageControlClient.PauseAnywhereCacheAsync(name);

// Create client
StorageControlClient storageControlClient = await StorageControlClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/buckets/[BUCKET]/anywhereCaches/[ANYWHERE_CACHE]";
// Make the request
AnywhereCache response = await storageControlClient.PauseAnywhereCacheAsync(name);