C# IAmazonS3.ListObjects方法代码示例

        /// <summary>
        /// Sets up the request needed to make an exact copy of the object leaving the parent method
        /// the ability to change just the attribute being requested to change.
        /// </summary>
        /// <param name="bucketName"></param>
        /// <param name="key"></param>
        /// <param name="version"></param>
        /// <param name="s3Client"></param>
        /// <param name="copyRequest"></param>
        /// <param name="putACLRequest"></param>
        static void SetupForObjectModification(IAmazonS3 s3Client, string bucketName, string key, string version, 
            out CopyObjectRequest copyRequest, out PutACLRequest putACLRequest)
        {
            // Get the existing ACL of the object
            GetACLRequest getACLRequest = new GetACLRequest();
            getACLRequest.BucketName = bucketName;
            getACLRequest.Key = key;
            if (version != null)
                getACLRequest.VersionId = version;
            GetACLResponse getACLResponse = s3Client.GetACL(getACLRequest);


            // Set the object's original ACL back onto it because a COPY
            // operation resets the ACL on the destination object.
            putACLRequest = new PutACLRequest();
            putACLRequest.BucketName = bucketName;
            putACLRequest.Key = key;
            putACLRequest.AccessControlList = getACLResponse.AccessControlList;


            ListObjectsResponse listObjectResponse = s3Client.ListObjects(new ListObjectsRequest
            {
                BucketName = bucketName,
                Prefix = key,
                MaxKeys = 1
            });

            if (listObjectResponse.S3Objects.Count != 1)
            {
                throw new InvalidOperationException("No object exists with this bucket name and key.");
            }

            GetObjectMetadataRequest getMetaRequest = new GetObjectMetadataRequest()
            {
                BucketName = bucketName,
                Key = key
            };
            GetObjectMetadataResponse getMetaResponse = s3Client.GetObjectMetadata(getMetaRequest);

            // Set the storage class on the object
            copyRequest = new CopyObjectRequest();
            copyRequest.SourceBucket = copyRequest.DestinationBucket = bucketName;
            copyRequest.SourceKey = copyRequest.DestinationKey = key;
            copyRequest.StorageClass = listObjectResponse.S3Objects[0].StorageClass == "STANDARD" ? S3StorageClass.Standard : S3StorageClass.ReducedRedundancy;
            if (version != null)
                copyRequest.SourceVersionId = version;

            copyRequest.WebsiteRedirectLocation = getMetaResponse.WebsiteRedirectLocation;
            copyRequest.ServerSideEncryptionMethod = getMetaResponse.ServerSideEncryptionMethod;
        }

        private long QuotaDelete(string domain, IAmazonS3 client, string key)
        {
            if (QuotaController != null)
            {
                var responce = client.ListObjects(new ListObjectsRequest
                {
                    BucketName = _bucket,
                    Prefix = key
                });

                if (responce.S3Objects != null && responce.S3Objects.Count > 0)
                {
                    var size = Convert.ToInt64(responce.S3Objects[0].Size);
                    QuotaController.QuotaUsedDelete(_modulename, domain, _dataList.GetData(domain), size);
                    return size;
                }
            }
            return 0;
        }

        //Picto Uploader- component to insert pictogramas from amazon into DataBase
        static void ListingObjects(IAmazonS3 client)
        {
            ListObjectsRequest list = new ListObjectsRequest
            {
                BucketName = "pictograms",
                MaxKeys = 2
            };

            string name;
            string url;

            using (SqlConnection conn = new SqlConnection())
            {
                conn.ConnectionString = connectionString;
                conn.Open();
                do
                {
                    ListObjectsResponse response = client.ListObjects(list);

                    // Process response.
                    foreach (S3Object entry in response.S3Objects)
                    {
                        name = entry.Key;
                        url = server + bucket + name;
                        int index = name.IndexOf("_");

                        if (index > 0) { name = name.Substring(0, index); }

                        else
                        {
                            index = name.IndexOf(".");
                            name = name.Substring(0, index);
                        }

                        SqlCommand insertCommand = new SqlCommand("INSERT INTO Pictograms (name, url) VALUES (@0, @1)", conn);

                        insertCommand.Parameters.Add(new SqlParameter("0", name));
                        insertCommand.Parameters.Add(new SqlParameter("1", url));

                        insertCommand.ExecuteNonQuery();

                    }

                    // If response is truncated, set the marker to get the next
                    // set of keys.
                    if (response.IsTruncated)
                    {
                        list.Marker = response.NextMarker;
                    }
                    else
                    {
                        list = null;
                    }

                } while (list != null);
            }
        }

        /// <summary>
        /// Deletes the artifacts associated with an import task using the bucket name
        /// and key prefix to the artifacts in Amazon S3. No check is performed to
        /// determine whether the associated conversion task is in progress.
        /// </summary>
        /// <param name="s3Client">
        /// An Amazon S3 client for the operation to use. This should have been constructed
        /// using credentials that have access to the bucket containing the image file
        /// artifacts and be scoped to the region containing the bucket.
        /// </param>
        /// <param name="bucketName">The name of the bucket containing the artifacts</param>
        /// <param name="keyPrefix">The common key prefix of the artifacts</param>
        /// <param name="progressCallback">Optional progress callback</param>
        public static void DeleteImageArtifacts(IAmazonS3 s3Client, 
                                                string bucketName, 
                                                string keyPrefix,
                                                CleanupProgressCallback progressCallback)
        {
            // build the full collection of keys to be deleted so that any progress
            // indicator managed by the caller is accurate
            SendProgressNotification(progressCallback, "Collating keys to image file artifacts", null);

            var artifactKeys = new List<string>();
            string marker = null;
            do
            {
                var listResponse = s3Client.ListObjects(new ListObjectsRequest
                {
                    BucketName = bucketName,
                    Prefix = keyPrefix,
                    Marker = marker
                });
                artifactKeys.AddRange(listResponse.S3Objects.Select(o => o.Key));
                marker = listResponse.NextMarker;
            } while (!string.IsNullOrEmpty(marker));

            if (artifactKeys.Count == 0)
            {
                var msg = string.Format(CultureInfo.InvariantCulture,
                                        "Found no image file artifacts with key prefix '{0}' to delete in bucket '{1}'.",
                                        keyPrefix,      
                                        bucketName);
                SendProgressNotification(progressCallback, msg, null);
                return;
            }

            var deletionMsg = string.Format(CultureInfo.InvariantCulture,
                                            "Deleting {0} image file artifacts (key prefix '{1}', bucket '{2}').", 
                                            artifactKeys.Count,
                                            keyPrefix,
                                            bucketName);
            SendProgressNotification(progressCallback, deletionMsg, 0);

            var index = 0;
            var processed = 0;
            do
            {
                var request = new DeleteObjectsRequest { BucketName = bucketName };
                while (request.Objects.Count < 1000 && index < artifactKeys.Count)
                {
                    request.Objects.Add(new KeyVersion { Key = artifactKeys[index++] });
                }

                s3Client.DeleteObjects(request);
                processed += request.Objects.Count;

                SendProgressNotification(progressCallback, deletionMsg, processed/artifactKeys.Count * 100);

            } while (processed < artifactKeys.Count);
        }