Exemplo de Suplemento do SharePoint de carregamento de arquivos grandes

O exemplo Core.LargeFileUpload mostra como usar um suplemento hospedado pelo provedor para carregar arquivos no SharePoint e como ignorar o limite de carregamento de arquivo de 2-MB.

Use esta solução para carregar arquivos maiores do que 2 MB no SharePoint.

Este exemplo é executado como um aplicativo de console que carrega arquivos em uma biblioteca de documentos usando um dos seguintes métodos:

• O métodoSaveBinaryDirect forma a classeMicrosoft.SharePoint.Client.File.
• A propriedade ContentStream na classe FileCreationInformation.
• Os métodos StartUpload, ContinueUpload, e FinishUpload na classeArquivo.

A tabela a seguir lista os métodos de carregamento de arquivos que estão disponíveis e descrevem quando usar cada método.

Opções para carregar arquivos

Antes de começar

Para começar, faça o download do suplemento de exemplo Core.LargeFileUpload no projeto Padrões e práticas do Desenvolvedor do Office 365 no GitHub.

Usando o suplemento de exemplo Core.LargeFileUpload

Quando você iniciar o código a seguir, um aplicativo do console aparecerá. Você deverá fornecer suas credenciais de logon e uma URL de conjunto de sites do SharePoint Online para Office 365.

Depois da autenticação, o aplicativo de console exibirá uma exceção. A exceção ocorre quando o método UploadDocumentContent no FileUploadService.cs tenta usar a propriedade FileCreationInformation.Content para carregar um arquivo maior que 2 MB. UploadDocumentContentUploadDocumentContent também cria uma biblioteca de documentos chamada Documentos caso ela ainda não exista. A biblioteca Documentosserá usada mais tarde no código a seguir.

public void UploadDocumentContent(ClientContext ctx, string libraryName, string filePath)
{
  Web web = ctx.Web;

  // Ensure that target library exists. Create if it is missing.
  if (!LibraryExists(ctx, web, libraryName))
  {
    CreateLibrary(ctx, web, libraryName);
  }

  FileCreationInformation newFile = new FileCreationInformation();

  // The next line of code causes an exception to be thrown for files larger than 2 MB.
  newFile.Content = System.IO.File.ReadAllBytes(filePath);
  newFile.Url = System.IO.Path.GetFileName(filePath);

  // Get instances to the given library.
  List docs = web.Lists.GetByTitle(libraryName);

  // Add file to the library.
  Microsoft.SharePoint.Client.File uploadFile = docs.RootFolder.Files.Add(newFile);
  ctx.Load(uploadFile);
  ctx.ExecuteQuery();
}

Em FileUploadService.cs, esse exemplo de código fornece três opções que você pode usar para carregar arquivos grandes para uma biblioteca de documentos:

• O métodoFile.SaveBinaryDirect.
• A propriedadeFileCreationInformation.ContentStreamFileCreationInformation.ContentStream.
• Os métodos StartUpload, ContinueUploade FinishUpload na classe arquivo.

Em FileUploadService.cs, SaveBinaryDirect usa o método Microsoft.SharePoint.Client.File.SaveBinaryDirect com um objeto FileStream para carregar arquivos em uma biblioteca de documentos.

public void SaveBinaryDirect(ClientContext ctx, string libraryName, string filePath)
{
  Web web = ctx.Web;
  // Ensure that the target library exists. Create it if it is missing.
  if (!LibraryExists(ctx, web, libraryName))
  {
    CreateLibrary(ctx, web, libraryName);
  }

  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);
  }
}

Em FileUploadService.cs, UploadDocumentContentStream usa a propriedade FileCreationInformation.ContentStream com o objeto FileStream para carregar um arquivo em uma biblioteca de documentos.

public void UploadDocumentContentStream(ClientContext ctx, string libraryName, string filePath)
{
  Web web = ctx.Web;
  // Ensure that the target library exists. Create it if it is missing.
  if (!LibraryExists(ctx, web, libraryName))
  {
    CreateLibrary(ctx, web, libraryName);
  }

  using (FileStream fs = new FileStream(filePath, FileMode.Open))
  {
    FileCreationInformation flciNewFile = new FileCreationInformation();

    // This is the key difference for the first case - using ContentStream property
    flciNewFile.ContentStream = fs;
    flciNewFile.Url = System.IO.Path.GetFileName(filePath);
    flciNewFile.Overwrite = true;

    List docs = web.Lists.GetByTitle(libraryName);
    Microsoft.SharePoint.Client.File uploadFile = docs.RootFolder.Files.Add(flciNewFile);

    ctx.Load(uploadFile);
    ctx.ExecuteQuery();
  }
}

Em FileUploadService.cs, UploadFileSlicePerSlice carrega um arquivo grande em uma biblioteca de documentos como um conjunto de partes ou fragmentos. UploadFileSlicePerSlice executa as seguintes tarefas:

1. Obtém um novo GUID. Para carregar um arquivo em partes, você deve usar um GUID exclusivo.
2. Calcula o tamanho das partes em bytes. Para calcular o tamanho do bloco em bytes, UploadFileSlicePerSlice usa fileChunkSizeInMB, que especifica o tamanho dos blocos individuais em MB.
3. Testa se o tamanho do arquivo a ser carregado (fileSize) é menor ou igual ao tamanho da parte (blockSize).
   • Se fileSize é menor ou igual ao tamanho da parte, a amostra garante que o arquivo ainda será carregado usando a propriedade FileCreationInformation.ContentStream. Lembre-se de que o tamanho recomendado da parte é de 10 MB ou mais.
   • Se fileSize for maior do que o tamanho da parte:
     • A parte do arquivo é lido em buffer
     • Se o tamanho da parte for igual ao tamanho do arquivo, o arquivo todo foi lido. O bloco é copiado para o lastBuffer. lastBuffer em seguida, o usa o File.FinishUpload para carregar o bloco.
   • Se o tamanho da parte não é igual ao tamanho do arquivo, há mais de uma parte para ler o arquivo. File.StartUpload o é chamado para carregar o primeiro bloco. fileoffset, que é usado como ponto de partida da próxima parte, é definido como a quantidade de bytes carregados da primeira parte. Quando a próxima parte é lida, se a última parte não tiver sido alcançada, File.ContinueUploadFile.ContinueUpload é chamado para carregar a próxima parte do arquivo. O processo se repete até que a última parte seja lida. Quando a última parte for lida File.FinishUpload carrega a última parte e compromete o arquivo. O conteúdo do arquivo será alterado em seguida, quando esse método estiver concluído.

As partes devem ser carregadas em ordem sequencial. Você não pode carregar fatias ao mesmo tempo (por exemplo, usando uma abordagem multithread).

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 = null;

  // 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
          {
            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;
}

Quando o código de exemplo for finalizado no seu site do Office 365, você pode ir para a biblioteca Documentos , escolhendo Documentos>Recentes. Verifique se a biblioteca Documentos contém três arquivos grandes.

Confira também

• exemplo Core.BulkDocumentUploader
• Soluções do Gerenciamento de conteúdo corporativo no SharePoint