Codieren und Decodieren einer Dateianlage programmgesteuert mithilfe von Visual C# in InfoPath 2003

Dieser Artikel erläutert, wie zum Codieren und Decodieren einer Dateianlage programmgesteuert mithilfe von Microsoft Visual C# in InfoPath 2003. Informationen dazu in InfoPath 2010 oder InfoPath 2007 finden Sie unter der folgenden Webseite: Codieren und eine Dateianlage decodieren programmgesteuert mit Visual C# in InfoPath 2010 oder in InfoPath 2007.

Microsoft bietet Programmierbeispiele lediglich zur Veranschaulichung, Garantien, gleich ob ausdrücklich oder konkludent. Dies umfasst, ist aber nicht beschränkt auf, KONKLUDENTEN GEWÄHRLEISTUNGEN der Handelsüblichkeit oder Eignung für einen bestimmten Zweck. Dieser Artikel setzt voraus, dass Sie mit der Programmierung vertraut sind. exemplarisch ist und mit den Tools, die zum Erstellen verwendet werden und Debuggen von Prozeduren. Microsoft Support-Technikern helfen, erläutern die die Funktionalität einer bestimmten Prozedur, aber sie nicht ändern diese Beispiele zur bieten zusätzliche Funktionalität und Programmierungsbeispiele zur Erfüllung Ihrer spezifische Anforderungen.

Erstellen Sie ein Visual C# InfoPath 2003-Projekt

1. Starten Sie Microsoft Visual Studio.NET 2003.
2. Auf der Datei im Menü klickenNeue, und klicken Sie dann auf Projekt.
3. In der Neues Projekt Klicken Sie im Dialogfeld klicken Sie aufVisual C#-Projekte in InfoPath-Projekten mit Microsoft Office Ordner.
4. In der Name Geben Sie im FeldAttachmentEncoding, und klicken Sie dann aufOK.
5. Klicken Sie im Microsoft Office-Projekt-AssistentenErstellen einer neuen Formularvorlage, und klicken Sie dann aufFertig stellen.
   
   Microsoft Office-Projekt-Assistent erstellt ein neue Visual Studio.NET 2003-Projekt mit dem Namen AttachmentEncoding. Ein InfoPath-Formularvorlage wird ebenfalls erstellt. Die InfoPath-Formularvorlage ist mit dem Namen AttachmentEncoding.

Erstellen einer Encoder-Klasse in Visual Studio.NET 2003

1. Im Projektmappen-Explorer mit der rechten MaustasteAttachmentEncoding, zeigen Sie auf Hinzufügen, und klicken Sie dann Klicken Sie auf Neues Element hinzufügen.
2. In der Neues Element hinzufügen Klicken Sie im Dialogfeld klicken Sie aufKlasse in der Vorlage im Bereich TypInfoPathAttachmentEncoder.cs in derName ein, und klicken Sie dann auf Öffnen.
3. Ersetzen Sie den gesamten Code in der InfoPathAttachmentEncoder.cs Datei mit dem folgenden Code.

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

Erstellen einer Decoder-Klasse in Visual Studio.NET 2003

1. Im Projektmappen-Explorer mit der rechten MaustasteAttachmentEncoding, zeigen Sie auf Hinzufügen, und klicken Sie dann Klicken Sie auf Neues Element hinzufügen.
2. In der Neues Element hinzufügen Klicken Sie im Dialogfeld klicken Sie aufKlasse in der Vorlage im Bereich TypInfoPathAttachmentDecoder.cs in derName ein, und klicken Sie dann auf Öffnen.
3. Ersetzen Sie den gesamten Code in der InfoPathAttachmentDecoder.cs Datei mit dem folgenden Code.

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

Hinzufügen eines Dateianlage-Steuerelements und ein Textfeld-Steuerelement zum InfoPath-Formular

