Como codificar e decodificar um anexo de arquivo programaticamente usando Visual C# no InfoPath 2003

Este artigo discute como codificar e decodificar um anexo de arquivo programaticamente usando Microsoft Visual C# no InfoPath 2003. Para obter informações sobre como fazer isso no InfoPath 2010 ou no InfoPath 2007, consulte a seguinte página web: Como codificar e decodificar um anexo de arquivo programaticamente usando Visual C# no InfoPath 2010 ou no InfoPath 2007  (http://support.microsoft.com/kb/2517906/ ) .

A Microsoft fornece exemplos de programação apenas para ilustração, sem garantia expressa ou implícita. Isso inclui, mas não está limitado a garantias implícitas de comercialização ou adequação para um determinado finalidade. Este artigo presume que você esteja familiarizado com a programação idioma que está sendo demonstrado e com as ferramentas usadas para criar e depurar procedimentos. Engenheiros de suporte da Microsoft podem ajudar a explicar a funcionalidade de um determinado procedimento, mas eles não modificarão esses exemplos para fornecer funcionalidade adicional ou construir procedimentos para atender às suas requisitos específicos.

Criar um projeto do Visual C# InfoPath 2003

1. Inicie o Microsoft Visual Studio.NET 2003.
2. Sobre o Arquivo menu, clique emNovoe clique em Projeto.
3. No Novo projeto caixa de diálogo, clique emProjetos do Visual C# em projetos do InfoPath de Microsoft Office pasta.
4. No Nome caixa, digiteAttachmentEncodinge clique emOK.
5. No Assistente de projeto Microsoft Office, clique emCriar um novo modelo de formulárioe clique emConcluir.
   
   O Assistente de projeto Microsoft Office cria um novo Visual Studio.NET 2003 projeto chamado AttachmentEncoding. Uma Modelo de formulário do InfoPath também é criado. É o modelo de formulário do InfoPath denominado AttachmentEncoding.

Crie uma classe de codificador no Visual Studio.NET 2003

1. No Solution Explorer, clique com o botão direitoAttachmentEncoding, aponte para Adicionare depois Clique em Adicionar Novo Item.
2. No Adicionar Novo Item caixa de diálogo, clique emClasse no Modelo painel, tipoInfoPathAttachmentEncoder.cs noNome caixa e clique Aberto.
3. Substituir todos os códigos de InfoPathAttachmentEncoder.cs arquivo com o código a seguir.

   using System;
   using System.IO;
   using System.Text;
   using System.Security.Cryptography;
   
   namespace InfoPathAttachmentEncoding
   {
   	/// <summary>
   	/// InfoPathAttachment encodes file data into the format expected by InfoPath for use in file attachment nodes.
   	/// </summary>
   	public class InfoPathAttachmentEncoder
   	{
   		private string base64EncodedFile = string.Empty;
   		private string fullyQualifiedFileName;
   
   		/// <summary>
   		/// Creates an encoder to create an InfoPath attachment string.
   		/// </summary>
   		/// <param name="fullyQualifiedFileName"></param>
   		public InfoPathAttachmentEncoder(string fullyQualifiedFileName)
   		{
   			if (fullyQualifiedFileName == string.Empty)
   				throw new ArgumentException("Must specify file name", "fullyQualifiedFileName");
   
   			if (!File.Exists(fullyQualifiedFileName))
   				throw new FileNotFoundException("File does not exist: " + fullyQualifiedFileName, fullyQualifiedFileName);
   
   			this.fullyQualifiedFileName = fullyQualifiedFileName;
   		}
   
   		/// <summary>
   		/// Returns a Base64 encoded string.
   		/// </summary>
   		/// <returns>String</returns>
   		public string ToBase64String()
   		{
   			if (base64EncodedFile != string.Empty)
   				return base64EncodedFile;
   
   			// This memory stream will hold the InfoPath file attachment buffer before Base64 encoding.
   			MemoryStream ms = new MemoryStream();
   
   			// Get the file information.
   			using (BinaryReader br = new BinaryReader(File.Open(fullyQualifiedFileName, FileMode.Open, FileAccess.Read, FileShare.Read)))
   			{
   				string fileName = Path.GetFileName(fullyQualifiedFileName);
   
   				uint fileNameLength = (uint)fileName.Length + 1;
   
   				byte[] fileNameBytes = Encoding.Unicode.GetBytes(fileName);
   
   				using (BinaryWriter bw = new BinaryWriter(ms))
   				{
   					// Write the InfoPath attachment signature. 
   					bw.Write(new byte[] { 0xC7, 0x49, 0x46, 0x41 });
   
   					// Write the default header information.
   					bw.Write((uint)0x14);	// size
   					bw.Write((uint)0x01);	// version
   					bw.Write((uint)0x00);	// reserved
   
   					// Write the file size.
   					bw.Write((uint)br.BaseStream.Length);
   
   					// Write the size of the file name.
   					bw.Write((uint)fileNameLength);
   
   					// Write the file name (Unicode encoded).
   					bw.Write(fileNameBytes);
   
   					// Write the file name terminator. This is two nulls in Unicode.
   					bw.Write(new byte[] {0,0});
   
   					// Iterate through the file reading data and writing it to the outbuffer.
   					byte[] data = new byte[64*1024];
   					int bytesRead = 1;
   
   					while (bytesRead > 0)
   					{
   						bytesRead = br.Read(data, 0, data.Length);
   						bw.Write(data, 0, bytesRead);
   					}
   				}
   			}
   
   
   			// This memorystream will hold the Base64 encoded InfoPath attachment.
   			MemoryStream msOut = new MemoryStream();
   
   			using (BinaryReader br = new BinaryReader(new MemoryStream(ms.ToArray())))
   			{
   				// Create a Base64 transform to do the encoding.
   				ToBase64Transform tf = new ToBase64Transform();
   
   				byte[] data = new byte[tf.InputBlockSize];
   				byte[] outData = new byte[tf.OutputBlockSize];
   
   				int bytesRead = 1;
   
   				while (bytesRead > 0)
   				{
   					bytesRead = br.Read(data, 0, data.Length);
   
   					if (bytesRead == data.Length)
   						tf.TransformBlock(data, 0, bytesRead, outData, 0);
   					else
   						outData = tf.TransformFinalBlock(data, 0, bytesRead);
   
   					msOut.Write(outData, 0, outData.Length);
   				}
   			}
   
   			msOut.Close();
   			
   			return base64EncodedFile = Encoding.ASCII.GetString(msOut.ToArray());
   		}
   	}
   }

