trading robots. StockSharp

Designer Knowledge Base

2019-04-25T12:28:29Z

Frequently asked questions about Designer:
1. How to download market data to the program?
2. How and where to specify an instrument for strategy backtesting?
3. How to create a condition in the strategy?
4. Compound indicators, methods of their decomposition.

Trend and countertrend! Don't choose to use it together.

2020-04-14T20:34:27Z

Previously, we have already discussed various trading methods that can be used when trading, in order to increase its profitability.
For most traders, following the trend is a sign of the correct approach to trading at the moment. Like saying: "Following the trend is already 50% successful trading". There is hardly a player in the market who will deny this statement, especially if the trend is turned in the right direction for the trader, he gets a guaranteed profit.
The trader's desire to extract the maximum profit is aimed at finding a point of entry into the market when the price is either minimal for buying the desired asset, or maximum for selling the existing one.
To determine such points, a trader often needs not only a flair, which is generally one of the most important qualities, but also the ability to use complexes from a combination of trend and counter-trend strategies.
In the market, there is always a kind of confrontation between trend traders and counter-trend traders, using pullbacks and local changes in market trends.
The key to success and, as a result, getting the maximum income, is to merge these two strategies in a combination of experience and trader's flair.
However, it is worth noting that even a less experienced market player can trade using a combination of these strategies, just using automated trading systems and trading robots. For example, such as "Mr. Hyde" from StockSharp, which allows even a less experienced trader to use the movement against the trend, in order to increase revenue.

What is the combined method of trading?
The basic rules are the basis for this method:
1. Finding a way to determine a long-term trend or trend on the chart.
2. Determining the opposite counter-method that allows you to determine the pullback signal, as well as a short – term trend change in the opposite direction-determining the counter-trend.
There are various methods for determining points of entry and identifying subjectively correct methods of determination. Often, these methods seem quite complex to novice traders, but when you look at them in detail, they are quite accessible.
Let's look at one of the ways.
First, we need to identify long-term trends in the market. To do this, we will build a price chart and a moving average chart with a period equal to 200. You can build such a graph using the S#.Designer program, using the tools provided in it.

This method is very common among analysts, and allows you to determine long-term trends in the market.
His idea is that if the price is located above the indicator line, the market is growing, and if it is lower, the price is decreasing.
This indicator line is a General indicator of the market trend. Now, to determine the entry points to the market, we add two more averages, using periods of 10 and 30 days.

What is the point?
In cases when the ten - day moving average will be above the thirty-day one and above the main two-hundred-day one, we can talk about a stable UP-trend.
UP-TREND is one of three types of trend, which is a sequence of rising lows or highs of prices. it is a series of consistently rising lows and highs of prices. In other words, UP-TREND shows price growth over a period of time. It is also called a bullish trend in the FOREX market.
If the situation with the moving average is the opposite, and the ten-day moving average is below the remaining two, then we can talk about a downtrend, or as it is commonly called a bearish trend.
A change in the direction of the trend can occur over a long period, and there may be an error in the form of a delay. In order to avoid this, you can use a counter-trend indicator.
Each user chooses such an indicator for himself, focusing on the convenience and technical capabilities. For example, to get market data, although the latter problem is solved using the same S#.Designer or Hydra, which downloads market data online.
For example, we will use an oscillator that will cross the zero line. For example, consider the graph below.

So, let's determine the points where the long-term trend is changing and where you can make an entry to the market. By placing the charts together, or combining them, we can determine the points at which we could enter the market. These points are shown in the graph below.

As you can see, this method is quite simple to work with. However it has its drawbacks:
- You need to understand that the method shows repeated signals, and it may turn out that the point that the trader has identified for entry may be a trend reversal.
- It is important to understand that any method can not be considered a fully automatic method and requires the intervention of the trader, and trading robots simplify the work of the trader, but also depend on its settings.
The General conclusion is simple: trading using a combined trend and counter-trend method allows the trader to increase their income by using the direction of market movement.
A trader should rely not only on trading systems and trading robots, but also on their intuition and knowledge, which together make it possible to increase profits.

S#. Data-download market data in two steps.

2020-04-08T20:22:45Z

Good afternoon.
We continue to talk about StockSharp's products, and in past articles we have analyzed the S#.Designer trading robot constructor, as well as the S#.Shell graphical framework, which helps you create trading robots, including in C# using the S#.API library.
The work of these programs is aimed at creating trading systems using programming languages or cubes, in which the lines of code are replaced with cubes for simplicity, performing trading operations or responsible for conditions and parameters.
Creating trading robots would not be complete without testing the newly created trading strategy. To test and debug trading robots, before launching on real trading, you need to conduct testing on market data to make sure that they work correctly, consider possible "thin spots" or errors that occur during trading.
Today, market data plays an important role not only for technical analysis of trading systems, but also for analysis of market behavior in General. Agree that having data on market behavior for the period of interest, under the appropriate conditions, you can accurately predict the behavior of the market, thus you can predict the development of events.
Today, market data is the most valuable information for a trader, and its search is necessary for him, both for future trading and for analyzing the actions performed.
The problem with getting market data is the small number of sources that provide information on favorable terms.
There are always restrictions for teaching, either the data is paid, or it is limited to the period for which it is provided. Moreover, the trader receives data from only one source, and changing sources to get other data is quite an inconvenient procedure.
Based on the needs of the trader in S#, we developed the S#.Data or just Hydra.
What is she setting up?
The S#.Data is a program for automatically loading market data.

The user is provided with a huge Arsenal of functions:
- Select the source of market data (more than a hundred sources to download).
- Selection of the necessary financial instrument that is of interest to the trader.
- Select data type: candles, tick deals and glasses
- An impressive selection of timeframes for downloading market data.

A huge advantage of Hydra is the ability to choose the data storage format. Thus, after downloading market data, the user saves it in a convenient format and can use it when testing their strategy on any platform. Data can be saved in two formats: in the special S#.Data (BIN) - binary format, which provides the maximum compression rate, or in CSV text format, which is convenient when analyzing data in other programs.

All the user needs is to configure the source of market data, select the tool and the required period. In this case, you can configure the program to continuously save market data.
The ability to use server mode allows you to save market data on the server and configure access from anywhere in the world, which allows you to create huge amounts of data for more detailed analysis or use in long-term auctions.
At the same time, S#.Data can use both historical and real-time data sources (for example, connecting SmartCOM to get glasses). This is possible by using an extensible (plug-in) source model.
Also, Hydra is a plugin that allows you to develop your own sources.
The ability of the Analytics function allows you to analyze data according to various criteria without leaving the program. Plotting the data of stock quotes and indexes, make the downloaded data more visible and more convenient to use.
A very important advantage that makes this program unique, in addition to a set of features that any other program can envy, is that the Hydra program is completely free.
All these features are not the limit of functionality, only bright distinctive features that make Hydra an indispensable tool for any trader who is especially set up for profit.

S#.Designer is a simple way to start a successful trade.

2020-03-31T19:05:01Z

More recently, we have reviewed a program such as Shell and the API library.
Of course, mastering the skills of programming trading strategies opens up huge horizons for the user not only as a trader, but also as a Creator of trading robots for sale.
However, not every user is interested in programming, and not every user is willing to spend time studying libraries.
Not every trader wants to learn how to write custom trading robots and often wants to create trading strategies for themselves.
Agree, it would be cool to have a program that can use ready-made components to create trading strategies.
S# understands this and has created a trading robot constructor that allows you to create trading robots using dice-Designer.

Now many people will start thinking: "What is it good for?".
Actually -.
First, it is more intuitive, meaning that it is easier for the user to navigate the program interface.
Secondly, the program is completely free, which allows the user to start working with it without investing a penny!
Third, the program integrates with all our products, such as Hydra, and moreover, it is able to download market data itself.

In General, the ability to download market data yourself is a huge advantage.
The user can use not several programs, but one to test the created trading strategies.
The interface is intuitive, and makes it easy to adapt to the user's environment.

What is a Designer?
Designer is a completely unique program. It differentiates strategy elements into the simplest elements, as in the constructor, and allows you to assemble a trading strategy from these elements.
The large functionality of dice allows you to create the simplest and most complex trading strategies. All you need from the user is to select the strategy functionality.
Cubes are divided into sections that include groups of cubes for the user's convenience. This allows to improve the understanding and interface of the program. However, the program prevents errors from occurring at the strategy design stage. in other words, if a cube contains data of one type, it will not transmit data to a cube with data of another type, which helps avoid errors.

This means that the user does not waste time identifying the causes of the error at the program development stage.
In General, the development stage is a separate Chapter. At this stage, the user is provided with all the tools for working out their strategy, from the functionality of dice, to the ability to integrate their elements and analyze the progress of strategy development step by step.
Back test is a convenient function implemented in the program. Step-by-step review of strategy execution using the stop button allows you to detect an error at any stage. Of course - this saves time, which in turn reduces the user's expenses.

More experienced users can create their own elements in C#. All you will need to do is create your own element, where the user saves their code. These elements and strategies in General work much faster than strategies written in the visual designer, which gives the user an incentive to develop at the same time, without changing the convenient development environment.
The advantage of strategies in C# is not limited when creating them.you can describe any algorithm and add standard operation cubes to it if you want. The strategy creation process takes place directly in S#.Designer or C# development environment (the most popular development environment is Microsoft Visual Studio), using the library for professional development of trading robots in C# and S#.API.

Speaking of Designer, we can say that it is a progressive product. The ability to include your own codes in software solutions allows you to expand the range of Designer applications. The possibility of testing reduces the potential risk. The ability to download and use it for free-makes the product available to anyone.
It just remains to start working

What is Stop-Loss and Take Profit?

2020-03-03T11:53:25Z

Stop-Loss-a type of order whose task is to set limits on possible trading losses.
This order is used automatically using automated trading systems, which we will discuss later. The essence is very simple: with the help of the Stop-Loss mechanism, when the set price level of the purchased asset (instrument) is reached, the position is closed. In fact, Stop-Loss insures the trader from an unplanned price drop.
This restriction mechanism is widely used for traders. It is used by experienced participants in the financial market, but novice traders often neglect this mechanism, although for them Stop-loss is almost the main method of saving their funds in a positive balance.

Stop-Loss, from a technical point of view, is a regular pending order that has an activation mechanism when the set price level of the asset is reached. The difference between the two types of pending orders is that when using a regular pending order, a new deal is opened, and when using a Stop loss, an existing one is closed.

As mentioned earlier, an important advantage of Stop-Loss Is the automation of the process, which eliminates the need to track price changes and make a decision manually. Of course, this reduces trading losses and time, which is fundamental for high-frequency algorithmic trading (HFT).
For example, in the program for creating trading robots Designer, it is possible to use the Stop-Loss mechanism by using the position protection cube, which can be configured and used as a reliable tool for reducing losses.

The use of the Stop-Loss pending order mechanism is widely used to reduce trading costs caused by losses. As a result, this leads to an increase in profits, not only by increasing the volume of successful operations, but also by reducing the volume of unprofitable ones. The use of this tool in trading strategies is now increasingly used, as it reduces losses, increasing the amount of profit at a constant (regulated) amount of transaction costs. Example of a trading strategy executed in the Designer program.

So, the main advantages that are inherent in a pending Stop-Loss order:
- Using a pending Stop-Loss order in trading strategies allows you to limit losses on a single trade by setting the loss level that is set by the trader himself, which makes the trading strategy more flexible and less risky.
- The use of this pending order insures the trader from an unpredictable situation in the market, in which the asset value may collapse, thereby protecting the user of the trading strategy from losing capital.
- Regulation of possible losses also has a positive effect on the trader's emotional state, preserving his nerves and psychological health.

There are a lot of reasons in the market that can cause a loss, and the frequency of their occurrence is unpredictable. However, the use of Stop-Loss allows you to protect yourself, make trading more convenient, limit risk, maximize profit, reduce the time to work with a trading strategy, and reduce the risk to emotional health.
An important point for working with a pending Stop-Loss order is to calculate the correct order level.

When placing an order, you need to know the following:
- First of all, a Stop-Loss order is a conditional order that is executed when the set price level is reached.
- The application consists of two parts: the application and the condition for its execution (conditions that are edited by the trader, and when a new condition is set, the old conditions are canceled).
- The request is located on the broker's server, through which the trade is carried out, and is sent only when the necessary condition is reached.

Let's look at the most well-known methods of working with Stop Loss:
- Fixed Stop-Loss:
The trader sets the value in the tool settings equal to the number of points from the initial price of the asset to open the order.
- Flexible Stop-Loss:
A more flexible method that takes the result of market analysis (minimum and maximum prices for an asset for a period, price change charts, and other analysis tools) as the basis for setting the opening price value. This is a more complex, but more reliable method than the previous one.
- Break-even trading:
A rather complex method aimed at dynamically changing the set Stop-Loss level by moving the set value from the drawdown area to the guaranteed profit area at a time when the price has already changed significantly in the set direction.
- Trailing stop:
A more advanced method of the previous method, which involves automatic means of transferring the Stop-Loss level.
- Trend:
We will devote a separate article to this method and analyze it later.

Let's add a few more words and talk about Take Profit.
Just like Stop-Loss, Take Profit is a pending order aimed at fixing profits. When the asset price reaches the price set by the trader, the order is executed, and the trader makes a profit by closing the position.
The level of execution of Take Profit is set by the trader himself, and as in the case of Stop-Loss, it is often used with the use of automated trading systems, trading robots and trading systems.
This type of order - limit, is executed only when the asset price reaches a predetermined level.
There are two types of "entry into a position" - the beginning of trading operations:
- Long position (long, long, buy) - purchase request;
- Short position (short, short, sell) - request for sale.

If we start trading with a purchase, we set the take Profit order execution level above the asset purchase price.
If we start trading with a sale, we set the take Profit order execution level below the asset's sale price.

In conclusion, it is worth mentioning the ratio of the orders considered.
Using both orders reduces the risk of loss and increases profit. The use of both of these orders in each of the trading situations is purely individual, it is impossible to say unequivocally what is most applicable, what is least. The level of use of pending orders is determined by the trader, in relation to each situation and trading strategy separately. However, the combination of techniques with the use of pending orders and trading robots makes it possible to facilitate the work of the trader, makes it possible to concentrate on analysis, reducing the time to track the situation on the stock market.

Designer - create a strategy based on MACD. Start with simple.

2019-05-06T18:15:06Z

Creating a strategy in the Designer program.

Let’s discuss an example of creating a trading strategy in a program based on the MACD indicator values.
The indicator’s goal is as follows:

1. If the MACD indicator histogram crosses the zero line from top to bottom, this is a sell signal.
2. The transition of the histogram from the negative to the positive zone is a buy signal.

Therefore, it is necessary to create conditions under which a trade will be made, namely, if the indicator value on the next candle changes its sign, then the signal is sent to make a trade.
To create a strategy, we need:

- Run the program.

- Select the Variable, Candles and Chart Panel blocks, connect them.

- Select an instrument with which we will test the strategy.

- Plot a candle chart.

- Select the Indicator and Chart Panel blocks. Connect the Indicator and Candles blocks.

- Plot a chart of the MACD indicator.

- Select the Variable block and assign it a numeric value of 0 for further comparison with the indicator value.

- Select the Comparison block and set the test condition in the properties: execution during the test, with the MACD indicator value greater than 0.

- Add two Variable blocks and Comparison block. One of the variables is set to -1 in the block properties. It will indicate the transition of the MACD curve value from negative to positive area. The second Variable value is set to 0 in the properties, that will indicate the initial indicator value.

- Set the condition in the Comparison block that will be fulfilled if the initial indicator value for the time frame is greater than the current one.

- Connect the Variable blocks via a trigger socket with the Comparison blocks, as shown in the figure.
Select the Logical Condition and Variable cubes.

- The execution condition of two comparisons will be checked in the Logical Condition cube. Set the AND condition in the properties of the Logical Condition cube and connect the cubes as shown in the figure.

- Set the value equal to -1 in the Variable cube and connect it with the Logical Condition cube via a trigger socket, and through the output connect to the input of the cube with a value of 0. This will allow overwriting the checkbox value when conditions are met, indicating within what range of values the MACD indicator curve is.

- Select the Open Position block, select the Buy direction in the settings and connect data and trigger with the socket, as shown in the figure.

- Select two Variable blocks in which to set the volume and portfolio for trading. Connect them with the corresponding sockets of the Open Position block.

- Similarly, create a routine for the Sales execution.

-The strategy is ready, let’s run it.

How to download market data to the Designer?

2019-04-25T12:35:50Z

In order to download market data to the Designer program for testing a trading strategy, you need to do the following:

1.Run the program.

2. Select the Market Data section in the top menu and click on it.

3. In the window that appears, select the Download Securities button in the Securities panel, in the menu that appears, tick the All option and select the storage. Then click the OK button .

4. In the list of downloaded securities, select the one we need.

5. Choose a period for which we need market data, and candles that we need.

6. Select the path to storage where our market data will be stored, for this, we click the “+” button.

7. In the menu that appears, select the full path to store the downloaded market data.

8. Click the Start button
9. In the window that appears, select the market data source.

10. In the window that appears, click the “+” button and select the source we need from the drop-down list.

11. Click the OK button.

Market data downloaded to your storage. Enjoy using.

S#.UI - StockSharp Graphic Framework

2018-11-15T16:25:45Z

In this paper, I will show how to use graphic components included in S#.API, in order to create a fully-featured application of the S#.Shell:

You will learn how to make a professional-level program with connection settings, output of securities, prices, and charts (and all this is saved and loaded upon restart). And the complexity of creating such an application is not a few months, but just a few hours (it is no joke! read to the end). This is the main advantage of the graphic framework, which I called by analogy S#.UI (this name is unofficial, I think it up myself).
I will not use complex constructs and design patterns that are understandable only to professional programmers. On the contrary, the paper's purpose is to show that the learning curve on creating your trading applications using S#.API is very short.
You will also be interested if you work in a company and make your own unique software (for example, you work in proprietary trading or a brokerage company). In this paper, you will be able to learn the practice of creating such systems (especially if you have just taken up your duties).

What You Need

1) Visual Studio 2017 (Community, free version), in which we will program.
2) Free connection to test exchange trading, I will use QUIK.

Creating Project

We create a new WPF application in Visual Studio.

After that we need to add the S#.API libraries, and how to do this is described here. I prefer installing with Nuget.
Since all S#.API graphic elements are based on DevExpress, and DevExpress libraries are included in S#.API, it would be foolish not to use them. All information about DevExpress graphic elements can be found in Google.
Let's go to the MainWindow.xaml window editor.

We replace Window with DXWindow, we will need it to use different color schemes.

Visual Studio will prompt us to add the necessary libraries.
We split the window into three parts, there will be a bar with buttons of connection setting and connection at the top. The window with logs will be below. All other panels are in the middle. The easiest way is to split the window in this way using LayoutControl from DevExpress.
We will add the elements we need to the resulting three parts.

Configuring Connection to Connector

We add two buttons, one button to configure connection and the second button to connect. To do this, we use the SimpleButton button from DevExpress. The buttons will be located at the top of application. We will place pictures familiar with Terminal and Designer on each button.

We will see such an image in the upper right corner of the screen form.

We double-click each button to create button click event handlers.
In MainWindow code it is necessary to declare the connector, as well as the file location and name where the connector settings will be stored.

We will open the connector configuration window in the connector settings button click event handler and save it to a file.

We will check in the constructor whether there is a directory and a file with the connector settings and, if there is one, we will load it into the connector.

Most S#.API objects have Save and Load methods, with which it is possible to save and load this object from an XML file.
We connect the connector in the connection button click event handler method.

Now we can run the program and test it.

Setting Dark Theme

I prefer a dark theme. Therefore, we make the program theme dark at once. To do this in the App.xaml file

We replace Application with charting:ExtendedBaseApplication. Visual Studio will prompt us to add the necessary libraries. And in the file App.xaml.cs delete ": Application". The code will be the following.

We write ApplicationThemeHelper.ApplicationThemeName = Theme.VS2017DarkName in the MainWindow constructor;
Full code at the moment:

Run to check the dark theme.

Creating Security Panel

We add the XAML folder where we will store all the created controls.
We add our first UserControll to the folder, let's call it SecurityGridControl.

We add one SecurityPicker element to it. In which the available securities will be displayed. Similar to the main window, we will use LayoutControl from DevExpress.

We go to the main window constructor and change the central part to the tab view. We place created control with SecurityPicker in one of the tabs.

Now we have the security panel, we need to set it a data source, in our case it is a connector. It was possible to write SecurityPanel.SecPicker.SecurityProvider = Connector in MainWindow constructor.
But we will not place code in the MainWindow that is not related to it. Therefore, I will create the Instance static variable, and assign it the MainWindow value in the MainWindow constructor.

Now we can call the MainWindow properties anywhere in our program using MainWindow.Instance.XXX code.
In the SecurityGridControl constructor, we specify Connector as a data source.

We run the program to check.

Adding Logging

The operation of the program, connector or robot must be monitored. For this purpose, S#.API has a special LogManager class. This class receives messages from sources and sends them to listeners. In our case, the sources will be Connector, strategies, etc., and listeners will be a file and log panel.
In the MainWindow code, we declare the LogManager object and the location where it will be stored.

In the MainWindow constructor, we create LogManager, set in it Connector as the source, and a file as the listener.

Similar to the security panel, we create a log panel, add another UserControl to the XAML folder. We call it MonitorControl. We add the Monitor element to it.

In the MonitorControl constructor, we set Monitor as a listener in LogManager.

We add the created MonitorControl to the bottom of MainWindow.

We run the program to check.

Creating Portfolio Panel

Similar to the security panel, we create a log panel, add another UserControl to the XAML folder. We call it PortfolioGridControl. We add the PortfolioGrid element to it.

In PortfolioGridControl constructor, we need to subscribe to new portfolio appearance events and event of new position appearance at Connector.

Thus, when a new portfolio appears, it will be displayed in the portfolio panel, and when a new position appears in the portfolio panel, the portfolio will update the position.
We add the created PortfolioGridControl panel to the central part of MainWindow.

We run the program to check.

We have a tab with portfolios.

Creating Order Panel

The order panel in S#.API has the ability to register orders, cancel orders and reregister them.
Similar to the security panel, we create an order panel, add another UserControl to the XAML folder. We call it OrderGridControl. We add the OrderGrid element to it.

OrderGrid has the OrderRegistering event, the OrderReRegistering event, and the OrderCanceling event.
Let's create their handlers.

In the order registration event handler, we create an OrderWindow window where we need to specify data sources for securities, portfolios, and market data. For all cases, this will be the Connector.
After that, we call OrderWindow using ShowModal method, if the OK button was clicked in this window, we register the order via the connector using the RegisterOrder method.

We do the same in the order reregistration event handler. Only in this case the event receives the Order object - this is the order that needs to be reregistered. Therefore, in OrderWindow, we specify Order = order.ReRegisterClone(newVolume: order.Balance) to fill in the fields of the OrderWindow window.
After that, we call OrderWindow using ShowModal method, if the OK button was clicked in this window, we will reregister the order via connector using the ReRegisterClone method. We pass to it old order, which should be cancelled, and the new one, which should be registered.

In the order canceling event handler, it is enough to call the CancelOrder method and pass to it the order that need to be canceled.

In order for Orders to be displayed in the OrderGrid, it is necessary in the OrderGridControl constructor to subscribe to new order appearance events and to a registration error event and pass these events to the OrderGrid.

We add the created OrderGridControl panel to the central part of MainWindow.

We run the program to check.

Creating Panel of Own Trades

Similar to the security panel, we create a panel of own trades, add another UserControl to the XAML folder. We call it MyTradeGridControl. We add the MyTradeGrid element to it.

In the MyTradeGridControl constructor, we need to subscribe to the new own trade appearance events and pass it to MyTradeGrid.

We add the created OrderGridControl panel to the central part of MainWindow.

We run the program to check.

Creating Order Book Panel

Similar to the previous panels, we create an order book panel, add another UserControl to the XAML folder. We call it MarketDepthControl.
In MainWindow we have already used LayoutControl, in this control we will also use LayoutControl. We split the panel into two parts horizontally.

We add SecurityPicker to the left side, we use it when we created the security panel.

Let's split the right part into vertical parts. There will be an order book on the top right.

In MarketDepthControl, we need to set some MaxHeight value, otherwise the application will not start.
Below the order book we will place the elements of specifying a portfolio, price, and order volume.

Here it is worth noting the Label property of LayoutItem, it allows to set the text over the element. And also the SpinEdit element from DevExpress, in which it is convenient to set numerical values. These elements look like this.

Even below, we will place the buttons to buy, sell.

Full code.

In the MarketDepthControl constructor, we set the security source for SecurityPicker and the portfolio source for PortfolioComboBox, in our case it will be Connector.

We create a security selection event handler in SecurityPicker. We check in it whether the selected security is not equal to zero. If it is not equal to zero, we save the received security to a local variable, we will need it when updating the order book. After that, we clear and register the received security in Connector to receive an order book using the RegisterMarketDepth method. Using the GetMarketDepth method, we get the current order book on security to update the MarketDepthControl.

To keep the order book updated in the MarketDepthControl constructor, we will subscribe to the MarketDepthChanged order book change event at the connector. In the handler of this event, we will check which security the received order book belongs to, and if it belongs to the security selected in SecurityPicker, we update MarketDepthControl with it.

We add the created MarketDepthControl panel to the central part of MainWindow.

At this stage, we can run the program and check the order book update operation.
We create a buy and sell buttons click event handler. In each handler we create an Order, in which we specify the security selected in SecurityPicker, the portfolio selected in PortfolioComboBox, the volume and price from the corresponding SpinEdit. We register the order in Connector using the RegisterOrder method.

Both handlers differ only by the order direction.
Let's make that the SpinEditPrice value is changed to the selected quote price when selecting a quote in the order book. To do this, we will create a handler for the SelectionChanged event at MarketDepthControl. In which we will update SpinEditPrice value by the price of the selected quote if the selected quote is not equal to zero

We run the program to check.

Saving Market Data

To save portfolios, securities, platforms, we need the CsvEntityRegistry class. We need to pass the entities storage location to it and call the Init method to load them.

To save candles, trades, etc., we will need StorageRegistry.

We will also need the SnapshotRegistry snapshot storages registry.

All this we pass to Connector when it is created.

Here I also specified that Connector will reconnect when the connection is broken, and also specified how many history days should be downloaded.
The Connector.LookupAll(); string queries the available data.

After starting the application, we will see that new folders have appeared in the Date folder.

And when reconnecting the security and portfolio panels will already be filled.

Creating Strategy Panel

I will create the strategy panel just like all previous panels.
We add another UserControl to the XAML folder. We call it StrategyControl. We split the screen form into two parts using the LayoutControl.
There will be a tab with a candle chart on the left side.

As well as a tab with strategy statistics,

Here I use StatisticParameterGrid to display strategy statistics and EquityCurveChart to display profit and loss chart.
In StatisticParameterGrid, we need to set some MaxHeight value, otherwise the application will not start.
The strategy properties in PropertyGridEx will be configured on the right side.

As well as strategy start and stop buttons.

Full code.

In the StrategyControl constructor, we set Connector as a data source for PropertyGridEx, we carried out similar actions in almost every control.

We need to somehow pass the strategy to our control. To do this, in StrategyControl I will create a BindStraregy method that will receive a strategy, save a link to it in the local variable, and also set a strategy in PropertyGridEx and StatisticParameterGrid.
Using the SetChart method, we pass the Chart candle chart to the strategy, after that, the Chart can be obtained in the strategy using the GetChart method. We also set the Connector for the strategy.

When working with the profit and loss chart, it is necessary to take into account that the strategy may start and stop several times, so every time the strategy starts, the chart should be cleared. To do this, let's create the ResetEquityCurveChart method, in which we will first clear EquityCurveChart. After that we need to create graphic elements for EquityCurveChart, for them we can set a name, color and line type.

Then, we subscribe to the PnL change event of the strategy and in this event handler we draw a new value on the EquityCurveChart profit loss chart.

Full method code.

We will call this method in the Start button click event handler. And also we will reset the strategy state and run it.

We will stop the strategy in the Stop button click event handler.

We add the created StrategyControl panel to the central part of MainWindow.

Creating Strategy

For example, let's consider creating a simple strategy with candles. Which will buy if the candle is growing (green), and sell if the candle is falling (red).
Let's create another folder in the project and store all our strategies in it. We create a new class in this folder and call it SimpleStrategy. All S# strategies must be inherited from the base class Strategy.

Since our strategy uses candles, we will create a public property CandleSeries, and set its default value in our strategy constructor.

Here I specified that candles in CandleSeries will be TimeFrameCandle with time span of 15 seconds (TimeSpan.FromSeconds(15)). We can specify the candle creating mode for CandleSeries - BuildCandlesMode. I specified that candles will be built (MarketDataBuildModes.Build), by default they will be built from ticks, but we can specify other data types as well.
Since we made the CandleSeries a public property, the CandleSeries can be additionally configured from the PropertyGridEx described in the previous paragraph.
All strategies have methods that can be overridden, we will need to override the OnStarted method. Which is called before the launch of the strategy and allows to preset its starting state.

Here we set the security for CandleSeries, which is specified in the PropertyGridEx. After that, we create a rule for processing the completed candle. See the documentation for details on working with rules. In the rule we specify the method that will process each completed candle, in our case it is the ProcessCandle method, it will be described later. After everything is set, we subscribe to the appearance of candles on the CandleSeries in connector using the SubscribeCandles method.
In our case, the ProcessCandle method contains the main strategy logic.

First of all, we need to determine whether the candle is real-time or historical, if the candle is historical, we ignore it. Not all strategies require this, for example, for strategies based on order books, this is not required, since order books are always real-time. There is no general way to determine whether a candle is real-time or historical, and in each strategy this problem will have to be solved independently depending on the strategy requirements. In this case, I will simply compare the candle closing time with the connector time, and if it does not exceed a certain lag, then I consider the candle real-time.

Next, we consider what candle it is and what the strategy current position. If the candle is growing, then at a position equal to 0, we will open a position with a market order for the volume set by us in PropertyGridEx. If the candle is growing and the position is less than 0, we reverse the position.

We do opposite actions for a falling candle.

At the moment, our strategy is ready to work. It should be passed to SimpleStrategyControl, which we created in the previous paragraph using the BindStraregy method. We do this in the MainWindow constructor immediately after the MainWindow components are initialized.

We run the program to check.

The strategy works, trades are made, but there are no candles and trades on the chart yet.

Adding Candles and Trades to Chart from Strategy

In the paragraph about the strategy panel, we passed the Chart candle chart to the strategy using the SetChart method. In the OnStarted strategy method, we check whether the strategy has a chart set, and if it is set, then we initialize the chart, as well as subscribe to the events of new own trade appearance and candle change.

InitChart chart initialization method.

Here we save the link to Chart in a local variable. We clear the chart. We also create chart elements for candles and trades and pass them to the chart.
The chart.GuiSync(()=>{ ... }); construct is necessary in order to initialize the chart in the main thread.
CandleSeriesProcessing is a method for drawing candles on a chart.

Here we get a candle from the CandleSeriesProcessing event of the connector, create ChartDrawData to display it on the chart. We specify the time data.Group(candle.OpenTime), specify that the candle should be added to the candle element of the chart .Add(_chartCandleElement, candle);. And we specify that the chart should draw new data.
We perform similar actions for trades.

We run the program to check.

Short conclusion

It is not necessary to spend a lot of time to create a complex and professional-looking application. In a few hours we created the fully-featured application with the ability to configure, display and trade directly.
Do not be afraid to try and create your own programs. I hope this paper will help you get used to this business.