The server does not allow messages larger than 5242880 bytes

Question

Elmah has recently reported this bug;

Microsoft.SharePoint.Client.ServerException: The request message is too big. The server does not allow messages larger than 5242880 bytes.

The code where it fell over was;

public SharepointFileInfo Save(byte[] file, string fileName)
{
    using (var context = new ClientContext(this.SharepointServer))
    {
        context.Credentials = new NetworkCredential(this.UserName, this.Password, this.Domain);

        var list = context.Web.Lists.GetByTitle(this.DocumentLibrary);
        var fileCreationInformation = new FileCreationInformation
                                          {
                                              Content = file,
                                              Overwrite = true,
                                              Url = fileName
                                          };
        var uploadFile = list.RootFolder.Files.Add(fileCreationInformation);
        var listItem = uploadFile.ListItemAllFields;
        listItem.Update();

        context.ExecuteQuery();

        if (this.Metadata.Count > 0)
        {
            this.SaveMetadata(uploadFile, context);
        }

        return GetSharepointFileInfo(context, list, uploadFile);
    }
}

I am using Sharepoint 2013. How do I fix this?

Answer 1

It's a normal problme. You use the classic API (new FileCreationInformation [...] context.ExecuteQuery()) which sent a HTTP requet to the server. You file is up to 5 Mb. So, IIS receive a huge request, and reject it. To Upload a file to SharePoint you need to use :

File.SaveBinaryDirect (with this you don't need to change settings ;) )

using (FileStream fs = new FileStream(filePath, FileMode.Open))
{
  Microsoft.SharePoint.Client.File.SaveBinaryDirect(ctx, string.Format("/{0}/{1}", libraryName, System.IO.Path.GetFileName(filePath)), fs, true);
}

Check this links to see how to upload a file to SharePoint using CSOM : Upload large files sample app for SharePoint

good luck

Answer 2

There is several approche to do that (upload file with metaData). I propose 2 methods to you (one simple, second more complex)

1. In 2 Times (simple)

   • Upload the the file with the File.SaveBinaryDirect
   • Get the SPFile with CSOM by the file URL with SP.Web.getFileByServerRelativeUrl and File.listItemAllFields methodes. Here an exemple : get listitem by file URL

2. With FileCreationInformation but more complex. You need to use : File.StartUpload, File.ContinueUpload and File.FinishUpload The code is from Microsoft the last part of the tuto, not mine

   public Microsoft.SharePoint.Client.File UploadFileSlicePerSlice(ClientContext ctx, string libraryName, string fileName,int fileChunkSizeInMB = 3){
   // Each sliced upload requires a unique ID.
   Guid uploadId = Guid.NewGuid();
   
   // Get the name of the file.
   string uniqueFileName = Path.GetFileName(fileName);
   
   // Ensure that target library exists, and create it if it is missing.
   if (!LibraryExists(ctx, ctx.Web, libraryName))
   {
       CreateLibrary(ctx, ctx.Web, libraryName);
   }
   // Get the folder to upload into. 
   List docs = ctx.Web.Lists.GetByTitle(libraryName);
   ctx.Load(docs, l => l.RootFolder);
   // Get the information about the folder that will hold the file.
   ctx.Load(docs.RootFolder, f => f.ServerRelativeUrl);
   ctx.ExecuteQuery();
   
   // File object.
   Microsoft.SharePoint.Client.File uploadFile;
   
   // Calculate block size in bytes.
   int blockSize = fileChunkSizeInMB * 1024 * 1024;
   
   // Get the information about the folder that will hold the file.
   ctx.Load(docs.RootFolder, f => f.ServerRelativeUrl);
   ctx.ExecuteQuery();
   
   
   // Get the size of the file.
   long fileSize = new FileInfo(fileName).Length;
   
   if (fileSize <= blockSize)
   {
       // Use regular approach.
       using (FileStream fs = new FileStream(fileName, FileMode.Open))
       {
           FileCreationInformation fileInfo = new FileCreationInformation();
           fileInfo.ContentStream = fs;
           fileInfo.Url = uniqueFileName;
           fileInfo.Overwrite = true;
           uploadFile = docs.RootFolder.Files.Add(fileInfo);
           ctx.Load(uploadFile);
           ctx.ExecuteQuery();
           // Return the file object for the uploaded file.
           return uploadFile;
       }
   }
   else
   {
       // Use large file upload approach.
       ClientResult<long> bytesUploaded = null;
   
       FileStream fs = null;
       try
       {
           fs = System.IO.File.Open(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
           using (BinaryReader br = new BinaryReader(fs))
           {
               byte[] buffer = new byte[blockSize];
               Byte[] lastBuffer = null;
               long fileoffset = 0;
               long totalBytesRead = 0;
               int bytesRead;
               bool first = true;
               bool last = false;
   
               // Read data from file system in blocks. 
               while ((bytesRead = br.Read(buffer, 0, buffer.Length)) > 0)
               {
                   totalBytesRead = totalBytesRead + bytesRead;
   
                   // You've reached the end of the file.
                   if (totalBytesRead == fileSize)
                   {
                       last = true;
                       // Copy to a new buffer that has the correct size.
                       lastBuffer = new byte[bytesRead];
                       Array.Copy(buffer, 0, lastBuffer, 0, bytesRead);
                   }
   
                   if (first)
                   {
                       using (MemoryStream contentStream = new MemoryStream())
                       {
                           // Add an empty file.
                           FileCreationInformation fileInfo = new FileCreationInformation();
                           fileInfo.ContentStream = contentStream;
                           fileInfo.Url = uniqueFileName;
                           fileInfo.Overwrite = true;
                           uploadFile = docs.RootFolder.Files.Add(fileInfo);
   
                           // Start upload by uploading the first slice. 
                           using (MemoryStream s = new MemoryStream(buffer))
                           {
                               // Call the start upload method on the first slice.
                               bytesUploaded = uploadFile.StartUpload(uploadId, s);
                               ctx.ExecuteQuery();
                               // fileoffset is the pointer where the next slice will be added.
                               fileoffset = bytesUploaded.Value;
                           }
   
                           // You can only start the upload once.
                           first = false;
                       }
                   }
                   else
                   {
                       // Get a reference to your file.
                       uploadFile = ctx.Web.GetFileByServerRelativeUrl(docs.RootFolder.ServerRelativeUrl + System.IO.Path.AltDirectorySeparatorChar + uniqueFileName);
   
                       if (last)
                       {
                           // Is this the last slice of data?
                           using (MemoryStream s = new MemoryStream(lastBuffer))
                           {
                               // End sliced upload by calling FinishUpload.
                               uploadFile = uploadFile.FinishUpload(uploadId, fileoffset, s);
                               ctx.ExecuteQuery();
   
                               // Return the file object for the uploaded file.
                               return uploadFile;
                           }
                       }
                       else
                       {
                           using (MemoryStream s = new MemoryStream(buffer))
                           {
                               // Continue sliced upload.
                               bytesUploaded = uploadFile.ContinueUpload(uploadId, fileoffset, s);
                               ctx.ExecuteQuery();
                               // Update fileoffset for the next slice.
                               fileoffset = bytesUploaded.Value;
                           }
                       }
                   }
   
               } // while ((bytesRead = br.Read(buffer, 0, buffer.Length)) > 0)
           }
       }
       finally
       {
           if (fs != null)
           {
               fs.Dispose();
           }
       }
   }
   return null;}
   

hope this help you