Capture "Longueur maximale de la demande dépassée"

J'écris une fonction de téléchargement et j'ai des problèmes pour attraper "System.Web.HttpException: la longueur maximale de la demande est dépassée" avec des fichiers plus grands que la taille maximale spécifiée httpRuntimedans web.config (taille maximale définie sur 5120). J'utilise un simple <input>pour le fichier.

Le problème est que l'exception est levée avant l'événement de clic du bouton de téléchargement, et l'exception se produit avant l'exécution de mon code. Alors, comment attraper et gérer l'exception?

EDIT: l'exception est lancée instantanément, donc je suis presque sûr que ce n'est pas un problème de délai d'attente en raison de connexions lentes.

Il n'y a malheureusement pas de moyen facile d'attraper une telle exception. Ce que je fais est de remplacer la méthode OnError au niveau de la page ou Application_Error dans global.asax, puis de vérifier s'il s'agissait d'un échec de Max Request et, le cas échéant, de transférer vers une page d'erreur.

protected override void OnError(EventArgs e) .....


private void Application_Error(object sender, EventArgs e)
{
    if (GlobalHelper.IsMaxRequestExceededException(this.Server.GetLastError()))
    {
        this.Server.ClearError();
        this.Server.Transfer("~/error/UploadTooLarge.aspx");
    }
}

C'est un hack mais le code ci-dessous fonctionne pour moi

const int TimedOutExceptionCode = -2147467259;
public static bool IsMaxRequestExceededException(Exception e)
{
    // unhandled errors = caught at global.ascx level
    // http exception = caught at page level

    Exception main;
    var unhandled = e as HttpUnhandledException;

    if (unhandled != null && unhandled.ErrorCode == TimedOutExceptionCode)
    {
        main = unhandled.InnerException;
    }
    else
    {
        main = e;
    }


    var http = main as HttpException;

    if (http != null && http.ErrorCode == TimedOutExceptionCode)
    {
        // hack: no real method of identifying if the error is max request exceeded as 
        // it is treated as a timeout exception
        if (http.StackTrace.Contains("GetEntireRawContent"))
        {
            // MAX REQUEST HAS BEEN EXCEEDED
            return true;
        }
    }

    return false;
}

Comme GateKiller l'a dit, vous devez changer le maxRequestLength. Vous devrez peut-être également modifier le executionTimeout au cas où la vitesse de téléchargement serait trop lente. Notez que vous ne voulez pas que l'un de ces paramètres soit trop gros, sinon vous serez ouvert aux attaques DOS.

La valeur par défaut pour executionTimeout est de 360 ​​secondes ou 6 minutes.

Vous pouvez modifier maxRequestLength et executionTimeout avec l' élément httpRuntime .

<?xml version="1.0" encoding="utf-8"?>
<configuration>
    <system.web>
        <httpRuntime maxRequestLength="102400" executionTimeout="1200" />
    </system.web>
</configuration>

ÉDITER:

Si vous souhaitez gérer l'exception malgré tout, comme cela a déjà été indiqué, vous devrez la gérer dans Global.asax. Voici un lien vers un exemple de code .

Vous pouvez résoudre ce problème en augmentant la longueur maximale de la requête dans votre web.config:

<?xml version="1.0" encoding="utf-8"?>
<configuration>
    <system.web>
        <httpRuntime maxRequestLength="102400" />
    </system.web>
</configuration>

L'exemple ci-dessus concerne une limite de 100 Mo.

Si vous souhaitez également une validation côté client afin de réduire le besoin de lever des exceptions, vous pouvez essayer d'implémenter la validation de la taille du fichier côté client.

Remarque: cela ne fonctionne que dans les navigateurs prenant en charge HTML5. http://www.html5rocks.com/en/tutorials/file/dndfiles/

<form id="FormID" action="post" name="FormID">
    <input id="target" name="target" class="target" type="file" />
</form>

<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.6.1/jquery.min.js" type="text/javascript"></script>

<script type="text/javascript" language="javascript">

    $('.target').change(function () {

        if (typeof FileReader !== "undefined") {
            var size = document.getElementById('target').files[0].size;
            // check file size

            if (size > 100000) {

                $(this).val("");

            }
        }

    });

</script>

Salut solution mentionnée par Damien McGivern, fonctionne uniquement sur IIS6,

Il ne fonctionne pas sur IIS7 et ASP.NET Development Server. J'obtiens la page affichant "404 - Fichier ou répertoire non trouvé."

Des idées?

ÉDITER:

Compris ... Cette solution ne fonctionne toujours pas sur ASP.NET Development Server, mais j'ai eu la raison pour laquelle elle ne fonctionnait pas sur IIS7 dans mon cas.

La raison en est qu'IIS7 a une analyse des demandes intégrée qui impose un plafond de fichier de téléchargement qui est par défaut de 30000000 octets (ce qui est légèrement inférieur à 30 Mo).

Et j'essayais de télécharger un fichier de taille 100 Mo pour tester la solution mentionnée par Damien McGivern (avec maxRequestLength = "10240" soit 10 Mo dans web.config). Maintenant, si je télécharge le fichier de taille> 10 Mo et <30 Mo, la page est redirigée vers la page d'erreur spécifiée. Mais si la taille du fichier est> 30 Mo, la vilaine page d'erreur intégrée affiche «404 - Fichier ou répertoire introuvable».

