Autodesk Map3d 2010 with WCF (II)

Author: Jonio, Dennis

I make absolutely no attempt here to explain why I have done the things the way I have done them in relationship to the grand scheme of WCF. There is just too much to explain and you really should get the book and improve on what I have done. I stopped a long time ago in trying to force Map3d to do multi-threading. As it turns out this is not debilitating at all, just use a Form.
The following are my concrete classes for the WCF interfaces found in the previous article. Making no value judgments, you do have to be impressed with how much Microsoft has done in producing the “behind the scenes” transport functionality. Since I wanted “required, reliable sessions with binary transport” I have coded towards the NetTcpBinding and the NetNamedPipeBinding.
As you can see there are two(2) methods for getting data to the service and the service has one(1) method to send data back to the client. During research I happened upon this multiple client subscription concept with a simple Guid identifier. I desperately wanted some kind of "session identifier" that was all ready in place, generic and robust. If you do the reading you will discover WCF has the concept of SessionId but in my mind's eye it is too crippled to be of any use for my purpose. This subscription paradigm struck me as a good, simple and straightforward idea.
The service itself.
Source code (C#):

+ expand sourceview plainprint?

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5. using System.ServiceModel;  
6.   
7. namespace DplXByteSrvcs  
8. {  
9.     [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single,  
10.                      ConcurrencyMode = ConcurrencyMode.Reentrant)]  
11.     public class ByteSrvcWCallbackImpl : IByteSrvcWCallback  
12.     {  
13.         public delegate void DataIsReady(byte[] hotData);  
14.         public DataIsReady DataReady = null;  
15.   
16.         public delegate void DQDataIsReady(string destinationQ, byte[] hotData);  
17.         public DQDataIsReady DQDataReady = null;  
18.   
19.         public delegate void GotControlPacket(byte[] hotPacket);  
20.         public GotControlPacket OnGotControlPacket = null;  
21.   
22.         public readonly Dictionary<guid, ibytesrvccallback=""> SrvcClients =   
23.                                                 new Dictionary<guid, ibytesrvccallback="">();  
24.   
25.         public void ControlPacket(byte[] ba)  
26.         {  
27.             int rtnval = 0;  
28.             if (ba != null)  
29.                 rtnval = ba.Length;  
30.             if (OnGotControlPacket != null)  
31.                 OnGotControlPacket(ba);  
32.   
33.             IByteSrvcCallback callback = OperationContext.Current.GetCallbackChannel<ibytesrvccallback>();  
34.             if (!SrvcClients.ContainsValue(callback))  
35.             {  
36.                 Guid clientId = Guid.NewGuid();  
37.                 if (callback != null)  
38.                 {  
39.                     lock (SrvcClients)  
40.                     {  
41.                         SrvcClients.Add(clientId, callback);  
42.                     }  
43.                 }  
44.             }  
45.         }  
46.         public int PipedIn(byte[] data)  
47.         {  
48.             int rtnval = 0;  
49.             if (data != null)  
50.                 rtnval = data.Length;  
51.   
52.             if (DataReady != null)  
53.                 DataReady(data);  
54.   
55.             return rtnval;  
56.         }  
57.         public int DQPipedIn(string destinationQ, byte[] data)  
58.         {  
59.             int rtnval = 0;  
60.             if (data != null)  
61.                 rtnval = data.Length;  
62.   
63.             if (DQDataReady != null)  
64.                 DQDataReady(destinationQ, data);  
65.   
66.             return rtnval;  
67.         }  
68.         Guid IByteSrvcWCallback.Subscribe()  
69.         {  
70.             IByteSrvcCallback callback =  
71.                 OperationContext.Current.GetCallbackChannel<ibytesrvccallback>();  
72.             Guid clientId = Guid.NewGuid();  
73.             if (callback != null)  
74.             {  
75.                 lock (SrvcClients)  
76.                 {  
77.                     SrvcClients.Add(clientId, callback);  
78.                 }  
79.             }  
80.             return clientId;  
81.         }  
82.         void IByteSrvcWCallback.UnSubscribe(Guid clientGID)  
83.         {  
84.             lock (SrvcClients)  
85.             {  
86.                 if (SrvcClients.ContainsKey(clientGID))  
87.                 {  
88.                     SrvcClients.Remove(clientGID);  
89.                 }  
90.             }  
91.         }  
92.         void IByteSrvcWCallback.NoOpButKeepAlive() { }  
93.   
94.     }//EOC  
95. }//EONS  
96. </ibytesrvccallback></ibytesrvccallback></guid,></guid,>  

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;

namespace DplXByteSrvcs
{
    [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single,
                     ConcurrencyMode = ConcurrencyMode.Reentrant)]
    public class ByteSrvcWCallbackImpl : IByteSrvcWCallback
    {
        public delegate void DataIsReady(byte[] hotData);
        public DataIsReady DataReady = null;

        public delegate void DQDataIsReady(string destinationQ, byte[] hotData);
        public DQDataIsReady DQDataReady = null;

        public delegate void GotControlPacket(byte[] hotPacket);
        public GotControlPacket OnGotControlPacket = null;

        public readonly Dictionary SrvcClients = 
                                                new Dictionary();

        public void ControlPacket(byte[] ba)
        {
            int rtnval = 0;
            if (ba != null)
                rtnval = ba.Length;
            if (OnGotControlPacket != null)
                OnGotControlPacket(ba);

            IByteSrvcCallback callback = OperationContext.Current.GetCallbackChannel();
            if (!SrvcClients.ContainsValue(callback))
            {
                Guid clientId = Guid.NewGuid();
                if (callback != null)
                {
                    lock (SrvcClients)
                    {
                        SrvcClients.Add(clientId, callback);
                    }
                }
            }
        }
        public int PipedIn(byte[] data)
        {
            int rtnval = 0;
            if (data != null)
                rtnval = data.Length;

            if (DataReady != null)
                DataReady(data);

            return rtnval;
        }
        public int DQPipedIn(string destinationQ, byte[] data)
        {
            int rtnval = 0;
            if (data != null)
                rtnval = data.Length;

            if (DQDataReady != null)
                DQDataReady(destinationQ, data);

            return rtnval;
        }
        Guid IByteSrvcWCallback.Subscribe()
        {
            IByteSrvcCallback callback =
                OperationContext.Current.GetCallbackChannel();
            Guid clientId = Guid.NewGuid();
            if (callback != null)
            {
                lock (SrvcClients)
                {
                    SrvcClients.Add(clientId, callback);
                }
            }
            return clientId;
        }
        void IByteSrvcWCallback.UnSubscribe(Guid clientGID)
        {
            lock (SrvcClients)
            {
                if (SrvcClients.ContainsKey(clientGID))
                {
                    SrvcClients.Remove(clientGID);
                }
            }
        }
        void IByteSrvcWCallback.NoOpButKeepAlive() { }

    }//EOC
}//EONS

You will discover as I did that the communications piece is really all about the client. Nothing much happens without them.
Now for the Client the callback class.
Source code (C#):

+ expand sourceview plainprint?

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.   
6. namespace DplXByteSrvcs  
7. {  
8.     public class ByteSrvcCallbackImpl : IByteSrvcCallback  
9.     {  
10.         public delegate void GotControlPacket(byte[] hotPacket);  
11.         public GotControlPacket OnGotControlPacket = null;  
12.   
13.         private byte[] m_ba;  
14.         public byte[] ControlPacket  
15.         {  
16.             get { return m_ba; }  
17.         }  
18.         public void SentControlPacket(byte[] ba)  
19.         {  
20.             m_ba = ba;  
21.             if (OnGotControlPacket != null)  
22.                 OnGotControlPacket(ba);  
23.         }  
24.     }  
25. }  

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DplXByteSrvcs
{
    public class ByteSrvcCallbackImpl : IByteSrvcCallback
    {
        public delegate void GotControlPacket(byte[] hotPacket);
        public GotControlPacket OnGotControlPacket = null;

        private byte[] m_ba;
        public byte[] ControlPacket
        {
            get { return m_ba; }
        }
        public void SentControlPacket(byte[] ba)
        {
            m_ba = ba;
            if (OnGotControlPacket != null)
                OnGotControlPacket(ba);
        }
    }
}