Conectores

Para trabalhar com bolsas e fontes de dados no S#, recomenda-se usar a classe base Connector.

Vamos examinar o trabalho com Connector. O código-fonte do exemplo pode ser encontrado no projeto Samples/01_Basic/01_ConnectAndDownloadInstruments.

Crie uma instância da classe Connector:

...
public Connector Connector;
...
public MainWindow()
{
	InitializeComponent();
	Connector = new Connector();
	InitConnector();
}

Para configurar o Connector, a API possui uma interface gráfica especial que permite configurar várias conexões simultaneamente. Como usá-la é descrito na seção Configuração gráfica.

...
private readonly IFileSystem _fileSystem = Paths.FileSystem;
private const string _connectorFile = "ConnectorFile.json";
...
private void Setting_Click(object sender, RoutedEventArgs e)
{
	if (Connector.Configure(this))
	{
		Connector.Save().Serialize(_fileSystem, _connectorFile);
	}
}

Da mesma forma, você pode adicionar conexões diretamente pelo código (sem janelas gráficas) usando o método de extensão TraderHelper.AddAdapter<TAdapter>(StockSharp.Algo.Connector connector, System.Action<TAdapter> init ):

...
// Adicionar adaptador para conectar à Binance
connector.AddAdapter<BinanceMessageAdapter>(a =>
{
	a.Key = "<Your API Key>";
	a.Secret = "<Your Secret Key>";
});

// Adicionar RSS para notícias
connector.AddAdapter<RssMessageAdapter>(a =>
{
	a.Address = "https://news-source.com/feed";
});

Você pode adicionar um número ilimitado de conexões a um único objeto Connector. Assim, é possível conectar-se simultaneamente a várias bolsas e corretoras a partir do programa.

No método InitConnector, definimos os manipuladores de eventos necessários para IConnector:

private void InitConnector()
{
	// Assinar evento de conexão bem-sucedida
	Connector.Connected += () =>
	{
		this.GuiAsync(() => ChangeConnectStatus(true));
	};

	// Assinar evento de erro de conexão
	Connector.ConnectionError += error => this.GuiAsync(() =>
	{
		ChangeConnectStatus(false);
		MessageBox.Show(this, error.ToString(), LocalizedStrings.ErrorConnection);
	});

	// Assinar evento de desconexão
	Connector.Disconnected += () => this.GuiAsync(() => ChangeConnectStatus(false));

	// Assinar evento de erro
	Connector.Error += error =>
		this.GuiAsync(() => MessageBox.Show(this, error.ToString(), LocalizedStrings.Str2955));

	// Assinar evento de falha na assinatura de dados de mercado
	Connector.SubscriptionFailed += (subscription, error, isSubscribe) =>
		this.GuiAsync(() => MessageBox.Show(this, error.ToString(),
			LocalizedStrings.Str2956Params.Put(subscription.DataType, subscription.SecurityId)));

	// Assinaturas para recebimento de dados

	// Instruments
	Connector.SecurityReceived += (sub, security) => _securitiesWindow.SecurityPicker.Securities.Add(security);

	// Tick trades
	Connector.TickTradeReceived += (sub, trade) => _tradesWindow.TradeGrid.Trades.TryAdd(trade);

	// Orders
	Connector.OrderReceived += (sub, order) => _ordersWindow.OrderGrid.Orders.TryAdd(order);

	// Own trades
	Connector.OwnTradeReceived += (sub, trade) => _myTradesWindow.TradeGrid.Trades.TryAdd(trade);

	// Positions
	Connector.PositionReceived += (sub, position) => _portfoliosWindow.PortfolioGrid.Positions.TryAdd(position);

	// Falhas no registro de ordens
	Connector.OrderRegisterFailReceived += (sub, fail) => _ordersWindow.OrderGrid.AddRegistrationFail(fail);

	// Falhas no cancelamento de ordens
	Connector.OrderCancelFailReceived += (sub, fail) => OrderFailed(fail);

	// Definir provedor de dados de mercado
	_securitiesWindow.SecurityPicker.MarketDataProvider = Connector;

	try
	{
		if (File.Exists(_connectorFile))
		{
			var ctx = new ContinueOnExceptionContext();
			ctx.Error += ex => ex.LogError();
			using (new Scope<ContinueOnExceptionContext>(ctx))
				Connector.Load(_connectorFile.Deserialize<SettingsStorage>(_fileSystem));
		}
	}
	catch
	{
	}

	ConfigManager.RegisterService<IExchangeInfoProvider>(new InMemoryExchangeInfoProvider());

	// Registrar provedor de adaptadores para configuração gráfica
	ConfigManager.RegisterService<IMessageAdapterProvider>(
		new InMemoryMessageAdapterProvider(Connector.Adapter.InnerAdapters));
}

Como salvar e carregar configurações do Connector em um arquivo pode ser encontrado na seção Salvando e Carregando Configurações.

Informações sobre a criação do seu próprio Connector podem ser encontradas na seção Criando Seu Próprio Conector.

O envio de ordens é descrito nas seções Ordens, Criando uma Nova Ordem, Criando uma Nova Ordem Stop.

Recursos adicionais

IFileSystem e Paths.FileSystem

Use IFileSystem para operações de arquivo, como serializar e desserializar configurações. A instância padrão está disponível através de Paths.FileSystem:

private readonly IFileSystem _fileSystem = Paths.FileSystem;

Os métodos Serialize e Deserialize sem o parâmetro IFileSystem estão marcados como [Obsolete].

Métodos assíncronos de ordens

Os seguintes métodos assíncronos estão disponíveis para trabalhar com ordens:

• RegisterOrderAsync - registra uma ordem de forma assíncrona.
• CancelOrderAsync - cancela uma ordem de forma assíncrona.
• EditOrderAsync - edita uma ordem de forma assíncrona.

SubscriptionsOnConnect

A propriedade SubscriptionsOnConnect controla as assinaturas que são realizadas automaticamente na conexão. Por padrão, inclui assinaturas de instrumentos, portfólios e ordens.

Eventos do adaptador

Os seguintes eventos estão disponíveis para rastrear eventos de adaptadores específicos:

• ConnectedEx - um adaptador específico se conectou.
• DisconnectedEx - um adaptador específico se desconectou.
• ConnectionErrorEx - ocorreu um erro de conexão em um adaptador específico.

Ciclo de vida da assinatura

• SubscriptionStarted - a assinatura foi iniciada.
• SubscriptionOnline - a assinatura mudou para o estado online: os dados históricos foram recebidos e a transmissão de dados em tempo real foi iniciada.
• SubscriptionFailed - erro de assinatura. O terceiro parâmetro, isSubscribe, indica se o erro ocorreu durante a assinatura ou o cancelamento da assinatura.
• SubscriptionStopped - a assinatura foi interrompida.

Veja também

Configuração gráfica