Передача собственных типов данных

[DataContract]
public struct ValuesStruct
{
    [DataMember]
    public StockSharp.Algo.Candles.Candle candle;
    [DataMember]
    public StockSharp.BusinessEntities.Trade[] allTrades;
    [DataMember]
    public DateTimeOffset terminalTime;
    [DataMember]
    public DateTimeOffset last_EnterTime;
    [DataMember]
    public DateTimeOffset last_ExitTime;
}

namespace stocksharp.ServiceContracts {
    public partial class WorkService : IWorkService
    {
        // >> Customizable strategy settings
        public List<int> tf_Periods = new List<int>
        {
            180
        };
        public List<ADX_Configuration> adx_cfgList = new List<ADX_Configuration>
        {
 
        };
 
        // >> Server processing
 
        public List<TimeFrame> timeFrameList;
        public List<TimeFrame> tf;
 
        public static List<Trade> AllTrades;
        public static DateTimeOffset TerminalTime;
        public static DateTimeOffset LastEnterTime;
        public static DateTimeOffset LastExitTime;
 
        public ServerDataObject currentDataObj;
 
        public void Init()
        {
            addLog("Init");
 
            AllTrades = new List<Trade>();
            TerminalTime = DateTimeOffset.Now;
            LastEnterTime = DateTimeOffset.Now;
            LastExitTime = DateTimeOffset.Now;
 
            timeFrameList = new List<TimeFrame>();
            foreach (var tf_per in tf_Periods)
                timeFrameList.Add(new TimeFrame(tf_per));
            // Initialize indicators (ind - indicator)
            foreach (var ind in adx_cfgList)
                timeFrameList[ind.TF_Number].adx.Add(new ADX(ind.Period, ind.Ma_Type));
        }
 
        public TradeState GetTradeState(ServerDataObject dataObj, NeedAction needAction)
        {
            addLog("GetTradeState");
 
            currentDataObj = dataObj;
 
            // -- Synchronizing of current via received
            // - Time
            TerminalTime = dataObj.TerminalTime;
            LastEnterTime = dataObj.LastEnterTime;
            LastExitTime = dataObj.LastExitTime;
            // - Trading
            AllTrades.AddRange(dataObj.NewTrades);
            Update_TfCandles();
 
            // -- Processing
            tf = timeFrameList;
            return updateTradeState(needAction);
        }
 
        public List<int> GetTimeFramePeriods()
        {
            addLog("GetTimeFramePeriods");
 
            return tf_Periods;
        }
        
        private bool Update_TfCandles()
        {
            addLog("Update_TfCandles");
 
 
            bool result = true;
 
            int i = -1;
            foreach (var _tf in timeFrameList)
            {
                i++;
                foreach (var candle in currentDataObj.NewCandles[i])
                {
                    if (_tf.Buffer.Count == 0 || candle.Time >= _tf.Buffer[_tf.Buffer.Count - 1].Time)
                    {
                        _tf.Process_Candle(candle);
                    }
                    else
                    {
                        result = false;
                    }
 
                }
            }
 
            return result;
        }
        private bool Process_UpdateIndicators()
        {
            addLog("Process_UpdateIndicators");
            
            foreach (var _tf in timeFrameList)
                _tf.Update_Indicators();
            tf = timeFrameList;
 
            return true;
        }
 
        void addLog(string message)
        {
            Console.WriteLine(DateTime.Now.ToString(@"yyyy/MM/dd HH:mm:ss |  ") + message);
        }
    }
}

            // -- init proxy
            
            BasicHttpBinding binding = new BasicHttpBinding();
            EndpointAddress address = new EndpointAddress("http://localhost:8010/WorkService");
            proxy = ChannelFactory<stocksharp.ServiceContracts.IWorkService>.CreateChannel(binding, address);
 
            proxy.Init();

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <services>
      <service name="stocksharp.ServiceContracts.WorkService" behaviorConfiguration="mexBehavior">
        <host>
          <baseAddresses>
            <add baseAddress="net.tcp://localhost:8010/WorkService"/>
            <add baseAddress="http://localhost:8020/WorkService"/>
          </baseAddresses>
        </host>
      <endpoint address="" binding="netTcpBinding" contract="stocksharp.ServiceContracts.IWorkService"/>
      <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange"/>
      </service>     
    </services>
  <behaviors>
    <serviceBehaviors>
      <behavior name="mexBehavior">
        <serviceMetadata httpGetEnabled="true"/>
      </behavior>
    </serviceBehaviors>
  </behaviors>
  </system.serviceModel>
