vous pouvez essayer d'ajouter un certain nombre aléatoire à votre url dans le cadre d'un querystring chaque fois que vous téléchargez le fichier. Cela garantit que les urls sont uniques à chaque fois.

pour les ex -

Random random = new Random();
string url = originalUrl + "?random=" + random.Next().ToString();
webclient.DownloadFile(url, downloadedfileurl);

Essayer NoCacheNoStore :

ne satisfait jamais une requête en utilisant des ressources du cache et ne cache pas de ressources. Si la ressource est présente dans le cache local, il est supprimé. Ce niveau de politique indique aux caches intermédiaires qu'elles devraient retirer la ressource. Dans le protocole de mise en cache HTTP, ceci est réalisé en utilisant la directive no-cache cache cache Control.

client.CachePolicy = new System.Net.Cache.RequestCachePolicy(System.Net.Cache.RequestCacheLevel.NoCacheNoStore); 

dans certains scénarios, le logiciel de débogage réseau peut causer ce problème. Pour vous assurer que votre url n'est pas mise en cache, vous pouvez ajouter un nombre aléatoire comme dernier paramètre pour rendre l'url unique. Ce paramètre aléatoire dans la plupart des cas est ignoré par les serveurs (qui essaient de lire les paramètres envoyés en tant que paires de valeurs de nom).

exemple: http://www.someserver.com/?param1=val1&ThisIsRandom=RandomValue

où C'Estrandom=RandomValue est la nouvelle paramètre ajouté.

je suppose que vous devrez utiliser webrequest / webresponse plutôt que webclient

    WebRequest request = WebRequest.Create(uri);
     // Define a cache policy for this request only. 
     HttpRequestCachePolicy noCachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore);
     request.CachePolicy = noCachePolicy;
     WebResponse response = request.GetResponse();

//below is the function for downloading the file

   public static int DownloadFile(String remoteFilename,
                           String localFilename)
    {
        // Function will return the number of bytes processed
        // to the caller. Initialize to 0 here.
        int bytesProcessed = 0;

        // Assign values to these objects here so that they can
        // be referenced in the finally block
        Stream remoteStream = null;
        Stream localStream = null;
        WebResponse response = null;

        // Use a try/catch/finally block as both the WebRequest and Stream
        // classes throw exceptions upon error
        try
        {
            // Create a request for the specified remote file name
            WebRequest request = WebRequest.Create(remoteFilename);
            // Define a cache policy for this request only. 
            HttpRequestCachePolicy noCachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore);
            request.CachePolicy = noCachePolicy;
            if (request != null)
            {
                // Send the request to the server and retrieve the
                // WebResponse object 
                response = request.GetResponse();

                if (response != null)
                {
                    if (response.IsFromCache)
                        //do what you want

                    // Once the WebResponse object has been retrieved,
                    // get the stream object associated with the response's data
                    remoteStream = response.GetResponseStream();

                    // Create the local file
                    localStream = File.Create(localFilename);

                    // Allocate a 1k buffer
                    byte[] buffer = new byte[1024];
                    int bytesRead;

                    // Simple do/while loop to read from stream until
                    // no bytes are returned
                    do
                    {
                        // Read data (up to 1k) from the stream
                        bytesRead = remoteStream.Read(buffer, 0, buffer.Length);

                        // Write the data to the local file
                        localStream.Write(buffer, 0, bytesRead);

                        // Increment total bytes processed
                        bytesProcessed += bytesRead;
                    } while (bytesRead > 0);
                }
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
        finally
        {
            // Close the response and streams objects here 
            // to make sure they're closed even if an exception
            // is thrown at some point
            if (response != null) response.Close();
            if (remoteStream != null) remoteStream.Close();
            if (localStream != null) localStream.Close();
        }

        // Return total bytes processed to caller.
        return bytesProcessed;
    }

client.CachePolicy = new RequestCachePolicy(RequestCacheLevel.BypassCache);

devrait marcher. Assurez-vous juste de vider le cache et de supprimer tous les fichiers téléchargés temporairement dans Internet Explorer avant en exécutant le code comme System.Net et C'est à dire que les deux utilisent le même cache.

j'ai eu un problème similaire avec powershell en utilisant webClient, qui était également présent après avoir changé pour utiliser webRequest. Ce que j'ai découvert, c'est que la socket est réutilisée et que cela provoque toutes sortes de cache Côté Serveur/réseau (et dans mon cas un équilibreur de charge est devenu trop problématique avec https). Le moyen de contourner cela est de désactiver keepalive et éventuellement pipeling dans l'objet webrequest comme ci-dessous qui va forcer une nouvelle prise pour chaque requête:

#Define Funcs Function httpRequest {
     param([string]$myurl)
     $r = [System.Net.WebRequest]::Create($myurl)
     $r.keepalive = 0
     $sr = new-object System.IO.StreamReader (($r.GetResponse()).GetResponseStream())
     $sr.ReadToEnd() }

