We write our own bot in .NET Core, part I

The word bot is short for word robot . If you associate with our familiar "work" - rightly so. The term comes from the Czech language. The writer Karel Capek used it for the first time in the art of RUR published in 1920

The real originator of the word was Karel's brother, Josef, and the works presented in art are living beings - special versions of human beings intended for hard work. Still, in the collective consciousness, Capek is the creator of the mechanical robot figure.

In fact, humanity has dreamed of mechanical helpers for thousands of years and it has been said that these dreams have been carried out more than once. There are many legends about mechanical servants or golems. Apparently Talos was a huge mechanical warrior who patrolled the sea waters around Crete and protected her from pirates.

Software bot

Today we will take a closer look at the software bot - and even try to write it ourselves. A bot is a program or service that can participate in a conversation with a human being. We can communicate with him via text via Skype, Slack, Messenger or by voice, just like with the Google Assistant or Siri on the iPhone.

These types of bots can be the future of how we interact with the software. Filling in the forms and selecting options will be replaced with a conversation, during which we will tell the context that understands the assistant what we want.

From the software side, we can distinguish a common pattern of writing:

• We write so-called reactions to occurring events
• Plugin (plugin) architecture allows you to write so-called respondents (this can be seen particularly well in the Google and Alex assistant, where everyone can extend the assistant's capabilities)

The choice of technology

In order to give an example of how we can write our own bot, I chose the .NET Core framework and the C # language. I did it because of its availability, multiplatformity, lightness and simplicity. It works everywhere and does not require a lot of downloading. The .NET Core SDK is installed from here .

As an editor and IDE, I can recommend the Visual Studio Code, available for download from here . We can also do without it and write in any text editor.

By installing .NET Core, we gain access to the dotnet command, which is used to build and run our applications.

What you need to know to get started

To pass the lesson here, you should:

• Know some programming and object languages ​​(understand more or less where the class is, and where the method ...)
• Be able to install and configure the program (Windows, MacOS or Linux - .NET Core is multiplatform)
• Be able to work from the command line - eg set up a folder and go to it
• Be able to manage a created group (band) on Slack

All examples can be run on Linux, MacOS or Windows.

Here we go

To create a new project in .NET Core technology, we set up a new directory, go to it (all of this is done from the command line). We do not have to be an administrator.

Then enter the command line:

dotnet new console

This creates a new .NET Core project in the current directory based on the command line application template (so-called console). This is a standard Hello World program.

We can then start it with the command:

dotnet run

If you want to edit files using a convenient editor, you can use the command to invoke Visual Studio Code in the current directory

code .

What do I cry - syntax C #

The newly created program now consists of only one Program.cs file. Recall the basic concepts associated with the syntax of C # languages ​​on the following screen.

The most important in this file are:

• The using section - which contains information about the namespaces we import into our project.
• The namespace section - containing the namespace of our code - the framework created it by default based on the folder name
• class section - here we define the class. Due to the fact that this is a special case - a command line application, the Program class was created to run such programs
• Main method - as in many other programming languages, this method is called entry point - it is automatically called by the run command via the framework. As we can see, Main also has parameters - in the args array we get parameters from the command line.

To easily program the bot for Slack, we will use the MargieBot open source library. Because it is available in the NuGet catalog, it is enough to write on the command line:

dotnet add package MargieBot

If we look at the .csproj file in our project, we notice that the appropriate reference has been added to this file.

The newly added library refers to several others, we have to solve these references by calling

dotnet restore

You can also press the corresponding button in Visual Studio Code, which will call this command for us.

Slack preparation

We can connect our bot to every existing Slack band. For this purpose, I started a new band in Slack.

To enable our bot to participate in discussions, we must add it in the administration panel.

We choose Administration -> Manage apps to enter the appropriate panel.

Then we enter Custom integrations and see the Bots section.

We click on the options of the new bot and we are able to configure its name, icon, and set several other options. However, the most important thing is the information contained in the Token API field. We will need this string of characters so that our bot can find the right Slack installation. Let's copy it.

Then we can add our new bot, using its name, to the channel - just like an ordinary user.

Preparation of the basic bot using the MargieBot library

After configuring Slack, we return to our program.

In the Program.cs file, add the using (below existing) command to use the MargieBot library namespace:

using MargieBot ;

Delete the existing call in the Main method Console.WriteLine and add:

Bot myBot = new Bot() ;

myBot.Connect("<tutaj wstawiamy klucz API Slacka>") ;

Console.Read() ;

The last command is to stop the program and prevent it from exiting. You should treat this solution as temporary.

We run our program with the command

dotnet run

Be choosing the Debug command in Visual Studio Code -> Start Debugging . By default, we can also press F5.

Leaving the program running, let's log in to our Slack. We will see that in the Applications section there appeared an active (with a green dot) bot with the name defined by us. First cats for fences.

Let's try to write to him:

As we can see in the running program, we received a message:

We receive a message regardless of whether it was a private message or the so-called mention, i.e write on the #general channel or other @ @swimming, e.g. "@navwabota hi colle".

We leave the program using Ctrl-C (command line), or by clicking "Stop Debugging" (Visual Studio Code). Returning to Slack, we notice that the dot next to the name of the bot has become gray.

We are teaching the bot new things

We managed to run the bot and receive a notification about the received messages. We used the infrastructure of the popular Slack program for this. Time to teach him something useful now.

Programming the simplest bot responses

At the beginning, let's add a simple response to the keyword. This is the basic ability that is also used by bots of various companies, as well as Siri.

We will use the functions provided with the MargieBot library for this purpose. We need to use the function provided by the Bot object from this library RespondsTo().With() Important: this function returns the same object, which makes it possible to combine them into strings.

For example, we can try to answer the "coffee" chain.

myBot.RespondsTo("kawa").With("ze śmietanką czy bez").With("espresso raz").With("zapraszam na filiżankę") ;

From now on, our bot will react to the word "coffee" using one of the defined answers. We restart it ("dotnet run").

Programming more complex answers

To be able to program more complex logic, we need to create a class that implements the IResponder interface provided by the MargieBot library. Let's create a new SimpleResponder.cs file

We can do this by selecting New File in the Visual Studio Code (or, if we have the "C # Extensions" add-on, create a new class file straight away).

We implement the CanRespond method so that it allows us to decide whether to run the logic of a given "responder". Suppose we want to write one that responds to the Hello. We indicate the implementation interface, giving its name after the colon.

The GetResponse method is more important, which allows us to create an answer by creating and returning a BotMessage object.

The creation of a new class is not enough, we still have to pass this type of object to our bot. We return to the Main () method.

myBot.Responders.Add(new SimpleResponder()) ;

As we can see, Responders is a collection. This means that we can have any number of responders operating in one bot. We intend to use it, but first - try the new bot function. Let's run it, and then write the text containing the word "hello" to it.

We teach our bot new tricks

In the next part of the article, we will create a new responder who will be able to answer questions related to the weather in the given city. We will take this opportunity to show you how to connect to the public REST interface that gives us the data. When we succeed, the next thing we will teach our bot will be a function that can actually be called artificial intelligence ...

We write our own bot in .NET Core, part I