</configuration>

            binding = new BasicHttpBinding();
            address = new EndpointAddress("net.tcp://localhost:8010/WorkService");
            proxy = ChannelFactory<stocksharp.ServiceContracts.IWorkService>.CreateChannel(binding, address);

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Description;
 
namespace Server {
    class Program {
        static void Main(string[] args) {
            Uri address = new Uri("http://localhost:8010/Test");
            WSHttpBinding binding = new WSHttpBinding(SecurityMode.None, true);
            using (ServiceHost host = new ServiceHost(typeof(Test), address)) {
                host.AddServiceEndpoint(typeof(ITest), binding, "");
                host.Description.Behaviors.Add(new ServiceMetadataBehavior { HttpGetEnabled = true });
                host.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexHttpBinding(), "mex");
                host.Opening += new EventHandler(host_Opening);
                host.Opened += new EventHandler(host_Opened);
                host.Open();
                Console.ReadLine();
            }
        }
 
        static void host_Opened(object sender, EventArgs e) {
            Console.WriteLine("Service is ready...");
        }
 
        static void host_Opening(object sender, EventArgs e) {
            Console.WriteLine("Opening service...");
        }
    }
    [ServiceBehavior(InstanceContextMode=InstanceContextMode.PerSession)]
    public class Test : ITest {
        private List<int> args = new List<int>();
        public void Open() {
            Console.WriteLine("Opening session...");
        }
 
        public void Operate(int arg) {
            args.Add(arg);
            Console.WriteLine("Do some work...");
            Console.WriteLine("args content: {0}", string.Join(" ", args));
        }
 
        public void Close() {
            Console.WriteLine("Closing session...");
        }
    }
    [ServiceContract(SessionMode=SessionMode.Required)]
    public interface ITest {
        [OperationContract(IsInitiating=true, IsTerminating=false)]
        void Open();
        [OperationContract(IsInitiating=false, IsTerminating=false)]
        void Operate(int arg);
        [OperationContract(IsInitiating=false, IsTerminating=true)]
        void Close();
    }
}

WSHttpBinding binding = new WSHttpBinding();
EndpointAddress address = new EndpointAddress("http://localhost:8010/WorkService");
proxy = ChannelFactory<stocksharp.ServiceContracts.IWorkService>.CreateChannel(binding, address);

Uri address = new Uri("http://localhost:8010/WorkService");
WSHttpBinding binding = new WSHttpBinding(SecurityMode.None, true);
 
using (ServiceHost host = new ServiceHost(typeof(WorkService), address))
{
    host.AddServiceEndpoint(typeof(IWorkService), binding, "");
    host.Description.Behaviors.Add(new ServiceMetadataBehavior { HttpGetEnabled = true });
    host.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexHttpBinding(), "mex");
 
    host.Opening += new EventHandler(host_Opening);
    host.Opened += new EventHandler(host_Opened);
    host.Open();
 
    Console.ReadLine();
}

namespace stocksharp.DataContracts {
    [DataContract]
    [KnownType("GetKnownTypes")]
    public class ServerDataObject
    {
        [DataMember]
        public List<Candle>[] NewCandles { get; set; }
        [DataMember]
        public List<Trade> NewTrades { get; set; }
        [DataMember]
        public DateTimeOffset TerminalTime { get; set; }
        [DataMember]
        public DateTimeOffset LastEnterTime { get; set; }
        [DataMember]
        public DateTimeOffset LastExitTime { get; set; }
 
        static Type[] GetKnownTypes()
        { 
            return new Type[]
            {
                typeof(TimeFrameCandle), typeof(RangeCandle), typeof(VolumeCandle), 
                typeof(TickCandle), typeof(PnFCandle), typeof(RenkoCandle)
            };
        }
    }
}