Développement d’un fonctoid cumulatif personnalisé

Utilisez un fonctoid cumulatif personnalisé pour effectuer des opérations d’accumulation pour les valeurs qui se produisent plusieurs fois dans un message d’instance.

Vous devez implémenter trois fonctions lors du développement d’un fonctoid cumulé. Les trois fonctions correspondent à l’initialisation, au cumul et à l’obtention d’actions dont la carte a besoin pour effectuer l’accumulation. Avant de discuter de ces fonctions, il est important de discuter de la sécurité des threads.

Rédiger un Functoid Thread-Safe

Le code fonctoid doit être thread-safe, car dans des conditions de contrainte, plusieurs instances d’une carte peuvent s’exécuter simultanément. Voici quelques-uns des points à mémoriser :

• L’état statique doit être sécurisé pour les threads.

• L’état de l’instance n’a pas toujours besoin d’être thread-safe.

• Conception en tenant compte de l'exécution dans des conditions de stress élevé. Évitez de prendre des verrous chaque fois que cela est possible.

• Évitez si possible la synchronisation.

  BizTalk Server fournit un mécanisme simple pour réduire la complexité de l’écriture d’un fonctoid cumulatif thread-safe. Les trois fonctions ont le même paramètre, une valeur d’index entier. BizTalk Server affecte un numéro unique à la valeur d’index lorsqu’il appelle votre fonction d’initialisation. Vous pouvez utiliser cette valeur comme index dans un tableau qui contient des valeurs cumulées, comme indiqué dans le code suivant :

private HashTable cumulativeArray = new HashTable();  
…  
// Initialization function  
public string InitCumulativeMultiply(int index)  
{  
    cumulativeArray[index] = 1.0;  
    return string.Empty;  
}  

Cet exemple utilise un hashTable au lieu d’un TableauList. Cela est dû au fait que la fonction d’initialisation peut ne pas être appelée avec des valeurs d’index dans l’ordre.

Implémentation des trois fonctions cumulatives

Vous devez implémenter trois fonctions pour chaque fonctoid cumulatif personnalisé que vous développez. Les fonctions et les méthodes que vous devez appeler dans le constructeur pour les définir sont résumées dans le tableau suivant. Toutes les fonctions retournent des valeurs de chaîne.

Initialisation

L’initialisation vous permet de préparer les mécanismes que vous utiliserez pour effectuer l’accumulation. Vous pouvez initialiser un tableau, réinitialiser une ou plusieurs valeurs ou charger d’autres ressources en fonction des besoins. La valeur de retour de chaîne n’est pas utilisée.

Accumulation

C’est là que vous effectuez l’opération d’accumulation appropriée pour votre fonctoid. Le serveur BizTalk transmet les trois paramètres suivants :

• Index. Valeur entière représentant une instance de carte. Plusieurs instances de mappage peuvent s’exécuter simultanément.

• Val. Chaîne contenant la valeur qui doit être cumulée. Sauf si vous écrivez une chaîne cumulate fonctoid, il s’agit d’une valeur numérique.

• Portée. Chaîne contenant un nombre indiquant quelle valeur d’élément ou d’attribut doit être cumulée. Les valeurs réelles sont déterminées par une implémentation.

  Vous décidez quelles valeurs accumuler et quelles valeurs ignorer. Par exemple, vous pouvez ignorer les valeurs qui ne sont pas inférieures à 0, mais lever une exception lorsqu’une valeur n’est pas numérique. BaseFunctoid fournit deux fonctions ( IsDate et IsNumeric) pour faciliter la validation.

La valeur de retour de chaîne n’est pas utilisée.

Obtenir

Lorsque BizTalk Server termine l’itération sur toutes les valeurs déterminées par les paramètres du fonctoid dans la carte, elle demande la valeur cumulée. La fonction get a un argument, Indexqui est une valeur entière représentant une instance de carte. Votre fonction doit utiliser la valeur d’index pour rechercher et retourner la valeur cumulée sous forme de chaîne.

Exemple :

