public void Throws()
{
var client = new AggregateTradeWebSocketClient();
Assert.Throws <ArgumentNullException>("symbol", () => client.Subscribe((string)null));
Assert.Throws <ArgumentNullException>("symbol", () => client.Subscribe(string.Empty));
}
/// <summary>
/// Example using manager without DI framework (not recommended).
/// </summary>
// ReSharper disable once InconsistentNaming
// ReSharper disable once UnusedMember.Local
private static void ExampleMainWithoutDI()
{
try
{
// Load configuration.
var configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", true, false)
.Build();
// Get configuration settings.
var symbols = configuration.GetSection("TradeHistory:Symbols").Get <string[]>()
?? new string[] { Symbol.BTC_USDT };
var limit = 25;
try { limit = Convert.ToInt32(configuration.GetSection("TradeHistory")?["Limit"]); }
catch { /* ignore */ }
var loggerFactory = new LoggerFactory();
loggerFactory.AddFile(configuration.GetSection("Logging:File"));
// Initialize all the things... a DI framework could instantiate for you...
var api = new BinanceApi(BinanceHttpClient.Instance, logger: loggerFactory.CreateLogger <BinanceApi>());
var tradeClient = new AggregateTradeClient(loggerFactory.CreateLogger <AggregateTradeClient>());
var webSocket = new DefaultWebSocketClient(logger: loggerFactory.CreateLogger <DefaultWebSocketClient>());
var stream = new BinanceWebSocketStream(webSocket, loggerFactory.CreateLogger <BinanceWebSocketStream>());
var controller = new BinanceWebSocketStreamController(api, stream, loggerFactory.CreateLogger <BinanceWebSocketStreamController>());
var publisher = new BinanceWebSocketStreamPublisher(controller, loggerFactory.CreateLogger <BinanceWebSocketStreamPublisher>());
var client = new AggregateTradeWebSocketClient(tradeClient, publisher, loggerFactory.CreateLogger <AggregateTradeWebSocketClient>());
var cache = new AggregateTradeWebSocketCache(api, client, loggerFactory.CreateLogger <AggregateTradeWebSocketCache>());
// Add error event handler.
controller.Error += (s, e) => HandleError(e.Exception);
foreach (var symbol in symbols)
{
// Subscribe to symbol with callback.
cache.Subscribe(symbol, limit, Display);
lock (_sync)
{
_message = symbol == symbols.Last()
? $"Symbol: \"{symbol}\" ...press any key to exit."
: $"Symbol: \"{symbol}\" ...press any key to continue.";
}
Console.ReadKey(true);
// Unsubscribe from symbol.
cache.Unsubscribe();
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine();
Console.WriteLine(" ...press any key to close window.");
Console.ReadKey(true);
}
}
public async Task SubscribeThrows()
{
var client = new AggregateTradeWebSocketClient(new Mock <IWebSocketClient>().Object);
await Assert.ThrowsAsync <ArgumentNullException>("symbol", () => client.SubscribeAsync(null, new CancellationToken()));
await Assert.ThrowsAsync <ArgumentException>("token", () => client.SubscribeAsync(Symbol.BTC_USDT, CancellationToken.None));
}
public async Task StreamThrows()
{
var client = new AggregateTradeWebSocketClient(new Mock <IWebSocketStream>().Object);
using (var cts = new CancellationTokenSource())
{
await Assert.ThrowsAsync <ArgumentNullException>("symbol", () => client.SubscribeAndStreamAsync(null, cts.Token));
}
}
public void Subscribe()
{
var client = new AggregateTradeWebSocketClient();
Assert.Empty(client.ObservedStreams);
Assert.Empty(client.Stream.ProvidedStreams);
client.Subscribe(Symbol.BTC_USDT);
Assert.True(client.ObservedStreams.Count() == 1);
Assert.True(client.Stream.ProvidedStreams.Count() == 1);
}
public void SubscribeThrows()
{
var client = new AggregateTradeWebSocketClient(new Mock <IWebSocketStream>().Object);
Assert.Throws <ArgumentNullException>("symbol", () => client.Subscribe(null));
}
public static async Task ExampleMain(string[] args)
{
// Initialize REST API client.
var api = new BinanceApi();
// Check connectivity.
if (await api.PingAsync())
{
Console.WriteLine("Successful!");
}
// Create user with API-Key and API-Secret.
using (var user = new BinanceApiUser("<API-Key>", "<API-Secret>"))
{
// Create a client (MARKET) order.
var order = new MarketOrder(user)
{
Symbol = Symbol.BTC_USDT,
Side = OrderSide.Buy,
Quantity = 0.01m
};
try
{
// Validate client order.
order.Validate();
// Send the TEST order.
await api.TestPlaceAsync(order);
Console.WriteLine("Test Order Successful!");
}
catch (Exception e)
{
Console.WriteLine($"Test Order Failed: \"{e.Message}\"");
}
}
// Initialize web socket client (with automatic streaming enabled).
var webSocketClient = new AggregateTradeWebSocketClient();
// Handle error events.
webSocketClient.Error += (s, e) => { Console.WriteLine(e.Exception.Message); };
// Subscribe callback to BTC/USDT (automatically begin streaming).
webSocketClient.Subscribe(Symbol.BTC_USDT, evt =>
{
var side = evt.Trade.IsBuyerMaker ? "SELL" : "BUY ";
// Handle aggregate trade events.
Console.WriteLine($"{evt.Trade.Symbol} {side} {evt.Trade.Quantity} @ {evt.Trade.Price}");
});
Console.ReadKey(true); // wait for user input.
// Unsubscribe from symbol (automatically end streaming).
webSocketClient.Unsubscribe();
// Initiatlize web socket cache (with automatic streaming enabled).
var webSocketCache = new DepthWebSocketCache();
// Handle error events.
webSocketCache.Error += (s, e) => { Console.WriteLine(e.Exception.Message); };
// Subscribe callback to symbol (automatically begin streaming).
webSocketCache.Subscribe(Symbol.BTC_USDT, evt =>
{
// Get symbol from cache (update cache if a symbol is missing).
var symbol = Symbol.Cache.Get(evt.OrderBook.Symbol);
var minBidPrice = evt.OrderBook.Bids.Last().Price;
var maxAskPrice = evt.OrderBook.Asks.Last().Price;
// Handle order book update events.
Console.WriteLine($"Bid Quantity: {evt.OrderBook.Depth(minBidPrice)} {symbol.BaseAsset} - " +
$"Ask Quantity: {evt.OrderBook.Depth(maxAskPrice)} {symbol.BaseAsset}");
});
Console.ReadKey(true); // wait for user input.
// Unsubscribe from symbol (automatically end streaming).
webSocketCache.Unsubscribe();
}
