<?xml version="1.0" encoding="utf-8" ?>
<ferme xmlns="http://developpez.com/ns/animauxdelaferme" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <animal id="">
    <espece></espece>
    <datenaissance></datenaissance>
    <description></description>
    <photo></photo>
    <nom></nom>
  </animal>
</ferme>

<?xml version="1.0" encoding="utf-8"?>
<xs:schema xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" attributeFormDefault="unqualified" 
elementFormDefault="qualified" targetNamespace="http://developpez.com/ns/animauxdelaferme" 
xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="ferme">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="animal">
          <xs:complexType>
            <xs:sequence>
              <xs:element name="espece" type="xs:string" />
              <xs:element name="datenaissance" type="xs:dateTime" />
              <xs:element name="description" type="xs:string" />
              <xs:element name="photo" type="xs:base64Binary" />
              <xs:element name="nom" type="xs:string" />
            </xs:sequence>
            <xs:attribute name="id" type="xs:integer" use="required" />
          </xs:complexType>
        </xs:element>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<ds:datastoreItem ds:itemID="{8DBF1AED-BD48-42B0-99A6-890F79C2D5FF}" 
xmlns:ds="http://schemas.openxmlformats.org/officeDocument/2006/customXml">
  <ds:schemaRefs>
    <ds:schemaRef ds:uri="http://developpez.com/ns/animauxdelaferme"/>
  </ds:schemaRefs>
</ds:datastoreItem>

<?xml version="1.0" encoding="utf-8"?><ferme xmlns="http://developpez.com/ns/animauxdelaferme" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <animal id="000339">
    <espece>JERSEY</espece>
    <datenaissance>2006-08-11</datenaissance>
    <description>Mathilde a la réputation de séduire tous les membres de la famille par sa personnalité attachante, sa docilité et sa présence. 
	Une vache de petite taille, fort charmante avec son pelage fauve.</description>
    <photo>.DAAYEBQYFBA.</photo>
    <nom>Mathilde</nom>
  </animal>
</ferme>

using System.IO;
using System.ServiceModel;
using System.Runtime.Serialization;
using System;

namespace FileUploadServiceLibrary
{
    [ServiceContract]
    public interface IUploadService
    {
        [OperationContract]
        ResultatTraitement UploadFile(byte[] file);
    }

    
    [DataContract]
    public class ResultatTraitement
    {
        [DataMember]
        public Guid NumDossier { get; set; }

        [DataMember]
        public bool Accepte { get; set; }

        [DataMember]
        public String Commentaire { get; set; }
    }
}

//Fichier sous forme de tableau de bytes envoyé par le client
private byte[] _fileBytes;
public byte[] FileBytes
{
    get
    {
        return _fileBytes;
    }
    set
    {
        _fileBytes = value;
    }
}

//Objet décrivant le résultat du traitement
private ResultatTraitement _resultatWorkflow;
public ResultatTraitement ResultatWorkflow
{
    get
    {
        return _resultatWorkflow;
    }
    set
    {
        _resultatWorkflow = value;
    }
}

private void TraitementUploadFile_ExecuteCode(object sender, EventArgs e)
{
    Console.Out.WriteLine("Réception d'un fichier");

    try
    {
        //on crée le répertoire
        if (!Directory.Exists(this.FolderPathToSaveDocs))
                Directory.CreateDirectory(this.FolderPathToSaveDocs);

        Console.WriteLine("Enregistrement du fichier sous: {0}", this.FormulairePath);
        //on enregistre le fichier sur le disque
        File.WriteAllBytes(FormulairePath, this.FileBytes);

        Console.WriteLine();
        Console.WriteLine("Fichier {0} enregistré", this.FormulairePath);
    }
    catch (IOException ex)
    {
        Console.WriteLine(
            String.Format("An exception was thrown while opening or writing to file {0}", this.FormulairePath));
        Console.WriteLine("Exception is: ");
        Console.WriteLine(ex.ToString());

        throw ex;
    }
}