L’exemple suivant montre comment créer un fonctoid personnalisé pour effectuer une multiplication cumulative. Il s’appuie sur un fichier de ressources contenant trois ressources de chaîne et une ressource bitmap de 16 x 16 pixels.

using System;  
using Microsoft.BizTalk.BaseFunctoids;  
using System.Reflection;  
using System.Text;  
using System.Collections;  
using System.Globalization;  
  
namespace Microsoft.Samples.BizTalk.CustomFunctoid  
{  
    public class CumulativeMultiplyFunctoid : BaseFunctoid  
    {  
        private ArrayList myCumulativeArray = new ArrayList();  
  
        public CumulativeMultiplyFunctoid() : base()  
        {  
            //ID for this functoid  
            ID = 6001;  
  
            // Resource assembly must be ProjectName.ResourceName if building with VS.Net  
            SetupResourceAssembly("Microsoft.Samples.BizTalk.CustomFunctoid.CustomFunctoidResources", Assembly.GetExecutingAssembly());  
  
            // Pass the resource ID names for functoid name, tooltip  
            // description and the 16x16 bitmap for the Map palette  
            SetName("IDS_CUMULATIVEMULTIPLYFUNCTOID_NAME");  
            SetTooltip("IDS_CUMULATIVEMULTIPLYFUNCTOID_TOOLTIP");  
            SetDescription("IDS_CUMULATIVEMULTIPLYFUNCTOID_DESCRIPTION");  
            SetBitmap("IDB_CUMULATIVEMULTIPLYFUNCTOID_BITMAP");  
  
            // Put this string handling function under the Cumulative  
            // Functoid tab in the Visual Studio toolbox for functoids  
            Category = FunctoidCategory.Cumulative;  
  
            // 2 required parameters, no optional parameters  
            SetMinParams(1);  
            SetMaxParams(2);  
  
            // Functoid accepts three inputs  
            AddInputConnectionType(ConnectionType.AllExceptRecord);  
            AddInputConnectionType((~ConnectionType.FunctoidCount) & (~ConnectionType.FunctoidIndex) & (~ConnectionType.FunctoidIteration) & (~ConnectionType.FunctoidCumulative) & (~ConnectionType.FunctoidLooping) & (~ConnectionType.Record));  
            AddInputConnectionType(ConnectionType.AllExceptRecord);  
  
            // Set the output connection type  
            OutputConnectionType = ConnectionType.AllExceptRecord;  
  
            // Set the Initialize, Cumulative and Get functions  
            SetExternalFunctionName(GetType().Assembly.FullName, "Microsoft.Samples.BizTalk.CustomFunctoid.CumulativeMultiplyFunctoid", "InitCumulativeMultiply");  
            SetExternalFunctionName2("AddToCumulativeMultiply");  
            SetExternalFunctionName3("GetCumulativeMultiply");  
        }  
  
        // Initialization function  
        public string InitCumulativeMultiply(int index)  
        {  
            if (index >= 0)  
            {  
                if (index >= myCumulativeArray.Count)  
                {  
                    myCumulativeArray.Add(1.0);  
                }  
                else  
                {  
                    myCumulativeArray[index] = 1.0;  
                }  
            }  
  
            return "";  
        }  
  
        // Cumulative function  
        public string AddToCumulativeMultiply(int index, string val, string reserved)  
        {  
            if (index < 0 || index >= myCumulativeArray.Count)  
            {  
                return "";  
            }  
  
            if (IsNumeric(val))  
            {  
                double dval = Convert.ToDouble(val, CultureInfo.InvariantCulture);  
                myCumulativeArray[index] = (double)(myCumulativeArray[index]) * dval;  
            }  
            return myCumulativeArray[index].ToString();  
        }  
  
        // Get Function  
        public string GetCumulativeMultiply(int index)  
        {  
            if (index < 0 || index >= myCumulativeArray.Count)  
            {  
                return "";  
            }  
  
            return myCumulativeArray[index].ToString();  
        }  
    }  

Voir aussi

Utilisation de BaseFunctoid
Développement d’un fonctoid intégré personnalisé
Functoid personnalisé (un exemple de BizTalk Server)