Donc, pour éviter cela, vous devez augmenter le max. longueur de contenu de demande autorisée pour votre site Web dans IIS7. Cela peut être fait en utilisant la commande suivante,

appcmd set config "SiteName" -section:requestFiltering -requestLimits.maxAllowedContentLength:209715200 -commitpath:apphost

J'ai défini le max. longueur du contenu à 200 Mo.

Après avoir effectué ce paramètre, la page est redirigée avec succès vers ma page d'erreur lorsque j'essaye de télécharger un fichier de 100 Mo

Reportez-vous à http://weblogs.asp.net/jgalloway/archive/2008/01/08/large-file-uploads-in-asp-net.aspx pour plus de détails.

Voici une autre manière, qui n'implique aucun "hacks", mais nécessite ASP.NET 4.0 ou version ultérieure:

//Global.asax
private void Application_Error(object sender, EventArgs e)
{
    var ex = Server.GetLastError();
    var httpException = ex as HttpException ?? ex.InnerException as HttpException;
    if(httpException == null) return;

    if(httpException.WebEventCode == WebEventCodes.RuntimeErrorPostTooLarge)
    {
        //handle the error
        Response.Write("Sorry, file is too big"); //show this message for instance
    }
}

Une façon de faire est de définir la taille maximale dans web.config comme cela a déjà été indiqué ci-dessus, par exemple

<system.web>         
    <httpRuntime maxRequestLength="102400" />     
</system.web>

Ensuite, lorsque vous gérez l'événement de téléchargement, vérifiez la taille et si elle dépasse un montant spécifique, vous pouvez le piéger, par exemple

protected void btnUploadImage_OnClick(object sender, EventArgs e)
{
    if (fil.FileBytes.Length > 51200)
    {
         TextBoxMsg.Text = "file size must be less than 50KB";
    }
}

Une solution qui fonctionne avec IIS7 et versions ultérieures: afficher une page d'erreur personnalisée lorsque le téléchargement de fichier dépasse la taille autorisée dans ASP.NET MVC

Dans IIS 7 et au-delà:

Fichier web.config:

<system.webServer>
  <security >
    <requestFiltering>
      <requestLimits maxAllowedContentLength="[Size In Bytes]" />
    </requestFiltering>
  </security>
</system.webServer>

Vous pouvez ensuite enregistrer le code derrière, comme ceci:

If FileUpload1.PostedFile.ContentLength > 2097152 Then ' (2097152 = 2 Mb)
  ' Exceeded the 2 Mb limit
  ' Do something
End If

Assurez-vous simplement que la [Taille en octets] dans le web.config est supérieure à la taille du fichier que vous souhaitez télécharger, vous n'obtiendrez pas l'erreur 404. Vous pouvez ensuite vérifier la taille du fichier dans le code en utilisant le ContentLength qui serait bien meilleur

Comme vous le savez probablement, la longueur maximale de la demande est configurée en DEUX endroits.

1. maxRequestLength - contrôlé au niveau de l'application ASP.NET
2. maxAllowedContentLength- sous <system.webServer>, contrôlé au niveau IIS

Le premier cas est couvert par d'autres réponses à cette question.

Pour attraper LE SECOND, vous devez le faire dans global.asax:

protected void Application_EndRequest(object sender, EventArgs e)
{
    //check for the "file is too big" exception if thrown at the IIS level
    if (Response.StatusCode == 404 && Response.SubStatusCode == 13)
    {
        Response.Write("Too big a file"); //just an example
        Response.End();
    }
}

Après le tag

<security>
     <requestFiltering>
         <requestLimits maxAllowedContentLength="4500000" />
     </requestFiltering>
</security>

ajouter la balise suivante

 <httpErrors errorMode="Custom" existingResponse="Replace">
  <remove statusCode="404" subStatusCode="13" />
  <error statusCode="404" subStatusCode="13" prefixLanguageFilePath="" path="http://localhost/ErrorPage.aspx" responseMode="Redirect" />
</httpErrors>

vous pouvez ajouter l'URL à la page d'erreur ...

Vous pouvez résoudre ce problème en augmentant la longueur maximale de la requête et le délai d'exécution dans votre web.config:

-Veuillez clarifier le délai d'exécution maximum de la râpe, puis 1200

<?xml version="1.0" encoding="utf-8"?> <configuration> <system.web> <httpRuntime maxRequestLength="102400" executionTimeout="1200" /> </system.web> </configuration>

Que diriez-vous de l'attraper à l'événement EndRequest?

protected void Application_EndRequest(object sender, EventArgs e)
    {
        HttpRequest request = HttpContext.Current.Request;
        HttpResponse response = HttpContext.Current.Response;
        if ((request.HttpMethod == "POST") &&
            (response.StatusCode == 404 && response.SubStatusCode == 13))
        {
            // Clear the response header but do not clear errors and
            // transfer back to requesting page to handle error
            response.ClearHeaders();
            HttpContext.Current.Server.Transfer(request.AppRelativeCurrentExecutionFilePath);
        }
    }

Il peut être vérifié via:

        var httpException = ex as HttpException;
        if (httpException != null)
        {
            if (httpException.WebEventCode == System.Web.Management.WebEventCodes.RuntimeErrorPostTooLarge)
            {
                // Request too large

                return;

            }
        }