//chemin du répertoire où enregistrer les différents fichiers
private string _folderPathToSaveDocs;
public string FolderPathToSaveDocs
{
    get
    {
        if (_folderPathToSaveDocs == null)
            _folderPathToSaveDocs = String.Format("formulaire_{0}", DateTime.Now.ToString("dd-MM-yyyy__HH_mm_ss"));
        return _folderPathToSaveDocs;
    }
}

//chemin où a été enregistré le formulaire envoyé par le client
private string _formulairePath;
public string FormulairePath
{
    get
    {
        if (_formulairePath == null)
            _formulairePath = Path.Combine(FolderPathToSaveDocs, "formulaire.docx");
        return _formulairePath;
    }
}

//fichier xsd permettant de valider le custom XML
private string _schemaPath = Path.Combine(System.Environment.CurrentDirectory, "Animal.xsd");
public string SchemaPath
{
    get
    {
        return _schemaPath;
    }
}

//référence du schéma du customXML
private string _schemaRef = @"http://developpez.com/ns/animauxdelaferme";
public string SchemaRef
{
    get
    {
        return _schemaRef;
    }
}

public partial class ExtractCustomXmlActivity : Activity

public static DependencyProperty FilePathProperty = DependencyProperty.Register("FilePath", typeof(string), typeof(ExtractCustomXmlActivity));

[DescriptionAttribute("Chemin du fichier OpenXML dont il faut extraire le custom Xml")]
[CategoryAttribute("Input")]
[BrowsableAttribute(true)]
[DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Visible)]
public string FilePath
{
    get
    {
        return ((string)(base.GetValue(ExtractCustomXmlActivity.FilePathProperty)));
    }
    set
    {
        base.SetValue(ExtractCustomXmlActivity.FilePathProperty, value);
    }
}

public static DependencyProperty CustomXmlProperty = DependencyProperty.Register("CustomXml", typeof(XDocument), typeof(ExtractCustomXmlActivity));

[DescriptionAttribute("XDocument résultant de l'extraction du custom Xml")]
[CategoryAttribute("Output")]
[BrowsableAttribute(true)]
[DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Visible)]
public XDocument CustomXml
{
    get
    {
        return ((XDocument)(base.GetValue(ExtractCustomXmlActivity.CustomXmlProperty)));
    }
    set
    {
        base.SetValue(ExtractCustomXmlActivity.CustomXmlProperty, value);
    }
}

public static DependencyProperty SchemaProperty = DependencyProperty.Register("Schema", typeof(string), typeof(ExtractCustomXmlActivity));

[DescriptionAttribute("Schema associé au custom Xml à extraire")]
[CategoryAttribute("Input")]
[BrowsableAttribute(true)]
[DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Visible)]
public string Schema
{
    get
    {
        return ((string)(base.GetValue(ExtractCustomXmlActivity.SchemaProperty)));
    }
    set
    {
        base.SetValue(ExtractCustomXmlActivity.SchemaProperty, value);
    }
}

protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
    Console.WriteLine("Extraction du custom XML");

    XNamespace ds = @"http://schemas.openxmlformats.org/officeDocument/2006/customXml";
    XNamespace nsmetier = Schema;            

    using (WordprocessingDocument wordDoc = WordprocessingDocument.Open(FilePath, false))
    {
        MainDocumentPart mainPart = wordDoc.MainDocumentPart;
        foreach (var customXmlPart in mainPart.CustomXmlParts)
        {
            //on ouvre le CustomXmlPropertiesPart associé au customXmlPart qu'on traite
            XDocument customXmlPropertiesPart = XDocument.Load(XmlReader.Create(customXmlPart.CustomXmlPropertiesPart.GetStream()));
            //namespace du schéma du Custom XML
            string uri = customXmlPropertiesPart.Descendants(ds + "schemaRef").First().Attribute(ds + "uri").Value;
            //si le namespace correspond à celui que l'on recherche
            if (uri.Equals(Schema, StringComparison.InvariantCultureIgnoreCase))
            {
                CustomXml = XDocument.Load(XmlReader.Create(customXmlPart.GetStream()));
                break;
            }
        }
        
    }
    return base.Execute(executionContext);
}

