Een bestandsbijlage programmatisch coderen en decoderen met behulp van Visual C# in InfoPath 2003

2023-10-17
Van toepassing op: InfoPath 2003

Samenvatting

In Microsoft Office InfoPath 2007 of in Microsoft Office InfoPath 2003 Service Pack 1 (SP1) kunt u een besturingselement Bestandsbijlage gebruiken om een bestand toe te voegen aan de InfoPath-formuliersjabloon. In specifieke omstandigheden kunt u het bestand dat is gekoppeld aan het besturingselement Bestandsbijlage coderen en vervolgens decoderen. In dit geval kunt u Microsoft Visual C# gebruiken om een encoderklasse en een decoderklasse te maken. Vervolgens kunt u de encoderklasse en de decoderklasse gebruiken om de bestandsbijlage te coderen en decoderen.

Inleiding

In dit artikel wordt beschreven hoe u een bestandsbijlage programmatisch kunt coderen en decoderen met behulp van Microsoft Visual C# in InfoPath 2003. Zie de volgende webpagina voor informatie over hoe u dit doet in InfoPath 2010 of in InfoPath 2007: Een bestandsbijlage programmatisch coderen en decoderen met behulp van Visual C# in InfoPath 2010 of in InfoPath 2007 .

Meer informatie

Microsoft verstrekt deze code zonder enige expliciete of impliciete garantie, daaronder mede begrepen, maar niet beperkt tot impliciete garanties met betrekking tot de verkoopbaarheid en/of geschiktheid voor een bepaald doel. In dit artikel wordt ervan uitgegaan dat u bekend bent met de programmeertaal VBScript, alsmede met de hulpprogramma's waarmee procedures worden gemaakt en waarmee fouten in procedures worden opgespoord. U kunt desgewenst contact opnemen met Microsoft Product Support Services voor uitleg over de functie van een bepaalde procedure. Microsoft Product Support Services is echter niet bereid de voorbeelden aan te passen om extra functies toe te voegen of om procedures te maken die aan uw specifieke eisen voldoen.

Een Visual C# InfoPath 2003-project maken

Start Microsoft Visual Studio .NET 2003.
Klik in het menu Bestand op Nieuw en klik vervolgens op Project.
Klik in het dialoogvenster Nieuw project op Visual C# Projects in de map Microsoft Office InfoPath Projects.
Typ AttachmentEncoding in het vak Naam en klik op OK.
Klik in de wizard Microsoft Office-project op Een nieuwe formuliersjabloon maken en klik vervolgens op Voltooien.

Met de wizard Microsoft Office Project maakt u een nieuw Visual Studio .NET 2003-project met de naam AttachmentEncoding. Er wordt ook een InfoPath-formuliersjabloon gemaakt. De InfoPath-formuliersjabloon heeft de naam AttachmentEncoding.

Een encoderklasse maken in Visual Studio .NET 2003

Klik in Solution Explorer met de rechtermuisknop op AttachmentEncoding, wijs Toevoegen aan en klik vervolgens op Nieuw item toevoegen.
Klik in het dialoogvenster Nieuw item toevoegen op Klasse in het deelvenster Sjabloon , typ InfoPathAttachmentEncoder.cs in het vak Naam en klik vervolgens op Openen.

Vervang alle code in het bestand InfoPathAttachmentEncoder.cs door de volgende 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());
}
}
}

Een Decoder-klasse maken in Visual Studio .NET 2003

Klik in Solution Explorer met de rechtermuisknop op AttachmentEncoding, wijs Toevoegen aan en klik vervolgens op Nieuw item toevoegen.
Klik in het dialoogvenster Nieuw item toevoegen op Klasse in het deelvenster Sjabloon , typ InfoPathAttachmentDecoder.cs in het vak Naam en klik vervolgens op Openen.

Vervang alle code in het bestand InfoPathAttachmentDecoder.cs door de volgende 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; }
}
}
}

