C# IConnector.Connect方法代码示例

        public void SetUp()
        {
            acceptor = new UdpAcceptor(IPAddress.Any, 8765,
                new TransportFactory<UdpHandle>(BaseUdpTransport.SequencedProtocolDescriptor,
                    h => new UdpSequencedServerTestTransport(h),
                    t => t is UdpSequencedServerTestTransport));
            connector = new UdpConnector(
                new TransportFactory<UdpClient>(BaseUdpTransport.SequencedProtocolDescriptor,
                    h => new UdpSequencedClientTestTransport(h),
                    t => t is UdpSequencedClientTestTransport));

            acceptor.NewTransportAccepted += delegate(ITransport transport, IDictionary<string, string> capabilities)
            {
                serverTransport = (UdpSequencedServerTestTransport)transport;
            };
            acceptor.Start();
            Thread acceptorThread = new Thread(delegate()
            {
                for (int i = 0; serverTransport == null && i < 100; i++)
                {
                    try
                    {
                        acceptor.Update();
                        Thread.Sleep(50);
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine("Acceptor Thread: " + e);
                    }
                }
            });
            acceptorThread.IsBackground = true;
            acceptorThread.Name = "Acceptor Thread";
            acceptorThread.Start();
            Thread.Sleep(50);

            clientTransport = (UdpSequencedClientTestTransport)connector.Connect("127.0.0.1", "8765", new Dictionary<string, string>());
            acceptorThread.Join();
            Assert.IsNotNull(clientTransport);
            Assert.IsNotNull(serverTransport);

            acceptor.Dispose();
            connector.Dispose();
        }

        public void TestTransport(IAcceptor acc, IConnector conn, string address, string port)
        {
            acceptor = acc;
            connector = conn;

            acceptor.Start();
            acceptor.NewTransportAccepted += SetupServer;
            acceptorThread = new Thread(RunAcceptor);
            acceptorThread.Name = "Acceptor";
            acceptorThread.IsBackground = true;
            acceptorThread.Start();

            client = connector.Connect(address, port, new Dictionary<string, string>());
            Assert.IsNotNull(client);
            client.PacketReceived += ClientReceivedPacket;

            for (int i = 0; i < 10; i++)
            {
                sourceData[0] = (byte)i;
                Debug("client: sending packet#" + i + ": "
                    + ByteUtils.DumpBytes(sourceData, 0, sourceData.Length));
                client.SendPacket(new TransportPacket(sourceData));
                if (failure.Length != 0)
                {
                    Assert.Fail(failure);
                }
                Thread.Sleep(500);
                client.Update();
            }
            Assert.AreEqual(10, serverPacketCount);
            Assert.AreEqual(10, clientPacketCount);

            try
            {
                client.SendPacket(new TransportPacket(new byte[client.MaximumPacketSize * 2]));
                Assert.Fail("Transport allowed sending packets exceeding its capacity");
            }
            catch (ContractViolation) { /* expected */ }
        }

		private void ConnectClick(object sender, RoutedEventArgs e)
		{
			var isDde = IsDde.IsChecked == true;

			if (isDde && Path.Text.IsEmpty())
			{
				MessageBox.Show(this, LocalizedStrings.Str2969);
				return;
			}

			if (Connector != null && !(Connector is FakeConnector))
				return;

			PosChart.Positions.Clear();
			PosChart.AssetPosition = null;
			PosChart.Refresh(1, 1, default(DateTimeOffset), default(DateTimeOffset));

			// создаем подключение
			Connector = new QuikTrader(Path.Text)
			{
				IsDde = isDde
			};

			if (isDde)
			{
				// изменяем метаданные так, чтобы начали обрабатывать дополнительные колонки опционов
				var columns = ((QuikTrader)Connector).SecuritiesTable.Columns;
				columns.Add(DdeSecurityColumns.Strike);
				columns.Add(DdeSecurityColumns.ImpliedVolatility);
				columns.Add(DdeSecurityColumns.UnderlyingSecurity);
				columns.Add(DdeSecurityColumns.TheorPrice);
				columns.Add(DdeSecurityColumns.OptionType);
				columns.Add(DdeSecurityColumns.ExpiryDate);
			}

			//_trader = new PlazaTrader { IsCGate = true };
			//_trader.Tables.Add(_trader.TableRegistry.Volatility);

			Portfolio.Connector = Connector;

			PosChart.MarketDataProvider = Connector;
			PosChart.SecurityProvider = Connector;

			// добавляем базовые активы в список
			Connector.NewSecurities += securities =>
				_assets.AddRange(securities.Where(s => s.Type == SecurityTypes.Future));

			Connector.SecuritiesChanged += securities =>
			{
				if ((PosChart.AssetPosition != null && securities.Contains(PosChart.AssetPosition.Security)) || PosChart.Positions.Cache.Select(p => p.Security).Intersect(securities).Any())
					_isDirty = true;
			};

			// подписываемся на событие новых сделок чтобы обновить текущую цену фьючерса
			Connector.NewTrades += trades =>
			{
				var assetPos = PosChart.AssetPosition;
				if (assetPos != null && trades.Any(t => t.Security == assetPos.Security))
					_isDirty = true;
			};

			Connector.NewPositions += positions => this.GuiAsync(() =>
			{
				var asset = SelectedAsset;

				if (asset == null)
					return;

				var assetPos = positions.FirstOrDefault(p => p.Security == asset);
				var newPos = positions.Where(p => p.Security.UnderlyingSecurityId == asset.Id).ToArray();

				if (assetPos == null && newPos.Length == 0)
					return;

				if (assetPos != null)
					PosChart.AssetPosition = assetPos;

				if (newPos.Length > 0)
					PosChart.Positions.AddRange(newPos);

				RefreshChart();
			});

			Connector.PositionsChanged += positions => this.GuiAsync(() =>
			{
				if ((PosChart.AssetPosition != null && positions.Contains(PosChart.AssetPosition)) || positions.Intersect(PosChart.Positions.Cache).Any())
					RefreshChart();
			});

			Connector.Connect();
		}