public static DependencyProperty SchemaPathProperty = DependencyProperty.Register("SchemaPath", typeof(string), typeof(ValidationXDocumentActivity));

[DescriptionAttribute("Chemin du fichier xsd permettant la validation du custom XML")]
[CategoryAttribute("Input")]
[BrowsableAttribute(true)]
[DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Visible)]
public string SchemaPath
{
    get
    {
        return ((string)(base.GetValue(ValidationXDocumentActivity.SchemaPathProperty)));
    }
    set
    {
        base.SetValue(ValidationXDocumentActivity.SchemaPathProperty, value);
    }
}

public static DependencyProperty XDocumentToValidateProperty = 
		  	DependencyProperty.Register("XDocumentToValidate", typeof(XDocument), typeof(ValidationXDocumentActivity));

[DescriptionAttribute("XDocument contenant le custom Xml à valider")]
[CategoryAttribute("Input")]
[BrowsableAttribute(true)]
[DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Visible)]
public XDocument XDocumentToValidate
{
    get
    {
        return ((XDocument)(base.GetValue(ValidationXDocumentActivity.XDocumentToValidateProperty)));
    }
    set
    {
        base.SetValue(ValidationXDocumentActivity.XDocumentToValidateProperty, value);
    }
}

public static DependencyProperty IsCustomXmlValideProperty = 
		  	DependencyProperty.Register("IsCustomXmlValide", typeof(bool), typeof(ValidationXDocumentActivity));

[DescriptionAttribute("Résultat de la validation")]
[CategoryAttribute("Output")]
[BrowsableAttribute(true)]
[DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Visible)]
public bool IsCustomXmlValide
{
    get
    {
        return ((bool)(base.GetValue(ValidationXDocumentActivity.IsCustomXmlValideProperty)));
    }
    set
    {
        base.SetValue(ValidationXDocumentActivity.IsCustomXmlValideProperty, value);
    }
}

/// <summary>
/// Valide le custom Xml du document
/// </summary>
/// <param name="executionContext"></param>
/// <returns></returns>
protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
    Console.WriteLine("Validation du custom XML");

    if (XDocumentToValidate != null)
    {
        try
        {
            //on charge le fichier xsd
            XmlSchemaSet xmlSchemaSet = LoadSchema(SchemaPath);

            XDocumentToValidate.Validate(xmlSchemaSet, null);
            IsCustomXmlValide = true;
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
    }    
    return base.Execute(executionContext);
}

static XmlSchemaSet LoadSchema(string schemaPath)
{
    XmlSchemaSet xmlSchemaSet = new XmlSchemaSet(new NameTable());
    using (XmlReader reader = XmlReader.Create(schemaPath))
    {
        //chargement du schéma
        XmlSchema animauxSchema = XmlSchema.Read(reader, null);
        reader.Close();
        //ajout du schéma au XmlSchemaSet
        xmlSchemaSet.Add(animauxSchema);
    }
    return xmlSchemaSet;
}

public static DependencyProperty CustomXmlToSaveProperty = DependencyProperty.Register("CustomXmlToSave", typeof(XDocument), typeof(SaveCustomXmlActivity));

[DescriptionAttribute("XDocument contenant le CustomXml à sauver")]
[CategoryAttribute("Input")]
[BrowsableAttribute(true)]
[DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Visible)]
public XDocument CustomXmlToSave
{
    get
    {
        return ((XDocument)(base.GetValue(SaveCustomXmlActivity.CustomXmlToSaveProperty)));
    }
    set
    {
        base.SetValue(SaveCustomXmlActivity.CustomXmlToSaveProperty, value);
    }
}

public static DependencyProperty SavePathProperty = DependencyProperty.Register("SavePath", typeof(string), typeof(SaveCustomXmlActivity));

[