public byte [] ReadSizedChunk ()
{
+ lock (read_lock) {
+
int length = reader.ReadVariableInt ();
if (length == 0)
return empty_bytes;
for (int readSize = 0; readSize < length; )
readSize += reader.Read (buffer, readSize, length - readSize);
return buffer;
+
+ }
}
- public void WriteSizedChunk (byte [] data, int index, int length)
+ void WriteSizedChunk (byte [] data, int index, int length)
{
writer.WriteVariableInt (length);
writer.Write (data, index, length);
XmlBinaryReaderSession reader_session;
int reader_session_items;
+ object read_lock = new object ();
+ object write_lock = new object ();
+
public Message ReadSizedMessage ()
{
+ lock (read_lock) {
+
// FIXME: implement full [MC-NMF].
int packetType;
benc.CurrentReaderSession = null;
return msg;
+
+ }
}
// FIXME: support timeout
public Message ReadUnsizedMessage (TimeSpan timeout)
{
+ lock (read_lock) {
+
// Encoding type 7 is expected
if (EncodingRecord != EncodingBinary)
throw new NotImplementedException (String.Format ("Message encoding {0:X} is not implemented yet", EncodingRecord));
Message msg = Encoder.ReadMessage (ms, (int) ms.Length);
return msg;
+
+ }
}
byte [] eof_buffer = new byte [1];
public void WriteSizedMessage (Message message)
{
+ lock (write_lock) {
+
ResetWriteBuffer ();
if (EncodingRecord != 8)
s.Write (buffer.GetBuffer (), 0, (int) buffer.Position);
s.Flush ();
+
+ }
}
// FIXME: support timeout
public void WriteUnsizedMessage (Message message, TimeSpan timeout)
{
+ lock (write_lock) {
+
ResetWriteBuffer ();
if (EncodingRecord != EncodingBinary)
s.WriteByte (UnsizedMessageTerminator); // terminator
s.Flush ();
+
+ }
}
public void WriteEndRecord ()
{
+ lock (write_lock) {
+
s.WriteByte (EndRecord); // it is required
s.Flush ();
+
+ }
}
public void ReadEndRecord ()
{
+ lock (read_lock) {
+
int b;
if ((b = s.ReadByte ()) != EndRecord)
throw new ProtocolException (String.Format ("EndRecord message was expected, got {0:X}", b));
+
+ }
}
}
}
proxy.SendMessage ();
//Wait for callback - sort of hack, but better than using wait handle to possibly block tests.
- Thread.Sleep (1000);
+ Thread.Sleep (2000);
//Cleanup
eventServiceHost.Close ();
Assert.IsTrue (CallbackReceived, "#2");
}
+ [Test]
+ public void CallbackExample2 ()
+ {
+ //Start service and use net.tcp binding
+ ServiceHost eventServiceHost = new ServiceHost (typeof (GreetingsService2));
+ NetTcpBinding tcpBindingpublish = new NetTcpBinding ();
+ tcpBindingpublish.Security.Mode = SecurityMode.None;
+ eventServiceHost.AddServiceEndpoint (typeof (IGreetings2), tcpBindingpublish, "net.tcp://localhost:8000/GreetingsService2");
+ eventServiceHost.Open ();
+
+ //Create client proxy
+ NetTcpBinding clientBinding = new NetTcpBinding ();
+ clientBinding.Security.Mode = SecurityMode.None;
+ EndpointAddress ep = new EndpointAddress ("net.tcp://localhost:8000/GreetingsService2");
+ ClientCallback2 cb = new ClientCallback2 ();
+ IGreetings2 proxy = DuplexChannelFactory<IGreetings2>.CreateChannel (new InstanceContext (cb), clientBinding, ep);
+
+ //Call service
+ proxy.SendMessage ();
+
+ //Wait for callback - sort of hack, but better than using wait handle to possibly block tests.
+ Thread.Sleep (2000);
+
+ //Cleanup
+ eventServiceHost.Close ();
+
+ Assert.IsTrue (CallbackSent2, "#1");
+ Assert.IsTrue (CallbackReceived2, "#2");
+ }
+
public static bool CallbackSent, CallbackReceived;
//Service implementation
[OperationContract (IsOneWay = true)]
void ShowMessage (string message);
}
+
+ public static bool CallbackSent2, CallbackReceived2;
+
+ //Service implementation
+ [ServiceBehavior (ConcurrencyMode = ConcurrencyMode.Multiple, InstanceContextMode = InstanceContextMode.Single)]
+ public class GreetingsService2 : IGreetings2
+ {
+ public void SendMessage ()
+ {
+ //Make a callback
+ IGreetingsCallback2 clientCallback = OperationContext.Current.GetCallbackChannel<IGreetingsCallback2> ();
+
+ clientCallback.ShowMessage ("Mono and WCF are GREAT!");
+ CallbackBehaviorAttributeTest.CallbackSent2 = true;
+ }
+ }
+
+ // Client callback interface implementation
+ [CallbackBehavior (ConcurrencyMode = ConcurrencyMode.Reentrant, UseSynchronizationContext = false)]
+ public class ClientCallback2 : IGreetingsCallback2
+ {
+ public void ShowMessage (string message)
+ {
+ CallbackBehaviorAttributeTest.CallbackReceived2 = true;
+ }
+ }
+
+ [ServiceContract (CallbackContract = typeof (IGreetingsCallback2))]
+ public interface IGreetings2
+ {
+ [OperationContract (IsOneWay = false)]
+ void SendMessage ();
+ }
+
+ [ServiceContract]
+ public interface IGreetingsCallback2
+ {
+ [OperationContract (IsOneWay = false)]
+ void ShowMessage (string message);
+ }
#endregion
}
}
projects / mono.git / commitdiff