Visual Studio没有响应上传大小为6MB的文件

Question

I am working on Visual studio 15. My application needs to upload a file of size 6MB. I am using .Net 4.5.1 with Entity Framework 6.

The following script and html code is written at view level razor to select and check uploading of file.

$('#SaveResponse').click(function () {
var data = new FormData();
var files = $("#imagefile").get(0).files;
    if (files.length > 0) {
        data.append("UploadedImage", files[0]);
    }
    else
    {
        alert('You have not selected any File');
        return;
    }
            $.ajax({
                async: false,
                cache: false,
                type: "POST",
                dataType: "json",
                contentType: false,
                processData: false,
                url: "@(Url.RouteUrl("UploadFile"))",
                data: data,
                success: function (JsonCP) {
                      if (JsonCP.msg != null) {
                        if (JsonCP.msg.Key) {
                            alert(JsonCP.msg.Value);
                            $("#fileUpload").val('');
                        } else 
                            alert(JsonCP.msg.Value);
                      }
                   },
                error: function (JsonCP) {
                    alert(JsonCP.msg.Value);
                 }
            });
        });

<table>
  <tr>
      <td align="right" width="200px">@Html.Label("Select the File:")</td>
      <td  align="left" width="200px"><input type="file" id="imagefile" />
      </td>
  </tr>
  <tr>
   <td colspan="2" align="center"><input type="button" value="Save this 
     Response"  id="SaveResponse" name="SaveResponse" /></td>
  </tr>
</table>

The following code is written in the controller to get the file to be uploaded and display appropriate message.

