Using the Microsoft .NET Operator

Select the .NET operator from the Insert an Operator or Adapter dialog, which you invoke with one of the following methods:

From the Insert an Operator or Adapter dialog that opens, select Microsoft .NET and double-click or press OK.

Name: Use this required field to specify or change the name of this instance of this component, which must be unique in the current EventFlow module. The name must contain only alphabetic characters, numbers, and underscores, and no hyphens or other special characters. The first character must be alphabetic or an underscore.

Operator: A read-only field that shows the formal name of the operator.

Class name: Shows the fully qualified class name that implements the functionality of this operator. If you need to reference this class name elsewhere in your application, you can right-click this field and select Copy from the context menu to place the full class name in the system clipboard.

Start options: This field provides a link to the Cluster Aware tab, where you configure the conditions under which this operator starts.

Enable Error Output Port: Select this check box to add an Error Port to this component. In the EventFlow canvas, the Error Port shows as a red output port, always the last port for the component. See Using Error Ports to learn about Error Ports.

Description: Optionally enter text to briefly describe the component's purpose and function. In the EventFlow Editor canvas, you can see the description by pressing Ctrl while the component's tooltip is displayed.

This section describes the properties on the Operator Properties tab in the Properties view for the .NET operator. Enter all text fields as string literals, not as expressions.

This tab contains the definition of the operator's output ports. The number of output schemas available here for definition depends on the value entered for the Number Of Output Ports setting on the Operator Properties tab as defined above. The other schemas (say, #7 through #10 if 6 was entered in Number Of Output Ports) are grayed out and their definitions are not used.

Use the settings in this tab to allow this operator or adapter to start and stop based on conditions that occur at runtime in a cluster with more than one node. During initial development of the fragment that contains this operator or adapter, and for maximum compatibility with TIBCO Streaming releases before 10.5.0, leave the Cluster start policy control in its default setting, Start with module.

Cluster awareness is an advanced topic that requires an understanding of StreamBase Runtime architecture features, including clusters, quorums, availability zones, and partitions. See Cluster Awareness Tab Settings on the Using Cluster Awareness page for instructions on configuring this tab.

Use the Concurrency tab to specify parallel regions for this instance of this component, or multiplicity options, or both. The Concurrency tab settings are described in Concurrency Options, and dispatch styles are described in Dispatch Styles.

A .NET operator can manage multiple input and output ports with complex schemas. However, to illustrate the process of creating one, let's look at a simple example with one input, one output, and basic schemas. Suppose you have code that calculates π (pi) to the Nth digit, and you want to invoke this code as a .NET operator in StreamBase. This is a C# method that you have compiled into an class library you called CalculatorAssembly.DLL. Its signature is:

string MyCalculatorClass.GetPi(int n) 

As you are defining an operator, you must specify the number of desired input and output ports and their associated schemas, which the .NET Operator must use to communicate with the application. For the purpose of computing a single string, all you need is one input port receiving a single field of type int (call it numDigits), and one output port emitting a string field (call it answer).

To begin, in Microsoft Visual Studio create a project to develop StreamBase client code in C# to extend StreamBase.SB.Operator. Your project should:

Name the resulting assembly MyDotNETOperator.DLL. The implementation of the StreamBase.SB.Operator subclass is as follows (error checking is omitted for clarity):

using StreamBase.SB; 
namespace MyNamespace { 

    public class MyDotNETOperator : Operator { 
        MyCalculatorClass calc = null; 
        public override void Init() { 

        // Create a calculator instance 
        calc = new MyCalculatorClass(); 
        } 
        public override void ProcessTuple(int port, Tuple tuple) { 

            // Get the input value from the tuple 
            tuple.GetInt(“numDigits”); 

            // Calculate the answer 
            string answer = calc.GetPi(numDigits); 

            // Place the answer in a new tuple 
            Tuple returnTuple = GetOutputSchema(0).CreateTuple(); 

            // Send the tuple on the operator’s output port #0 
            SendOutput(0, returnTuple); 
        } ProcessTuple calls 

        // The class needs a public default constructor
        // that can be compiler-generated or explicitly defined, 
        // which will be used by the .NET Operator to create the instance 
        public MyDotNETOperator() { } 
    }     
} 

Compile the MyDotNETOperator.DLL assembly and place it alongside CalculatorAssembly.DLL in a directory you might call C:\MyAssemblies\. Include the accompanying .PDB files if you will be debugging your code. This is all the code that your .NET operator needs.

Now create your StreamBase EventFlow application. In StreamBase Studio:

When your application starts, the .NET Runtime Environment loads along with all the assemblies, creating an instance of MyDotNETOperator. Enter a value for numDigits in the Manual Input view and click Send Data.

The tuple goes to the .NET assembly code, where method processTuple calls your algorithm to calculate the value of pi to the specified precision. Method SendOutput returns the result to your myPi .NET operator, which emits it to its output stream as a string tuple. Verify the result in the Output Streams view.