Crie uma classe de decodificador de Visual Studio.NET 2003

1. No Solution Explorer, clique com o botão direitoAttachmentEncoding, aponte para Adicionare depois Clique em Adicionar Novo Item.
2. No Adicionar Novo Item caixa de diálogo, clique emClasse no Modelo painel, tipoInfoPathAttachmentDecoder.cs noNome caixa e clique Aberto.
3. Substituir todos os códigos de InfoPathAttachmentDecoder.cs arquivo com o código a seguir.

   using System;
   using System.IO;
   using System.Text;
   
   namespace InfoPathAttachmentEncoding
   {
   	/// <summary>
   	/// Decodes a file attachment and saves it to a specified path.
   	/// </summary>
   	public class InfoPathAttachmentDecoder
   	{
   		private const int SP1Header_Size = 20;
   		private const int FIXED_HEADER = 16;
   
   		private int fileSize;
   		private int attachmentNameLength;
   		private string attachmentName;
   		private byte[] decodedAttachment;
   
   		/// <summary>
   		/// Accepts the Base64 encoded string
   		/// that is the attachment.
   		/// </summary>
   		public InfoPathAttachmentDecoder(string theBase64EncodedString)
   		{
   			byte [] theData = Convert.FromBase64String(theBase64EncodedString);
   			using(MemoryStream ms = new MemoryStream(theData))
   			{
   				BinaryReader theReader = new BinaryReader(ms);			
   				DecodeAttachment(theReader);
   			}
   		}
   
   		private void DecodeAttachment(BinaryReader theReader)
   		{
   			//Position the reader to get the file size.
   			byte[] headerData = new byte[FIXED_HEADER];
   			headerData = theReader.ReadBytes(headerData.Length);
   
   			fileSize = (int)theReader.ReadUInt32();
   			attachmentNameLength = (int)theReader.ReadUInt32() * 2;
   			
   			byte[] fileNameBytes = theReader.ReadBytes(attachmentNameLength);
   			//InfoPath uses UTF8 encoding.
   			Encoding enc = Encoding.Unicode;
   			attachmentName = enc.GetString(fileNameBytes, 0, attachmentNameLength - 2);
   			decodedAttachment = theReader.ReadBytes(fileSize);
   		}
   
   		public void SaveAttachment(string saveLocation)
   		{
   			string fullFileName = saveLocation;
   			if(!fullFileName.EndsWith(Path.DirectorySeparatorChar))
   			{
   				fullFileName += Path.DirectorySeparatorChar;
   			}
   
   			fullFileName += attachmentName;
   
   			if(File.Exists(fullFileName))
   				File.Delete(fullFileName);
   			
   			FileStream fs = new FileStream(fullFileName, FileMode.CreateNew);
   			BinaryWriter bw = new BinaryWriter(fs);
   			bw.Write(decodedAttachment);
   
   			bw.Close();
   			fs.Close();
   		}
   
   		public string Filename
   		{
   			get{ return attachmentName; }
   		}
   
   		public byte[] DecodedAttachment
   		{
   			get{ return decodedAttachment; }
   		}
   	}	
   }
   
   

