Delete all objects in an S3 bucket.
/// <summary>
/// Delete all of the objects stored in an existing Amazon S3 bucket.
/// </summary>
/// <param name="client">An initialized Amazon S3 client object.</param>
/// <param name="bucketName">The name of the bucket from which the
/// contents will be deleted.</param>
/// <returns>A boolean value that represents the success or failure of
/// deleting all of the objects in the bucket.</returns>
public static async Task<bool> DeleteBucketContentsAsync(IAmazonS3 client, string bucketName)
{
// Iterate over the contents of the bucket and delete all objects.
var request = new ListObjectsV2Request
{
BucketName = bucketName,
};
try
{
ListObjectsV2Response response;
do
{
response = await client.ListObjectsV2Async(request);
response.S3Objects
.ForEach(async obj => await client.DeleteObjectAsync(bucketName, obj.Key));
// If the response is truncated, set the request ContinuationToken
// from the NextContinuationToken property of the response.
request.ContinuationToken = response.NextContinuationToken;
}
while (response.IsTruncated);
return true;
}
catch (AmazonS3Exception ex)
{
Console.WriteLine($"Error deleting objects: {ex.Message}");
return false;
}
}
Delete multiple objects in a non-versioned S3 bucket.
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Amazon.S3;
using Amazon.S3.Model;
/// <summary>
/// This example shows how to delete multiple objects from an Amazon Simple
/// Storage Service (Amazon S3) bucket.
/// </summary>
public class DeleteMultipleObjects
{
/// <summary>
/// The Main method initializes the Amazon S3 client and the name of
/// the bucket and then passes those values to MultiObjectDeleteAsync.
/// </summary>
public static async Task Main()
{
const string bucketName = "amzn-s3-demo-bucket";
// If the Amazon S3 bucket from which you wish to delete objects is not
// located in the same AWS Region as the default user, define the
// AWS Region for the Amazon S3 bucket as a parameter to the client
// constructor.
IAmazonS3 s3Client = new AmazonS3Client();
await MultiObjectDeleteAsync(s3Client, bucketName);
}
/// <summary>
/// This method uses the passed Amazon S3 client to first create and then
/// delete three files from the named bucket.
/// </summary>
/// <param name="client">The initialized Amazon S3 client object used to call
/// Amazon S3 methods.</param>
/// <param name="bucketName">The name of the Amazon S3 bucket where objects
/// will be created and then deleted.</param>
public static async Task MultiObjectDeleteAsync(IAmazonS3 client, string bucketName)
{
// Create three sample objects which we will then delete.
var keysAndVersions = await PutObjectsAsync(client, 3, bucketName);
// Now perform the multi-object delete, passing the key names and
// version IDs. Since we are working with a non-versioned bucket,
// the object keys collection includes null version IDs.
DeleteObjectsRequest multiObjectDeleteRequest = new DeleteObjectsRequest
{
BucketName = bucketName,
Objects = keysAndVersions,
};
// You can add a specific object key to the delete request using the
// AddKey method of the multiObjectDeleteRequest.
try
{
DeleteObjectsResponse response = await client.DeleteObjectsAsync(multiObjectDeleteRequest);
Console.WriteLine("Successfully deleted all the {0} items", response.DeletedObjects.Count);
}
catch (DeleteObjectsException e)
{
PrintDeletionErrorStatus(e);
}
}
/// <summary>
/// Prints the list of errors raised by the call to DeleteObjectsAsync.
/// </summary>
/// <param name="ex">A collection of exceptions returned by the call to
/// DeleteObjectsAsync.</param>
public static void PrintDeletionErrorStatus(DeleteObjectsException ex)
{
DeleteObjectsResponse errorResponse = ex.Response;
Console.WriteLine("x {0}", errorResponse.DeletedObjects.Count);
Console.WriteLine($"Successfully deleted {errorResponse.DeletedObjects.Count}.");
Console.WriteLine($"No. of objects failed to delete = {errorResponse.DeleteErrors.Count}");
Console.WriteLine("Printing error data...");
foreach (DeleteError deleteError in errorResponse.DeleteErrors)
{
Console.WriteLine($"Object Key: {deleteError.Key}\t{deleteError.Code}\t{deleteError.Message}");
}
}
/// <summary>
/// This method creates simple text file objects that can be used in
/// the delete method.
/// </summary>
/// <param name="client">The Amazon S3 client used to call PutObjectAsync.</param>
/// <param name="number">The number of objects to create.</param>
/// <param name="bucketName">The name of the bucket where the objects
/// will be created.</param>
/// <returns>A list of keys (object keys) and versions that the calling
/// method will use to delete the newly created files.</returns>
public static async Task<List<KeyVersion>> PutObjectsAsync(IAmazonS3 client, int number, string bucketName)
{
List<KeyVersion> keys = new List<KeyVersion>();
for (int i = 0; i < number; i++)
{
string key = "ExampleObject-" + new System.Random().Next();
PutObjectRequest request = new PutObjectRequest
{
BucketName = bucketName,
Key = key,
ContentBody = "This is the content body!",
};
PutObjectResponse response = await client.PutObjectAsync(request);
// For non-versioned bucket operations, we only need the
// object key.
KeyVersion keyVersion = new KeyVersion
{
Key = key,
};
keys.Add(keyVersion);
}
return keys;
}
}
Delete multiple objects in a versioned S3 bucket.
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Amazon.S3;
using Amazon.S3.Model;
/// <summary>
/// This example shows how to delete objects in a version-enabled Amazon
/// Simple StorageService (Amazon S3) bucket.
/// </summary>
public class DeleteMultipleObjects
{
public static async Task Main()
{
string bucketName = "amzn-s3-demo-bucket";
// If the AWS Region for your Amazon S3 bucket is different from
// the AWS Region of the default user, define the AWS Region for
// the Amazon S3 bucket and pass it to the client constructor
// like this:
// RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
IAmazonS3 s3Client;
s3Client = new AmazonS3Client();
await DeleteMultipleObjectsFromVersionedBucketAsync(s3Client, bucketName);
}
/// <summary>
/// This method removes multiple versions and objects from a
/// version-enabled Amazon S3 bucket.
/// </summary>
/// <param name="client">The initialized Amazon S3 client object used to call
/// DeleteObjectVersionsAsync, DeleteObjectsAsync, and
/// RemoveDeleteMarkersAsync.</param>
/// <param name="bucketName">The name of the bucket from which to delete
/// objects.</param>
public static async Task DeleteMultipleObjectsFromVersionedBucketAsync(IAmazonS3 client, string bucketName)
{
// Delete objects (specifying object version in the request).
await DeleteObjectVersionsAsync(client, bucketName);
// Delete objects (without specifying object version in the request).
var deletedObjects = await DeleteObjectsAsync(client, bucketName);
// Additional exercise - remove the delete markers Amazon S3 returned from
// the preceding response. This results in the objects reappearing
// in the bucket (you can verify the appearance/disappearance of
// objects in the console).
await RemoveDeleteMarkersAsync(client, bucketName, deletedObjects);
}
/// <summary>
/// Creates and then deletes non-versioned Amazon S3 objects and then deletes
/// them again. The method returns a list of the Amazon S3 objects deleted.
/// </summary>
/// <param name="client">The initialized Amazon S3 client object used to call
/// PubObjectsAsync and NonVersionedDeleteAsync.</param>
/// <param name="bucketName">The name of the bucket where the objects
/// will be created and then deleted.</param>
/// <returns>A list of DeletedObjects.</returns>
public static async Task<List<DeletedObject>> DeleteObjectsAsync(IAmazonS3 client, string bucketName)
{
// Upload the sample objects.
var keysAndVersions2 = await PutObjectsAsync(client, bucketName, 3);
// Delete objects using only keys. Amazon S3 creates a delete marker and
// returns its version ID in the response.
List<DeletedObject> deletedObjects = await NonVersionedDeleteAsync(client, bucketName, keysAndVersions2);
return deletedObjects;
}
/// <summary>
/// This method creates several temporary objects and then deletes them.
/// </summary>
/// <param name="client">The S3 client.</param>
/// <param name="bucketName">Name of the bucket.</param>
/// <returns>Async task.</returns>
public static async Task DeleteObjectVersionsAsync(IAmazonS3 client, string bucketName)
{
// Upload the sample objects.
var keysAndVersions1 = await PutObjectsAsync(client, bucketName, 3);
// Delete the specific object versions.
await VersionedDeleteAsync(client, bucketName, keysAndVersions1);
}
/// <summary>
/// Displays the list of information about deleted files to the console.
/// </summary>
/// <param name="e">Error information from the delete process.</param>
private static void DisplayDeletionErrors(DeleteObjectsException e)
{
var errorResponse = e.Response;
Console.WriteLine($"No. of objects successfully deleted = {errorResponse.DeletedObjects.Count}");
Console.WriteLine($"No. of objects failed to delete = {errorResponse.DeleteErrors.Count}");
Console.WriteLine("Printing error data...");
foreach (var deleteError in errorResponse.DeleteErrors)
{
Console.WriteLine($"Object Key: {deleteError.Key}\t{deleteError.Code}\t{deleteError.Message}");
}
}
/// <summary>
/// Delete multiple objects from a version-enabled bucket.
/// </summary>
/// <param name="client">The initialized Amazon S3 client object used to call
/// DeleteObjectVersionsAsync, DeleteObjectsAsync, and
/// RemoveDeleteMarkersAsync.</param>
/// <param name="bucketName">The name of the bucket from which to delete
/// objects.</param>
/// <param name="keys">A list of key names for the objects to delete.</param>
private static async Task VersionedDeleteAsync(IAmazonS3 client, string bucketName, List<KeyVersion> keys)
{
var multiObjectDeleteRequest = new DeleteObjectsRequest
{
BucketName = bucketName,
Objects = keys, // This includes the object keys and specific version IDs.
};
try
{
Console.WriteLine("Executing VersionedDelete...");
DeleteObjectsResponse response = await client.DeleteObjectsAsync(multiObjectDeleteRequest);
Console.WriteLine($"Successfully deleted all the {response.DeletedObjects.Count} items");
}
catch (DeleteObjectsException ex)
{
DisplayDeletionErrors(ex);
}
}
/// <summary>
/// Deletes multiple objects from a non-versioned Amazon S3 bucket.
/// </summary>
/// <param name="client">The initialized Amazon S3 client object used to call
/// DeleteObjectVersionsAsync, DeleteObjectsAsync, and
/// RemoveDeleteMarkersAsync.</param>
/// <param name="bucketName">The name of the bucket from which to delete
/// objects.</param>
/// <param name="keys">A list of key names for the objects to delete.</param>
/// <returns>A list of the deleted objects.</returns>
private static async Task<List<DeletedObject>> NonVersionedDeleteAsync(IAmazonS3 client, string bucketName, List<KeyVersion> keys)
{
// Create a request that includes only the object key names.
DeleteObjectsRequest multiObjectDeleteRequest = new DeleteObjectsRequest();
multiObjectDeleteRequest.BucketName = bucketName;
foreach (var key in keys)
{
multiObjectDeleteRequest.AddKey(key.Key);
}
// Execute DeleteObjectsAsync.
// The DeleteObjectsAsync method adds a delete marker for each
// object deleted. You can verify that the objects were removed
// using the Amazon S3 console.
DeleteObjectsResponse response;
try
{
Console.WriteLine("Executing NonVersionedDelete...");
response = await client.DeleteObjectsAsync(multiObjectDeleteRequest);
Console.WriteLine("Successfully deleted all the {0} items", response.DeletedObjects.Count);
}
catch (DeleteObjectsException ex)
{
DisplayDeletionErrors(ex);
throw; // Some deletions failed. Investigate before continuing.
}
// This response contains the DeletedObjects list which we use to delete the delete markers.
return response.DeletedObjects;
}
/// <summary>
/// Deletes the markers left after deleting the temporary objects.
/// </summary>
/// <param name="client">The initialized Amazon S3 client object used to call
/// DeleteObjectVersionsAsync, DeleteObjectsAsync, and
/// RemoveDeleteMarkersAsync.</param>
/// <param name="bucketName">The name of the bucket from which to delete
/// objects.</param>
/// <param name="deletedObjects">A list of the objects that were deleted.</param>
private static async Task RemoveDeleteMarkersAsync(IAmazonS3 client, string bucketName, List<DeletedObject> deletedObjects)
{
var keyVersionList = new List<KeyVersion>();
foreach (var deletedObject in deletedObjects)
{
KeyVersion keyVersion = new KeyVersion
{
Key = deletedObject.Key,
VersionId = deletedObject.DeleteMarkerVersionId,
};
keyVersionList.Add(keyVersion);
}
// Create another request to delete the delete markers.
var multiObjectDeleteRequest = new DeleteObjectsRequest
{
BucketName = bucketName,
Objects = keyVersionList,
};
// Now, delete the delete marker to bring your objects back to the bucket.
try
{
Console.WriteLine("Removing the delete markers .....");
var deleteObjectResponse = await client.DeleteObjectsAsync(multiObjectDeleteRequest);
Console.WriteLine($"Successfully deleted the {deleteObjectResponse.DeletedObjects.Count} delete markers");
}
catch (DeleteObjectsException ex)
{
DisplayDeletionErrors(ex);
}
}
/// <summary>
/// Create temporary Amazon S3 objects to show how object deletion wors in an
/// Amazon S3 bucket with versioning enabled.
/// </summary>
/// <param name="client">The initialized Amazon S3 client object used to call
/// PutObjectAsync to create temporary objects for the example.</param>
/// <param name="bucketName">A string representing the name of the S3
/// bucket where we will create the temporary objects.</param>
/// <param name="number">The number of temporary objects to create.</param>
/// <returns>A list of the KeyVersion objects.</returns>
private static async Task<List<KeyVersion>> PutObjectsAsync(IAmazonS3 client, string bucketName, int number)
{
var keys = new List<KeyVersion>();
for (var i = 0; i < number; i++)
{
string key = "ObjectToDelete-" + new System.Random().Next();
PutObjectRequest request = new PutObjectRequest
{
BucketName = bucketName,
Key = key,
ContentBody = "This is the content body!",
};
var response = await client.PutObjectAsync(request);
KeyVersion keyVersion = new KeyVersion
{
Key = key,
VersionId = response.VersionId,
};
keys.Add(keyVersion);
}
return keys;
}
}
For API details, see DeleteObjects in AWS SDK for .NET API Reference.
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4