Een besturingselement Bestandsbijlage en een besturingselement Tekstvak toevoegen aan het InfoPath-formulier

Klik in de formuliersjabloon AttachmentEncoding InfoPath op Besturingselementen in het taakvenster Ontwerptaken .
Klik in het taakvenster Besturingselementen op Bestandsbijlage onder Besturingselementen invoegen.
Klik met de rechtermuisknop op het besturingselement Bestandsbijlage en klik vervolgens op Eigenschappen van bestandsbijlage.
Typ in het dialoogvenster Eigenschappen van bestandsbijlage hetAttachmentField in het vak Veldnaam en klik op OK.
Klik in het taakvenster Besturingselementen op Tekstvak onder Besturingselementen invoegen.
Klik met de rechtermuisknop op het besturingselement Tekstvak en klik vervolgens op Eigenschappen van tekstvak.
Typ deAttachmentName in het vak Veldnaam in het dialoogvenster Eigenschappen van tekstvak en klik op OK.

Een knop Bijvoegen toevoegen aan het InfoPath-formulier

Klik in het taakvenster Besturingselementen op Knop onder Besturingselementen invoegen.
Klik met de rechtermuisknop op het nieuwe knopbesturingselement en klik vervolgens op Knopeigenschappen.
Typ In het dialoogvenster Knopeigenschappen Bijvoegen in het vak Label , typ btnAttach in het vak Id en klik vervolgens op Formuliercode bewerken.

Voeg de volgende code toe aan de 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();
}

Een knop Opslaan toevoegen aan het InfoPath-formulier

Schakel over naar de Formuliersjabloon AttachmentEncoding InfoPath.
Klik in het taakvenster Besturingselementen op Knop onder Besturingselementen invoegen.
Klik met de rechtermuisknop op het nieuwe knopbesturingselement en klik vervolgens op Knopeigenschappen.
Typ in het dialoogvenster Knopeigenschappen Opslaan in het vak Label , typ btnSave in het vak Id en klik vervolgens op Formuliercode bewerken.

Voeg de volgende code toe aan de 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>");
}

Opmerking

Vervang in deze code door de locatie waar u het bestand wilt opslaan.

Zorg ervoor dat de InfoPath-formuliersjabloon volledig wordt vertrouwd

Voordat u dit formulier kunt testen, moet de InfoPath-formuliersjabloon volledig worden vertrouwd. U kunt een van de volgende methoden gebruiken om ervoor te zorgen dat de InfoPath-formuliersjabloon volledig wordt vertrouwd:

Gebruik het configuratiehulpprogramma Microsoft .NET Framework 1.1 om alleen machtigingen voor volledig vertrouwen toe te kennen aan uw Visual C#-code.
Gebruik het hulpprogramma RegForm van de InfoPath Software Development Kit (SDK) om van het formulier een volledig vertrouwd formulier te maken. Hiermee verleent u volledige vertrouwensmachtigingen voor uw Visual C#-code.
Gebruik een certificaat voor ondertekening van code om het formuliersjabloonbestand (.xsn) digitaal te ondertekenen. Wanneer u een certificaat voor ondertekening van code gebruikt om het formuliersjabloonbestand digitaal te ondertekenen, wordt gebruikers gevraagd het formulier te vertrouwen wanneer ze het formulier openen. Hierdoor wordt het formulier volledig vertrouwd. Daarom worden machtigingen voor volledig vertrouwen verleend aan uw Visual C#-code.
Gebruik de MACRO IPFullTrust van de InfoPath SDK om van het formulier een volledig vertrouwd formulier te maken. De MACRO IPFullTrust automatiseert het instellen van het manifestbestand (.xsf) en het formuliersjabloonbestand in het InfoPath-project voor volledig vertrouwen. De IPFullTrust-macro registreert vervolgens automatisch de formuliersjabloon.

