DotNet Connector Guide

The DotNet Connector allows you to call .NET code from a Mule flow.

DotNet Documents:


This document assumes that you are familiar with Mule, the Anypoint Studio interface, and Global Elements. Further, it is assumed that you are familiar with the Microsoft .NET Framework.

To complete this tutorial, you need the following components installed on your machine:

Note: The .NET connector version 1.0 is incompatible with version 2.0. See the .NET connector migration guide if you are an existing user of .NET connector 1.0.

Installing the DotNet Connector in Anypoint Studio

You can install a connector in Anypoint Studio using the instructions in To Install a Connector from Anypoint Exchange.


This example introduces the DotNet Connector and shows you how to configure it to execute a method in a .NET assembly.

The example uses the following Mule message processors:

Component Description

DotNet Connector

Execute Microsoft .NET code from inside a Mule flow.

HTTP Connector

Enables the example application to receive and send HTTP requests.

Set Payload Transformer

The set payload transformer sets the payload to whatever you define. The payload can be a literal string or a Mule Expression.


The DataMapper is a Mule transformer that delivers simple, yet powerful, visual design of complex data transformations for use in Mule flows

Step 1. Creating a .NET Component

  1. Start Visual Studio and create a new C# Class Library project.

  2. In Anypoint Studio, select File > New > Project.

  3. In the New Project dialog, select the Class Library template under Visual C#. Name the Project “Test.SampleComponent”.

  4. Create a class named Sample with the following code:

    namespace Test.SampleComponent
       public class Sample
           public object ExecuteComplex(Person person)
             person.Name += " updated from .net";
             person.MyRide.Brand = person.MyRide.Brand.Replace("GM", Chevrolet");
             person.MyRide.Model = person.MyRide.Model + " - " + "400x";
             person.MyRide.ExteriorColor.Name += "ISH";
             person.MyRide.ExteriorColor.RGB = "no clue";
             return person;
  5. Compile the project to create the Test.SampleComponent.dll assembly.

  6. Copy the .dll file to the C:\Sample directory.

Step 2. Creating a New Anypoint Studio Project

  1. Start Anypoint Studio and create a new project.

  2. Select File > New > Mule Project.

  3. In the New Mule Project configuration menu, provide a name for this project: dotnet_demo.

  4. Click Finish.

A new project opens with a blank canvas for building the flow, and the palette with Message Processors to the right.

Step 3. Creating a DotNet Global Element

To create and configure a DotNet global element, follow these steps:

  1. Click the Global Elements tab at the base of the canvas, then click Create.

  2. Use DotNet Connector as filter to locate, then select the Global Type:

  3. Choose DotNet: External Assembly and click OK.

  4. Configure the External Assembly global type:

    Parameter Value



    Enable DataSense

    True (select the check box)



    Grant Full Trust to the .NET assembly

    True (select the check box)

    Declared methods only

    True (select the check box)

    Assembly Path

    Path to the Test.SampleComponent.dll file

    You will reference this global element when configuring the DotNet connector.

Step 4. Creating a Demo Flow

  1. In Anypoint Studio, drag an HTTP connector onto the canvas, and select it to open the properties editor console.

  2. Add a new HTTP Listener Configuration global element:

    1. In General Settings, click Add button:

    2. Configure the following HTTP parameters:

      Field Value







      Exchange Patterns


      Display Name

      HTTP (or any other name you prefer)

  3. Reference the HTTP Listener Configuration global element:

  4. Drag a set payload transformer into the canvas, then select it to open the properties editor console.

  5. Configure the required filter parameters as follows:

    Field Value


    { "name" : "bar", "lastName" : "foo", "id" : 1, "myRide" : \{ "Model" : "Coupe", "Brand" : "GM", "Color" : \{ "Name" : "red", "RGB" : "123,220,213" } } }}

    Display Name

    Set Payload (or any other name you prefer)

    The string you enter in the Value field represents a serialized JSON object for a Person class:

    namespace Test.SampleComponent{
      public class Person
            public string Name {
              get; set;
            public int Id {
              get; set;
            public string LastName {
              get; set;
            public Car MyRide {
              get; set;
        public class Car
           public string Model {
             get; set;
           public string Brand {
             get; set;
           public Color ExteriorColor {
             get; set;
  6. Drag a DataMapper from the palette, and place it into the canvas after the Set Payload transformer.

  7. Configure the parameters as follows:

    Field Value

    Display Name

    JSON to ExecuteComplex (or any other name you prefer)




    From Example

    True (Check)


    Enter the path to the input.json sample file.

    Before you run this application, create a JSON sample file named input.json and copy the following content into it:

"person" : { "name" : "bar", "lastName" :  "foo", "id" : 1, "myRide" : { "Model" : "Coupe", "Brand" : "GM", "Color" : { "Name" : "red", "RGB" : "123,220,213" }  } }}.

+ . Click Create Mapping.

+ image::datamapper-mappingscreen.png[]

+ . Drag the DotNet connector in the Palette, then place it into the canvas after the set payload transformer. Configure the DotNet connector as shown below.

+ image::dotnet-connectorscreen.png[DotNet+Connectorscreen]


Field Value



Method name

Test.SampleComponent.Sample.ExecuteComplex(Test.SampleComponent.Person person)

Display Name

DotNet Connector (or any other name you prefer)

Config Reference


+ Note that the Config Reference field references the DotNet global element created previously.

After completing the above steps, your application flow should look like this:


XML Code

<mule xmlns:tracking="" xmlns:data-mapper="" xmlns:http="" xmlns:dotnet="" xmlns="" xmlns:doc=""
 xmlns:spring="" xmlns:xsi=""
 <dotnet:externalConfig name="DotNet_External_Assembly" scope="Transient" path="C:\Samples\Test.SampleComponent.dll" doc:name="DotNet: External Assembly"/>
<http:listener-config name="HTTP_Listener_Configuration" host="" port="8081" basePath="dotnet" doc:name="HTTP Listener Configuration"/>
<http:connector name="HTTP_HTTPS" cookieSpec="netscape" validateConnections="true" sendBufferSize="0" receiveBufferSize="0" receiveBacklog="0" clientSoTimeout="10000" serverSoTimeout="10000" socketSoLinger="0" doc:name="HTTP-HTTPS"/>
<data-mapper:config name="JSON_To_ExecuteComplex" transformationGraphPath="json_to_executecomplex.grf" doc:name="JSON_To_ExecuteComplex"/>
 <flow name="dotnet-demoFlow1" doc:name="dotnet-demoFlow1">
 <http:listener config-ref="HTTP_Listener_Configuration" path="/" doc:name="HTTP"/>
 <data-mapper:transform config-ref="JSON_To_ExecuteComplex" doc:name="JSON To ExecuteComplex" path="dotnet"/>
 <dotnet:execute config-ref="DotNet_External_Assembly" methodName="Test.SampleComponent.Sample, Test.SampleComponent, Version=, Culture=neutral, PublicKeyToken=null | ExecuteComplex(Test.SampleComponent.Person person) -&gt; System.Object" doc:name="DotNet"/>

Step 5. Running the Application

You are now ready to run the project! First, you can test run the application from Studio:

  1. Right-click your application in the Package Explorer pane.

  2. Select Run As > Mule Application.

  3. Fire up a browser and go to ` http://localhost:8081/dotnet/?name=foo&age=10 ` to see the results.


Step 6. About the Example Application

The flow you built in Anypoint Studio contains message processors – including the HTTP Connector, Data Mapper, Set Payload Transformer and the DotNet Connector — and it is the "Mule messages" that carry data between these message processors.

A Mule message contains the following components:

  • Payload: The actual data contained in the message

  • Properties: Message metadata, which can include user-defined parameters

In this example, we can see the DotNet connector was able to receive parameters from Mule, and to create and return a new message payload that was routed by Mule back to the caller. The DotNet Connector allows .NET components to be used to provide custom logic to Mule flows.

See Also