utiliser HTTPRequest est certainement la bonne réponse pour votre problème. Cependant, si vous souhaitez empêcher votre WebBrowser / WebClient d'utiliser des pages mises en cache, vous devez inclure non seulement "no-cache" mais tous ces en-têtes:

<meta http-equiv="Cache-control" content="no-cache">
<meta http-equiv="Cache-control" content="no-store">
<meta http-equiv="Pragma" content="no-cache">
<meta http-equiv="Expires" content="-1">

Dans IE11, il n'a pas fonctionné pour moi jusqu'à ce que j'ai inclus un ou les deux les deux derniers.

toutes les méthodes ici semblent ne peut pas résoudre un problème: Si une page web a déjà été accessible et maintenant supprimée du serveur, la méthode HttpWebResponse.GetResponse () vous donnera une réponse pour une copie mise en cache commençant par "avant qu'une période de temps suffisant ne soit passée, ou que vous redémarriez l'ordinateur, cela ne déclenchera pas l'exception prévue pour l'erreur 404 page not found, vous ne pouvez pas savoir que la page web n'exsit pas du tout maintenant.

j'ai tout essayé:

• Définir l'en-tête ("Cache-Control", "no-cache")
• Set "demande.CachePolicy " à "noCachePolicy "
• supprimer les fichiers GFT/history.
• utilisez Internet câblé sans routeur .......... NE FONCTIONNE PAS!

Heureusement, si la page web a changé de contenu, HttpWebResponse.GetResponse() vous donnera une nouvelle page pour refléter le changement.

vérifiez que vous n'êtes pas limité de taux! Je récupérais ça d'un serveur nginx:

403 Interdit

voici le programme que j'utilisais (C#)

using System;
using System.IO;
using System.Net;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            DownloadFile();
            Console.ReadLine();
        }

        public static void DownloadFile()
        {
            var downloadedDatabaseFile = Path.Combine(Path.GetTempPath(), Path.GetTempFileName());
            Console.WriteLine(downloadedDatabaseFile);

            var client = new WebClient();
            client.DownloadProgressChanged += (sender, args) =>
            {
                Console.WriteLine("{0} of {1} {2}%", args.BytesReceived, args.TotalBytesToReceive, args.ProgressPercentage);
            };

            client.DownloadFileCompleted += (sender, args) =>
            {
                Console.WriteLine("Download file complete");

                if (args.Error != null)
                {
                    Console.WriteLine(args.Error.Message);
                }
            };

            client.DownloadFileAsync(new Uri("http://geolite.maxmind.com/download/geoip/database/GeoLiteCity.dats.gz"), downloadedDatabaseFile);
        }
    }
}

la console imprime:

C:\Users\jake.scott.WIN-J8OUFV09HQ8\AppData\Local\Temp\tmp7CA.tmp
Download file complete
The remote server returned an error: (403) Forbidden.

puisque j'utilise le suivant:

wclient.CachePolicy = new System.Net.Cache.RequestCachePolicy(System.Net.Cache.RequestCacheLevel.NoCacheNoStore);
wclient.Headers.Add("Cache-Control", "no-cache");

Je n'ai plus de fichier caché.

j'ai en outre ajouté cette fonction que j'ai trouvé, pour supprimer les fichiers temp IE avant chaque appel:

private void del_IE_files()
{
    string path = Environment.GetFolderPath(Environment.SpecialFolder.InternetCache);
    //for deleting files

    System.IO.DirectoryInfo DInfo = new DirectoryInfo(path);
    FileAttributes Attr = DInfo.Attributes;
    DInfo.Attributes = FileAttributes.Normal;

    foreach (FileInfo file in DInfo.GetFiles())
    {
        file.Delete();
    }

    foreach (DirectoryInfo dir in DInfo.GetDirectories())
    {
        try
        {
            dir.Delete(true); //delete subdirectories and files
        }
        catch
        {

        }
    }
}

si vous avez accès au serveur web, ouvrez Internet Explorer allez à

Internet Explorer -> Internet Options -> Browsing History "Settings" -> Temporary Internet Files "never"

videz le Cache du navigateur et voilà, ça va marcher!