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 field to specify or change the component's name, which must be unique in the application. 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: A field that shows the fully qualified class name that implements the functionality of this operator. Use this class name when loading the operator in StreamSQL programs with the APPLY JAVA statement. You can right-click this field and select Copy from the context menu to place the full class name in the system clipboard.

Start with application: If this field is set to Yes or to a module parameter that evaluates to true, an instance of this operator starts as part of the containing StreamBase Server. If this field is set to No or to a module parameter that evaluates to false, the adapter is loaded with the server, but does not start until you send an sbadmin resume command, or until you start the component with StreamBase Manager. With this option set to No or false, the operator does not start even if the application as a whole is suspended and later resumed. The recommended setting is selected by default.

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 and Error Streams to learn about Error Ports.

Description: Optionally enter text to briefly describe the component's purpose and function. In the EventFlow 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 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 Debug Perspective’s Manual Input pane 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 Application Output pane.