1. In der AttachmentEncoding InfoPath-Formularvorlage Klicken Sie auf Steuerelemente in der Formularentwurf Aufgabe Bereich.
2. In der Steuerelementeim Aufgabenbereich, klicken Sie aufDatei Anlage unterEinfügen von Steuerelementen.
3. Mit der rechten Maustaste die Dateianlage Kontrolle, und klicken Sie dann auf Eigenschaften für Dateianlage.
4. In der Eigenschaften für Dateianlage Dialogfeld Geben Sie im Feld theAttachmentField in der Feld Name ein, und klicken Sie dann auf OK.
5. In der Steuerelementeim Aufgabenbereich, klicken Sie aufTextfeld unterEinfügen von Steuerelementen.
6. Mit der rechten Maustaste die Textfeld Steuerelement, und klicken Sie dann Klicken Sie auf Eigenschaften für Textfeld.
7. In der Eigenschaften für Textfeld Klicken Sie im Dialogfeld Typ theAttachmentName in der Feld Name ein, und klicken Sie dann auf OK.

Hinzufügen einer Schaltfläche Anfügen zum InfoPath-Formular

1. In der Steuerelementeim Aufgabenbereich, klicken Sie aufSchaltfläche unterEinfügen von Steuerelementen.
2. Mit der rechten Maustaste das neue Schaltfläche Steuerelement, und Klicken Sie dann auf Button-Eigenschaften.
3. In der Button-Eigenschaften im Dialogfeld TypAnfügen Klicken Sie im Dialogfeld Bezeichnung Geben Sie im FeldbtnAttach Klicken Sie im Dialogfeld ID ein, und klicken Sie dann aufFormularcode bearbeiten.
4. Fügen Sie folgenden Code in der btnAttach_OnClick Methode.

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

Hinzufügen einer Schaltfläche Speichern zum InfoPath-Formular

1. Wechseln Sie zum AttachmentEncoding InfoPath-Formular Vorlage.
2. In der Steuerelementeim Aufgabenbereich, klicken Sie aufSchaltfläche unterEinfügen von Steuerelementen.
3. Mit der rechten Maustaste das neue Schaltfläche Steuerelement, und Klicken Sie dann auf Button-Eigenschaften.
4. In der Button-Eigenschaften im Dialogfeld TypSpeichern Klicken Sie im Dialogfeld Bezeichnung Geben Sie im FeldbtnSave Klicken Sie im Dialogfeld ID ein, und klicken Sie dann aufFormularcode bearbeiten.
5. Fügen Sie folgenden Code in der btnSave_OnClick Methode.

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

   Hinweis In diesem Code ersetzen <Path to="" save="" the="" file=""></Path> mit dem Speicherort, in dem Sie speichern möchten, die Datei.

Stellen Sie sicher, dass die InfoPath-Formularvorlage voll vertrauenswürdig ist.

Bevor Sie dieses Formular, die InfoPath-Formularvorlage testen vollständig vertrauenswürdig sein. Sie können eine der folgenden Methoden verwenden, um sicherzustellen sich die InfoPath-Formularvorlage voll vertrauenswürdig:

• Verwenden Sie das Microsoft.NET Framework 1.1 Configuration-Dienstprogramm zum Erteilen von Berechtigungen für volle Vertrauenswürdigkeit nur auf Visual C# Code.
• Verwenden Sie das Dienstprogramm RegForm aus dem InfoPath-Software Development Kit (SDK) um das Formular ein voll vertrauenswürdiges Formular machen. Dies gewährt voll Vertrauen Sie Ihre Visual C# Code Berechtigungen.
• Verwenden Sie ein codesigniertes Zertifikat zum digitalen Signieren des Formulars die Formularvorlagendatei (XSN). Wenn Sie ein codesigniertes Zertifikat zum Signieren verwenden die Formularvorlagendatei Benutzer werden aufgefordert, das Formular zu vertrauen, wenn sie öffnen die Formular. Dadurch wird das Formular voll vertrauenswürdig. Daher sind Berechtigungen für volle Vertrauenswürdigkeit Ihr Visual C# Code gewährt.
• Verwendung der IPFullTrust Makro aus dem InfoPath-SDK, um das Formular voll vertrauenswürdig machen Formular. Die IPFullTrust Makro automatisiert das Festlegen der Manifestdatei (XSF) und das Formular Vorlagendatei in das InfoPath-Projekt für volle Vertrauenswürdigkeit, und klicken Sie dann die IPFullTrust Makro wird die Formularvorlage automatisch registriert.
  
  Für Weitere Informationen zum Installieren und verwenden Sie das Makro, finden Sie auf der Microsoft Developer Network (MSDN)-Website:
  http://msdn2.Microsoft.com/en-us/library/aa202736 (office.11) aspx

  (http://msdn2.microsoft.com/en-us/library/aa202736(office.11).aspx)
• Mithilfe der externen Automatisierung in InfoPath aufrufen, die RegisterSolution Methode. In der Regel wird diese Methode nur bei der Formularentwicklung verwendet weil ein registriertes Formular nur für einen einzelnen Computer registriert. Für alle zusätzliche Formulare müssen andere Benutzer zusätzliche Formulare selbst registrieren Computer. Diese Methode für zusätzliche Formulare wird nicht empfohlen. Wir empfehlen eine der vorherigen Methoden ein, wenn Sie das Formular veröffentlichen.

Da dieses Formular noch in der Entwicklung ist, können Sie die Last-Methode. Suchen Sie hierzu das AttachmentEncoding InfoPath-Formular Vorlage, und befolgen Sie die folgenden Schritte aus:

1. Auf der Werkzeuge im Menü klicken Formular Optionen.
2. Klicken Sie auf die Sicherheit Registerkarte.
3. Deaktivieren Sie die Sicherheit automatisch ermitteln auf der Grundlage der Entwurf des Formulars (empfohlen) das Kontrollkästchen.
   
   Hinweis InfoPath kann Geschäftslogik nicht automatisch erkennen, erfordert volle Vertrauenswürdigkeit. Daher müssen Sie explizit Full erteilen Vertrauen Sie Berechtigungen.
4. Klicken Sie auf Volle Vertrauenswürdigkeit, und klicken Sie dann aufOK.
5. Schließen Sie die AttachmentEncoding InfoPath-Formularvorlage. Wenn Sie aufgefordert werden, um Änderungen zu speichern, klicken Sie auf Ja.
   
   Hinweis Schließen Sie nicht die Visual Studio.NET 2003-Projekt.
6. In Visual Studio.NET 2003, doppelklicken Sie auf dieManifest.xsf die Datei im Projektmappen-Explorer. Die Datei Manifest.xsf wird geöffnet.
7. Suchen Sie in den Stammknoten der publishUrl Attribut. Entfernen Sie die publishUrl Attribut und den Wert der publishUrl Attribut.
8. Speichern Sie die Änderungen, und schließen Sie dann die Manifest.xsf Datei.
9. Klicken Sie auf Start, klicken Sie auf Ausführen, Typ Notizblock, und klicken Sie dann aufOK.
10. Fügen Sie den folgenden Code in die leere Textdatei.

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

    Hinweis In diesem Code ersetzen<project_folder_url></project_folder_url> mit dem Pfad der Datei Manifest.xsf im Projektordner. Denken Sie daran, den Pfad der Flucht der Datei Manifest.xsf. Alle einfache umgekehrte Schrägstriche (\) im Pfad müssen durch ersetzt werden zwei umgekehrte Schrägstriche (\).
11. Speichern Sie die Datei Manifest.xsf auf dem Computer als der Register.js-Datei.
12. Aufrufen der RegisterSolution Methode, doppelklicken Sie auf die Register.js Datei, die Sie erstellt haben.

Das Formular testen

1. In der AttachmentEncoding-Visual Studio.NET 2003-Projekts Klicken Sie auf Start auf der Debuggen Menü. Dadurch wird gestartet Das InfoPath-Formular im Vorschaumodus.
2. Geben Sie den Pfad der Datei im InfoPath-Formular, Sie möchten, fügen in das Textfeld ein, und klicken Sie aufAnfügen.
   
   Hinweis Doppelklicken Sie auf die Dateianlage die Steuerung an Stellen Sie sicher, dass die Datei richtig codiert ist.
3. Klicken Sie auf Speichern. Suchen Sie den Pfad, die Sie gemäß dem "Hinzufügen einer Speichern Schaltfläche zum InfoPath-Formular" Abschnitt.
4. Um den Test zu beenden, klicken Sie auf Schließen Vorschau.

Weitere Informationen zu Datei-Attachment-header formatieren, die folgenden MSDN-Website: