Come codificare e decodificare un file allegato a livello di codice utilizzando Visual C# in InfoPath 2003

Riepilogo

In Microsoft Office InfoPath 2007 o Microsoft Office InfoPath 2003 Service Pack 1 (SP1), è possibile utilizzare un controllo File allegati per allegare un file al modello di modulo di InfoPath. In circostanze particolari, si consiglia di codificare e decodificare quindi il file che è associato al controllo File allegato . In questo caso, è possibile utilizzare Microsoft Visual C# per creare una classe di codificatore e una decodificatore di classe. Quindi, è possibile utilizzare le classi di codificatore e decodificatore per codificare e decodificare il file allegato.

INTRODUZIONE

In questo articolo viene illustrato come codificare e decodificare un file allegato a livello di codice utilizzando Microsoft Visual C# in InfoPath 2003. Per informazioni su come eseguire questa operazione, in InfoPath 2010 o InfoPath 2007, vedere la seguente pagina web: come codificare e decodificare un file allegato a livello di codice utilizzando Visual C# in InfoPath 2010 o InfoPath 2007 .

Ulteriori informazioni

Microsoft fornisce esempi di programmazione a scopo puramente illustrativo, senza alcuna garanzia espressa o implicita. Ciò include, ma non limitato a, le garanzie implicite di commerciabilità o idoneità per uno scopo particolare. In questo articolo si presuppone che si abbia familiarità con il linguaggio di programmazione in questione e gli strumenti utilizzati per creare ed eseguire la procedura di debug. I tecnici del supporto Microsoft possono spiegare la funzionalità di una particolare procedura, ma in nessun caso possono modificare questi esempi per fornire funzionalità aggiuntive o creare procedure atte a soddisfare specifiche esigenze.

Creare un progetto Visual C# in InfoPath 2003

  1. Avviare Microsoft Visual Studio .NET 2003.
  2. Dal menu File , fare clic su
    Nuovo, quindi fare clic su progetto.
  3. Nella finestra di dialogo Nuovo progetto , fare clic su
    Progetti di visual C# nella cartella progetti di Microsoft Office InfoPath.
  4. Nella casella nome , digitare
    AttachmentEncodinge quindi fare clic su
    OK.
  5. Nella creazione guidata progetto di Microsoft Office, fare clic su
    Crea un nuovo modello di moduloe quindi fare clic su
    Fine.

    La creazione guidata progetto di Microsoft Office crea un nuovo progetto di Visual Studio .NET 2003 denominato AttachmentEncoding. Viene inoltre creato un modello di modulo di InfoPath. Il modello di modulo di InfoPath è denominato AttachmentEncoding.

Creare una classe del codificatore in Visual Studio .NET 2003

  1. In Esplora soluzioni, fare doppio clic
    AttachmentEncoding, scegliere Aggiungie quindi fare clic su Aggiungi nuovo elemento.
  2. Nella finestra di dialogo Aggiungi nuovo elemento , fare clic su
    Classe nel riquadro tipo modello
    InfoPathAttachmentEncoder.cs nel
    Nome e quindi scegliere Apri.
  3. Sostituire tutto il codice nel file InfoPathAttachmentEncoder.cs con il codice riportato di seguito.
    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());
    }
    }
    }

Creare una classe Decoder in Visual Studio .NET 2003

  1. In Esplora soluzioni, fare doppio clic
    AttachmentEncoding, scegliere Aggiungie quindi fare clic su Aggiungi nuovo elemento.
  2. Nella finestra di dialogo Aggiungi nuovo elemento , fare clic su
    Classe nel riquadro tipo modello
    InfoPathAttachmentDecoder.cs nel
    Nome e quindi scegliere Apri.
  3. Sostituire tutto il codice nel file InfoPathAttachmentDecoder.cs con il codice riportato di seguito.
    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; }
    }
    }
    }


Aggiungere un controllo File allegato e un controllo casella di testo per il modulo di InfoPath

  1. Nel modello di modulo AttachmentEncoding InfoPath, fare clic su controlli nel riquadro attività Attività di progettazione .
  2. Nel riquadro attività controlli , fare clic su File allegato in
    Inserire i controlli.
  3. Pulsante destro del mouse il controllo File allegato e quindi fare clic su Proprietà File allegato.
  4. Nella finestra di dialogo Proprietà File allegato , digitare theAttachmentField nella casella Nome campo e quindi fare clic su OK.
  5. Nel riquadro attività controlli , fare clic su Casella di testo in
    Inserire i controlli.
  6. Destro del mouse sul controllo Casella di testo e quindi fare clic su Proprietà casella di testo.
  7. Nella finestra di dialogo Proprietà casella di testo , digitare theAttachmentName nella casella Nome campo e quindi fare clic su OK.

Aggiungere un pulsante Allega il modulo di InfoPath

  1. Nel riquadro attività controlli , fare clic sul pulsante
    Inserire i controlli.
  2. Destro del mouse sul nuovo controllo pulsante e quindi fare clic sul Pulsante Proprietà.
  3. Nella finestra di dialogo Proprietà pulsante digitare
    Connetti nella casella etichetta digitare
    btnAttach nella casella ID e quindi fare clic su
    Modifica codice modulo.
  4. Aggiungere il codice seguente nel metodo btnAttach_OnClick .
    //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();
    }

Aggiungere un pulsante Salva il modulo di InfoPath

  1. Passare al modello di modulo AttachmentEncoding InfoPath.
  2. Nel riquadro attività controlli , fare clic sul pulsante
    Inserire i controlli.
  3. Destro del mouse sul nuovo controllo pulsante e quindi fare clic sul Pulsante Proprietà.
  4. Nella finestra di dialogo Proprietà pulsante digitare
    Salva nella casella etichetta digitare
    btnSave nella casella ID e quindi fare clic su
    Modifica codice modulo.
  5. Aggiungere il codice seguente nel metodo _OnClick di btnSave .
    //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>");
    }

    Nota: In questo codice, sostituire < percorso in cui salvare il file > con il percorso in cui si desidera salvare il file.

Assicurarsi che il modello di modulo di InfoPath è completamente attendibile

Prima di poter testare questo modulo, il modello di modulo di InfoPath deve essere completamente attendibile. Per assicurarsi che il modello di modulo di InfoPath è completamente attendibile, è possibile utilizzare uno dei seguenti metodi:
  • Utilizzare l'utilità di configurazione di Microsoft.NET Framework 1.1 per concedere autorizzazioni di attendibilità solo al codice Visual C#.
  • Utilizzare l'utilità di RegForm di InfoPath Software Development Kit (SDK) per rendere il modulo di un modulo completamente attendibile. In questo modo si concede autorizzazioni di attendibilità al codice Visual C#.
  • Utilizzare un certificato di firma del codice per firmare digitalmente i file di modello di modulo (con estensione xsn). Quando si utilizza un certificato di firma del codice per firmare digitalmente il file di modello di modulo, gli utenti richiesto per considerare attendibile il modulo quando aprono il modulo. In questo modo il modulo completamente attendibile. Pertanto, autorizzazioni di attendibilità sono concesse al codice Visual C#.
  • Utilizzare la macro IPFullTrust del SDK di InfoPath per rendere il modulo di un modulo completamente attendibile. La macro IPFullTrust consente di automatizzare l'impostazione del file manifesto (. xsf) e il file di modello di modulo nel progetto di InfoPath per l'attendibilità totale e quindi la macro IPFullTrust registra automaticamente il modello di modulo.

    Per ulteriori informazioni su come installare e utilizzare la macro, visitare il seguente sito Web Microsoft Developer Network (MSDN):
  • Utilizzare l'automazione esterna in InfoPath per chiamare il metodo RegisterSolution . In genere, questo metodo viene utilizzato solo per lo sviluppo di form poiché un modulo registrato viene registrato solo per un singolo computer. Per i moduli aggiuntivi, altri utenti devono registrare i moduli aggiuntivi sui propri computer. Si sconsiglia di utilizzare questo metodo per i moduli aggiuntivi. Si consiglia di uno qualsiasi dei metodi precedenti, quando si pubblica il modulo.
Poiché questo modulo è in fase di sviluppo di form, è possibile utilizzare l'ultimo metodo. A tale scopo, individuare il modello di modulo AttachmentEncoding InfoPath e attenersi alla seguente procedura:
  1. Dal menu Strumenti , fare clic su Opzioni modulo.
  2. Fare clic sulla scheda protezione .
  3. Fare clic per deselezionare la casella di controllo determina automaticamente il livello di protezione in base alla progettazione del modulo (scelta consigliata) .

    Nota: InfoPath non può rilevare automaticamente la logica di business che richiede autorizzazioni di attendibilità. Pertanto, è necessario concedere esplicitamente autorizzazioni di attendibilità.
  4. Fare clic su Attendibilità completae quindi fare clic su
    OK.
  5. Chiudere il modello di modulo AttachmentEncoding InfoPath. Se viene chiesto di salvare le modifiche, fare clic su .

    Nota: Non chiudere il progetto di Visual Studio .NET 2003.
  6. In Visual Studio .NET 2003, fare doppio clic su di
    File manifest in Esplora soluzioni. Apre il file manifest.
  7. Nel nodo principale, individuare l'attributo publishUrl . Rimuovere l'attributo publishUrl e il valore dell'attributo publishUrl .
  8. Salvare le modifiche e chiudere il file manifest.
  9. Fare clic su Start, scegliere Esegui, digitare notepade quindi fare clic su
    OK.
  10. Aggiungere il codice seguente al file di testo vuoto.
    oApp = WScript.CreateObject("InfoPath.ExternalApplication");strAbsolutePath = "<project_folder_url>\\Manifest.xsf";
    oApp.RegisterSolution(strAbsolutePath,"overwrite");

    Nota: In questo codice, sostituire
    < project_folder_url > con il percorso del file manifest nella cartella del progetto. Ricordarsi di escape il percorso del file manifest. Tutti solo le barre rovesciate (\) nel percorso devono essere sostituite con due barre rovesciate (\).
  11. Salvare il file manifest del computer del file Register.js.
  12. Per chiamare il metodo RegisterSolution , fare doppio clic sul file Register.js che è stato creato.

Verificare il modulo

  1. Nel progetto AttachmentEncoding Visual Studio .NET 2003, scegliere Avvia dal menu Debug . Il modulo di InfoPath verrà avviato in modalità anteprima.
  2. Il modulo di InfoPath, digitare il percorso del file che si desidera allegare nella casella di testo e quindi fare clic su
    Allegare.

    Nota: Fare doppio clic sul controllo File allegato per verificare che il file è codificato correttamente.
  3. Fare clic su Salva. Individuare il percorso specificato nella sezione "Aggiungere un pulsante Salva per il modulo di InfoPath".
  4. Per terminare il test, fare clic su Chiudi anteprima.

Riferimenti

Per ulteriori informazioni sul formato di intestazione di file allegati, visitare il seguente sito Web MSDN:
Proprietà

ID articolo: 892730 - Ultima revisione: 30 gen 2017 - Revisione: 1

Microsoft Office InfoPath 2003

Feedback