Verifica dell'esistenza di un BLOB nell'archiviazione di Azure

Ho una domanda molto semplice (spero!) - Voglio solo scoprire se esiste un BLOB (con un nome che ho definito) in un particolare contenitore. Lo scaricherò se esiste e, in caso contrario, farò qualcos'altro.

Ho fatto qualche ricerca sugli intertubes e apparentemente c'era una funzione chiamata DoesExist o qualcosa di simile ... ma come con così tante API di Azure, questo non sembra più essere lì (o, se lo è, ha un nome molto abilmente mascherato).

La nuova API ha la chiamata alla funzione .Exists (). Assicurati solo di usare il GetBlockBlobReference, che non esegue la chiamata al server. Rende la funzione semplice come:

public static bool BlobExistsOnCloud(CloudBlobClient client, 
    string containerName, string key)
{
     return client.GetContainerReference(containerName)
                  .GetBlockBlobReference(key)
                  .Exists();  
}

Nota: questa risposta non è più aggiornata. Si prega di consultare la risposta di Richard per un modo semplice per verificare l'esistenza

No, non ti stai perdendo qualcosa di semplice ... abbiamo fatto un buon lavoro nel nascondere questo metodo nella nuova libreria StorageClient. :)

Ho appena scritto un post sul blog per rispondere alla tua domanda: http://blog.smarx.com/posts/testing-existence-of-a-windows-azure-blob .

La risposta breve è: utilizzare CloudBlob.FetchAttributes (), che esegue una richiesta HEAD sul BLOB.

Sembra zoppo che è necessario catturare un'eccezione per testarlo esiste il BLOB.

public static bool Exists(this CloudBlob blob)
{
    try
    {
        blob.FetchAttributes();
        return true;
    }
    catch (StorageClientException e)
    {
        if (e.ErrorCode == StorageErrorCode.ResourceNotFound)
        {
            return false;
        }
        else
        {
            throw;
        }
    }
}

Se il BLOB è pubblico, ovviamente, puoi semplicemente inviare una richiesta HEAD HTTP - da uno qualsiasi dei miliardi di lingue / ambienti / piattaforme che sanno come farlo - e controllare la risposta.

Le API di Azure di base sono interfacce HTTP basate su XML RESTful. La libreria StorageClient è uno dei tanti wrapper possibili attorno a loro. Ecco un altro che ha fatto Sriram Krishnan in Python:

http://www.sriramkrishnan.com/blog/2008/11/python-wrapper-for-windows-azure.html

Mostra anche come eseguire l'autenticazione a livello HTTP.

Ho fatto una cosa simile per me stesso in C #, perché preferisco vedere Azure attraverso l'obiettivo di HTTP / REST piuttosto che attraverso l'obiettivo della libreria StorageClient. Per un bel po 'non mi ero nemmeno preso la briga di implementare un metodo ExistsBlob. Tutti i miei BLOB erano pubblici ed era banale eseguire HTTP HEAD.

La nuova libreria di archiviazione di Windows Azure contiene già il metodo Exist (). È in Microsoft.WindowsAzure.Storage.dll.

Disponibile come pacchetto NuGet
Creato da:
ID Microsoft : WindowsAzure.Storage
Versione: 2.0.5.1

Vedi anche msdn

Se non ti piace usare il metodo dell'eccezione, la versione c # di base di ciò che Judell suggerisce è di seguito. Attenzione però che dovresti davvero gestire anche altre possibili risposte.

HttpWebRequest myReq = (HttpWebRequest)WebRequest.Create(url);
myReq.Method = "HEAD";
HttpWebResponse myResp = (HttpWebResponse)myReq.GetResponse();
if (myResp.StatusCode == HttpStatusCode.OK)
{
    return true;
}
else
{
    return false;
}

Se il tuo BLOB è pubblico e hai bisogno solo di metadati:

        HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
        request.Method = "HEAD";
        string code = "";
        try
        {
            HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            code = response.StatusCode.ToString();
        }
        catch 
        {
        }

        return code; // if "OK" blob exists

Con l'SDK aggiornato, una volta che hai CloudBlobReference puoi chiamare Exists () sul tuo riferimento.

Vedi http://msdn.microsoft.com/en-us/library/microsoft.windowsazure.storage.blob.cloudblockblob.exists.aspx

Questo è il modo in cui lo faccio. Mostra il codice completo per chi ne ha bisogno.

        // Parse the connection string and return a reference to the storage account.
        CloudStorageAccount storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("AzureBlobConnectionString"));

        CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();

        // Retrieve reference to a previously created container.
        CloudBlobContainer container = blobClient.GetContainerReference("ContainerName");

        // Retrieve reference to a blob named "test.csv"
        CloudBlockBlob blockBlob = container.GetBlockBlobReference("test.csv");

        if (blockBlob.Exists())
        {
          //Do your logic here.
        }

Sebbene la maggior parte delle risposte qui siano tecnicamente corrette, la maggior parte degli esempi di codice sta effettuando chiamate sincrone / bloccanti. A meno che tu non sia vincolato da una piattaforma o una base di codice molto vecchia, le chiamate HTTP dovrebbero sempre essere eseguite in modo asincrono e in questo caso l'SDK lo supporta completamente. Basta usare ExistsAsync()invece di Exists().

bool exists = await client.GetContainerReference(containerName)
    .GetBlockBlobReference(key)
    .ExistsAsync();

Ecco una soluzione diversa se non ti piacciono le altre soluzioni:

Sto usando la versione 12.4.1 del pacchetto NuGet Azure.Storage.Blobs.

Ottengo un oggetto Azure.Pageable che è un elenco di tutti i BLOB in un contenitore. Quindi controllo se il nome di BlobItem è uguale alla proprietà Name di ciascun BLOB all'interno del contenitore utilizzando LINQ . (Se tutto è valido, ovviamente)

using Azure.Storage.Blobs;
using Azure.Storage.Blobs.Models;
using System.Linq;
using System.Text.RegularExpressions;

public class AzureBlobStorage
{
    private BlobServiceClient _blobServiceClient;

    public AzureBlobStorage(string connectionString)
    {
        this.ConnectionString = connectionString;
        _blobServiceClient = new BlobServiceClient(this.ConnectionString);
    }

    public bool IsContainerNameValid(string name)
    {
        return Regex.IsMatch(name, "^[a-z0-9](?!.*--)[a-z0-9-]{1,61}[a-z0-9]$", RegexOptions.Singleline | RegexOptions.CultureInvariant);
    }

    public bool ContainerExists(string name)
    {
        return (IsContainerNameValid(name) ? _blobServiceClient.GetBlobContainerClient(name).Exists() : false);
    }

    public Azure.Pageable<BlobItem> GetBlobs(string containerName, string prefix = null)
    {
        try
        {
            return (ContainerExists(containerName) ? 
                _blobServiceClient.GetBlobContainerClient(containerName).GetBlobs(BlobTraits.All, BlobStates.All, prefix, default(System.Threading.CancellationToken)) 
                : null);
        }
        catch
        {
            throw;
        }
    }

    public bool BlobExists(string containerName, string blobName)
    {
        try
        {
            return (from b in GetBlobs(containerName)
                     where b.Name == blobName
                     select b).FirstOrDefault() != null;
        }
        catch
        {
            throw;
        }
    }
}

Spero che questo aiuti qualcuno in futuro.