Adicione um controle de anexo de arquivo e um controle de caixa de texto ao formulário do InfoPath

1. No modelo de formulário AttachmentEncoding InfoPath, Clique em Controles no Tarefas de design tarefa painel.
2. No Controlespainel de tarefas, clique emArquivo Anexo emInserir controles.
3. Com o botão direito do Anexo de arquivo controle, e, em seguida, clique em Propriedades de anexo de arquivo.
4. No Propriedades de anexo de arquivo caixa de diálogo caixa, digite theAttachmentField no Campo Nome caixa e clique OK.
5. No Controlespainel de tarefas, clique emCaixa de texto emInserir controles.
6. Com o botão direito do Caixa de texto controle e então Clique em Propriedades da caixa de texto.
7. No Propriedades da caixa de texto caixa de diálogo tipo theAttachmentName no Campo Nome caixa e clique OK.

Adicionar um botão Anexar ao formulário do InfoPath

1. No Controlespainel de tarefas, clique emBotão emInserir controles.
2. Botão direito do mouse o novo Botão controle, e Clique em Propriedades do botão.
3. No Propriedades do botão caixa de diálogo, digiteAnexar no Rótulo caixa, digitebtnAttach no IDENTIFICAÇÃO caixa e cliqueEditar código do formulário.
4. Adicione o seguinte código para o btnAttach_OnClick método.

   //Get a reference to the attachment node.
   IXMLDOMNode theAttachmentNode = thisXDocument.DOM.selectSingleNode("my:myFields/my:theAttachmentField");
   
   //Get a reference to the filename node.
   IXMLDOMNode fileNameNode = thisXDocument.DOM.selectSingleNode("my:myFields/my:theAttachmentName");
   //Get the text of the node.
   String fileName = fileNameNode.text;
   if(fileName.Length > 0)
   {
   	//Encode the file and assign it to the attachment node.
   	InfoPathAttachmentEncoding.Encoder myEncoder = new InfoPathAttachmentEncoding.Encoder(fileName);
   	if(theAttachmentNode.attributes.getNamedItem("xsi:nil") != null)
   		theAttachmentNode.attributes.removeNamedItem("xsi:nil");
   	theAttachmentNode.text = myEncoder.ToBase64String();
   }	
   

Adicionar um botão Salvar ao formulário do InfoPath

1. Alterne para o formulário do AttachmentEncoding InfoPath modelo.
2. No Controlespainel de tarefas, clique emBotão emInserir controles.
3. Botão direito do mouse o novo Botão controle, e Clique em Propriedades do botão.
4. No Propriedades do botão caixa de diálogo, digiteSalvar no Rótulo caixa, digitebtnSave no IDENTIFICAÇÃO caixa e cliqueEditar código do formulário.
5. Adicione o seguinte código para o btnSave _OnClick método.

   //Get a reference to the attachment node.
   IXMLDOMNode n = thisXDocument.DOM.selectSingleNode("my:myFields/my:theAttachmentField");
   //Get the text of the node.
   String theAttachment = n.text;
   if(theAttachment.Length > 0)
   {
   	InfoPathAttachmentEncoding.Decoder myDecoder = new InfoPathAttachmentEncoding.Decoder(theAttachment);
   	myDecoder.SaveAttachment(@"<Path to save the file>");
   }			
   

   Observação Nesse código, substitua <Path to="" save="" the="" file=""></Path> com o local onde deseja salvar o arquivo.

Certifique-se de que o modelo de formulário do InfoPath é totalmente confiável

Antes você pode testar esse formulário, o modelo de formulário do InfoPath deve ser totalmente confiável. Você pode usar um dos seguintes métodos para certificar-se que o modelo de formulário do InfoPath é totalmente confiável:

• Use o Microsoft.NET Framework 1.1 Configuration utility Para conceder permissões de confiança total somente para seu código Visual C#.
• Use o utilitário RegForm do InfoPath Software Development Kit (SDK) para tornar o formulário um formulário totalmente confiável. Isso concede completo Permissões para seu código Visual C# de confiança.
• Usar um certificado de assinatura de código para assinar digitalmente o formulário arquivo de modelo (. xsn). Quando você usa um certificado de assinatura de código para assinar digitalmente o arquivo de modelo de formulário, os usuários são solicitados a confiar no formulário quando abrem o formulário. Isso torna o formulário totalmente confiável. Portanto, são permissões de confiança total concedido para seu código Visual C#.
• Use o IPFullTrust macro do SDK do InfoPath para tornar o formulário totalmente confiável formulário. O IPFullTrust macro automatiza a configuração de formulário e o arquivo de manifesto (. xsf) arquivo de modelo do projeto do InfoPath para confiança total e o IPFullTrust macro registra automaticamente o modelo de formulário.
  
  Para mais informações sobre como instalar e usar a macro, visite o seguinte Web site da Microsoft Developer Network (MSDN):
  . aspx http://msdn2.microsoft.com/en-us/library/aa202736 (office.11) (http://msdn2.microsoft.com/en-us/library/aa202736(office.11).aspx)
• Usar a automação externa no InfoPath para chamar o RegisterSolution método. Normalmente, esse método é usado somente para desenvolvimento de formulários porque um formulário registrado registra somente para um computador individual. Para qualquer formulários adicionais, outros usuários devem registrar os formulários adicionais em sua própria computadores. Não recomendamos esse método para formulários adicionais. Recomendamos qualquer um dos métodos anteriores, quando você publicar o formulário.

Este formulário está em desenvolvimento do formulário, você pode usar o último método. Para fazer isso, localize o formulário AttachmentEncoding InfoPath modelo e, em seguida, siga estas etapas:

1. Sobre o Ferramentas menu, clique em Formulário Opções.
2. Clique no Segurança guia.
3. Clique para limpar a Determinar automaticamente a segurança nível com base no design do formulário (recomendado) caixa de seleção.
   
   Observação O InfoPath não pode detectar automaticamente lógica de negócios que requer permissões de confiança total. Portanto, você deve explicitamente conceder completo Permissões de confiança.
4. Clique em Confiança totale clique emOK.
5. Feche o modelo de formulário AttachmentEncoding InfoPath. Se você for solicitado para salvar as alterações, clique em Sim.
   
   Observação Não feche o Visual Studio.NET 2003 projeto.
6. Em Visual Studio.NET 2003, clique duas vezes oManifest. xsf arquivo no Solution Explorer. O arquivo manifest. xsf é aberta.
7. No nó raiz, localize a publishUrl atributo. Remover o publishUrl atributo e o valor da publishUrl atributo.
8. Salvar as alterações e feche o manifest. xsf arquivo.
9. Clique em Início, clique em Executar, tipo Bloco de notase clique emOK.
10. Adicione o seguinte código ao arquivo de texto em branco.

    oApp = WScript.CreateObject("InfoPath.ExternalApplication");
    strAbsolutePath = "<project_folder_url>\\Manifest.xsf";
    oApp.RegisterSolution(strAbsolutePath,"overwrite"); 
    

    Observação Nesse código, substitua<project_folder_url></project_folder_url> com o caminho para o Arquivo manifest. xsf na pasta do projeto. Lembre-se de escape o caminho para o Arquivo manifest. xsf. Barras todos os única invertidas (\) no caminho devem ser substituídas por duas barras invertidas (\).
11. Salve o arquivo manifest. xsf no computador como o Arquivo Register.js.
12. Para chamar a RegisterSolution método, clique duas vezes o Register.js arquivo você criou.

Testar o formulário

1. Em Visual Studio AttachmentEncoding.NET 2003 projeto, Clique em Início sobre o Depuração menu. Isso inicia o formulário do InfoPath no modo de visualização.
2. No formulário do InfoPath, digite o caminho do arquivo que você deseja anexar na caixa de texto e clique emAnexar.
   
   Observação Clique duas vezes o Anexo de arquivo controle Verifique se que o arquivo está codificado corretamente.
3. Clique em Salvar. Localize o caminho que você fornecidas no "adicionar um Salvar botão para o formulário do InfoPath" seção.
4. Para finalizar o teste, clique em Fechar Visualização.

Para obter mais informações sobre o cabeçalho de anexo de arquivo Formatar, visite o seguinte site da MSDN: