public void TestOneWayCallbackConcurencyOnNamedPipe() { var address = @"net.pipe://127.0.0.1/testpipename" + MethodBase.GetCurrentMethod().Name; var srv = new CallbackService(); var callback = new CallbackServiceCallback(); using (var server = new ServiceHost(srv, new Uri(address))) { server.AddServiceEndpoint(typeof(ICallbackService), new NetNamedPipeBinding { }, address); server.Open(); using (var channelFactory = new DuplexChannelFactory<ICallbackService>(new InstanceContext(callback), new NetNamedPipeBinding { })) { var client = channelFactory.CreateChannel(new EndpointAddress(address)); for (int i = 0; i < 20; i++) client.OneWayExecute(); while (callback.Count != 20) { Thread.Sleep(10); } } } }
public RobotClient() { // Initilize communication channel DuplexChannelFactory = new DuplexChannelFactory<IUiPathRemoteDuplexContract>(new InstanceContext(this), "DefaultDuplexEndpoint"); DuplexChannelFactory.Credentials.Windows.AllowedImpersonationLevel = System.Security.Principal.TokenImpersonationLevel.Impersonation; Channel = DuplexChannelFactory.CreateChannel(); }
public void CallAsync_wait_done() { var address = @"net.pipe://127.0.0.1/" + this.GetType().Name + "_" + MethodBase.GetCurrentMethod().Name; var binding = new NetNamedPipeBinding(); var done = new ManualResetEvent(false); var srv = new AsyncService(done); var callback = new AsyncServiceCallback(); using (var host = new ServiceHost(srv, new Uri(address))) { host.AddServiceEndpoint(typeof(IAsyncService), binding, address); host.Open(); ThreadPool.QueueUserWorkItem(_ => { using (var factory = new DuplexChannelFactory<IAsyncService>(new InstanceContext(callback), binding)) { var client = factory.CreateChannel(new EndpointAddress(address)); AsyncCallback act = (x) => { Assert.AreEqual(x.AsyncState, 1); }; var result = client.BeginServiceAsyncMethod(act, 1); result.AsyncWaitHandle.WaitOne(); Assert.AreEqual(result.AsyncState, 1); client.EndServiceAsyncMethod(result); } }); done.WaitOne(); } }
public MainWindow() { InitializeComponent(); EndpointAddress endpointAddress = new EndpointAddress("http://localhost:31337/BesiegedServer/BesiegedMessage"); DuplexChannelFactory<IBesiegedServer> duplexChannelFactory = new DuplexChannelFactory<IBesiegedServer>(m_Client, new WSDualHttpBinding(), endpointAddress); m_BesiegedServer = duplexChannelFactory.CreateChannel(); // Subscribe in a separate thread to preserve the UI thread Task.Factory.StartNew(() => { CommandConnect commandConnect = new CommandConnect(); m_BesiegedServer.SendMessage(commandConnect.ToXml()); }); Task.Factory.StartNew(() => { while (true) { Command command = m_Client.MessageQueue.Take(); ProcessMessage(command); } }, TaskCreationOptions.LongRunning); GameLobbyCollection = new ObservableCollection<CommandNotifyGame>(); DataContext = this; }
//其他成员 private void MonitorForm_Load(object sender, EventArgs e) { string header = string.Format("{0, -13}{1, -22}{2}", "Client", "Time", "Event"); this.listBoxExecutionProgress.Items.Add(header); _syncContext = SynchronizationContext.Current; _callbackInstance = new InstanceContext(new CalculatorCallbackService()); _channelFactory = new DuplexChannelFactory<ICalculator>(_callbackInstance, "calculatorservice"); EventMonitor.MonitoringNotificationSended += ReceiveMonitoringNotification; this.Disposed += delegate { EventMonitor.MonitoringNotificationSended -= ReceiveMonitoringNotification; _channelFactory.Close(); }; for (int i = 0; i < 2; i++) { ThreadPool.QueueUserWorkItem(state => { int clientId = Interlocked.Increment(ref _clientId); EventMonitor.Send(clientId, EventType.StartCall); ICalculator proxy = _channelFactory.CreateChannel(); using (OperationContextScope contextScope = new OperationContextScope(proxy as IContextChannel)) { MessageHeader<int> messageHeader = new MessageHeader<int>(clientId); OperationContext.Current.OutgoingMessageHeaders.Add(messageHeader.GetUntypedHeader(EventMonitor.CientIdHeaderLocalName, EventMonitor.CientIdHeaderNamespace)); proxy.Add(1, 2); } EventMonitor.Send(clientId, EventType.EndCall); }, null); } }
public static void RequestResponseOverWebSocketManually_Echo_RoundTrips_Guid() { DuplexChannelFactory<IWcfDuplexService> factory = null; Guid guid = Guid.NewGuid(); NetHttpBinding binding = new NetHttpBinding(); binding.WebSocketSettings.TransportUsage = WebSocketTransportUsage.Always; WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callbackService); try { factory = new DuplexChannelFactory<IWcfDuplexService>(context, binding, new EndpointAddress(Endpoints.NetHttpWebSocketTransport_Address)); IWcfDuplexService duplexProxy = factory.CreateChannel(); Task.Run(() => duplexProxy.Ping(guid)); Guid returnedGuid = callbackService.CallbackGuid; Assert.True(guid == returnedGuid, string.Format("The sent GUID does not match the returned GUID. Sent '{0}', Received: '{1}'", guid, returnedGuid)); } finally { if (factory != null && factory.State != CommunicationState.Closed) { factory.Abort(); } } }
private void StartP2PClient( ) { string s = ConfigurationManager.AppSettings["IsSupportGroup"]; if (s.Equals("no", StringComparison.OrdinalIgnoreCase)) { return; } InstanceContext context = new InstanceContext(new P2PChatService()); DuplexChannelFactory<IP2PChatService> factory = new DuplexChannelFactory<IP2PChatService>(context,"p2p", new EndpointAddress("net.p2p://" + groupId)); channel = factory.CreateChannel(); clients.Add(groupId, this); new Thread(new ThreadStart(() => { try { channel.Join(); } catch (Exception ex) { MyLogger.Logger.Error("进入群组聊天室时出错",ex); } })).Start(); }
public MainWindow(string s) { InitializeComponent(); //initialize the connections try { DuplexChannelFactory<IDealer> channel = new DuplexChannelFactory<IDealer>(this, "DealerEndPoint"); //activate the dealer object. dealer = channel.CreateChannel(); //does this in turn call the dealer constructor?? myCallbackKey = dealer.PlayerJoin(s); lblMoney.Content = 2000; cmboNumber.ItemsSource = dealer.RouletteWheel; cmboNumber.DisplayMemberPath = "Key"; cmboRange.Items.Add("1-12"); cmboRange.Items.Add("13-24"); cmboRange.Items.Add("25-36"); cmboColor.Items.Add("Red"); cmboColor.Items.Add("Black"); cmboOddEven.Items.Add("Odd"); cmboOddEven.Items.Add("Even"); } catch (Exception ex) { MessageBox.Show("Error starting the service: " + ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error); } }
public ClientViewModel() { var channelFactory = new DuplexChannelFactory<IChattingService>(new ClientService(), "ChattingServiceEndPoint"); _server = channelFactory.CreateChannel(); This = this; CreateCommands(); }
public bool Connect(ClientCrawlerInfo clientCrawlerInfo) { try { var site = new InstanceContext(this); var binding = new NetTcpBinding(SecurityMode.None); //var address = new EndpointAddress("net.tcp://localhost:22222/chatservice/"); var address = new EndpointAddress("net.tcp://193.124.113.235:22222/chatservice/"); var factory = new DuplexChannelFactory<IRemoteCrawler>(site, binding, address); proxy = factory.CreateChannel(); ((IContextChannel)proxy).OperationTimeout = new TimeSpan(1, 0, 10); clientCrawlerInfo.ClientIdentifier = _singletoneId; proxy.Join(clientCrawlerInfo); return true; } catch (Exception ex) { MessageBox.Show("Error happened" + ex.Message); return false; } }
public RegisterViewModel() { var channelFactory = new DuplexChannelFactory<IChattingService>(new ClientService(), "ChattingServiceEndPoint"); _server = channelFactory.CreateChannel(); Register = new RelayCommand(OnRegister, () => !(string.IsNullOrEmpty(UserName) || string.IsNullOrEmpty(Password))); ClearCommand = new RelayCommand(OnClear); }
public static void ConnectIpc(IServiceRemotingCallback serviceRemotingCallback) { InstanceContext instanceContext = new InstanceContext(serviceRemotingCallback); PipeFactory = new DuplexChannelFactory<IServiceRemoting>(instanceContext, new NetNamedPipeBinding(), new EndpointAddress("net.pipe://localhost/BitCollectors.PlinkService/PlinkService")); RemotingObject = PipeFactory.CreateChannel(); }
static void Main(string[] args) { Console.Title = "Client"; Console.WriteLine("Press any key to connect to server"); Console.ReadKey(); // InstanceContext - представляет метод вызываемый сервисом на клиенте. InstanceContext context = new InstanceContext(new Context()); // Создаем фабрику дуплексных каналов на клиенте. DuplexChannelFactory<IContractService> factory = new DuplexChannelFactory<IContractService>( context, new NetTcpBinding(), "net.tcp://localhost:9000/MyService" ); // Создаем конкретный канал. IContractService server = factory.CreateChannel(); server.ServerMethod(); Console.WriteLine("Connected"); Console.ReadKey(); Console.ReadKey(); }
static void Main(string[] args) { var fact = new ChannelFactory<IDeviceManagerService>("deviceEndpoint"); InstanceContext callback = new InstanceContext(new ServiceCallback()); var dup = new DuplexChannelFactory<ICardReaderEventsSubscribe>(callback, "dupSocket"); var cardReaderSub = dup.CreateChannel(); var cha = fact.CreateChannel(); using (fact) { var devices = cha.GetAllDevices(); //cha.Open(new devices[0].FullSerialNumber ); } Console.WriteLine("try a new"); Console.ReadKey(); Console.WriteLine("REading duplex"); cardReaderSub.SubscribeToCardSwipeByhost("Local"); Console.ReadKey(); var fact1 = new ChannelFactory<IDeviceManagerService>("deviceEndpoint"); var cha1 = fact1.CreateChannel(); using (fact1) { var devices = cha1.GetAllDevices(); } }
public MainWindow() { try { //Center the window on startup WindowStartupLocation = System.Windows.WindowStartupLocation.CenterScreen; InitializeComponent(); createGrid(); // Configure the Endpoint details DuplexChannelFactory<ITileBag> channel = new DuplexChannelFactory<ITileBag>(this, "TileBag"); // Activate a remote Bag object bag = channel.CreateChannel(); // Register this client for the callback service bag.RegisterForCallbacks(); lblPlayerScore.Content = 0; pWin = new PlayerLobby(this, bag.ClientCount); pWin.Show(); this.Hide(); } catch (Exception ex) { MessageBox.Show("Error Initializing Window " + ex.Message); } }
/// <summary> /// Connect to game server /// </summary> /// <param name="IP"></param> /// <returns></returns> public bool Connect(String IP) { // Create a pipeFactory DuplexChannelFactory<IMessage> pipeFactory = new DuplexChannelFactory<IMessage>( new InstanceContext(this), new NetTcpBinding(), //new EndpointAddress(String.Format("net.tcp://{0}:8000/GameServer", IP))); new EndpointAddress(String.Format("net.tcp://{0}:8000/GameServer", "localhost"))); try { // Creating the communication channel pipeProxy = pipeFactory.CreateChannel(); // register for events pipeProxy.Subscribe(); // join the game myID = pipeProxy.join(me.Username, me.money, me.numOfGames, me.ID); if (pipeProxy.runningGame()) { pipeProxy.resetGame(); } return true; } catch (Exception e) { return false; } }
public static void NetTcpBinding_DuplexCallback_ReturnsXmlComplexType() { DuplexChannelFactory<IWcfDuplexService_Xml> factory = null; NetTcpBinding binding = null; WcfDuplexServiceCallback callbackService = null; InstanceContext context = null; IWcfDuplexService_Xml serviceProxy = null; Guid guid = Guid.NewGuid(); try { binding = new NetTcpBinding(); binding.Security.Mode = SecurityMode.None; callbackService = new WcfDuplexServiceCallback(); context = new InstanceContext(callbackService); factory = new DuplexChannelFactory<IWcfDuplexService_Xml>(context, binding, new EndpointAddress(Endpoints.Tcp_NoSecurity_XmlDuplexCallback_Address)); serviceProxy = factory.CreateChannel(); serviceProxy.Ping_Xml(guid); XmlCompositeTypeDuplexCallbackOnly returnedType = callbackService.XmlCallbackGuid; // validate response Assert.True((guid.ToString() == returnedType.StringValue), String.Format("The Guid to string value sent was not the same as what was returned.\nSent: {0}\nReturned: {1}", guid.ToString(), returnedType.StringValue)); ((ICommunicationObject)serviceProxy).Close(); factory.Close(); } finally { ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
public void btnUpload_Click(object sender, EventArgs e) { MediaDto mediaInfo = proxy.UploadRequest(String.Empty); var tcpBinding = new NetTcpBinding { Security = { Mode = SecurityMode.None, Transport = {ClientCredentialType = TcpClientCredentialType.Windows}, Message = {ClientCredentialType = MessageCredentialType.Windows} }, ReliableSession = {Enabled = true} }; var tcpAddress = new EndpointAddress("net.tcp://" + mediaInfo.Address + ":" + mediaInfo.Port + "/MediaService"); mediaChannelFactory = new DuplexChannelFactory<IMediaContract>(new InstanceContext(new MediaServiceCallBack()), tcpBinding, tcpAddress); mediaChannelFactory.Closing += delegate { mediaContract = null; mediaChannelFactory = null; }; mediaContract = mediaChannelFactory.CreateChannel(); mediaContract.SayHello("Upload test."); }
public MainWindow() { InitializeComponent(); try { // Configure the ABCs of using CardsLibrary DuplexChannelFactory<IWordList> channel = new DuplexChannelFactory<IWordList>(this, "WordFunEndPoint"); // Activate a WordList object words = channel.CreateChannel(); // Register for callbacks callbackId = words.RegisterForCallbacks(); _countdownTimer = new DispatcherTimer(); _countdownTimer.Interval = new TimeSpan(0, 0, 1); _countdownTimer.Tick += new EventHandler(CountdownTimerStep); } catch (Exception ex) { MessageBox.Show(ex.Message); } }
public ApplicationManager(IMessengerManager messenger, ITranslationManager translation, IConfigurationManager configuration, IUserManager user, INotifyIconManager notifyIcon, IEventLogManager logger, IControllerConfigurationManager controller, IThemeManager theme) { Messenger = messenger; Translation = translation; Configuration = configuration; User = user; NotifyIcon = notifyIcon; Logger = logger; Controller = controller; Theme = theme; Logger.Initialize(Constants.SERVICE_NAME); Logger.Subscribe(param => Messenger.NotifyColleagues(AppMessages.NEW_LOG_MESSAGE, param.Entry)); string a = Configuration.GetData(ConfOptions.OPTION_ACCENT); string t = Configuration.GetData(ConfOptions.OPTION_THEME); Theme.SetTheme(a, t); Translation.ChangeLanguage(Configuration.GetData(ConfOptions.OPTION_LANGUAGE)); DuplexChannelFactory<ISubscribingService> pipeFactory = new DuplexChannelFactory<ISubscribingService>(new ServiceCommand(Messenger), new NetNamedPipeBinding(), new EndpointAddress(Constants.PIPE_ADDRESS + Constants.SERVICE_NAME)); Service = pipeFactory.CreateChannel(); Service.Subscribe(); }
private void submitButton_Click(object sender, RoutedEventArgs e) { var login = loginTextBox.Text; var pass = passwordTextBox.Password; Action<String> status = s => { statusLabel.Content = s; statusLabel.ToolTip = s; }; try { channelFactory = new DuplexChannelFactory<IService>(new ClientImplementation(_MainWindow), "DnDServiceEndPoint"); server = channelFactory.CreateChannel(); if (server.Login(login, pass)) { _MainWindow.InitializeServer(channelFactory, server); this.DialogResult = true; } else { statusLabel.Content = "Login lub hasło nie są poprawne!"; return; } } catch (Exception ex) { statusLabel.Content = "Nastąpił błąd! Spróbuj ponownie"; System.IO.StreamWriter file = new System.IO.StreamWriter("log.txt"); file.WriteLine(ex.ToString()); file.Close(); return; } this.Close(); }
public void connect(String url, IAudioServiceCallBack callback, EventHandler openedEvt = null, EventHandler faultEvt = null) //url = "net.tcp://localhost:8080/AudioService" { try { duplex = new DuplexChannelFactory<IAudioService>(callback, new NetTcpBinding(), new EndpointAddress(url)); service = duplex.CreateChannel(); channel = (ICommunicationObject)service; IClientChannel c = (IClientChannel)channel; c.OperationTimeout = TimeSpan.FromSeconds(5); channel.Opened += new EventHandler(delegate(object o, EventArgs e) { Console.WriteLine("Connection ok!"); }); if(openedEvt != null) channel.Opened += openedEvt; if(faultEvt != null) channel.Faulted += faultEvt; channel.Faulted += new EventHandler(delegate(object o, EventArgs e) { Console.WriteLine("Connection lost"); }); } catch (Exception e) { Console.WriteLine("Connection error: " + e.Message); } }
public static void ServiceContract_TypedProxy_AsyncTask_CallbackReturn() { DuplexChannelFactory<IWcfDuplexTaskReturnService> factory = null; Guid guid = Guid.NewGuid(); NetTcpBinding binding = new NetTcpBinding(); binding.Security.Mode = SecurityMode.None; DuplexTaskReturnServiceCallback callbackService = new DuplexTaskReturnServiceCallback(); InstanceContext context = new InstanceContext(callbackService); try { factory = new DuplexChannelFactory<IWcfDuplexTaskReturnService>(context, binding, new EndpointAddress(Endpoints.Tcp_NoSecurity_TaskReturn_Address)); IWcfDuplexTaskReturnService serviceProxy = factory.CreateChannel(); Task<Guid> task = serviceProxy.Ping(guid); Guid returnedGuid = task.Result; Assert.Equal(guid, returnedGuid); factory.Close(); } finally { if (factory != null && factory.State != CommunicationState.Closed) { factory.Abort(); } } }
public static void Test() { string baseAddress = "net.tcp://" + Environment.MachineName + ":8000/Service"; ServiceHost host = new ServiceHost(typeof(Service), new Uri(baseAddress)); host.AddServiceEndpoint(typeof(ITest), new NetTcpBinding(SecurityMode.None), ""); host.Open(); Console.WriteLine("Host opened"); AutoResetEvent evt = new AutoResetEvent(false); MyCallback callback = new MyCallback(evt); DuplexChannelFactory<ITest> factory = new DuplexChannelFactory<ITest>( new InstanceContext(callback), new NetTcpBinding(SecurityMode.None), new EndpointAddress(baseAddress)); ITest proxy = factory.CreateChannel(); Console.WriteLine(proxy.Hello("foo bar")); evt.WaitOne(); ((IClientChannel)proxy).Close(); factory.Close(); Console.Write("Press ENTER to close the host"); Console.ReadLine(); host.Close(); }
public MainWindow() { InitializeComponent(); //Initialization Code try { // Configure the Endpoint details DuplexChannelFactory<IPig> channel = new DuplexChannelFactory<IPig>(this, "Pig"); // Activate a remote Shoe object pig = channel.CreateChannel(); // Regsister this client for the callbacks service callbackId = pig.RegisterForCallbacks(); // If they join after the game is started, this player will not be included in the game if( callbackId == 0 ) { MessageBox.Show("Game has already started"); this.Close(); } this.Title = "Hello Player " + callbackId; } catch (Exception ex) { MessageBox.Show(ex.Message); } }
public OrationiSlave() { Binding binding = new NetTcpBinding(SecurityMode.None); EndpointAddress defaultEndpointAddress = new EndpointAddress("net.tcp://localhost:57344/Orationi/Master/v1/"); EndpointAddress discoveredEndpointAddress = DiscoverMaster(); ContractDescription contractDescription = ContractDescription.GetContract(typeof(IOrationiMasterService)); ServiceEndpoint serviceEndpoint = new ServiceEndpoint(contractDescription, binding, discoveredEndpointAddress ?? defaultEndpointAddress); var channelFactory = new DuplexChannelFactory<IOrationiMasterService>(this, serviceEndpoint); try { channelFactory.Open(); } catch (Exception ex) { channelFactory?.Abort(); } try { _masterService = channelFactory.CreateChannel(); _communicationObject = (ICommunicationObject)_masterService; _communicationObject.Open(); } catch (Exception ex) { if (_communicationObject != null && _communicationObject.State == CommunicationState.Faulted) _communicationObject.Abort(); } }
public RemoteExecutorClient(string hostname) { _executorServiceCallback = new RemoteExecutorCallback(); var context = new InstanceContext(_executorServiceCallback); // TODO: Process more than this single Endpoint named "NetTcpBinding_IExecutorService". // What about InstanceContext. Do we need another one if more than one Endpoint is parameterized. // Will it be usefull to offer more than one endpoint? // -> It will be usefull. What about offering chooseable predefined Endpoints? Eg.: NamedPipe or TCP. // .) NamedPipe will be used for local Executors or for the "Send a message to the Executor" Service. // .) TCP will be used for Executors on other machines. var uri = new Uri("net.tcp://" + hostname + ":9000/RExServer"); EndpointIdentity identity = EndpointIdentity.CreateSpnIdentity("RExTheMighty"); _channelFactory = new DuplexChannelFactory<IRemoteExecutor>( context, new NetTcpBinding(), new EndpointAddress(uri, identity)); _reconnectTimer = new System.Timers.Timer(ReconnectTimeout) {AutoReset = false}; // Wait after channel failure before reconnect. _reconnectTimer.Elapsed += (s, e) => { try { if (!_isConnected) { Connect(); } } catch (Exception ex) { Log.Trace("Failed to reconnect: "+ ex.Message); } }; _isConnected = false; }
public static void RequestResponseOverWebSocketManually_Echo_RoundTrips_Guid() { DuplexChannelFactory<IWcfDuplexService> factory = null; IWcfDuplexService duplexProxy = null; Guid guid = Guid.NewGuid(); try { // *** SETUP *** \\ NetHttpBinding binding = new NetHttpBinding(); binding.WebSocketSettings.TransportUsage = WebSocketTransportUsage.Always; WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callbackService); factory = new DuplexChannelFactory<IWcfDuplexService>(context, binding, new EndpointAddress(Endpoints.NetHttpWebSocketTransport_Address)); duplexProxy = factory.CreateChannel(); // *** EXECUTE *** \\ Task.Run(() => duplexProxy.Ping(guid)); Guid returnedGuid = callbackService.CallbackGuid; // *** VALIDATE *** \\ Assert.True(guid == returnedGuid, string.Format("The sent GUID does not match the returned GUID. Sent '{0}', Received: '{1}'", guid, returnedGuid)); // *** CLEANUP *** \\ factory.Close(); ((ICommunicationObject)duplexProxy).Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)duplexProxy, factory); } }
static void Main(string[] args) { try { DuplexChannelFactory<IServerWithCallback> cf = new DuplexChannelFactory<IServerWithCallback>( new CallbackImpl(), new NetTcpBinding(), new EndpointAddress("net.tcp://192.168.1.1:9078/DataService")); IServerWithCallback srv = cf.CreateChannel(); CounterStatues cs = new CounterStatues { CounterName = "Counter eeee", CounterNumber = "ttt", CounterStatus =CounterStatues.CounterStatusEn.Lock, UserId = "yahoo", IpAddress = "192.168.50.90" }; srv.StartDataOutput(cs); System.Threading.ParameterizedThreadStart pt = new System.Threading.ParameterizedThreadStart(ServerChecker); System.Threading.Thread checkserver = new System.Threading.Thread(pt); checkserver.Start(srv); Console.Read(); } catch (Exception ex) { Console.WriteLine(ex.Message); Console.WriteLine("Try again ..."); System.Threading.Thread.Sleep(600); Main(null); } }
/// <summary> /// 截获从Client端发送的消息转发到目标终结点并获得返回值给Client端 /// </summary> /// <param name="requestMessage"></param> /// <returns></returns> public Message ProcessMessage(Message requestMessage) { //Binding binding = null; EndpointAddress endpointAddress = null; GetServiceEndpoint(requestMessage, out endpointAddress); IDuplexRouterCallback callback = OperationContext.Current.GetCallbackChannel<IDuplexRouterCallback>(); NetTcpBinding tbinding = new NetTcpBinding("netTcpExpenseService_ForSupplier"); using (DuplexChannelFactory<IRouterService> factory = new DuplexChannelFactory<IRouterService>(new InstanceContext(null, new DuplexRouterCallback(callback)), tbinding, endpointAddress)) { factory.Endpoint.Behaviors.Add(new MustUnderstandBehavior(false)); IRouterService proxy = factory.CreateChannel(); using (proxy as IDisposable) { // 请求消息记录 IClientChannel clientChannel = proxy as IClientChannel; //Console.WriteLine(String.Format("Request received at {0}, to {1}\r\n\tAction: {2}", DateTime.Now, clientChannel.RemoteAddress.Uri.AbsoluteUri, requestMessage.Headers.Action)); if (WcfServerManage.IsDebug) hostwcfMsg(DateTime.Now, String.Format("路由请求消息发送: {0}", clientChannel.RemoteAddress.Uri.AbsoluteUri)); // 调用绑定的终结点的服务方法 Message responseMessage = proxy.ProcessMessage(requestMessage); // 应答消息记录 //Console.WriteLine(String.Format("Reply received at {0}\r\n\tAction: {1}", DateTime.Now, responseMessage.Headers.Action)); //Console.WriteLine(); //hostwcfMsg(DateTime.Now, String.Format("应答消息: {0}", responseMessage.Headers.Action)); return responseMessage; } } }
static void Main(string[] args) { AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException); InstanceContext context = new InstanceContext(new ConsoleCallback()); _factory = new DuplexChannelFactory <IRemoteConsole>(context, _endpointName); while (true) { IRemoteConsole remoteConsole = connectToServer(); if (remoteConsole == null) { return; } DoWork(remoteConsole); } }
/// <summary> /// 在用户登录UMP或智能客户端时 调用此方法 可更新用户在线信息 /// </summary> public void Login() { try { NetTcpBinding binding = CommonFuncs.CreateNetTcpBinding(); EndpointAddress myEndpoint = CommonFuncs.CreateEndPoint(session.AppServerInfo.Address, "8083"); DuplexChannelFactory <IService16001Channel> fac = new DuplexChannelFactory <IService16001Channel>(this, binding, myEndpoint); iClient = fac.CreateChannel(); iClient.LoginSystem(session); } catch (Exception ex) { MessageBox.Show(ex.Message); } }
public static ServiceHelper Create() { ServiceHelper helper = new ServiceHelper(); CallbackClient callbackClient = new CallbackClient(); InstanceContext context = new InstanceContext(callbackClient); DuplexChannelFactory <IManagementService> factory = new DuplexChannelFactory <IManagementService>( context, new NetNamedPipeBinding(), new EndpointAddress("net.pipe://localhost/Wingnut")); helper.Channel = factory.CreateChannel(); return(helper); }
// valid address, but the scheme is incorrect public static void CreateChannel_BasicHttpBinding_Throws_InvalidOperation() { WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callback); Binding binding = new BasicHttpBinding(BasicHttpSecurityMode.None); // Contract requires Duplex, but Binding 'BasicHttpBinding' doesn't support it or isn't configured properly to support it. var exception = Assert.Throws <InvalidOperationException>(() => { DuplexChannelFactory <IWcfDuplexService> factory = new DuplexChannelFactory <IWcfDuplexService>(context, binding, "http://basichttp-not-duplex"); factory.CreateChannel(); }); Assert.True(exception.Message.Contains("BasicHttpBinding"), string.Format("InvalidOperationException exception string should contain 'BasicHttpBinding'. Actual message:\r\n" + exception.ToString())); }
/// <summary> /// 生成透明代理类 /// </summary> /// <returns></returns> ImyService createClient() { //设置nettcp NetTcpBinding ws = new NetTcpBinding(); ws.MaxReceivedMessageSize = 2147483647; ws.MaxBufferPoolSize = 2147483647; ws.MaxReceivedMessageSize = 2147483647; ws.ReaderQuotas.MaxStringContentLength = 2147483647; ws.Security.Mode = SecurityMode.None; //通过回调函数,bingding,和address 就不用config了 DuplexChannelFactory <ImyService> mcf = new DuplexChannelFactory <ImyService>(this, ws, address); return(mcf.CreateChannel()); }
/// <summary> /// This method is opening channel to the NMS /// </summary> private void OpenChannel() { DuplexChannelFactory <INMSSubscriber> factory = new DuplexChannelFactory <INMSSubscriber>( new InstanceContext(instance), new NetTcpBinding(), new EndpointAddress("net.tcp://localhost:10010/INMSSubscriber")); try { proxy = factory.CreateChannel(); } catch (Exception ex) { Console.WriteLine(ex.Message); } }
public PlayerCommunicationClient(Guid serverId) { //var factory = new DuplexChannelFactory<PlayerCommunicationServiceInterface>(new InstanceContext(this), new NetNamedPipeBinding(), new EndpointAddress($"net.pipe://localhost/LogRecorderAndPlayer/{serverId.ToString().Replace("-", "")}/{serverId.ToString().Replace("-", "")}")); var binding = new NetNamedPipeBinding(); binding.Security.Mode = NetNamedPipeSecurityMode.None; binding.Security.Transport.ProtectionLevel = ProtectionLevel.None; var factory = new DuplexChannelFactory <PlayerCommunicationServiceInterface>(new InstanceContext(this), binding, new EndpointAddress($"net.pipe://localhost/{serverId.ToString().Replace("-", "")}/LRAPService{serverId.ToString().Replace("-", "")}")); // var factory = new DuplexChannelFactory<INamedPipeService>(new InstanceContext(this), new NetNamedPipeBinding(), new EndpointAddress($"net.pipe://localhost/{serverId.ToString().Replace("-", "")}/LRAPService")); Proxy = factory.CreateChannel(); ((IClientChannel)Proxy).Faulted += NamedPipeClient_Faulted; ((IClientChannel)Proxy).Opened += NamedPipeClient_Opened; ((IClientChannel)Proxy).Open(); }
// Connect to the service public void connect() { var binding = new NetTcpBinding(); var endpoint = new EndpointAddress("net.tcp://localhost:9000/IGameService"); var channelFactory = new DuplexChannelFactory <IServiceInterface>(callback, binding, endpoint); try { connection = channelFactory.CreateChannel(); getCommObj().Open(); } catch (Exception ex) { Trace.WriteLine("Exception on connecting to service: " + ex); } }
private void Disconnect() { if (factory != null) { try { factory.Close(TimeSpan.FromSeconds(2.0)); } catch (TimeoutException) { factory.Abort(); } } factory = null; }
public static T Get <T>(string connectionString, object callbackImplementation, IEndpointBehavior behavior = null) { PropertyString connectionProperties = new PropertyString(connectionString); bool isWindowsCredential; NetTcpBinding binding = getBinding(connectionProperties, out isWindowsCredential); EndpointAddress endPointAddress = getEndPoint(connectionProperties, isWindowsCredential); InstanceContext instanceContext = new InstanceContext(callbackImplementation); DuplexChannelFactory <T> factory = new DuplexChannelFactory <T>(instanceContext, binding, endPointAddress); if (behavior != null) { factory.Endpoint.EndpointBehaviors.Add(behavior); } setupFactory(factory, connectionProperties, isWindowsCredential); return(factory.CreateChannel()); }
public void ConnectToCalculationEngine() { // Capture the UI synchronization context _uiSyncContext = SynchronizationContext.Current; // The client callback interface must be hosted for the server to invoke the callback // Open a connection to the message service via the proxy factory = new DuplexChannelFactory <ICacheService>( new InstanceContext(this), new NetTcpBinding(), new EndpointAddress("net.tcp://localhost:10012/ICacheService")); proxy = factory.CreateChannel(); proxy.Register(""); //put a button window closing so that we can unsubscribe from ds }
public static IGinService CreateServiceClient(object context, int port) { var iContext = new InstanceContext(context); var myBinding = new WSDualHttpBinding { ClientBaseAddress = new Uri(@"http://localhost:8738/GinService/ShellExtension/" + port) }; var endpointIdentity = EndpointIdentity.CreateDnsIdentity("localhost"); var myEndpoint = new EndpointAddress(new Uri("http://localhost:8733/GinService/"), endpointIdentity); var myChannelFactory = new DuplexChannelFactory <IGinService>(iContext, myBinding, myEndpoint); var client = myChannelFactory.CreateChannel(); return(client); }
static void Main(string[] args) { InstanceContext instanceContext = new InstanceContext(new CalculateCallback()); using (DuplexChannelFactory <ICalculator> channelFactory = new DuplexChannelFactory <ICalculator>(instanceContext, "CalculatorService")) { ICalculator proxy = channelFactory.CreateChannel(); using (proxy as IDisposable) { proxy.Add(1, 2); Console.Read(); } } }
public MainWindow() { InitializeComponent(); DataContext = this; _pexeso_Page = new Pexeso_Page(this); var client = new DuplexChannelFactory <IPexesoService>(instanceContext, "PexesoClient"); _pexesoServiceClient = client.CreateChannel(); InvitationResultCame += MainWindow_InvitationResultCame; _activePlayers_Page = new ActivePlayers_Page(this); _frame_Main = new Frame(); _frame_Main.SetValue(Grid.RowProperty, 1); Grid_Main.Children.Add(_frame_Main); }
public MainWindow() { InitializeComponent(); channelFactory = new DuplexChannelFactory <IMessengerService>(new ClientCallback(), "MessageServiceEndPoint"); Server = channelFactory.CreateChannel(); UserName = Environment.UserName; mutex = new Mutex(true, MutexName, out createdNew); if (!createdNew) { // Show opened App MessageBox.Show("This program is already running"); Application.Current.Shutdown(0); } Server.Login(UserName); }
private void CreateProxy() { try { //***git NetTcpBinding netTcpbinding = new NetTcpBinding(); EndpointAddress endpointAddress = new EndpointAddress("net.tcp://localhost:7002/Sub"); InstanceContext callback = new InstanceContext(this); DuplexChannelFactory <ISubscription> channelFactory = new DuplexChannelFactory <ISubscription>(callback, netTcpbinding, endpointAddress); subscriptionProxy = channelFactory.CreateChannel(); } catch (Exception e) { throw e; //TODO Log error : PubSub not started } }
// DuplexChannelBase IPeerConnectorClient CreateInnerClient(RemotePeerConnection conn) { conn.Instance = new LocalPeerReceiver(this); conn.Instance.WelcomeReceived += delegate(WelcomeInfo welcome) { conn.NodeId = welcome.NodeId; // FIXME: handle referrals }; // FIXME: pass more setup parameters var binding = new NetTcpBinding(); binding.Security.Mode = SecurityMode.None; var channel_factory = new DuplexChannelFactory <IPeerConnectorClient> (conn.Instance, binding); return(channel_factory.CreateChannel(new EndpointAddress("net.p2p://" + node.MeshId + "/"), conn.Address.EndpointAddress.Uri)); }
public MainWindow() { InitializeComponent(); _channelfactory = new DuplexChannelFactory <IChattingService>(new ClientCallback(), "ChattingServiceEndPoint"); Server = _channelfactory.CreateChannel(); btn_Send.Click += btn_Send_Click; btn_Login.Click += btn_Login_Click; btn_Logout.Click += btn_Logout_Click; btn_Update.Click += btn_Update_Click; this.Closed += MainWindow_Closed; this.DataContext = this; }
protected override void OnServiceStarted() { var channelFactory = new DuplexChannelFactory <TServiceInterface>(this, NetworkingExtensions.GetServiceBinding(_protocol)); TestService = channelFactory.CreateChannel(new EndpointAddress(ServiceUri)); try { _serviceProcessId = TestService.Initialize(); } catch (Exception e) { _failReason = new SerializableException(e); TestService = null; } _serviceStartedEvent.Set(); }
private void StartClient() { var group = GetServiceModelSectionGroup(); if (group != null) { var pipeFactory = new DuplexChannelFactory <IReplicatorService>(ReplicatorServiceCallback, group.Client.Endpoints[0].Name); _pipeProxy = pipeFactory.CreateChannel(); ((IClientChannel)_pipeProxy).Open(); _pipeProxy.RegisterForUpdates(); } else { throw new ConfigurationErrorsException("Нет необходомой конфигурации system.serviceModel"); } }
public static IReadService CreateChannelTools() { lock (mutexCreateChannel) { try { if (Channelclient != null) { return(Channelclient); } InstanceContext ic = null; HOST = $"{Registry.GetValue("HKEY_CURRENT_USER\\Software\\FormConfiguration", "IPAddress", null)}"; if (Registry.GetValue("HKEY_CURRENT_USER\\Software\\FormConfiguration", "Port", null) == null) { return(null); } PORT = ushort.Parse( $"{Registry.GetValue("HKEY_CURRENT_USER\\Software\\FormConfiguration", "Port", null)}"); ic = new InstanceContext(new ReadServiceCallbackClient()); // Create a channel factory. var b = new NetTcpBinding(); b.Security.Mode = SecurityMode.Transport; b.Security.Transport.ClientCredentialType = TcpClientCredentialType.Windows; b.Security.Transport.ProtectionLevel = ProtectionLevel.EncryptAndSign; b.MaxBufferSize = 1000000; b.MaxBufferPoolSize = 1000000; b.MaxReceivedMessageSize = 1000000; b.OpenTimeout = TimeSpan.FromMinutes(2); b.SendTimeout = TimeSpan.FromMinutes(2); b.ReceiveTimeout = TimeSpan.FromMinutes(10); var endPoint = new EndpointAddress( new Uri($"net.Tcp://{HOST}:{PORT}/AdvancedScada/{CHANNEL}")); var factory = new DuplexChannelFactory <IReadService>(ic, b, endPoint); Channelclient = factory.CreateChannel(); } catch (CommunicationException ex) { var err = new HMIException.ScadaException("ServiceBaseClient", ex.Message); } } return(Channelclient); }
private void MakeTraceProxy(object callbackinstance, string endpointConfigurationName) { InstanceContext context = new InstanceContext(callbackinstance); context.SynchronizationContext = new SubContext(); // if no endpoint configuratino passed, it will default to the enpointname in SubscriptionServiceClientEndpoint setting if (!string.IsNullOrEmpty(endpointConfigurationName)) { //Use endpoint specified in SubscriptionServiceClientEndpoint setting m_endpointName = endpointConfigurationName; m_ChannelFactory = new DuplexChannelFactory <ISubscriptionService>(context, m_endpointName); } else { //Use endpoint with the ISubscriptionService contract lock (locked) { if (string.IsNullOrEmpty(m_endpointName)) { ClientSection sectionGroup = ConfigurationManager.GetSection("system.serviceModel/client") as ClientSection; foreach (ChannelEndpointElement endpoint in sectionGroup.Endpoints) { if (endpoint.Contract.EndsWith(".ISubscriptionService")) { //m_subEndpoint = endpoint; m_endpointName = endpoint.Name; break; } } if (string.IsNullOrEmpty(m_endpointName)) { throw new Exception("Unable to find endpoint configured for the ISubscriptionService contract."); } } } m_ChannelFactory = new DuplexChannelFactory <ISubscriptionService>(context, m_endpointName); } m_ChannelFactory.Faulted += new EventHandler(ChannelFactory_Faulted); m_Client = m_ChannelFactory.CreateChannel(); ((ICommunicationObject)m_Client).Faulted += new EventHandler(ClientChannel_Faulted); }
private void BuildListenClientService() { if (listenServiceFactory == null) { if (string.IsNullOrEmpty(serviceHostAddr)) { serviceHostAddr = System.Configuration.ConfigurationManager.AppSettings["ServiceHostAddr"]; } InstanceContext instanceContext = new InstanceContext(instance); NetTcpBinding binding = new NetTcpBinding(); binding.ReceiveTimeout = new TimeSpan(0, 5, 0); binding.SendTimeout = new TimeSpan(0, 5, 0); Uri baseAddress = new Uri(string.Format("net.tcp://{0}/ListenService", serviceHostAddr)); listenServiceFactory = new DuplexChannelFactory <IListenService>(instanceContext, binding, new EndpointAddress(baseAddress)); } proxyListenService = listenServiceFactory.CreateChannel(); }
public void InitializeNotify() { try { //将回调类型的实例传递给通道 DuplexChannelFactory <IPushService> channel = new DuplexChannelFactory <IPushService>(new InstanceContext(this), "push"); _pushProxy = channel.CreateChannel(); _pushProxy.Regist(_id); Rectangle rct = Screen.AllScreens[0].WorkingArea; this.Left = rct.Width - this.Width - 5; this.Top = rct.Height; } catch { } }
/// <summary> /// Create a connection to a musicplayer server. /// </summary> /// <param name="player">The musicplayer.</param> /// <param name="address">The server ip address.</param> /// <param name="port">The server port.</param> public ClientConnection(IMusicPlayer player, IPAddress address, int port) : base(player) { _client = new WCFServerClient(this); var serviceAddress = $"net.tcp://{address}:{port}/"; var binding = new NetTcpContextBinding(SecurityMode.None) { CloseTimeout = new TimeSpan(0, 1, 0), ReceiveTimeout = new TimeSpan(1, 0, 0), SendTimeout = new TimeSpan(0, 1, 0), MaxReceivedMessageSize = 100000000 }; // 100Mb _factory = new DuplexChannelFactory <IServerContract>(new InstanceContext(_client), binding, serviceAddress); _server = _factory.CreateChannel(); _server.Anounce(); }
public void CallAsync_noServer_done() { var address = @"net.pipe://127.0.0.1/" + this.GetType().Name + "_" + MethodBase.GetCurrentMethod().Name; var binding = new NetNamedPipeBinding(); var callback = new AsyncServiceCallback(); using (var factory = new DuplexChannelFactory <IAsyncService>(new InstanceContext(callback), binding)) { var client = factory.CreateChannel(new EndpointAddress(address)); AsyncCallback act = x => Assert.AreEqual(x.AsyncState, 1); IAsyncResult result = client.BeginServiceAsyncMethod(act, 1); result.AsyncWaitHandle.WaitOne(); Assert.AreEqual(result.AsyncState, 1); } }
private static void StartClient2(string address) { Console.WriteLine("Server address = " + address); var clb = new CallbackServiceCallback(); Console.WriteLine("Client started"); var factory = new DuplexChannelFactory <ICallbackService2>(new InstanceContext(clb), _binding); var client = factory.CreateChannel(new EndpointAddress(address)); for (int i = 0; i < 6; i++) { client.CallOneWay(new CallData()); client.Call(); Thread.Sleep(new Random((int)DateTime.Now.Ticks).Next(2000, 3000)); } }
public static void CreateChannel_Using_Http_NoSecurity() { WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callback); Binding binding = new NetHttpBinding(BasicHttpSecurityMode.None); EndpointAddress endpoint = new EndpointAddress(FakeAddress.HttpAddress); DuplexChannelFactory <IWcfDuplexService> factory = new DuplexChannelFactory <IWcfDuplexService>(context, binding, endpoint); // Can't cast to IDuplexSessionChannel to IRequestChannel on http var exception = Assert.Throws <InvalidCastException>(() => { factory.CreateChannel(); }); // Can't check that the InvalidCastException message as .NET Native only reports this message for all InvalidCastExceptions: // "System.InvalidCastException: Arg_InvalidCastException" }
static void Main(string[] args) { var ctx = new InstanceContext(new ChatCallback()); //var chatClient = new ConsoleModeChatClient.ChatClient.ChatSvcClient(ctx); var chatClient = new DuplexChannelFactory <ChatClient.IChat>(ctx, "netTcpBinding.ChatSvc").CreateChannel(); var name = args.Count() == 0 ? "Mr Nobody" : args[0]; chatClient.join(name); string what = ReadAndPrompt(name); while (what != null) { chatClient.send(what); what = ReadAndPrompt(name); } chatClient.leave(); }
private void Close() { m_working = false; try { if (null != m_clientChannel) { ((ICommunicationObject)m_clientChannel).Close(); } } catch (CommunicationException commEx) { Error(string.Format("Communication when closing channel: {0}", commEx.Message)); ((ICommunicationObject)m_clientChannel).Abort(); } catch (Exception ex) { Error(string.Format("Exception when closing channel: {0}", ex.Message)); ((ICommunicationObject)m_clientChannel).Abort(); } finally { m_clientChannel = null; } try { if (null != m_factory) { m_factory.Close(); } } catch (CommunicationException commEx) { Error(string.Format("Communication when closing factory: {0}", commEx.Message)); m_factory.Abort(); } catch (Exception ex) { Error(string.Format("Exception when closing factory: {0}", ex.Message)); m_factory.Abort(); } finally { m_factory = null; } }