[System.Web.Mvc.AcceptVerbs(HttpVerbs.Post)]
    public ActionResult UploadFile()
    {
        UploadResponseModel rm = new UploadResponseModel();
        try
        {
            if (System.Web.HttpContext.Current.Request.Files.AllKeys.Any())
            {
                var httpPostedFile = 
            System.Web.HttpContext.Current.Request.Files["UploadedImage"];
                if (httpPostedFile != null)
                {
                    string fileSavePath = 
           Path.Combine(HttpContext.Server.MapPath("~/UploadedFiles"), 
              Path.GetFileName(httpPostedFile.FileName));
                    httpPostedFile.SaveAs(fileSavePath);
                    rm.responseModel.response.ResponseImage = 
                       System.IO.File.ReadAllBytes(filesavePath)
                    if (rm.responseModel.insertResponse() != 1)
                        rm.msg = new KeyValuePair<bool, string>(false, 
                            "row is not saved successfully."); 
                    else
                        rm.msg=new KeyValuePair<bool,string>(true,"File 
                          uploaded Successfully.");
                 }
                else
                rm.msg = new KeyValuePair<bool, string>(false, "Could not 
                    get the file.");
            }
            else
          rm.msg = new KeyValuePair<bool, string>(false, "No file found to 
                                 Upload.");
        }
        catch (Exception ex)
        {
     rm.msg = new KeyValuePair<bool, string>(false, "Can not Upload the 
       file: "  + ex.Message);
        }
        return Json(rm, JsonRequestBehavior.AllowGet);
    }
  } 

The following function is used to insert a row in sql database table called Responses.

public int insertResponse()
{
   using (Entities cntx = new Entities())
   {
    cntx.Responses.Add(this.response);cntx.Entry(this.response).
    State = System.Data.Entity.EntityState.Added;
    int ex=cntx.SaveChanges();
    return ex;
   }
  }

One of the column of responses table called responseImage is datatype of fileStream. Another column of it is of type uniqueIdentifier. The table creation sql is given below.

CREATE TABLE [dbo].[Responses] (
[ResponseId]       UNIQUEIDENTIFIER           ROWGUIDCOL NOT NULL,
[ResponseImage]    VARBINARY (MAX) FILESTREAM NULL,
     CONSTRAINT [PK_Responses] PRIMARY KEY CLUSTERED ([ResponseId] ASC) 
     FILESTREAM_ON  [FileStreamGroup], UNIQUE NONCLUSTERED ([ResponseId] ASC)
  );

The Web confif file is set like this

<system.web>
  <authentication mode="None" />
  <compilation debug="true" targetFramework="4.5.1" />
  <httpRuntime targetFramework="4.5.1" maxRequestLength="3145728" 
    executionTimeout="9999999" useFullyQualifiedRedirectUrl="false" 
    minFreeThreads="8" minLocalRequestFreeThreads="4" 
    appRequestQueueLimit="1000"/>
</system.web>

<system.webServer>

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

The program works correctly and shows proper message for files of small size, But for the files of size 3 MB it does not show any error message not even out of memory. But the row and file are saved. Why it is not showing any message although it is uploading the file?

Answer 1

if we are manipulating the file stream directly the problem can be solved in thr following way.

public int insertStreamResponse(HttpPostedFile file)
    {
        SqlConnection sqlConnection = new SqlConnection();
        sqlConnection.ConnectionString = "Data 
        Source=HOME\\MSQLEXPRESS2016;Initial Catalog=Evaluation;Integrated 
         Security=True";
        sqlConnection.Open();
        SqlCommand sqlCommand = new SqlCommand();
        sqlCommand.Connection = sqlConnection;
        sqlCommand.CommandType = CommandType.Text;
        sqlCommand.CommandText = "insert into responses values
        (ResponseId, (0X))";
        SqlParameter parameter;
        parameter = new System.Data.SqlClient.SqlParameter("@ResponseId", 
        System.Data.SqlDbType.UniqueIdentifier);
        parameter.Value = this.response.ResponseId;
        sqlCommand.Parameters.Add(parameter);
        SqlCommand helperCommand = new SqlCommand();
        sqlCommand.Transaction = sqlConnection.BeginTransaction();
        sqlCommand.ExecuteNonQuery();
        helperCommand.Connection = sqlConnection;
        helperCommand.Transaction = sqlCommand.Transaction;
        helperCommand.CommandText = "SELECT 
        GET_FILESTREAM_TRANSACTION_CONTEXT()";
        Object transactionContext = helperCommand.ExecuteScalar();
        helperCommand.CommandText = "SELECT ResponseImage.PathName() FROM 
        Responses WHERE [ResponseId] = @Id";
        parameter = new System.Data.SqlClient.SqlParameter("@Id", 
        System.Data.SqlDbType.UniqueIdentifier);
        helperCommand.Parameters.Add(parameter);
        helperCommand.Parameters["@Id"].Value = sqlCommand.Parameters
        ["@ResponseId"].Value;
        string filePathInServer = (string)helperCommand.ExecuteScalar();
        byte[] buffer = new byte[file.ContentLength];
        //read from the input file 
        Stream fileStream = file.InputStream;
        if (fileStream.CanRead)
            fileStream.Read(buffer, 0, file.ContentLength);
        else return 0;
        //write into the  file stream
        SqlFileStream sqlFileStream = new SqlFileStream(filePathInServer, 
        (byte[])transactionContext, System.IO.FileAccess.Write);
        if (sqlFileStream.CanWrite)
            sqlFileStream.Write(buffer, 0, file.ContentLength);
        else return 0;
        sqlCommand.Transaction.Commit();
        sqlConnection.Close();
        return 1;
    }

Answer 2

If you are using IIS for hosting your application, then the default upload file size if 4MB. To increase it, please use this below section in your web.config -

<configuration> <system.web> <httpRuntime maxRequestLength="1048576" /> </system.web> </configuration>

For IIS7 and above, you also need to add the lines below:

<system.webServer> <security> <requestFiltering> <requestLimits maxAllowedContentLength="1073741824" /> </requestFiltering> </security> </system.webServer>

Note: maxAllowedContentLength is measured in bytes while maxRequestLength is measured in kilobytes, which is why the values differ in this config example. (Both are equivalent to 1 GB.)