Télécharger le fichier avec WebClient ou HttpClient?

Je suis en train de télécharger un fichier à partir d'une URL et je dois choisir entre le client web et HttpClient. J'ai référencé cette article et plusieurs autres articles sur l'internet. Partout, il est suggéré d'aller pour HttpClient en raison de sa grande asynchrone de soutien et d'autres .Net 4.5 privilèges. Mais je ne suis pas encore totalement convaincu et besoin de plus d'entrées.

Je suis à l'aide de code ci-dessous pour télécharger le fichier à partir d'internet:

WebClient:

WebClient client = new WebClient();
client.DownloadFile(downloadUrl, filePath);

HttpClient:

using (HttpClient client = new HttpClient())
{        
    using (HttpResponseMessage response = await client.GetAsync(url))
    using (Stream streamToReadFrom = await response.Content.ReadAsStreamAsync())
    {
    }
}

De mon point de vue, je vois qu'un seul inconvénient dans l'utilisation de WebClient, qui serait le non appel asynchrone, le blocage du thread appelant. Mais si je ne suis pas inquiet sur le blocage de fil ou de l'utilisation client.DownloadFileAsync() de tirer parti de l'asynchrone en charge?

D'autre part, si j'utilise HttpClient, n'est-ce pas, je le chargement de chaque octet d'un fichier dans la mémoire et écriture dans un fichier local? Si la taille du fichier est trop grand, ne sera pas de surcharge de mémoire être cher? Qui pourrait être évité si nous utilisons le service WebClient, car il va écrire directement sur un fichier local et ne consomme pas de mémoire système.

Donc, si la performance est ma plus grande priorité, l'approche qui dois-je utiliser pour le téléchargement? Je voudrais être clarifié si mon hypothèse ci-dessus est fausse, et je suis ouvert à toute autre approche ainsi.

Ne stackoverflow.com/questions/37799419/... de l'aide?
Voir aussi codereview.stackexchange.com/questions/69950/... .
Il y a encore un problème avec WebClient: Il ne fonctionnera pas dans .NET de Base.
"inconvénient dans l'utilisation de WebClient...le non appel asynchrone, le blocage du thread appelant" Donc utiliser les DownloadFileAsync.
WebClient est obsolète sincd 2012 et les deux extraits sont en train de faire des choses différentes. Vous pouvez utiliser HttpClient.GetStreamAsync pour obtenir un flux de données dans le fichier en une seule ligne, puis utiliser .CopyToAsync() de copier le flux du contenu d'un fichier de flux
ain't I loading every single byte of a file into memory non, sauf si vous demandez explicitement pour cette avec GetByteArrayAsync
tu veux sans doute dire DownloadFileTaskAsync. L'ancienne DownloadFileAsync utiliser les événements pour informer que le téléchargement terminé, il n'est pas asynchrone dans le sens utilisé de nos jours
Avez-vous un exemple pour qui? Ça sonne bien, mais je suis trop nouveau pour qu'il fonctionne.

InformationsquelleAutor Saket | 2017-08-16

.net c#httpclient rest webclient

Voici ma démarche.

Si vous appelez un WebApi pour obtenir un fichier, puis d'un contrôleur de la méthode que vous pouvez utiliser HttpClient OBTENIR la demande et le retour de flux de fichiers à l'aide de FileStreamResult type de retour.

public async Task<ActionResult> GetAttachment(int FileID)
{
    UriBuilder uriBuilder = new UriBuilder();
    uriBuilder.Scheme = "https";
    uriBuilder.Host = "api.example.com";

    var Path = "/files/download";
    uriBuilder.Path = Path;
    using (HttpClient client = new HttpClient())
    {
        client.BaseAddress = new Uri(uriBuilder.ToString());
        client.DefaultRequestHeaders.Accept.Clear();
        client.DefaultRequestHeaders.Add("authorization", access_token); //if any
        client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
        HttpResponseMessage response = await client.GetAsync(uriBuilder.ToString());

            if (response.IsSuccessStatusCode)
            {
                System.Net.Http.HttpContent content = response.Content;
                var contentStream = await content.ReadAsStreamAsync(); //get the actual content stream
                return File(contentStream, content_type, filename);
            }
            else
            {
                throw new FileNotFoundException();
            }
    }
}