Ga voor meer informatie over het installeren en gebruiken van de macro naar de volgende MSDN-website (Microsoft Developer Network):

https://msdn.microsoft.com/en-us/library/aa202736(office.11).aspx
Gebruik externe automatisering in InfoPath om de methode RegisterSolution aan te roepen. Deze methode wordt doorgaans alleen gebruikt voor formulierontwikkeling omdat een geregistreerd formulier alleen wordt geregistreerd voor een afzonderlijke computer. Voor extra formulieren moeten andere gebruikers de aanvullende formulieren registreren op hun eigen computers. Deze methode wordt niet aanbevolen voor extra formulieren. We raden een van de vorige methoden aan wanneer u het formulier publiceert.

Omdat dit formulier wordt ontwikkeld, kunt u de laatste methode gebruiken. Ga hiervoor naar de formuliersjabloon AttachmentEncoding InfoPath en voer de volgende stappen uit:

Klik in het menu Extra op Formulieropties.
Klik op het tabblad Beveiliging.
Schakel het selectievakje Automatisch beveiligingsniveau bepalen op basis van het ontwerp (aanbevolen) van het formulier uit.

Opmerking InfoPath kan niet automatisch bedrijfslogica detecteren waarvoor machtigingen voor volledig vertrouwen zijn vereist. Daarom moet u expliciet machtigingen voor volledig vertrouwen verlenen.
Klik op Volledig vertrouwen en klik vervolgens op OK.
Sluit de Formuliersjabloon AttachmentEncoding InfoPath. Als u wordt gevraagd om wijzigingen op te slaan, klikt u op Ja.

Opmerking Sluit het Visual Studio .NET 2003-project niet.
Dubbelklik in Visual Studio .NET 2003 op het bestand Manifest.xsf in Solution Explorer. Het bestand Manifest.xsf wordt geopend.
Zoek in het hoofdknooppunt het kenmerk publishUrl. Verwijder het kenmerk publishUrl en de waarde van het kenmerk publishUrl.
Sla de wijzigingen op en sluit het bestand Manifest.xsf.
Klik op Start, klik op Uitvoeren, typ Kladblok en klik vervolgens op OK.
Voeg de volgende code toe aan het lege tekstbestand.
```
oApp = WScript.CreateObject("InfoPath.ExternalApplication");
strAbsolutePath = "<project_folder_url>\\Manifest.xsf";
oApp.RegisterSolution(strAbsolutePath,"overwrite"); 
```
Opmerking Vervang in deze code project_folder_url door het pad van het bestand Manifest.xsf in de projectmap. Vergeet niet om het pad van het bestand Manifest.xsf te escapen. Alle enkele backslashes (\) in het pad moeten worden vervangen door twee backslashes (\\).
Sla het bestand Manifest.xsf op de computer op als het Register.js-bestand.
Als u de methode RegisterSolution wilt aanroepen, dubbelklikt u op het Register.js bestand dat u hebt gemaakt.

Het formulier testen

Klik in het project AttachmentEncoding Visual Studio .NET 2003 op Start in het menu Foutopsporing . Hiermee wordt het InfoPath-formulier gestart in de preview-modus.
Typ in het InfoPath-formulier het pad van het bestand dat u wilt bijvoegen in het tekstvak en klik op Bijvoegen.

Opmerking Dubbelklik op het besturingselement Bestandsbijlage om te controleren of het bestand correct is gecodeerd.
Klik op Opslaan. Zoek het pad dat u hebt opgegeven in de sectie ' Knop Opslaan toevoegen aan het InfoPath-formulier'.
Klik op Voorbeeld sluiten om de test te beëindigen.

Verwijzingen

Ga naar de volgende MSDN-website voor meer informatie over de indeling van de bestandsbijlageheader:

Bestanden bijvoegen in InfoPath 2003 https://msdn.microsoft.com/en-us/library/aa168351(office.11).aspx

Delen via