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();
}
}
}
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);
}
}
/// <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;
}
}
}
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 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 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();
}
}
}
/// <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;
}
}
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);
}
}
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;
}
}
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();
}
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 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 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 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 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();
}
public void CallLocalService()
{
var address = @"ipc:///1/test.test/test" + MethodBase.GetCurrentMethod().Name;
var binding = new LocalBinding();
var data = new CallbackData { Data = "1" };
var srv = new CallbackService(data);
var callback = new CallbackServiceCallback();
using (var host = new ServiceHost(srv, new Uri(address)))
{
host.AddServiceEndpoint(typeof(ICallbackService), binding, address);
host.Open();
using (var factory = new DuplexChannelFactory<ICallbackService>(new InstanceContext(callback), binding))
{
var client = factory.CreateChannel(new EndpointAddress(address));
client.Call();
}
callback.Wait.WaitOne();
Assert.AreEqual(data.Data, callback.Called.Data);
}
}
//其他成员
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 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);
}
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 ClientViewModel()
{
var channelFactory = new DuplexChannelFactory<IChattingService>(new ClientService(), "ChattingServiceEndPoint");
_server = channelFactory.CreateChannel();
This = this;
CreateCommands();
}
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();
}
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 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);
}
}
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 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();
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;
}
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();
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 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);
}
}
// Asking for ChainTrust only should succeed if the certificate is
// chain-trusted.
public static void NetTcp_SecModeTrans_Duplex_Callback_Succeeds()
{
string clientCertThumb = null;
EndpointAddress endpointAddress = null;
DuplexChannelFactory <IWcfDuplexService> factory = null;
IWcfDuplexService serviceProxy = null;
Guid guid = Guid.NewGuid();
try
{
// *** SETUP *** \\
NetTcpBinding binding = new NetTcpBinding(SecurityMode.Transport);
binding.Security.Transport.ClientCredentialType = TcpClientCredentialType.Certificate;
endpointAddress = new EndpointAddress(new Uri(
Endpoints.Tcp_Certificate_Duplex_Address));
clientCertThumb = ServiceUtilHelper.ClientCertificate.Thumbprint;
WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback();
InstanceContext context = new InstanceContext(callbackService);
factory = new DuplexChannelFactory <IWcfDuplexService>(context, binding, endpointAddress);
factory.Credentials.ServiceCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.ChainTrust;
factory.Credentials.ClientCertificate.SetCertificate(
StoreLocation.CurrentUser,
StoreName.My,
X509FindType.FindByThumbprint,
clientCertThumb);
serviceProxy = factory.CreateChannel();
// *** EXECUTE *** \\
// Ping on another thread.
Task.Run(() => serviceProxy.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 *** \\
((ICommunicationObject)serviceProxy).Close();
((ICommunicationObject)factory).Close();
}
finally
{
// *** ENSURE CLEANUP *** \\
ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory);
}
}
protected override void OnStart(string[] args)
{
Common.InitialiseLogFolder();
logging.AddToLog("OnStart", true);
InstanceContext site = new InstanceContext(this);
NetTcpBinding tcpBinding = new NetTcpBinding();
tcpBinding.TransactionFlow = false;
tcpBinding.ReliableSession.Ordered = true;
tcpBinding.Security.Message.ClientCredentialType = MessageCredentialType.None;
tcpBinding.Security.Transport.ProtectionLevel = System.Net.Security.ProtectionLevel.None;
tcpBinding.Security.Transport.ClientCredentialType = TcpClientCredentialType.None;
tcpBinding.Security.Mode = SecurityMode.None;
EndpointAddress myEndpoint = new EndpointAddress("net.tcp://" + Common.DBConnection + ":8731/WCFService/");
var myChannelFactory = new DuplexChannelFactory <IWCFService>(site, tcpBinding);
wcfObj = myChannelFactory.CreateChannel(myEndpoint);
wcfObj.Subscribe();
Common.CreateComputerObject(sourceName);
try
{
logging.AddToLog("Creating Service object", true);
OSAEObject svcobj = OSAEObjectManager.GetObjectByName("SERVICE-" + Common.ComputerName);
if (svcobj == null)
{
OSAEObjectManager.ObjectAdd("SERVICE-" + Common.ComputerName, "SERVICE-" + Common.ComputerName, "SERVICE", "", "SYSTEM", true);
}
OSAEObjectStateManager.ObjectStateSet("SERVICE-" + Common.ComputerName, "ON", sourceName);
}
catch (Exception ex)
{
logging.AddToLog("Error creating service object - " + ex.Message, true);
}
if (connectToService())
{
Thread loadPluginsThread = new Thread(new ThreadStart(LoadPlugins));
loadPluginsThread.Start();
}
//Clock.Interval = 5000;
//Clock.Start();
//Clock.Elapsed += new System.Timers.ElapsedEventHandler(checkConnection);
}
private void Login(object sender, RoutedEventArgs e)
{
try
{
// var tcpBind = new NetTcpBinding();
// tcpBind.MaxReceivedMessageSize = int.MaxValue;
// tcpBind.Security.Mode = SecurityMode.Transport;
//
//
// var cf = new DuplexChannelFactory<IServer>(new InstanceContext(this), tcpBind, new EndpointAddress("net.tcp://192.168.178.56:1"));
// cf.Credentials.Windows.ClientCredential.UserName = "******";
// cf.Credentials.Windows.ClientCredential.Password = "******";
var tcpBind = new NetTcpBinding();
tcpBind.MaxReceivedMessageSize = int.MaxValue;
tcpBind.Security.Mode = SecurityMode.TransportWithMessageCredential;
tcpBind.Security.Transport.ClientCredentialType = TcpClientCredentialType.Certificate;
var dual = new WSDualHttpBinding();
dual.Security.Mode = WSDualHttpSecurityMode.Message;
dual.Security.Message.ClientCredentialType = MessageCredentialType.Certificate;
dual.Security.Message.NegotiateServiceCredential = true;
//var cf = new DuplexChannelFactory<IServer>(new InstanceContext(this), dual, new EndpointAddress("http://192.168.178.56:2"));
EndpointIdentity identity = EndpointIdentity.CreateDnsIdentity("RootCA");
EndpointAddress address = new EndpointAddress(new Uri("net.tcp://DESKTOP-MFV9PIV:3"), identity);
var cf = new DuplexChannelFactory <IServer>(new InstanceContext(this), tcpBind, address);
cf.Credentials.ClientCertificate.SetCertificate(StoreLocation.LocalMachine, StoreName.My, X509FindType.FindByThumbprint, "db56b195af62c2e65ae9243deac64eba8a34ed73");
cf.Credentials.Windows.ClientCredential.UserName = "******";
cf.Credentials.Windows.ClientCredential.Password = "******";
cf.Credentials.ServiceCertificate.Authentication.CertificateValidationMode = System.ServiceModel.Security.X509CertificateValidationMode.None;
server = cf.CreateChannel();
server.Login(nameTb.Text);
}
catch (Exception ex)
{
MessageBox.Show($"Fehler:{ex.Message}");
Debugger.Break();
}
}
public NebulaMasterServiceCB(string sAddr, int iPort)
{
NetTcpBinding hBinding = new NetTcpBinding();
//hBinding.MaxBufferPoolSize = 0;
//hBinding.MaxBufferSize = 51200;
hBinding.MaxReceivedMessageSize = 2147483647;
hBinding.Security.Mode = SecurityMode.None;
EndpointAddress hAddr = new EndpointAddress($"net.tcp://{sAddr}:{iPort}/NebulaMasterService");
DuplexChannelFactory <INebulaMasterService> hFactory = new DuplexChannelFactory <INebulaMasterService>(typeof(NebulaMasterServiceCB), hBinding, hAddr);
Service = hFactory.CreateChannel(new InstanceContext(this));
m_hModules = new List <INebulaModule>();
IEnumerable <INebulaModule> hModules = from hA in Directory.GetFiles(Environment.CurrentDirectory, "*.dll").SafeSelect(hF => Assembly.UnsafeLoadFrom(hF))
from hT in hA.GetTypes()
from hI in hT.GetInterfaces()
where hI == typeof(INebulaModule)
select Activator.CreateInstance(hT) as INebulaModule; //Manco dante porcoddio
foreach (INebulaModule hModule in hModules)
{
try
{
hModule.Start(Service);
m_hModules.Add(hModule);
}
catch (Exception)
{
//Skip faulted modules
}
}
NebulaModuleInfo[] hModuleInfos = m_hModules.Select(x => x.ModuleInfo).ToArray();
Service.Register(Environment.MachineName, hModuleInfos);
foreach (INebulaModule hModule in m_hModules)
{
try
{
hModule.RegistrationComplete();
}
catch (Exception)
{
//Skip faulted modules
}
}
}
} // end of method
/// <summary>
/// GetMessageHistory
/// Gets a list of ChatMessages to update
/// the UI list box
/// </summary>
private void UpdateMessageHistoryUI()
{
// If User is Not Logged In
if (!IsUserLoggedIn(userName))
{
return;
}
// Clear the List Box
lstChatMessages.Items.Clear();
// Temporary variable to hold the list of chat messages
List <ChatMessage> historyChat;
// Retrieve the New Messages
DuplexChannelFactory <IChatService> cf = new DuplexChannelFactory <IChatService>(this, "NetTcpBinding_IChatService");
cf.Open();
IChatService proxy = cf.CreateChannel();
if (proxy != null)
{
try
{
// retrieve the chat history
historyChat = proxy.GetMessageHistory();
// Update the UI
foreach (ChatMessage item in historyChat)
{
lstChatMessages.Items.Add(item);
}
IsChatHistoryLoaded = true;
} // end of try
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message, System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Namespace + "." + System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name);
MessageBox.Show(ex.Message);
}
} // end of if
else
{
// Cannot Connect to Server
MessageBox.Show("Cannot Create a Channel to a Proxy. Check Your Configuration Settings.", "Proxy", MessageBoxButtons.OK);
} // end of else
} // end of method
public static void DuplexCallback_Throws_FaultException_ReturnsFaultedTask()
{
DuplexChannelFactory <IWcfDuplexTaskReturnService> factory = null;
Guid guid = Guid.NewGuid();
NetTcpBinding binding = null;
DuplexTaskReturnServiceCallback callbackService = null;
InstanceContext context = null;
EndpointAddress endpointAddress = null;
IWcfDuplexTaskReturnService serviceProxy = null;
// *** VALIDATE *** \\
FaultException <FaultDetail> exception = Assert.Throws <FaultException <FaultDetail> >(() =>
{
// *** SETUP *** \\
binding = new NetTcpBinding();
binding.Security.Mode = SecurityMode.None;
endpointAddress = new EndpointAddress(Endpoints.Tcp_NoSecurity_TaskReturn_Address);
callbackService = new DuplexTaskReturnServiceCallback();
context = new InstanceContext(callbackService);
factory = new DuplexChannelFactory <IWcfDuplexTaskReturnService>(context, binding, endpointAddress);
serviceProxy = factory.CreateChannel();
// *** EXECUTE *** \\
try
{
Task <Guid> task = serviceProxy.FaultPing(guid);
if ((task as IAsyncResult).AsyncWaitHandle.WaitOne(ScenarioTestHelpers.TestTimeout))
{
Guid returnedGuid = task.GetAwaiter().GetResult();
}
else
{
throw new TimeoutException(String.Format("The call to the Service did not complete within the alloted time of: {0}", ScenarioTestHelpers.TestTimeout));
}
}
finally
{
// *** ENSURE CLEANUP *** \\
ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory);
}
});
// *** ADDITIONAL VALIDATION *** \\
string exceptionCodeName = "ServicePingFaultCallback";
string exceptionReason = "Reason: Testing FaultException returned from Duplex Callback";
Assert.True(String.Equals(exceptionCodeName, exception.Code.Name), String.Format("Expected exception code name: {0}\nActual exception code name: {1}", exceptionCodeName, exception.Code.Name));
Assert.True(String.Equals(exceptionReason, exception.Reason.GetMatchingTranslation().Text), String.Format("Expected exception reason: {0}\nActual exception reason: {1}", exceptionReason, exception.Reason.GetMatchingTranslation().Text));
}
private T CreateProductService <T>(string serviceName)
{
var binding = new NetTcpBinding()
{
MaxBufferPoolSize = 2147483647, MaxReceivedMessageSize = 2147483647
};
binding.Security.Mode = SecurityMode.None;
var factory = new DuplexChannelFactory <T>(
new WCFClientCallbackManager(),
binding,
new EndpointAddress(string.Format("net.tcp://{0}:{1}/{2}", _address, _port, serviceName)));
return(factory.CreateChannel());
}
private static void DuplexSample()
{
var binding = new WSDualHttpBinding();
var address =
new EndpointAddress("http://localhost:8733/Design_Time_Addresses/MessageService/Service1/");
var clientCallback = new ClientCallback();
var context = new InstanceContext(clientCallback);
var factory = new DuplexChannelFactory <IMyMessage>(context, binding, address);
IMyMessage messageChannel = factory.CreateChannel();
messageChannel.MessageToServer("From the server");
}
private void CreateProxy()
{
try
{
EndpointAddress endpointAddress = new EndpointAddress("net.tcp://localhost:3002/Sub");
InstanceContext callback = new InstanceContext(this);
DuplexChannelFactory <ISubscription> channelFactory = new DuplexChannelFactory <ISubscription>(callback, NetTcpBindingCreator.Create(), endpointAddress);
subscriptionProxy = channelFactory.CreateChannel();
}
catch (Exception e)
{
throw e;
//TODO Log error : PubSub not started
}
}
/// <summary>
/// 콜백객체를 사용할 경우의 웹서비스 프록시 반환
/// </summary>
/// <param name="webServiceUrl"></param>
/// <param name="ClientCallback">
/// IWebServiceCallback을 구현한 클라이언트 측의 객체를 래핑한 InstanceContext객체
/// EX)
/// WebServiceCallback callback = new WebServiceCallback();
/// InstanceContext ctx = new InstanceContext(callback); 에서 ctx
/// </param>
/// <returns>
/// 채널이 연결된 웹서비스객체
/// </returns>
private IWebService CallWebserviceUsingCallback(string webServiceUrl, DuplexChannelFactory <IWebService> WebServiceChannel, InstanceContext ClientCallback)
{
EndpointAddress epa = new EndpointAddress(
new Uri(webServiceUrl),
new DnsEndpointIdentity(System.IdentityModel.Claims.Claim.CreateDnsClaim("HTPSecureManager"))
);
IWebService webservice = WebServiceChannel.CreateChannel
(
ClientCallback,
epa
);
return(webservice);
}
/// <summary>
/// Creates a service connection to the callback service behind the specified service interface.
/// Please prefer <see cref="M:GetServiceWrapper{T}()"/> method!
/// See documentation for further information.
/// </summary>
/// <remarks>Use this method only if you need to keep a connection to a service open longer than possible with <see cref="M:GetServiceWrapper{T}()"/>.
/// When finished with the work (or it is safe to release the instance), make a call to <see cref="M:CloseServiceInstance(object)"/> to safely close and dispose the service connection.</remarks>
/// <typeparam name="T">The service interface type.</typeparam>
/// <param name="callbackObject">The object representing the callback to use. Must not be null.</param>
/// <returns>A service connection to the service behind the specified service interface.</returns>
public static T GetCallbackServiceInstance <T>(object callbackObject) where T : class, IExposedService
{
AssertContractTypeCorrect(typeof(T));
Assertions.AssertNotNull(callbackObject, "callbackObject");
Binding binding = ServiceBindingCache.GetBindingForContractType(typeof(T));
DuplexChannelFactory <T> factory = new DuplexChannelFactory <T>(callbackObject, binding, GetEndpointAddress(typeof(T), binding));
ApplyX509IfConfigured(factory);
T channel = factory.CreateChannel();
channel.Ping();
return(channel);
}
static void Main(string[] args)
{
Console.Title = "Client";
Console.WriteLine("Press Enter when the service is ready");
Console.ReadLine();
InstanceContext context = new InstanceContext(new StockCallback());
DuplexChannelFactory <IStock> factory = new DuplexChannelFactory <IStock>(context, "StockEP");
IStock proxy = factory.CreateChannel();
proxy.RegisterForQuote("MSFT");
Console.WriteLine("Waiting for stock updates. Press Enter to stop");
Console.ReadLine();
}
private void MaterialFlatButton1_Click(object sender, EventArgs e)
{
var netTcp = new NetTcpBinding();
netTcp.MaxReceivedMessageSize = int.MaxValue;
netTcp.Security.Mode = SecurityMode.Message;
var cf = new DuplexChannelFactory <IServer>(this, netTcp, new EndpointAddress("net.tcp://192.168.2.39:1"));
cf.Credentials.Windows.ClientCredential.UserName = "******";
cf.Credentials.Windows.ClientCredential.Password = "******";
server = cf.CreateChannel();
server.Login(userNameTextBox.Text);
}
public static T CreateMaxItemsChannel <T>(InstanceContext callbackInstance, Binding binding, EndpointAddress endpoint)
{
DuplexChannelFactory <T> factory = new DuplexChannelFactory <T>(callbackInstance, binding, endpoint);
foreach (OperationDescription op in factory.Endpoint.Contract.Operations)
{
var dataContractBehavior = op.Behaviors.Find <DataContractSerializerOperationBehavior>();
if (dataContractBehavior != null)
{
dataContractBehavior.MaxItemsInObjectGraph = int.MaxValue;
}
}
return(factory.CreateChannel());
}
} // END PlayLetter_Click()
/************************
* HELPER METHODS *
************************/
/*
* Purpose: Creates object that implements the callback contract.
* Initialization done in constructor.
*/
public void NewGame()
{
//Create a Game object with WCF
channel = new DuplexChannelFactory<IGame>(this, "GameEndPoint");
newGame = channel.CreateChannel(); //this return IGame interface
//Register to receive callbacks
newGame.RegisterForCallbacks();
// Set new word
wordInfo = newGame.SetNewWord();
LoadCharFields();
} // END NewGame()
//
public AgencyClient()
{
EndpointAddress endpointAddress = new EndpointAddress("http://localhost:8090/Agency");
WSDualHttpBinding binding = new WSDualHttpBinding();
binding.ClientBaseAddress = new Uri("http://localhost:808/WSDualOnXP/");
DuplexChannelFactory <IAgencyService> channelFactory =
new DuplexChannelFactory <IAgencyService>(
this,
binding,
endpointAddress);
Channel = channelFactory.CreateChannel();
}
protected override void OnServiceStarted()
{
var channelFactory = new DuplexChannelFactory <TServiceInterface>(this, NetworkingExtensions.GetServiceBinding());
TestService = channelFactory.CreateChannel(new EndpointAddress(ServiceUri));
try
{
_serviceProcessId = TestService.Initialize();
}
catch
{
TestService = null;
}
_serviceStartedEvent.Set();
}
public void Start(int iNetPort, int iWebPort, string sMsAddr, int iMsPort)
{
MasaterServerEndPoint = new IPEndPoint(IPAddress.Parse(sMsAddr), iMsPort);
IMasterServer hNewNode = m_hMSChannelFactory.CreateChannel(new EndpointAddress($"net.tcp://{MasaterServerEndPoint.Address}:{MasaterServerEndPoint.Port}/ElysiumMasterServer"));
(hNewNode as ICommunicationObject).Faulted += OnMasterServerChannelClosed;
(hNewNode as ICommunicationObject).Closed += OnMasterServerChannelClosed;
this.Start(iNetPort, iWebPort);
hNewNode.Register(iNetPort);
hNewNode.GetNodes(int.MaxValue).ToList().ForEach(x => this.Connect(x.Address.ToString(), x.Port));
}
public bool Call <TReturn>(Func <IContract, TReturn> f, out TReturn result)
{
result = default;
try
{
result = f(factory.CreateChannel());
}
catch (Exception e)
{
return(false);
}
return(true);
}
public Form1()
{
InitializeComponent();
InstanceContext instanceContext = new InstanceContext(new CallbackHandler(this));
//client = new NetFilesServiceClient(instanceContext);
NetTcpBinding binding = new NetTcpBinding(SecurityMode.None);
DuplexChannelFactory <INetFilesService> factory = new DuplexChannelFactory <INetFilesService>(instanceContext, binding);
Uri adress = new Uri("net.tcp://astrakhan.chickenkiller.com:8000/NetFilesService");
EndpointAddress endpoint = new EndpointAddress(adress.ToString());
//Связь с сервером не устанавливается до тех пор, пока не будет вызван метод Join
client = factory.CreateChannel(endpoint);
}
private static void OpenChannel()
{
try
{
factory = new DuplexChannelFactory <IChatService>(new ChatResult(), "DuplexEP");
proxy = factory.CreateChannel();
//Define an operation timeout to limit the operation time
((IClientChannel)proxy).OperationTimeout = TimeSpan.FromSeconds(_connectionTimeoutSeconds);
}
catch (Exception e)
{
Report.log(DeviceToReport.Client_Proxy, LogLevel.Exception, e.Message);
throw e;
}
}
public static void ServiceContract_TypedProxy_DuplexCallback()
{
DuplexChannelFactory <IDuplexChannelService> factory = null;
StringBuilder errorBuilder = new StringBuilder();
Guid guid = Guid.NewGuid();
try
{
NetTcpBinding binding = new NetTcpBinding();
binding.Security.Mode = SecurityMode.None;
DuplexChannelServiceCallback callbackService = new DuplexChannelServiceCallback();
InstanceContext context = new InstanceContext(callbackService);
factory = new DuplexChannelFactory <IDuplexChannelService>(context, binding, new EndpointAddress(Endpoints.Tcp_NoSecurity_DuplexCallback_Address));
IDuplexChannelService serviceProxy = factory.CreateChannel();
serviceProxy.Ping(guid);
Guid returnedGuid = callbackService.CallbackGuid;
if (guid != returnedGuid)
{
errorBuilder.AppendLine(String.Format("The sent GUID does not match the returned GUID. Sent: {0} Received: {1}", guid, returnedGuid));
}
factory.Close();
}
catch (Exception ex)
{
errorBuilder.AppendLine(String.Format("Unexpected exception was caught: {0}", ex.ToString()));
for (Exception innerException = ex.InnerException; innerException != null; innerException = innerException.InnerException)
{
errorBuilder.AppendLine(String.Format("Inner exception: {0}", innerException.ToString()));
}
}
finally
{
if (factory != null && factory.State != CommunicationState.Closed)
{
factory.Abort();
}
}
if (errorBuilder.Length != 0)
{
Assert.True(errorBuilder.Length == 0, string.Format("Test Scenario: ServiceContract_TypedProxy_DuplexCallback FAILED with the following errors: {0}", errorBuilder));
}
}
public iProxy(string strIP, string strPort)
{
try
{
if (EventLibCallback.oCallBack == null)
{
EventLibrary.EventLibCallback.oCallBack = new EventLibrary.EventLib();
}
//EndpointAddress address = new EndpointAddress("net.tcp://" + strIP + ":" + strPort + "/TestWCFService");
EndpointAddress address = new EndpointAddress("net.tcp://localhost:9008/TestWCFService");
XmlDictionaryReaderQuotas myReaderQuotas = new XmlDictionaryReaderQuotas();
myReaderQuotas.MaxStringContentLength = Int32.MaxValue;
myReaderQuotas.MaxArrayLength = Int32.MaxValue;
myReaderQuotas.MaxDepth = Int32.MaxValue;
NetTcpBinding oBinding = new NetTcpBinding();
oBinding.GetType().GetProperty("ReaderQuotas").SetValue(oBinding, myReaderQuotas, null);
oBinding.ReceiveTimeout = new TimeSpan(1, 0, 0);
oBinding.MaxBufferSize = Int32.MaxValue;
oBinding.MaxReceivedMessageSize = Int32.MaxValue;
oBinding.Security.Mode = SecurityMode.None;
DuplexChannelFactory <IService> oCF = new DuplexChannelFactory <IService>(EventLibrary.EventLibCallback.oCallBack, oBinding, address);
foreach (OperationDescription op in oCF.Endpoint.Contract.Operations)
{
var dataContractBehavior = op.Behaviors.Find <DataContractSerializerOperationBehavior>();
if (dataContractBehavior != null)
{
dataContractBehavior.MaxItemsInObjectGraph = int.MaxValue;
}
}
_Service = oCF.CreateChannel();
oCF.Opened += new EventHandler(oCF_Opened);
oCF.Closed += new EventHandler(oCF_Closed);
((IContextChannel)_Service).OperationTimeout = new TimeSpan(0, 20, 0);
Status = true;
}
catch (Exception ex)
{
Status = false;
}
}
private async Task TryConnectAsync()
{
if (IsConnected)
{
await DisconnectAsync(true).ConfigureAwait(false);
}
if (string.IsNullOrEmpty(Username) ||
string.IsNullOrEmpty(ServerAddress))
{
StatusMessage = "Could not connect, username or server address invalid";
return;
}
try
{
StatusMessage = "Connecting...";
var binding = new WSDualHttpBinding();
var endpoint = new EndpointAddress(ServerAddress + "/Design_Time_Addresses/ALCS/HiChatService/");
var instanceContext = new InstanceContext(this);
var channelFactory = new DuplexChannelFactory <IHiChatService>(instanceContext,
binding, endpoint);
channel = channelFactory.CreateChannel();
var task = Task.Run(() => channel.Connect(Username));
if (await Task.WhenAny(task, Task.Delay(15000)) != task)
{
StatusMessage = "Connection timed out";
channel = null;
return;
}
if (task.Result == null)
{
StatusMessage = "Could not connect, server refused connection";
channel = null;
}
else
{
ConnectedUser = task.Result;
StatusMessage = "Connection successful";
}
}
catch (Exception e)
{
StatusMessage = $"Could not connect, exception: {e.Message}";
await DisconnectAsync(false).ConfigureAwait(false);
}
}
private void login(object sender, RoutedEventArgs e)
{
try
{
DuplexChannelFactory <IFishService> channel;
string hostName = Dns.GetHostName();
string myIP = Dns.GetHostByName(hostName).AddressList[0].ToString();
if (endpoint_box.Text != "")
{
myIP = endpoint_box.Text;
}
string endpointStr = "net.tcp://" + myIP + ":13200/CardsLibrary/FishService";
//channel = new DuplexChannelFactory<IFishService>(this, "FishService", new EndpointAddress( endpointStr));
//channel.Endpoint.ListenUri = new Uri(endpointStr);
NetTcpBinding binding = new NetTcpBinding();
binding.Security.Mode = SecurityMode.None;
binding.Name = "FishService";
channel = new DuplexChannelFactory <IFishService>(this, binding,
new EndpointAddress(endpointStr));
// Activate a MessageBoard object
fishService = channel.CreateChannel();
}
catch (Exception ex)
{
ErrorWindow win2 = new ErrorWindow(ex.Message);
win2.Show();
}
try
{
if (fishService.AddPlayer(login_box.Text))
{
ViewGameList();
user.Username = login_box.Text;
}
else
{
ErrorWindow win2 = new ErrorWindow("The username selected is allready in use. Please select another username");
win2.ShowDialog();
}
}
catch (Exception ex)
{
ErrorWindow win2 = new ErrorWindow(ex.Message);
win2.Show();
}
}
} // end of method
private void UpdateOnlineUsersListboxUI()
{
// If User is Not Logged In
if (LoggedInUser.Username == null)
{
MessageBox.Show("Please Login First !");
return;
}
// Clear the List Box
lbOnlineUsers.Items.Clear();
// Temporary variable to hold the list of chat messages
List <string> receivedOnlineUsers;
// Retrieve the New Messages
DuplexChannelFactory <IOneToOneChatService> cf = new DuplexChannelFactory <IOneToOneChatService>(this, "NetTcpBinding_IOneToOneChatService");
cf.Open();
IOneToOneChatService proxy = cf.CreateChannel();
if (proxy != null)
{
try
{
// retrieve the online username from the server
receivedOnlineUsers = proxy.GetAllOnlineUsers(LoggedInUser.Username);
// Update the UI
foreach (string item in receivedOnlineUsers)
{
lbOnlineUsers.Items.Add(item);
}
} // end of try
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message, System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Namespace + "." + System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name);
MessageBox.Show(ex.Message);
}
} // end of if
else
{
// Cannot Connect to Server
MessageBox.Show("Cannot Create a Channel to a Proxy. Check Your Configuration Settings.", "Proxy", MessageBoxButtons.OK);
} // end of else
} // end of method
public ICharacterFeedChannel CreateChannel()
{
try
{
DuplexChannelFactory <ICharacterFeedChannel> factory = new DuplexChannelFactory <ICharacterFeedChannel>(
new InstanceContext(this),
"CharacterFeedEndpoint");
factory.Open();
return(factory.CreateChannel());
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message + "|" + ex.StackTrace);
}
return(null);
}
// 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()));
}
public OperationResult <UserExt> Connect()
{
try
{
context = new InstanceContext(relationsCallback);
factory = new DuplexChannelFactory <IRelations>(context, connectionString);
factory.Faulted += Factory_Faulted;
channel = factory.CreateChannel();
var res = channel.Authentication(token);
return(res);
}
catch (CommunicationException ex)
{
return(new OperationResult <UserExt>(null, false, "Connection error"));
}
}
/// <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);
}
}