InformationsquelleAutor Ingale88s

Voici une façon de l'utiliser pour télécharger une URL et l'enregistrer dans un fichier: (Je suis avec windows 7, donc pas de WindowsRT disponible pour moi, donc je suis également en utilisant le Système.IO.)

public static class WebUtils
{
private static Lazy<IWebProxy> proxy = new Lazy<IWebProxy>(() => string.IsNullOrEmpty(Settings.Default.WebProxyAddress) ? null : new WebProxy { Address = new Uri(Settings.Default.WebProxyAddress), UseDefaultCredentials = true });
public static IWebProxy Proxy
{
get { return WebUtils.proxy.Value; }
}
public static Task DownloadAsync(string requestUri, string filename)
{
if (requestUri == null)
throw new ArgumentNullException(“requestUri”);
return DownloadAsync(new Uri(requestUri), filename);
}
public static async Task DownloadAsync(Uri requestUri, string filename)
{
if (filename == null)
throw new ArgumentNullException("filename");
if (Proxy != null)
WebRequest.DefaultWebProxy = Proxy;
using (var httpClient = new HttpClient())
{
using (var request = new HttpRequestMessage(HttpMethod.Get, requestUri))
{
using (Stream contentStream = await (await httpClient.SendAsync(request)).Content.ReadAsStreamAsync(), stream = new FileStream(filename, FileMode.Create, FileAccess.Write, FileShare.None, Constants.LargeBufferSize, true))
{
await contentStream.CopyToAsync(stream);
}
}
}
}
}

Notez que le code est l'enregistrement de l'adresse du serveur proxy que j'utilise (au travail) dans un cadre, et à l'aide que, si un tel paramètre est spécifié. Sinon, il devrait vous dire tout ce que vous devez savoir concernant l'utilisation de la HttpClient bêta pour télécharger et enregistrer un fichier.

codereview.stackexchange.com/questions/69950/... peut être intéressant à lire.
La plupart de ce code n'est pas lié à la question. HttpClient instances de ne pas être éliminés immédiatement.

InformationsquelleAutor Nirzar

De code appelé à plusieurs reprises, vous ne pas voulez mettre HttpClient dans un using bloc (il va laisser pendre les ports ouverts)

Pour le téléchargement d'un fichier avec HttpClient, j'ai trouvé cette méthode d'extension qui semblait être une bonne solution fiable et à moi:

public static class HttpContentExtensions
{
public static Task ReadAsFileAsync(this HttpContent content, string filename, bool overwrite)
{
string pathname = Path.GetFullPath(filename);
if (!overwrite && File.Exists(filename))
{
throw new InvalidOperationException(string.Format("File {0} already exists.", pathname));
}
FileStream fileStream = null;
try
{
fileStream = new FileStream(pathname, FileMode.Create, FileAccess.Write, FileShare.None);
return content.CopyToAsync(fileStream).ContinueWith(
(copyTask) =>
{
fileStream.Close();
});
}
catch
{
if (fileStream != null)
{
fileStream.Close();
}
throw;
}
}
}

InformationsquelleAutor Thymine

Vous pouvez le faire en natif .Net 4.5+. J'ai essayé de faire les choses à votre manière et puis j'ai trouvé une méthode dans Intellisense qui semblait faire sens.

https://docs.microsoft.com/en-us/dotnet/api/system.io.stream.copytoasync?view=netframework-4.7.2

uri = new Uri(generatePdfsRetrieveUrl + pdfGuid + ".pdf");
HttpClient client = new HttpClient();
var response = await client.GetAsync(uri);
using (var fs = new FileStream(
HostingEnvironment.MapPath(string.Format("~/Downloads/{0}.pdf", pdfGuid)), 
FileMode.CreateNew))
{
await response.Content.CopyToAsync(fs);
}

InformationsquelleAutor Bluebaron

Vous devez vous connecter pour publier un commentaire.