lanju-client/shangjian/XGL.Thrift/ThriftService.cs

/**
 * Autogenerated by Thrift Compiler (0.9.0)
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.IO;
using Thrift;
using Thrift.Collections;
using System.Runtime.Serialization;
using Thrift.Protocol;
using Thrift.Transport;

public partial class ThriftService {
  public interface Iface {
    string sendCheckBarcode(string barcode);
    #if SILVERLIGHT
    IAsyncResult Begin_sendCheckBarcode(AsyncCallback callback, object state, string barcode);
    string End_sendCheckBarcode(IAsyncResult asyncResult);
    #endif
    string sendCarMaterialList(List<string> CarNosOrMater, string order_code);
    #if SILVERLIGHT
    IAsyncResult Begin_sendCarMaterialList(AsyncCallback callback, object state, List<string> CarNosOrMater, string order_code);
    string End_sendCarMaterialList(IAsyncResult asyncResult);
    #endif
    string sendMaterialList(List<string> MaterialNos);
    #if SILVERLIGHT
    IAsyncResult Begin_sendMaterialList(AsyncCallback callback, object state, List<string> MaterialNos);
    string End_sendMaterialList(IAsyncResult asyncResult);
    #endif
    string SendSetCarInfo(string carno, string materialno, string materialdesc, string locatorid, string outlocatorstate, string optdt);
    #if SILVERLIGHT
    IAsyncResult Begin_SendSetCarInfo(AsyncCallback callback, object state, string carno, string materialno, string materialdesc, string locatorid, string outlocatorstate, string optdt);
    string End_SendSetCarInfo(IAsyncResult asyncResult);
    #endif
    string SendCheckServerState();
    #if SILVERLIGHT
    IAsyncResult Begin_SendCheckServerState(AsyncCallback callback, object state, );
    string End_SendCheckServerState(IAsyncResult asyncResult);
    #endif
    string GetReceiveCarNo(string carno);
    #if SILVERLIGHT
    IAsyncResult Begin_GetReceiveCarNo(AsyncCallback callback, object state, string carno);
    string End_GetReceiveCarNo(IAsyncResult asyncResult);
    #endif
    string GetLocatorInfoList();
    #if SILVERLIGHT
    IAsyncResult Begin_GetLocatorInfoList(AsyncCallback callback, object state, );
    string End_GetLocatorInfoList(IAsyncResult asyncResult);
    #endif
    string GetOutLocatorList();
    #if SILVERLIGHT
    IAsyncResult Begin_GetOutLocatorList(AsyncCallback callback, object state, );
    string End_GetOutLocatorList(IAsyncResult asyncResult);
    #endif
    string SendOutLocatorBarcode(string barcode);
    #if SILVERLIGHT
    IAsyncResult Begin_SendOutLocatorBarcode(AsyncCallback callback, object state, string barcode);
    string End_SendOutLocatorBarcode(IAsyncResult asyncResult);
    #endif
    string GetLineAreaList(List<LineArea> linearealist);
    #if SILVERLIGHT
    IAsyncResult Begin_GetLineAreaList(AsyncCallback callback, object state, List<LineArea> linearealist);
    string End_GetLineAreaList(IAsyncResult asyncResult);
    #endif
    string GetCarAreaList(List<CarArea> cararealist);
    #if SILVERLIGHT
    IAsyncResult Begin_GetCarAreaList(AsyncCallback callback, object state, List<CarArea> cararealist);
    string End_GetCarAreaList(IAsyncResult asyncResult);
    #endif
    string GetOrderList(List<Order> orderlist);
    #if SILVERLIGHT
    IAsyncResult Begin_GetOrderList(AsyncCallback callback, object state, List<Order> orderlist);
    string End_GetOrderList(IAsyncResult asyncResult);
    #endif
    string GetOutCarLineList(List<OutCarLine> outcarlinelist);
    #if SILVERLIGHT
    IAsyncResult Begin_GetOutCarLineList(AsyncCallback callback, object state, List<OutCarLine> outcarlinelist);
    string End_GetOutCarLineList(IAsyncResult asyncResult);
    #endif
    string GetMaterialList(List<string> MaterialNos);
    #if SILVERLIGHT
    IAsyncResult Begin_GetMaterialList(AsyncCallback callback, object state, List<string> MaterialNos);
    string End_GetMaterialList(IAsyncResult asyncResult);
    #endif
    string GetUpDownMaterielNum(string siteno);
    #if SILVERLIGHT
    IAsyncResult Begin_GetUpDownMaterielNum(AsyncCallback callback, object state, string siteno);
    string End_GetUpDownMaterielNum(IAsyncResult asyncResult);
    #endif
    string SendDeleteRelief();
    #if SILVERLIGHT
    IAsyncResult Begin_SendDeleteRelief(AsyncCallback callback, object state, );
    string End_SendDeleteRelief(IAsyncResult asyncResult);
    #endif
    string SendUpdateDownNum();
    #if SILVERLIGHT
    IAsyncResult Begin_SendUpdateDownNum(AsyncCallback callback, object state, );
    string End_SendUpdateDownNum(IAsyncResult asyncResult);
    #endif
    string GetDownLineNum(string downnum);
    #if SILVERLIGHT
    IAsyncResult Begin_GetDownLineNum(AsyncCallback callback, object state, string downnum);
    string End_GetDownLineNum(IAsyncResult asyncResult);
    #endif
    string GetMaterielNumByKBList(List<MaterielNumKB> materielnumlist);
    #if SILVERLIGHT
    IAsyncResult Begin_GetMaterielNumByKBList(AsyncCallback callback, object state, List<MaterielNumKB> materielnumlist);
    string End_GetMaterielNumByKBList(IAsyncResult asyncResult);
    #endif
    string GetFaultList(List<Fault> faultlist);
    #if SILVERLIGHT
    IAsyncResult Begin_GetFaultList(AsyncCallback callback, object state, List<Fault> faultlist);
    string End_GetFaultList(IAsyncResult asyncResult);
    #endif
    string GetAreaPlcList(List<AreaPlc> areaplclist);
    #if SILVERLIGHT
    IAsyncResult Begin_GetAreaPlcList(AsyncCallback callback, object state, List<AreaPlc> areaplclist);
    string End_GetAreaPlcList(IAsyncResult asyncResult);
    #endif
    string SendInsertFault();
    #if SILVERLIGHT
    IAsyncResult Begin_SendInsertFault(AsyncCallback callback, object state, );
    string End_SendInsertFault(IAsyncResult asyncResult);
    #endif
    string SendUpdateFault();
    #if SILVERLIGHT
    IAsyncResult Begin_SendUpdateFault(AsyncCallback callback, object state, );
    string End_SendUpdateFault(IAsyncResult asyncResult);
    #endif
    string ShowUpBarcode(string barcode, string materialno, string message, int status);
    #if SILVERLIGHT
    IAsyncResult Begin_ShowUpBarcode(AsyncCallback callback, object state, string barcode, string materialno, string message, int status);
    string End_ShowUpBarcode(IAsyncResult asyncResult);
    #endif
    string DataForRestart();
    #if SILVERLIGHT
    IAsyncResult Begin_DataForRestart(AsyncCallback callback, object state, );
    string End_DataForRestart(IAsyncResult asyncResult);
    #endif
    string MaterialRemove(string barcode);
    #if SILVERLIGHT
    IAsyncResult Begin_MaterialRemove(AsyncCallback callback, object state, string barcode);
    string End_MaterialRemove(IAsyncResult asyncResult);
    #endif
  }

  public class Client : Iface {
    public Client(TProtocol prot) : this(prot, prot)
    {
    }

    public Client(TProtocol iprot, TProtocol oprot)
    {
      iprot_ = iprot;
      oprot_ = oprot;
    }

    protected TProtocol iprot_;
    protected TProtocol oprot_;
    protected int seqid_;

    public TProtocol InputProtocol
    {
      get { return iprot_; }
    }
    public TProtocol OutputProtocol
    {
      get { return oprot_; }
    }


    
    #if SILVERLIGHT
    public IAsyncResult Begin_sendCheckBarcode(AsyncCallback callback, object state, string barcode)
    {
      return send_sendCheckBarcode(callback, state, barcode);
    }

    public string End_sendCheckBarcode(IAsyncResult asyncResult)
    {
      oprot_.Transport.EndFlush(asyncResult);
      return recv_sendCheckBarcode();
    }

    #endif

    public string sendCheckBarcode(string barcode)
    {
      #if !SILVERLIGHT
      send_sendCheckBarcode(barcode);
      return recv_sendCheckBarcode();

      #else
      var asyncResult = Begin_sendCheckBarcode(null, null, barcode);
      return End_sendCheckBarcode(asyncResult);

      #endif
    }
    #if SILVERLIGHT
    public IAsyncResult send_sendCheckBarcode(AsyncCallback callback, object state, string barcode)
    #else
    public void send_sendCheckBarcode(string barcode)
    #endif
    {
      oprot_.WriteMessageBegin(new TMessage("sendCheckBarcode", TMessageType.Call, seqid_));
      sendCheckBarcode_args args = new sendCheckBarcode_args();
      args.Barcode = barcode;
      args.Write(oprot_);
      oprot_.WriteMessageEnd();
      #if SILVERLIGHT
      return oprot_.Transport.BeginFlush(callback, state);
      #else
      oprot_.Transport.Flush();
      #endif
    }

    public string recv_sendCheckBarcode()
    {
      TMessage msg = iprot_.ReadMessageBegin();
      if (msg.Type == TMessageType.Exception) {
        TApplicationException x = TApplicationException.Read(iprot_);
        iprot_.ReadMessageEnd();
        throw x;
      }
      sendCheckBarcode_result result = new sendCheckBarcode_result();
      result.Read(iprot_);
      iprot_.ReadMessageEnd();
      if (result.__isset.success) {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "sendCheckBarcode failed: unknown result");
    }

    
    #if SILVERLIGHT
    public IAsyncResult Begin_sendCarMaterialList(AsyncCallback callback, object state, List<string> CarNosOrMater, string order_code)
    {
      return send_sendCarMaterialList(callback, state, CarNosOrMater, order_code);
    }

    public string End_sendCarMaterialList(IAsyncResult asyncResult)
    {
      oprot_.Transport.EndFlush(asyncResult);
      return recv_sendCarMaterialList();
    }

    #endif

    public string sendCarMaterialList(List<string> CarNosOrMater, string order_code)
    {
      #if !SILVERLIGHT
      send_sendCarMaterialList(CarNosOrMater, order_code);
      return recv_sendCarMaterialList();

      #else
      var asyncResult = Begin_sendCarMaterialList(null, null, CarNosOrMater, order_code);
      return End_sendCarMaterialList(asyncResult);

      #endif
    }
    #if SILVERLIGHT
    public IAsyncResult send_sendCarMaterialList(AsyncCallback callback, object state, List<string> CarNosOrMater, string order_code)
    #else
    public void send_sendCarMaterialList(List<string> CarNosOrMater, string order_code)
    #endif
    {
      oprot_.WriteMessageBegin(new TMessage("sendCarMaterialList", TMessageType.Call, seqid_));
      sendCarMaterialList_args args = new sendCarMaterialList_args();
      args.CarNosOrMater = CarNosOrMater;
      args.Order_code = order_code;
      args.Write(oprot_);
      oprot_.WriteMessageEnd();
      #if SILVERLIGHT
      return oprot_.Transport.BeginFlush(callback, state);
      #else
      oprot_.Transport.Flush();
      #endif
    }

    public string recv_sendCarMaterialList()
    {
      TMessage msg = iprot_.ReadMessageBegin();
      if (msg.Type == TMessageType.Exception) {
        TApplicationException x = TApplicationException.Read(iprot_);
        iprot_.ReadMessageEnd();
        throw x;
      }
      sendCarMaterialList_result result = new sendCarMaterialList_result();
      result.Read(iprot_);
      iprot_.ReadMessageEnd();
      if (result.__isset.success) {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "sendCarMaterialList failed: unknown result");
    }

    
    #if SILVERLIGHT
    public IAsyncResult Begin_sendMaterialList(AsyncCallback callback, object state, List<string> MaterialNos)
    {
      return send_sendMaterialList(callback, state, MaterialNos);
    }

    public string End_sendMaterialList(IAsyncResult asyncResult)
    {
      oprot_.Transport.EndFlush(asyncResult);
      return recv_sendMaterialList();
    }

    #endif

    public string sendMaterialList(List<string> MaterialNos)
    {
      #if !SILVERLIGHT
      send_sendMaterialList(MaterialNos);
      return recv_sendMaterialList();

      #else
      var asyncResult = Begin_sendMaterialList(null, null, MaterialNos);
      return End_sendMaterialList(asyncResult);

      #endif
    }
    #if SILVERLIGHT
    public IAsyncResult send_sendMaterialList(AsyncCallback callback, object state, List<string> MaterialNos)
    #else
    public void send_sendMaterialList(List<string> MaterialNos)
    #endif
    {
      oprot_.WriteMessageBegin(new TMessage("sendMaterialList", TMessageType.Call, seqid_));
      sendMaterialList_args args = new sendMaterialList_args();
      args.MaterialNos = MaterialNos;
      args.Write(oprot_);
      oprot_.WriteMessageEnd();
      #if SILVERLIGHT
      return oprot_.Transport.BeginFlush(callback, state);
      #else
      oprot_.Transport.Flush();
      #endif
    }

    public string recv_sendMaterialList()
    {
      TMessage msg = iprot_.ReadMessageBegin();
      if (msg.Type == TMessageType.Exception) {
        TApplicationException x = TApplicationException.Read(iprot_);
        iprot_.ReadMessageEnd();
        throw x;
      }
      sendMaterialList_result result = new sendMaterialList_result();
      result.Read(iprot_);
      iprot_.ReadMessageEnd();
      if (result.__isset.success) {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "sendMaterialList failed: unknown result");
    }

    
    #if SILVERLIGHT
    public IAsyncResult Begin_SendSetCarInfo(AsyncCallback callback, object state, string carno, string materialno, string materialdesc, string locatorid, string outlocatorstate, string optdt)
    {
      return send_SendSetCarInfo(callback, state, carno, materialno, materialdesc, locatorid, outlocatorstate, optdt);
    }

    public string End_SendSetCarInfo(IAsyncResult asyncResult)
    {
      oprot_.Transport.EndFlush(asyncResult);
      return recv_SendSetCarInfo();
    }

    #endif

    public string SendSetCarInfo(string carno, string materialno, string materialdesc, string locatorid, string outlocatorstate, string optdt)
    {
      #if !SILVERLIGHT
      send_SendSetCarInfo(carno, materialno, materialdesc, locatorid, outlocatorstate, optdt);
      return recv_SendSetCarInfo();

      #else
      var asyncResult = Begin_SendSetCarInfo(null, null, carno, materialno, materialdesc, locatorid, outlocatorstate, optdt);
      return End_SendSetCarInfo(asyncResult);

      #endif
    }
    #if SILVERLIGHT
    public IAsyncResult send_SendSetCarInfo(AsyncCallback callback, object state, string carno, string materialno, string materialdesc, string locatorid, string outlocatorstate, string optdt)
    #else
    public void send_SendSetCarInfo(string carno, string materialno, string materialdesc, string locatorid, string outlocatorstate, string optdt)
    #endif
    {
      oprot_.WriteMessageBegin(new TMessage("SendSetCarInfo", TMessageType.Call, seqid_));
      SendSetCarInfo_args args = new SendSetCarInfo_args();
      args.Carno = carno;
      args.Materialno = materialno;
      args.Materialdesc = materialdesc;
      args.Locatorid = locatorid;
      args.Outlocatorstate = outlocatorstate;
      args.Optdt = optdt;
      args.Write(oprot_);
      oprot_.WriteMessageEnd();
      #if SILVERLIGHT
      return oprot_.Transport.BeginFlush(callback, state);
      #else
      oprot_.Transport.Flush();
      #endif
    }

    public string recv_SendSetCarInfo()
    {
      TMessage msg = iprot_.ReadMessageBegin();
      if (msg.Type == TMessageType.Exception) {
        TApplicationException x = TApplicationException.Read(iprot_);
        iprot_.ReadMessageEnd();
        throw x;
      }
      SendSetCarInfo_result result = new SendSetCarInfo_result();
      result.Read(iprot_);
      iprot_.ReadMessageEnd();
      if (result.__isset.success) {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "SendSetCarInfo failed: unknown result");
    }

    
    #if SILVERLIGHT
    public IAsyncResult Begin_SendCheckServerState(AsyncCallback callback, object state, )
    {
      return send_SendCheckServerState(callback, state);
    }

    public string End_SendCheckServerState(IAsyncResult asyncResult)
    {
      oprot_.Transport.EndFlush(asyncResult);
      return recv_SendCheckServerState();
    }

    #endif

    public string SendCheckServerState()
    {
      #if !SILVERLIGHT
      send_SendCheckServerState();
      return recv_SendCheckServerState();

      #else
      var asyncResult = Begin_SendCheckServerState(null, null, );
      return End_SendCheckServerState(asyncResult);

      #endif
    }
    #if SILVERLIGHT
    public IAsyncResult send_SendCheckServerState(AsyncCallback callback, object state, )
    #else
    public void send_SendCheckServerState()
    #endif
    {
      oprot_.WriteMessageBegin(new TMessage("SendCheckServerState", TMessageType.Call, seqid_));
      SendCheckServerState_args args = new SendCheckServerState_args();
      args.Write(oprot_);
      oprot_.WriteMessageEnd();
      #if SILVERLIGHT
      return oprot_.Transport.BeginFlush(callback, state);
      #else
      oprot_.Transport.Flush();
      #endif
    }

    public string recv_SendCheckServerState()
    {
      TMessage msg = iprot_.ReadMessageBegin();
      if (msg.Type == TMessageType.Exception) {
        TApplicationException x = TApplicationException.Read(iprot_);
        iprot_.ReadMessageEnd();
        throw x;
      }
      SendCheckServerState_result result = new SendCheckServerState_result();
      result.Read(iprot_);
      iprot_.ReadMessageEnd();
      if (result.__isset.success) {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "SendCheckServerState failed: unknown result");
    }

    
    #if SILVERLIGHT
    public IAsyncResult Begin_GetReceiveCarNo(AsyncCallback callback, object state, string carno)
    {
      return send_GetReceiveCarNo(callback, state, carno);
    }

    public string End_GetReceiveCarNo(IAsyncResult asyncResult)
    {
      oprot_.Transport.EndFlush(asyncResult);
      return recv_GetReceiveCarNo();
    }

    #endif

    public string GetReceiveCarNo(string carno)
    {
      #if !SILVERLIGHT
      send_GetReceiveCarNo(carno);
      return recv_GetReceiveCarNo();

      #else
      var asyncResult = Begin_GetReceiveCarNo(null, null, carno);
      return End_GetReceiveCarNo(asyncResult);

      #endif
    }
    #if SILVERLIGHT
    public IAsyncResult send_GetReceiveCarNo(AsyncCallback callback, object state, string carno)
    #else
    public void send_GetReceiveCarNo(string carno)
    #endif
    {
      oprot_.WriteMessageBegin(new TMessage("GetReceiveCarNo", TMessageType.Call, seqid_));
      GetReceiveCarNo_args args = new GetReceiveCarNo_args();
      args.Carno = carno;
      args.Write(oprot_);
      oprot_.WriteMessageEnd();
      #if SILVERLIGHT
      return oprot_.Transport.BeginFlush(callback, state);
      #else
      oprot_.Transport.Flush();
      #endif
    }

    public string recv_GetReceiveCarNo()
    {
      TMessage msg = iprot_.ReadMessageBegin();
      if (msg.Type == TMessageType.Exception) {
        TApplicationException x = TApplicationException.Read(iprot_);
        iprot_.ReadMessageEnd();
        throw x;
      }
      GetReceiveCarNo_result result = new GetReceiveCarNo_result();
      result.Read(iprot_);
      iprot_.ReadMessageEnd();
      if (result.__isset.success) {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "GetReceiveCarNo failed: unknown result");
    }

    
    #if SILVERLIGHT
    public IAsyncResult Begin_GetLocatorInfoList(AsyncCallback callback, object state, )
    {
      return send_GetLocatorInfoList(callback, state);
    }

    public string End_GetLocatorInfoList(IAsyncResult asyncResult)
    {
      oprot_.Transport.EndFlush(asyncResult);
      return recv_GetLocatorInfoList();
    }

    #endif

    public string GetLocatorInfoList()
    {
      #if !SILVERLIGHT
      send_GetLocatorInfoList();
      return recv_GetLocatorInfoList();

      #else
      var asyncResult = Begin_GetLocatorInfoList(null, null, );
      return End_GetLocatorInfoList(asyncResult);

      #endif
    }
    #if SILVERLIGHT
    public IAsyncResult send_GetLocatorInfoList(AsyncCallback callback, object state, )
    #else
    public void send_GetLocatorInfoList()
    #endif
    {
      oprot_.WriteMessageBegin(new TMessage("GetLocatorInfoList", TMessageType.Call, seqid_));
      GetLocatorInfoList_args args = new GetLocatorInfoList_args();
      args.Write(oprot_);
      oprot_.WriteMessageEnd();
      #if SILVERLIGHT
      return oprot_.Transport.BeginFlush(callback, state);
      #else
      oprot_.Transport.Flush();
      #endif
    }

    public string recv_GetLocatorInfoList()
    {
      TMessage msg = iprot_.ReadMessageBegin();
      if (msg.Type == TMessageType.Exception) {
        TApplicationException x = TApplicationException.Read(iprot_);
        iprot_.ReadMessageEnd();
        throw x;
      }
      GetLocatorInfoList_result result = new GetLocatorInfoList_result();
      result.Read(iprot_);
      iprot_.ReadMessageEnd();
      if (result.__isset.success) {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "GetLocatorInfoList failed: unknown result");
    }

    
    #if SILVERLIGHT
    public IAsyncResult Begin_GetOutLocatorList(AsyncCallback callback, object state, )
    {
      return send_GetOutLocatorList(callback, state);
    }

    public string End_GetOutLocatorList(IAsyncResult asyncResult)
    {
      oprot_.Transport.EndFlush(asyncResult);
      return recv_GetOutLocatorList();
    }

    #endif

    public string GetOutLocatorList()
    {
      #if !SILVERLIGHT
      send_GetOutLocatorList();
      return recv_GetOutLocatorList();

      #else
      var asyncResult = Begin_GetOutLocatorList(null, null, );
      return End_GetOutLocatorList(asyncResult);

      #endif
    }
    #if SILVERLIGHT
    public IAsyncResult send_GetOutLocatorList(AsyncCallback callback, object state, )
    #else
    public void send_GetOutLocatorList()
    #endif
    {
      oprot_.WriteMessageBegin(new TMessage("GetOutLocatorList", TMessageType.Call, seqid_));
      GetOutLocatorList_args args = new GetOutLocatorList_args();
      args.Write(oprot_);
      oprot_.WriteMessageEnd();
      #if SILVERLIGHT
      return oprot_.Transport.BeginFlush(callback, state);
      #else
      oprot_.Transport.Flush();
      #endif
    }

    public string recv_GetOutLocatorList()
    {
      TMessage msg = iprot_.ReadMessageBegin();
      if (msg.Type == TMessageType.Exception) {
        TApplicationException x = TApplicationException.Read(iprot_);
        iprot_.ReadMessageEnd();
        throw x;
      }
      GetOutLocatorList_result result = new GetOutLocatorList_result();
      result.Read(iprot_);
      iprot_.ReadMessageEnd();
      if (result.__isset.success) {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "GetOutLocatorList failed: unknown result");
    }

    
    #if SILVERLIGHT
    public IAsyncResult Begin_SendOutLocatorBarcode(AsyncCallback callback, object state, string barcode)
    {
      return send_SendOutLocatorBarcode(callback, state, barcode);
    }

    public string End_SendOutLocatorBarcode(IAsyncResult asyncResult)
    {
      oprot_.Transport.EndFlush(asyncResult);
      return recv_SendOutLocatorBarcode();
    }

    #endif

    public string SendOutLocatorBarcode(string barcode)
    {
      #if !SILVERLIGHT
      send_SendOutLocatorBarcode(barcode);
      return recv_SendOutLocatorBarcode();

      #else
      var asyncResult = Begin_SendOutLocatorBarcode(null, null, barcode);
      return End_SendOutLocatorBarcode(asyncResult);

      #endif
    }
    #if SILVERLIGHT
    public IAsyncResult send_SendOutLocatorBarcode(AsyncCallback callback, object state, string barcode)
    #else
    public void send_SendOutLocatorBarcode(string barcode)
    #endif
    {
      oprot_.WriteMessageBegin(new TMessage("SendOutLocatorBarcode", TMessageType.Call, seqid_));
      SendOutLocatorBarcode_args args = new SendOutLocatorBarcode_args();
      args.Barcode = barcode;
      args.Write(oprot_);
      oprot_.WriteMessageEnd();
      #if SILVERLIGHT
      return oprot_.Transport.BeginFlush(callback, state);
      #else
      oprot_.Transport.Flush();
      #endif
    }

    public string recv_SendOutLocatorBarcode()
    {
      TMessage msg = iprot_.ReadMessageBegin();
      if (msg.Type == TMessageType.Exception) {
        TApplicationException x = TApplicationException.Read(iprot_);
        iprot_.ReadMessageEnd();
        throw x;
      }
      SendOutLocatorBarcode_result result = new SendOutLocatorBarcode_result();
      result.Read(iprot_);
      iprot_.ReadMessageEnd();
      if (result.__isset.success) {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "SendOutLocatorBarcode failed: unknown result");
    }

    
    #if SILVERLIGHT
    public IAsyncResult Begin_GetLineAreaList(AsyncCallback callback, object state, List<LineArea> linearealist)
    {
      return send_GetLineAreaList(callback, state, linearealist);
    }

    public string End_GetLineAreaList(IAsyncResult asyncResult)
    {
      oprot_.Transport.EndFlush(asyncResult);
      return recv_GetLineAreaList();
    }

    #endif

    public string GetLineAreaList(List<LineArea> linearealist)
    {
      #if !SILVERLIGHT
      send_GetLineAreaList(linearealist);
      return recv_GetLineAreaList();

      #else
      var asyncResult = Begin_GetLineAreaList(null, null, linearealist);
      return End_GetLineAreaList(asyncResult);

      #endif
    }
    #if SILVERLIGHT
    public IAsyncResult send_GetLineAreaList(AsyncCallback callback, object state, List<LineArea> linearealist)
    #else
    public void send_GetLineAreaList(List<LineArea> linearealist)
    #endif
    {
      oprot_.WriteMessageBegin(new TMessage("GetLineAreaList", TMessageType.Call, seqid_));
      GetLineAreaList_args args = new GetLineAreaList_args();
      args.Linearealist = linearealist;
      args.Write(oprot_);
      oprot_.WriteMessageEnd();
      #if SILVERLIGHT
      return oprot_.Transport.BeginFlush(callback, state);
      #else
      oprot_.Transport.Flush();
      #endif
    }

    public string recv_GetLineAreaList()
    {
      TMessage msg = iprot_.ReadMessageBegin();
      if (msg.Type == TMessageType.Exception) {
        TApplicationException x = TApplicationException.Read(iprot_);
        iprot_.ReadMessageEnd();
        throw x;
      }
      GetLineAreaList_result result = new GetLineAreaList_result();
      result.Read(iprot_);
      iprot_.ReadMessageEnd();
      if (result.__isset.success) {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "GetLineAreaList failed: unknown result");
    }

    
    #if SILVERLIGHT
    public IAsyncResult Begin_GetCarAreaList(AsyncCallback callback, object state, List<CarArea> cararealist)
    {
      return send_GetCarAreaList(callback, state, cararealist);
    }

    public string End_GetCarAreaList(IAsyncResult asyncResult)
    {
      oprot_.Transport.EndFlush(asyncResult);
      return recv_GetCarAreaList();
    }

    #endif

    public string GetCarAreaList(List<CarArea> cararealist)
    {
      #if !SILVERLIGHT
      send_GetCarAreaList(cararealist);
      return recv_GetCarAreaList();

      #else
      var asyncResult = Begin_GetCarAreaList(null, null, cararealist);
      return End_GetCarAreaList(asyncResult);

      #endif
    }
    #if SILVERLIGHT
    public IAsyncResult send_GetCarAreaList(AsyncCallback callback, object state, List<CarArea> cararealist)
    #else
    public void send_GetCarAreaList(List<CarArea> cararealist)
    #endif
    {
      oprot_.WriteMessageBegin(new TMessage("GetCarAreaList", TMessageType.Call, seqid_));
      GetCarAreaList_args args = new GetCarAreaList_args();
      args.Cararealist = cararealist;
      args.Write(oprot_);
      oprot_.WriteMessageEnd();
      #if SILVERLIGHT
      return oprot_.Transport.BeginFlush(callback, state);
      #else
      oprot_.Transport.Flush();
      #endif
    }

    public string recv_GetCarAreaList()
    {
      TMessage msg = iprot_.ReadMessageBegin();
      if (msg.Type == TMessageType.Exception) {
        TApplicationException x = TApplicationException.Read(iprot_);
        iprot_.ReadMessageEnd();
        throw x;
      }
      GetCarAreaList_result result = new GetCarAreaList_result();
      result.Read(iprot_);
      iprot_.ReadMessageEnd();
      if (result.__isset.success) {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "GetCarAreaList failed: unknown result");
    }

    
    #if SILVERLIGHT
    public IAsyncResult Begin_GetOrderList(AsyncCallback callback, object state, List<Order> orderlist)
    {
      return send_GetOrderList(callback, state, orderlist);
    }

    public string End_GetOrderList(IAsyncResult asyncResult)
    {
      oprot_.Transport.EndFlush(asyncResult);
      return recv_GetOrderList();
    }

    #endif

    public string GetOrderList(List<Order> orderlist)
    {
      #if !SILVERLIGHT
      send_GetOrderList(orderlist);
      return recv_GetOrderList();

      #else
      var asyncResult = Begin_GetOrderList(null, null, orderlist);
      return End_GetOrderList(asyncResult);

      #endif
    }
    #if SILVERLIGHT
    public IAsyncResult send_GetOrderList(AsyncCallback callback, object state, List<Order> orderlist)
    #else
    public void send_GetOrderList(List<Order> orderlist)
    #endif
    {
      oprot_.WriteMessageBegin(new TMessage("GetOrderList", TMessageType.Call, seqid_));
      GetOrderList_args args = new GetOrderList_args();
      args.Orderlist = orderlist;
      args.Write(oprot_);
      oprot_.WriteMessageEnd();
      #if SILVERLIGHT
      return oprot_.Transport.BeginFlush(callback, state);
      #else
      oprot_.Transport.Flush();
      #endif
    }

    public string recv_GetOrderList()
    {
      TMessage msg = iprot_.ReadMessageBegin();
      if (msg.Type == TMessageType.Exception) {
        TApplicationException x = TApplicationException.Read(iprot_);
        iprot_.ReadMessageEnd();
        throw x;
      }
      GetOrderList_result result = new GetOrderList_result();
      result.Read(iprot_);
      iprot_.ReadMessageEnd();
      if (result.__isset.success) {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "GetOrderList failed: unknown result");
    }

    
    #if SILVERLIGHT
    public IAsyncResult Begin_GetOutCarLineList(AsyncCallback callback, object state, List<OutCarLine> outcarlinelist)
    {
      return send_GetOutCarLineList(callback, state, outcarlinelist);
    }

    public string End_GetOutCarLineList(IAsyncResult asyncResult)
    {
      oprot_.Transport.EndFlush(asyncResult);
      return recv_GetOutCarLineList();
    }

    #endif

    public string GetOutCarLineList(List<OutCarLine> outcarlinelist)
    {
      #if !SILVERLIGHT
      send_GetOutCarLineList(outcarlinelist);
      return recv_GetOutCarLineList();

      #else
      var asyncResult = Begin_GetOutCarLineList(null, null, outcarlinelist);
      return End_GetOutCarLineList(asyncResult);

      #endif
    }
    #if SILVERLIGHT
    public IAsyncResult send_GetOutCarLineList(AsyncCallback callback, object state, List<OutCarLine> outcarlinelist)
    #else
    public void send_GetOutCarLineList(List<OutCarLine> outcarlinelist)
    #endif
    {
      oprot_.WriteMessageBegin(new TMessage("GetOutCarLineList", TMessageType.Call, seqid_));
      GetOutCarLineList_args args = new GetOutCarLineList_args();
      args.Outcarlinelist = outcarlinelist;
      args.Write(oprot_);
      oprot_.WriteMessageEnd();
      #if SILVERLIGHT
      return oprot_.Transport.BeginFlush(callback, state);
      #else
      oprot_.Transport.Flush();
      #endif
    }

    public string recv_GetOutCarLineList()
    {
      TMessage msg = iprot_.ReadMessageBegin();
      if (msg.Type == TMessageType.Exception) {
        TApplicationException x = TApplicationException.Read(iprot_);
        iprot_.ReadMessageEnd();
        throw x;
      }
      GetOutCarLineList_result result = new GetOutCarLineList_result();
      result.Read(iprot_);
      iprot_.ReadMessageEnd();
      if (result.__isset.success) {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "GetOutCarLineList failed: unknown result");
    }

    
    #if SILVERLIGHT
    public IAsyncResult Begin_GetMaterialList(AsyncCallback callback, object state, List<string> MaterialNos)
    {
      return send_GetMaterialList(callback, state, MaterialNos);
    }

    public string End_GetMaterialList(IAsyncResult asyncResult)
    {
      oprot_.Transport.EndFlush(asyncResult);
      return recv_GetMaterialList();
    }

    #endif

    public string GetMaterialList(List<string> MaterialNos)
    {
      #if !SILVERLIGHT
      send_GetMaterialList(MaterialNos);
      return recv_GetMaterialList();

      #else
      var asyncResult = Begin_GetMaterialList(null, null, MaterialNos);
      return End_GetMaterialList(asyncResult);

      #endif
    }
    #if SILVERLIGHT
    public IAsyncResult send_GetMaterialList(AsyncCallback callback, object state, List<string> MaterialNos)
    #else
    public void send_GetMaterialList(List<string> MaterialNos)
    #endif
    {
      oprot_.WriteMessageBegin(new TMessage("GetMaterialList", TMessageType.Call, seqid_));
      GetMaterialList_args args = new GetMaterialList_args();
      args.MaterialNos = MaterialNos;
      args.Write(oprot_);
      oprot_.WriteMessageEnd();
      #if SILVERLIGHT
      return oprot_.Transport.BeginFlush(callback, state);
      #else
      oprot_.Transport.Flush();
      #endif
    }

    public string recv_GetMaterialList()
    {
      TMessage msg = iprot_.ReadMessageBegin();
      if (msg.Type == TMessageType.Exception) {
        TApplicationException x = TApplicationException.Read(iprot_);
        iprot_.ReadMessageEnd();
        throw x;
      }
      GetMaterialList_result result = new GetMaterialList_result();
      result.Read(iprot_);
      iprot_.ReadMessageEnd();
      if (result.__isset.success) {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "GetMaterialList failed: unknown result");
    }

    
    #if SILVERLIGHT
    public IAsyncResult Begin_GetUpDownMaterielNum(AsyncCallback callback, object state, string siteno)
    {
      return send_GetUpDownMaterielNum(callback, state, siteno);
    }

    public string End_GetUpDownMaterielNum(IAsyncResult asyncResult)
    {
      oprot_.Transport.EndFlush(asyncResult);
      return recv_GetUpDownMaterielNum();
    }

    #endif

    public string GetUpDownMaterielNum(string siteno)
    {
      #if !SILVERLIGHT
      send_GetUpDownMaterielNum(siteno);
      return recv_GetUpDownMaterielNum();

      #else
      var asyncResult = Begin_GetUpDownMaterielNum(null, null, siteno);
      return End_GetUpDownMaterielNum(asyncResult);

      #endif
    }
    #if SILVERLIGHT
    public IAsyncResult send_GetUpDownMaterielNum(AsyncCallback callback, object state, string siteno)
    #else
    public void send_GetUpDownMaterielNum(string siteno)
    #endif
    {
      oprot_.WriteMessageBegin(new TMessage("GetUpDownMaterielNum", TMessageType.Call, seqid_));
      GetUpDownMaterielNum_args args = new GetUpDownMaterielNum_args();
      args.Siteno = siteno;
      args.Write(oprot_);
      oprot_.WriteMessageEnd();
      #if SILVERLIGHT
      return oprot_.Transport.BeginFlush(callback, state);
      #else
      oprot_.Transport.Flush();
      #endif
    }

    public string recv_GetUpDownMaterielNum()
    {
      TMessage msg = iprot_.ReadMessageBegin();
      if (msg.Type == TMessageType.Exception) {
        TApplicationException x = TApplicationException.Read(iprot_);
        iprot_.ReadMessageEnd();
        throw x;
      }
      GetUpDownMaterielNum_result result = new GetUpDownMaterielNum_result();
      result.Read(iprot_);
      iprot_.ReadMessageEnd();
      if (result.__isset.success) {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "GetUpDownMaterielNum failed: unknown result");
    }

    
    #if SILVERLIGHT
    public IAsyncResult Begin_SendDeleteRelief(AsyncCallback callback, object state, )
    {
      return send_SendDeleteRelief(callback, state);
    }

    public string End_SendDeleteRelief(IAsyncResult asyncResult)
    {
      oprot_.Transport.EndFlush(asyncResult);
      return recv_SendDeleteRelief();
    }

    #endif

    public string SendDeleteRelief()
    {
      #if !SILVERLIGHT
      send_SendDeleteRelief();
      return recv_SendDeleteRelief();

      #else
      var asyncResult = Begin_SendDeleteRelief(null, null, );
      return End_SendDeleteRelief(asyncResult);

      #endif
    }
    #if SILVERLIGHT
    public IAsyncResult send_SendDeleteRelief(AsyncCallback callback, object state, )
    #else
    public void send_SendDeleteRelief()
    #endif
    {
      oprot_.WriteMessageBegin(new TMessage("SendDeleteRelief", TMessageType.Call, seqid_));
      SendDeleteRelief_args args = new SendDeleteRelief_args();
      args.Write(oprot_);
      oprot_.WriteMessageEnd();
      #if SILVERLIGHT
      return oprot_.Transport.BeginFlush(callback, state);
      #else
      oprot_.Transport.Flush();
      #endif
    }

    public string recv_SendDeleteRelief()
    {
      TMessage msg = iprot_.ReadMessageBegin();
      if (msg.Type == TMessageType.Exception) {
        TApplicationException x = TApplicationException.Read(iprot_);
        iprot_.ReadMessageEnd();
        throw x;
      }
      SendDeleteRelief_result result = new SendDeleteRelief_result();
      result.Read(iprot_);
      iprot_.ReadMessageEnd();
      if (result.__isset.success) {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "SendDeleteRelief failed: unknown result");
    }

    
    #if SILVERLIGHT
    public IAsyncResult Begin_SendUpdateDownNum(AsyncCallback callback, object state, )
    {
      return send_SendUpdateDownNum(callback, state);
    }

    public string End_SendUpdateDownNum(IAsyncResult asyncResult)
    {
      oprot_.Transport.EndFlush(asyncResult);
      return recv_SendUpdateDownNum();
    }

    #endif

    public string SendUpdateDownNum()
    {
      #if !SILVERLIGHT
      send_SendUpdateDownNum();
      return recv_SendUpdateDownNum();

      #else
      var asyncResult = Begin_SendUpdateDownNum(null, null, );
      return End_SendUpdateDownNum(asyncResult);

      #endif
    }
    #if SILVERLIGHT
    public IAsyncResult send_SendUpdateDownNum(AsyncCallback callback, object state, )
    #else
    public void send_SendUpdateDownNum()
    #endif
    {
      oprot_.WriteMessageBegin(new TMessage("SendUpdateDownNum", TMessageType.Call, seqid_));
      SendUpdateDownNum_args args = new SendUpdateDownNum_args();
      args.Write(oprot_);
      oprot_.WriteMessageEnd();
      #if SILVERLIGHT
      return oprot_.Transport.BeginFlush(callback, state);
      #else
      oprot_.Transport.Flush();
      #endif
    }

    public string recv_SendUpdateDownNum()
    {
      TMessage msg = iprot_.ReadMessageBegin();
      if (msg.Type == TMessageType.Exception) {
        TApplicationException x = TApplicationException.Read(iprot_);
        iprot_.ReadMessageEnd();
        throw x;
      }
      SendUpdateDownNum_result result = new SendUpdateDownNum_result();
      result.Read(iprot_);
      iprot_.ReadMessageEnd();
      if (result.__isset.success) {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "SendUpdateDownNum failed: unknown result");
    }

    
    #if SILVERLIGHT
    public IAsyncResult Begin_GetDownLineNum(AsyncCallback callback, object state, string downnum)
    {
      return send_GetDownLineNum(callback, state, downnum);
    }

    public string End_GetDownLineNum(IAsyncResult asyncResult)
    {
      oprot_.Transport.EndFlush(asyncResult);
      return recv_GetDownLineNum();
    }

    #endif

    public string GetDownLineNum(string downnum)
    {
      #if !SILVERLIGHT
      send_GetDownLineNum(downnum);
      return recv_GetDownLineNum();

      #else
      var asyncResult = Begin_GetDownLineNum(null, null, downnum);
      return End_GetDownLineNum(asyncResult);

      #endif
    }
    #if SILVERLIGHT
    public IAsyncResult send_GetDownLineNum(AsyncCallback callback, object state, string downnum)
    #else
    public void send_GetDownLineNum(string downnum)
    #endif
    {
      oprot_.WriteMessageBegin(new TMessage("GetDownLineNum", TMessageType.Call, seqid_));
      GetDownLineNum_args args = new GetDownLineNum_args();
      args.Downnum = downnum;
      args.Write(oprot_);
      oprot_.WriteMessageEnd();
      #if SILVERLIGHT
      return oprot_.Transport.BeginFlush(callback, state);
      #else
      oprot_.Transport.Flush();
      #endif
    }

    public string recv_GetDownLineNum()
    {
      TMessage msg = iprot_.ReadMessageBegin();
      if (msg.Type == TMessageType.Exception) {
        TApplicationException x = TApplicationException.Read(iprot_);
        iprot_.ReadMessageEnd();
        throw x;
      }
      GetDownLineNum_result result = new GetDownLineNum_result();
      result.Read(iprot_);
      iprot_.ReadMessageEnd();
      if (result.__isset.success) {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "GetDownLineNum failed: unknown result");
    }

    
    #if SILVERLIGHT
    public IAsyncResult Begin_GetMaterielNumByKBList(AsyncCallback callback, object state, List<MaterielNumKB> materielnumlist)
    {
      return send_GetMaterielNumByKBList(callback, state, materielnumlist);
    }

    public string End_GetMaterielNumByKBList(IAsyncResult asyncResult)
    {
      oprot_.Transport.EndFlush(asyncResult);
      return recv_GetMaterielNumByKBList();
    }

    #endif

    public string GetMaterielNumByKBList(List<MaterielNumKB> materielnumlist)
    {
      #if !SILVERLIGHT
      send_GetMaterielNumByKBList(materielnumlist);
      return recv_GetMaterielNumByKBList();

      #else
      var asyncResult = Begin_GetMaterielNumByKBList(null, null, materielnumlist);
      return End_GetMaterielNumByKBList(asyncResult);

      #endif
    }
    #if SILVERLIGHT
    public IAsyncResult send_GetMaterielNumByKBList(AsyncCallback callback, object state, List<MaterielNumKB> materielnumlist)
    #else
    public void send_GetMaterielNumByKBList(List<MaterielNumKB> materielnumlist)
    #endif
    {
      oprot_.WriteMessageBegin(new TMessage("GetMaterielNumByKBList", TMessageType.Call, seqid_));
      GetMaterielNumByKBList_args args = new GetMaterielNumByKBList_args();
      args.Materielnumlist = materielnumlist;
      args.Write(oprot_);
      oprot_.WriteMessageEnd();
      #if SILVERLIGHT
      return oprot_.Transport.BeginFlush(callback, state);
      #else
      oprot_.Transport.Flush();
      #endif
    }

    public string recv_GetMaterielNumByKBList()
    {
      TMessage msg = iprot_.ReadMessageBegin();
      if (msg.Type == TMessageType.Exception) {
        TApplicationException x = TApplicationException.Read(iprot_);
        iprot_.ReadMessageEnd();
        throw x;
      }
      GetMaterielNumByKBList_result result = new GetMaterielNumByKBList_result();
      result.Read(iprot_);
      iprot_.ReadMessageEnd();
      if (result.__isset.success) {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "GetMaterielNumByKBList failed: unknown result");
    }

    
    #if SILVERLIGHT
    public IAsyncResult Begin_GetFaultList(AsyncCallback callback, object state, List<Fault> faultlist)
    {
      return send_GetFaultList(callback, state, faultlist);
    }

    public string End_GetFaultList(IAsyncResult asyncResult)
    {
      oprot_.Transport.EndFlush(asyncResult);
      return recv_GetFaultList();
    }

    #endif

    public string GetFaultList(List<Fault> faultlist)
    {
      #if !SILVERLIGHT
      send_GetFaultList(faultlist);
      return recv_GetFaultList();

      #else
      var asyncResult = Begin_GetFaultList(null, null, faultlist);
      return End_GetFaultList(asyncResult);

      #endif
    }
    #if SILVERLIGHT
    public IAsyncResult send_GetFaultList(AsyncCallback callback, object state, List<Fault> faultlist)
    #else
    public void send_GetFaultList(List<Fault> faultlist)
    #endif
    {
      oprot_.WriteMessageBegin(new TMessage("GetFaultList", TMessageType.Call, seqid_));
      GetFaultList_args args = new GetFaultList_args();
      args.Faultlist = faultlist;
      args.Write(oprot_);
      oprot_.WriteMessageEnd();
      #if SILVERLIGHT
      return oprot_.Transport.BeginFlush(callback, state);
      #else
      oprot_.Transport.Flush();
      #endif
    }

    public string recv_GetFaultList()
    {
      TMessage msg = iprot_.ReadMessageBegin();
      if (msg.Type == TMessageType.Exception) {
        TApplicationException x = TApplicationException.Read(iprot_);
        iprot_.ReadMessageEnd();
        throw x;
      }
      GetFaultList_result result = new GetFaultList_result();
      result.Read(iprot_);
      iprot_.ReadMessageEnd();
      if (result.__isset.success) {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "GetFaultList failed: unknown result");
    }

    
    #if SILVERLIGHT
    public IAsyncResult Begin_GetAreaPlcList(AsyncCallback callback, object state, List<AreaPlc> areaplclist)
    {
      return send_GetAreaPlcList(callback, state, areaplclist);
    }

    public string End_GetAreaPlcList(IAsyncResult asyncResult)
    {
      oprot_.Transport.EndFlush(asyncResult);
      return recv_GetAreaPlcList();
    }

    #endif

    public string GetAreaPlcList(List<AreaPlc> areaplclist)
    {
      #if !SILVERLIGHT
      send_GetAreaPlcList(areaplclist);
      return recv_GetAreaPlcList();

      #else
      var asyncResult = Begin_GetAreaPlcList(null, null, areaplclist);
      return End_GetAreaPlcList(asyncResult);

      #endif
    }
    #if SILVERLIGHT
    public IAsyncResult send_GetAreaPlcList(AsyncCallback callback, object state, List<AreaPlc> areaplclist)
    #else
    public void send_GetAreaPlcList(List<AreaPlc> areaplclist)
    #endif
    {
      oprot_.WriteMessageBegin(new TMessage("GetAreaPlcList", TMessageType.Call, seqid_));
      GetAreaPlcList_args args = new GetAreaPlcList_args();
      args.Areaplclist = areaplclist;
      args.Write(oprot_);
      oprot_.WriteMessageEnd();
      #if SILVERLIGHT
      return oprot_.Transport.BeginFlush(callback, state);
      #else
      oprot_.Transport.Flush();
      #endif
    }

    public string recv_GetAreaPlcList()
    {
      TMessage msg = iprot_.ReadMessageBegin();
      if (msg.Type == TMessageType.Exception) {
        TApplicationException x = TApplicationException.Read(iprot_);
        iprot_.ReadMessageEnd();
        throw x;
      }
      GetAreaPlcList_result result = new GetAreaPlcList_result();
      result.Read(iprot_);
      iprot_.ReadMessageEnd();
      if (result.__isset.success) {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "GetAreaPlcList failed: unknown result");
    }

    
    #if SILVERLIGHT
    public IAsyncResult Begin_SendInsertFault(AsyncCallback callback, object state, )
    {
      return send_SendInsertFault(callback, state);
    }

    public string End_SendInsertFault(IAsyncResult asyncResult)
    {
      oprot_.Transport.EndFlush(asyncResult);
      return recv_SendInsertFault();
    }

    #endif

    public string SendInsertFault()
    {
      #if !SILVERLIGHT
      send_SendInsertFault();
      return recv_SendInsertFault();

      #else
      var asyncResult = Begin_SendInsertFault(null, null, );
      return End_SendInsertFault(asyncResult);

      #endif
    }
    #if SILVERLIGHT
    public IAsyncResult send_SendInsertFault(AsyncCallback callback, object state, )
    #else
    public void send_SendInsertFault()
    #endif
    {
      oprot_.WriteMessageBegin(new TMessage("SendInsertFault", TMessageType.Call, seqid_));
      SendInsertFault_args args = new SendInsertFault_args();
      args.Write(oprot_);
      oprot_.WriteMessageEnd();
      #if SILVERLIGHT
      return oprot_.Transport.BeginFlush(callback, state);
      #else
      oprot_.Transport.Flush();
      #endif
    }

    public string recv_SendInsertFault()
    {
      TMessage msg = iprot_.ReadMessageBegin();
      if (msg.Type == TMessageType.Exception) {
        TApplicationException x = TApplicationException.Read(iprot_);
        iprot_.ReadMessageEnd();
        throw x;
      }
      SendInsertFault_result result = new SendInsertFault_result();
      result.Read(iprot_);
      iprot_.ReadMessageEnd();
      if (result.__isset.success) {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "SendInsertFault failed: unknown result");
    }

    
    #if SILVERLIGHT
    public IAsyncResult Begin_SendUpdateFault(AsyncCallback callback, object state, )
    {
      return send_SendUpdateFault(callback, state);
    }

    public string End_SendUpdateFault(IAsyncResult asyncResult)
    {
      oprot_.Transport.EndFlush(asyncResult);
      return recv_SendUpdateFault();
    }

    #endif

    public string SendUpdateFault()
    {
      #if !SILVERLIGHT
      send_SendUpdateFault();
      return recv_SendUpdateFault();

      #else
      var asyncResult = Begin_SendUpdateFault(null, null, );
      return End_SendUpdateFault(asyncResult);

      #endif
    }
    #if SILVERLIGHT
    public IAsyncResult send_SendUpdateFault(AsyncCallback callback, object state, )
    #else
    public void send_SendUpdateFault()
    #endif
    {
      oprot_.WriteMessageBegin(new TMessage("SendUpdateFault", TMessageType.Call, seqid_));
      SendUpdateFault_args args = new SendUpdateFault_args();
      args.Write(oprot_);
      oprot_.WriteMessageEnd();
      #if SILVERLIGHT
      return oprot_.Transport.BeginFlush(callback, state);
      #else
      oprot_.Transport.Flush();
      #endif
    }

    public string recv_SendUpdateFault()
    {
      TMessage msg = iprot_.ReadMessageBegin();
      if (msg.Type == TMessageType.Exception) {
        TApplicationException x = TApplicationException.Read(iprot_);
        iprot_.ReadMessageEnd();
        throw x;
      }
      SendUpdateFault_result result = new SendUpdateFault_result();
      result.Read(iprot_);
      iprot_.ReadMessageEnd();
      if (result.__isset.success) {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "SendUpdateFault failed: unknown result");
    }

    
    #if SILVERLIGHT
    public IAsyncResult Begin_ShowUpBarcode(AsyncCallback callback, object state, string barcode, string materialno, string message, int status)
    {
      return send_ShowUpBarcode(callback, state, barcode, materialno, message, status);
    }

    public string End_ShowUpBarcode(IAsyncResult asyncResult)
    {
      oprot_.Transport.EndFlush(asyncResult);
      return recv_ShowUpBarcode();
    }

    #endif

    public string ShowUpBarcode(string barcode, string materialno, string message, int status)
    {
      #if !SILVERLIGHT
      send_ShowUpBarcode(barcode, materialno, message, status);
      return recv_ShowUpBarcode();

      #else
      var asyncResult = Begin_ShowUpBarcode(null, null, barcode, materialno, message, status);
      return End_ShowUpBarcode(asyncResult);

      #endif
    }
    #if SILVERLIGHT
    public IAsyncResult send_ShowUpBarcode(AsyncCallback callback, object state, string barcode, string materialno, string message, int status)
    #else
    public void send_ShowUpBarcode(string barcode, string materialno, string message, int status)
    #endif
    {
      oprot_.WriteMessageBegin(new TMessage("ShowUpBarcode", TMessageType.Call, seqid_));
      ShowUpBarcode_args args = new ShowUpBarcode_args();
      args.Barcode = barcode;
      args.Materialno = materialno;
      args.Message = message;
      args.Status = status;
      args.Write(oprot_);
      oprot_.WriteMessageEnd();
      #if SILVERLIGHT
      return oprot_.Transport.BeginFlush(callback, state);
      #else
      oprot_.Transport.Flush();
      #endif
    }

    public string recv_ShowUpBarcode()
    {
      TMessage msg = iprot_.ReadMessageBegin();
      if (msg.Type == TMessageType.Exception) {
        TApplicationException x = TApplicationException.Read(iprot_);
        iprot_.ReadMessageEnd();
        throw x;
      }
      ShowUpBarcode_result result = new ShowUpBarcode_result();
      result.Read(iprot_);
      iprot_.ReadMessageEnd();
      if (result.__isset.success) {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "ShowUpBarcode failed: unknown result");
    }

    
    #if SILVERLIGHT
    public IAsyncResult Begin_DataForRestart(AsyncCallback callback, object state, )
    {
      return send_DataForRestart(callback, state);
    }

    public string End_DataForRestart(IAsyncResult asyncResult)
    {
      oprot_.Transport.EndFlush(asyncResult);
      return recv_DataForRestart();
    }

    #endif

    public string DataForRestart()
    {
      #if !SILVERLIGHT
      send_DataForRestart();
      return recv_DataForRestart();

      #else
      var asyncResult = Begin_DataForRestart(null, null, );
      return End_DataForRestart(asyncResult);

      #endif
    }
    #if SILVERLIGHT
    public IAsyncResult send_DataForRestart(AsyncCallback callback, object state, )
    #else
    public void send_DataForRestart()
    #endif
    {
      oprot_.WriteMessageBegin(new TMessage("DataForRestart", TMessageType.Call, seqid_));
      DataForRestart_args args = new DataForRestart_args();
      args.Write(oprot_);
      oprot_.WriteMessageEnd();
      #if SILVERLIGHT
      return oprot_.Transport.BeginFlush(callback, state);
      #else
      oprot_.Transport.Flush();
      #endif
    }

    public string recv_DataForRestart()
    {
      TMessage msg = iprot_.ReadMessageBegin();
      if (msg.Type == TMessageType.Exception) {
        TApplicationException x = TApplicationException.Read(iprot_);
        iprot_.ReadMessageEnd();
        throw x;
      }
      DataForRestart_result result = new DataForRestart_result();
      result.Read(iprot_);
      iprot_.ReadMessageEnd();
      if (result.__isset.success) {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "DataForRestart failed: unknown result");
    }

    
    #if SILVERLIGHT
    public IAsyncResult Begin_MaterialRemove(AsyncCallback callback, object state, string barcode)
    {
      return send_MaterialRemove(callback, state, barcode);
    }

    public string End_MaterialRemove(IAsyncResult asyncResult)
    {
      oprot_.Transport.EndFlush(asyncResult);
      return recv_MaterialRemove();
    }

    #endif

    public string MaterialRemove(string barcode)
    {
      #if !SILVERLIGHT
      send_MaterialRemove(barcode);
      return recv_MaterialRemove();

      #else
      var asyncResult = Begin_MaterialRemove(null, null, barcode);
      return End_MaterialRemove(asyncResult);

      #endif
    }
    #if SILVERLIGHT
    public IAsyncResult send_MaterialRemove(AsyncCallback callback, object state, string barcode)
    #else
    public void send_MaterialRemove(string barcode)
    #endif
    {
      oprot_.WriteMessageBegin(new TMessage("MaterialRemove", TMessageType.Call, seqid_));
      MaterialRemove_args args = new MaterialRemove_args();
      args.Barcode = barcode;
      args.Write(oprot_);
      oprot_.WriteMessageEnd();
      #if SILVERLIGHT
      return oprot_.Transport.BeginFlush(callback, state);
      #else
      oprot_.Transport.Flush();
      #endif
    }

    public string recv_MaterialRemove()
    {
      TMessage msg = iprot_.ReadMessageBegin();
      if (msg.Type == TMessageType.Exception) {
        TApplicationException x = TApplicationException.Read(iprot_);
        iprot_.ReadMessageEnd();
        throw x;
      }
      MaterialRemove_result result = new MaterialRemove_result();
      result.Read(iprot_);
      iprot_.ReadMessageEnd();
      if (result.__isset.success) {
        return result.Success;
      }
      throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "MaterialRemove failed: unknown result");
    }

  }
  public class Processor : TProcessor {
    public Processor(Iface iface)
    {
      iface_ = iface;
      processMap_["sendCheckBarcode"] = sendCheckBarcode_Process;
      processMap_["sendCarMaterialList"] = sendCarMaterialList_Process;
      processMap_["sendMaterialList"] = sendMaterialList_Process;
      processMap_["SendSetCarInfo"] = SendSetCarInfo_Process;
      processMap_["SendCheckServerState"] = SendCheckServerState_Process;
      processMap_["GetReceiveCarNo"] = GetReceiveCarNo_Process;
      processMap_["GetLocatorInfoList"] = GetLocatorInfoList_Process;
      processMap_["GetOutLocatorList"] = GetOutLocatorList_Process;
      processMap_["SendOutLocatorBarcode"] = SendOutLocatorBarcode_Process;
      processMap_["GetLineAreaList"] = GetLineAreaList_Process;
      processMap_["GetCarAreaList"] = GetCarAreaList_Process;
      processMap_["GetOrderList"] = GetOrderList_Process;
      processMap_["GetOutCarLineList"] = GetOutCarLineList_Process;
      processMap_["GetMaterialList"] = GetMaterialList_Process;
      processMap_["GetUpDownMaterielNum"] = GetUpDownMaterielNum_Process;
      processMap_["SendDeleteRelief"] = SendDeleteRelief_Process;
      processMap_["SendUpdateDownNum"] = SendUpdateDownNum_Process;
      processMap_["GetDownLineNum"] = GetDownLineNum_Process;
      processMap_["GetMaterielNumByKBList"] = GetMaterielNumByKBList_Process;
      processMap_["GetFaultList"] = GetFaultList_Process;
      processMap_["GetAreaPlcList"] = GetAreaPlcList_Process;
      processMap_["SendInsertFault"] = SendInsertFault_Process;
      processMap_["SendUpdateFault"] = SendUpdateFault_Process;
      processMap_["ShowUpBarcode"] = ShowUpBarcode_Process;
      processMap_["DataForRestart"] = DataForRestart_Process;
      processMap_["MaterialRemove"] = MaterialRemove_Process;
    }

    protected delegate void ProcessFunction(int seqid, TProtocol iprot, TProtocol oprot);
    private Iface iface_;
    protected Dictionary<string, ProcessFunction> processMap_ = new Dictionary<string, ProcessFunction>();

    public bool Process(TProtocol iprot, TProtocol oprot)
    {
      try
      {
        TMessage msg = iprot.ReadMessageBegin();
        ProcessFunction fn;
        processMap_.TryGetValue(msg.Name, out fn);
        if (fn == null) {
          TProtocolUtil.Skip(iprot, TType.Struct);
          iprot.ReadMessageEnd();
          TApplicationException x = new TApplicationException (TApplicationException.ExceptionType.UnknownMethod, "Invalid method name: '" + msg.Name + "'");
          oprot.WriteMessageBegin(new TMessage(msg.Name, TMessageType.Exception, msg.SeqID));
          x.Write(oprot);
          oprot.WriteMessageEnd();
          oprot.Transport.Flush();
          return true;
        }
        fn(msg.SeqID, iprot, oprot);
      }
      catch (IOException)
      {
        return false;
      }
      return true;
    }

    public void sendCheckBarcode_Process(int seqid, TProtocol iprot, TProtocol oprot)
    {
      sendCheckBarcode_args args = new sendCheckBarcode_args();
      args.Read(iprot);
      iprot.ReadMessageEnd();
      sendCheckBarcode_result result = new sendCheckBarcode_result();
      result.Success = iface_.sendCheckBarcode(args.Barcode);
      oprot.WriteMessageBegin(new TMessage("sendCheckBarcode", TMessageType.Reply, seqid)); 
      result.Write(oprot);
      oprot.WriteMessageEnd();
      oprot.Transport.Flush();
    }

    public void sendCarMaterialList_Process(int seqid, TProtocol iprot, TProtocol oprot)
    {
      sendCarMaterialList_args args = new sendCarMaterialList_args();
      args.Read(iprot);
      iprot.ReadMessageEnd();
      sendCarMaterialList_result result = new sendCarMaterialList_result();
      result.Success = iface_.sendCarMaterialList(args.CarNosOrMater, args.Order_code);
      oprot.WriteMessageBegin(new TMessage("sendCarMaterialList", TMessageType.Reply, seqid)); 
      result.Write(oprot);
      oprot.WriteMessageEnd();
      oprot.Transport.Flush();
    }

    public void sendMaterialList_Process(int seqid, TProtocol iprot, TProtocol oprot)
    {
      sendMaterialList_args args = new sendMaterialList_args();
      args.Read(iprot);
      iprot.ReadMessageEnd();
      sendMaterialList_result result = new sendMaterialList_result();
      result.Success = iface_.sendMaterialList(args.MaterialNos);
      oprot.WriteMessageBegin(new TMessage("sendMaterialList", TMessageType.Reply, seqid)); 
      result.Write(oprot);
      oprot.WriteMessageEnd();
      oprot.Transport.Flush();
    }

    public void SendSetCarInfo_Process(int seqid, TProtocol iprot, TProtocol oprot)
    {
      SendSetCarInfo_args args = new SendSetCarInfo_args();
      args.Read(iprot);
      iprot.ReadMessageEnd();
      SendSetCarInfo_result result = new SendSetCarInfo_result();
      result.Success = iface_.SendSetCarInfo(args.Carno, args.Materialno, args.Materialdesc, args.Locatorid, args.Outlocatorstate, args.Optdt);
      oprot.WriteMessageBegin(new TMessage("SendSetCarInfo", TMessageType.Reply, seqid)); 
      result.Write(oprot);
      oprot.WriteMessageEnd();
      oprot.Transport.Flush();
    }

    public void SendCheckServerState_Process(int seqid, TProtocol iprot, TProtocol oprot)
    {
      SendCheckServerState_args args = new SendCheckServerState_args();
      args.Read(iprot);
      iprot.ReadMessageEnd();
      SendCheckServerState_result result = new SendCheckServerState_result();
      result.Success = iface_.SendCheckServerState();
      oprot.WriteMessageBegin(new TMessage("SendCheckServerState", TMessageType.Reply, seqid)); 
      result.Write(oprot);
      oprot.WriteMessageEnd();
      oprot.Transport.Flush();
    }

    public void GetReceiveCarNo_Process(int seqid, TProtocol iprot, TProtocol oprot)
    {
      GetReceiveCarNo_args args = new GetReceiveCarNo_args();
      args.Read(iprot);
      iprot.ReadMessageEnd();
      GetReceiveCarNo_result result = new GetReceiveCarNo_result();
      result.Success = iface_.GetReceiveCarNo(args.Carno);
      oprot.WriteMessageBegin(new TMessage("GetReceiveCarNo", TMessageType.Reply, seqid)); 
      result.Write(oprot);
      oprot.WriteMessageEnd();
      oprot.Transport.Flush();
    }

    public void GetLocatorInfoList_Process(int seqid, TProtocol iprot, TProtocol oprot)
    {
      GetLocatorInfoList_args args = new GetLocatorInfoList_args();
      args.Read(iprot);
      iprot.ReadMessageEnd();
      GetLocatorInfoList_result result = new GetLocatorInfoList_result();
      result.Success = iface_.GetLocatorInfoList();
      oprot.WriteMessageBegin(new TMessage("GetLocatorInfoList", TMessageType.Reply, seqid)); 
      result.Write(oprot);
      oprot.WriteMessageEnd();
      oprot.Transport.Flush();
    }

    public void GetOutLocatorList_Process(int seqid, TProtocol iprot, TProtocol oprot)
    {
      GetOutLocatorList_args args = new GetOutLocatorList_args();
      args.Read(iprot);
      iprot.ReadMessageEnd();
      GetOutLocatorList_result result = new GetOutLocatorList_result();
      result.Success = iface_.GetOutLocatorList();
      oprot.WriteMessageBegin(new TMessage("GetOutLocatorList", TMessageType.Reply, seqid)); 
      result.Write(oprot);
      oprot.WriteMessageEnd();
      oprot.Transport.Flush();
    }

    public void SendOutLocatorBarcode_Process(int seqid, TProtocol iprot, TProtocol oprot)
    {
      SendOutLocatorBarcode_args args = new SendOutLocatorBarcode_args();
      args.Read(iprot);
      iprot.ReadMessageEnd();
      SendOutLocatorBarcode_result result = new SendOutLocatorBarcode_result();
      result.Success = iface_.SendOutLocatorBarcode(args.Barcode);
      oprot.WriteMessageBegin(new TMessage("SendOutLocatorBarcode", TMessageType.Reply, seqid)); 
      result.Write(oprot);
      oprot.WriteMessageEnd();
      oprot.Transport.Flush();
    }

    public void GetLineAreaList_Process(int seqid, TProtocol iprot, TProtocol oprot)
    {
      GetLineAreaList_args args = new GetLineAreaList_args();
      args.Read(iprot);
      iprot.ReadMessageEnd();
      GetLineAreaList_result result = new GetLineAreaList_result();
      result.Success = iface_.GetLineAreaList(args.Linearealist);
      oprot.WriteMessageBegin(new TMessage("GetLineAreaList", TMessageType.Reply, seqid)); 
      result.Write(oprot);
      oprot.WriteMessageEnd();
      oprot.Transport.Flush();
    }

    public void GetCarAreaList_Process(int seqid, TProtocol iprot, TProtocol oprot)
    {
      GetCarAreaList_args args = new GetCarAreaList_args();
      args.Read(iprot);
      iprot.ReadMessageEnd();
      GetCarAreaList_result result = new GetCarAreaList_result();
      result.Success = iface_.GetCarAreaList(args.Cararealist);
      oprot.WriteMessageBegin(new TMessage("GetCarAreaList", TMessageType.Reply, seqid)); 
      result.Write(oprot);
      oprot.WriteMessageEnd();
      oprot.Transport.Flush();
    }

    public void GetOrderList_Process(int seqid, TProtocol iprot, TProtocol oprot)
    {
      GetOrderList_args args = new GetOrderList_args();
      args.Read(iprot);
      iprot.ReadMessageEnd();
      GetOrderList_result result = new GetOrderList_result();
      result.Success = iface_.GetOrderList(args.Orderlist);
      oprot.WriteMessageBegin(new TMessage("GetOrderList", TMessageType.Reply, seqid)); 
      result.Write(oprot);
      oprot.WriteMessageEnd();
      oprot.Transport.Flush();
    }

    public void GetOutCarLineList_Process(int seqid, TProtocol iprot, TProtocol oprot)
    {
      GetOutCarLineList_args args = new GetOutCarLineList_args();
      args.Read(iprot);
      iprot.ReadMessageEnd();
      GetOutCarLineList_result result = new GetOutCarLineList_result();
      result.Success = iface_.GetOutCarLineList(args.Outcarlinelist);
      oprot.WriteMessageBegin(new TMessage("GetOutCarLineList", TMessageType.Reply, seqid)); 
      result.Write(oprot);
      oprot.WriteMessageEnd();
      oprot.Transport.Flush();
    }

    public void GetMaterialList_Process(int seqid, TProtocol iprot, TProtocol oprot)
    {
      GetMaterialList_args args = new GetMaterialList_args();
      args.Read(iprot);
      iprot.ReadMessageEnd();
      GetMaterialList_result result = new GetMaterialList_result();
      result.Success = iface_.GetMaterialList(args.MaterialNos);
      oprot.WriteMessageBegin(new TMessage("GetMaterialList", TMessageType.Reply, seqid)); 
      result.Write(oprot);
      oprot.WriteMessageEnd();
      oprot.Transport.Flush();
    }

    public void GetUpDownMaterielNum_Process(int seqid, TProtocol iprot, TProtocol oprot)
    {
      GetUpDownMaterielNum_args args = new GetUpDownMaterielNum_args();
      args.Read(iprot);
      iprot.ReadMessageEnd();
      GetUpDownMaterielNum_result result = new GetUpDownMaterielNum_result();
      result.Success = iface_.GetUpDownMaterielNum(args.Siteno);
      oprot.WriteMessageBegin(new TMessage("GetUpDownMaterielNum", TMessageType.Reply, seqid)); 
      result.Write(oprot);
      oprot.WriteMessageEnd();
      oprot.Transport.Flush();
    }

    public void SendDeleteRelief_Process(int seqid, TProtocol iprot, TProtocol oprot)
    {
      SendDeleteRelief_args args = new SendDeleteRelief_args();
      args.Read(iprot);
      iprot.ReadMessageEnd();
      SendDeleteRelief_result result = new SendDeleteRelief_result();
      result.Success = iface_.SendDeleteRelief();
      oprot.WriteMessageBegin(new TMessage("SendDeleteRelief", TMessageType.Reply, seqid)); 
      result.Write(oprot);
      oprot.WriteMessageEnd();
      oprot.Transport.Flush();
    }

    public void SendUpdateDownNum_Process(int seqid, TProtocol iprot, TProtocol oprot)
    {
      SendUpdateDownNum_args args = new SendUpdateDownNum_args();
      args.Read(iprot);
      iprot.ReadMessageEnd();
      SendUpdateDownNum_result result = new SendUpdateDownNum_result();
      result.Success = iface_.SendUpdateDownNum();
      oprot.WriteMessageBegin(new TMessage("SendUpdateDownNum", TMessageType.Reply, seqid)); 
      result.Write(oprot);
      oprot.WriteMessageEnd();
      oprot.Transport.Flush();
    }

    public void GetDownLineNum_Process(int seqid, TProtocol iprot, TProtocol oprot)
    {
      GetDownLineNum_args args = new GetDownLineNum_args();
      args.Read(iprot);
      iprot.ReadMessageEnd();
      GetDownLineNum_result result = new GetDownLineNum_result();
      result.Success = iface_.GetDownLineNum(args.Downnum);
      oprot.WriteMessageBegin(new TMessage("GetDownLineNum", TMessageType.Reply, seqid)); 
      result.Write(oprot);
      oprot.WriteMessageEnd();
      oprot.Transport.Flush();
    }

    public void GetMaterielNumByKBList_Process(int seqid, TProtocol iprot, TProtocol oprot)
    {
      GetMaterielNumByKBList_args args = new GetMaterielNumByKBList_args();
      args.Read(iprot);
      iprot.ReadMessageEnd();
      GetMaterielNumByKBList_result result = new GetMaterielNumByKBList_result();
      result.Success = iface_.GetMaterielNumByKBList(args.Materielnumlist);
      oprot.WriteMessageBegin(new TMessage("GetMaterielNumByKBList", TMessageType.Reply, seqid)); 
      result.Write(oprot);
      oprot.WriteMessageEnd();
      oprot.Transport.Flush();
    }

    public void GetFaultList_Process(int seqid, TProtocol iprot, TProtocol oprot)
    {
      GetFaultList_args args = new GetFaultList_args();
      args.Read(iprot);
      iprot.ReadMessageEnd();
      GetFaultList_result result = new GetFaultList_result();
      result.Success = iface_.GetFaultList(args.Faultlist);
      oprot.WriteMessageBegin(new TMessage("GetFaultList", TMessageType.Reply, seqid)); 
      result.Write(oprot);
      oprot.WriteMessageEnd();
      oprot.Transport.Flush();
    }

    public void GetAreaPlcList_Process(int seqid, TProtocol iprot, TProtocol oprot)
    {
      GetAreaPlcList_args args = new GetAreaPlcList_args();
      args.Read(iprot);
      iprot.ReadMessageEnd();
      GetAreaPlcList_result result = new GetAreaPlcList_result();
      result.Success = iface_.GetAreaPlcList(args.Areaplclist);
      oprot.WriteMessageBegin(new TMessage("GetAreaPlcList", TMessageType.Reply, seqid)); 
      result.Write(oprot);
      oprot.WriteMessageEnd();
      oprot.Transport.Flush();
    }

    public void SendInsertFault_Process(int seqid, TProtocol iprot, TProtocol oprot)
    {
      SendInsertFault_args args = new SendInsertFault_args();
      args.Read(iprot);
      iprot.ReadMessageEnd();
      SendInsertFault_result result = new SendInsertFault_result();
      result.Success = iface_.SendInsertFault();
      oprot.WriteMessageBegin(new TMessage("SendInsertFault", TMessageType.Reply, seqid)); 
      result.Write(oprot);
      oprot.WriteMessageEnd();
      oprot.Transport.Flush();
    }

    public void SendUpdateFault_Process(int seqid, TProtocol iprot, TProtocol oprot)
    {
      SendUpdateFault_args args = new SendUpdateFault_args();
      args.Read(iprot);
      iprot.ReadMessageEnd();
      SendUpdateFault_result result = new SendUpdateFault_result();
      result.Success = iface_.SendUpdateFault();
      oprot.WriteMessageBegin(new TMessage("SendUpdateFault", TMessageType.Reply, seqid)); 
      result.Write(oprot);
      oprot.WriteMessageEnd();
      oprot.Transport.Flush();
    }

    public void ShowUpBarcode_Process(int seqid, TProtocol iprot, TProtocol oprot)
    {
      ShowUpBarcode_args args = new ShowUpBarcode_args();
      args.Read(iprot);
      iprot.ReadMessageEnd();
      ShowUpBarcode_result result = new ShowUpBarcode_result();
      result.Success = iface_.ShowUpBarcode(args.Barcode, args.Materialno, args.Message, args.Status);
      oprot.WriteMessageBegin(new TMessage("ShowUpBarcode", TMessageType.Reply, seqid)); 
      result.Write(oprot);
      oprot.WriteMessageEnd();
      oprot.Transport.Flush();
    }

    public void DataForRestart_Process(int seqid, TProtocol iprot, TProtocol oprot)
    {
      DataForRestart_args args = new DataForRestart_args();
      args.Read(iprot);
      iprot.ReadMessageEnd();
      DataForRestart_result result = new DataForRestart_result();
      result.Success = iface_.DataForRestart();
      oprot.WriteMessageBegin(new TMessage("DataForRestart", TMessageType.Reply, seqid)); 
      result.Write(oprot);
      oprot.WriteMessageEnd();
      oprot.Transport.Flush();
    }

    public void MaterialRemove_Process(int seqid, TProtocol iprot, TProtocol oprot)
    {
      MaterialRemove_args args = new MaterialRemove_args();
      args.Read(iprot);
      iprot.ReadMessageEnd();
      MaterialRemove_result result = new MaterialRemove_result();
      result.Success = iface_.MaterialRemove(args.Barcode);
      oprot.WriteMessageBegin(new TMessage("MaterialRemove", TMessageType.Reply, seqid)); 
      result.Write(oprot);
      oprot.WriteMessageEnd();
      oprot.Transport.Flush();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class sendCheckBarcode_args : TBase
  {
    private string _barcode;

    public string Barcode
    {
      get
      {
        return _barcode;
      }
      set
      {
        __isset.barcode = true;
        this._barcode = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool barcode;
    }

    public sendCheckBarcode_args() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 1:
            if (field.Type == TType.String) {
              Barcode = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("sendCheckBarcode_args");
      oprot.WriteStructBegin(struc);
      TField field = new TField();
      if (Barcode != null && __isset.barcode) {
        field.Name = "barcode";
        field.Type = TType.String;
        field.ID = 1;
        oprot.WriteFieldBegin(field);
        oprot.WriteString(Barcode);
        oprot.WriteFieldEnd();
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("sendCheckBarcode_args(");
      sb.Append("Barcode: ");
      sb.Append(Barcode);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class sendCheckBarcode_result : TBase
  {
    private string _success;

    public string Success
    {
      get
      {
        return _success;
      }
      set
      {
        __isset.success = true;
        this._success = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool success;
    }

    public sendCheckBarcode_result() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 0:
            if (field.Type == TType.String) {
              Success = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("sendCheckBarcode_result");
      oprot.WriteStructBegin(struc);
      TField field = new TField();

      if (this.__isset.success) {
        if (Success != null) {
          field.Name = "Success";
          field.Type = TType.String;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Success);
          oprot.WriteFieldEnd();
        }
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("sendCheckBarcode_result(");
      sb.Append("Success: ");
      sb.Append(Success);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class sendCarMaterialList_args : TBase
  {
    private List<string> _CarNosOrMater;
    private string _order_code;

    public List<string> CarNosOrMater
    {
      get
      {
        return _CarNosOrMater;
      }
      set
      {
        __isset.CarNosOrMater = true;
        this._CarNosOrMater = value;
      }
    }

    public string Order_code
    {
      get
      {
        return _order_code;
      }
      set
      {
        __isset.order_code = true;
        this._order_code = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool CarNosOrMater;
      public bool order_code;
    }

    public sendCarMaterialList_args() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 1:
            if (field.Type == TType.List) {
              {
                CarNosOrMater = new List<string>();
                TList _list0 = iprot.ReadListBegin();
                for( int _i1 = 0; _i1 < _list0.Count; ++_i1)
                {
                  string _elem2 = null;
                  _elem2 = iprot.ReadString();
                  CarNosOrMater.Add(_elem2);
                }
                iprot.ReadListEnd();
              }
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          case 2:
            if (field.Type == TType.String) {
              Order_code = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("sendCarMaterialList_args");
      oprot.WriteStructBegin(struc);
      TField field = new TField();
      if (CarNosOrMater != null && __isset.CarNosOrMater) {
        field.Name = "CarNosOrMater";
        field.Type = TType.List;
        field.ID = 1;
        oprot.WriteFieldBegin(field);
        {
          oprot.WriteListBegin(new TList(TType.String, CarNosOrMater.Count));
          foreach (string _iter3 in CarNosOrMater)
          {
            oprot.WriteString(_iter3);
          }
          oprot.WriteListEnd();
        }
        oprot.WriteFieldEnd();
      }
      if (Order_code != null && __isset.order_code) {
        field.Name = "order_code";
        field.Type = TType.String;
        field.ID = 2;
        oprot.WriteFieldBegin(field);
        oprot.WriteString(Order_code);
        oprot.WriteFieldEnd();
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("sendCarMaterialList_args(");
      sb.Append("CarNosOrMater: ");
      sb.Append(CarNosOrMater);
      sb.Append(",Order_code: ");
      sb.Append(Order_code);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class sendCarMaterialList_result : TBase
  {
    private string _success;

    public string Success
    {
      get
      {
        return _success;
      }
      set
      {
        __isset.success = true;
        this._success = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool success;
    }

    public sendCarMaterialList_result() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 0:
            if (field.Type == TType.String) {
              Success = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("sendCarMaterialList_result");
      oprot.WriteStructBegin(struc);
      TField field = new TField();

      if (this.__isset.success) {
        if (Success != null) {
          field.Name = "Success";
          field.Type = TType.String;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Success);
          oprot.WriteFieldEnd();
        }
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("sendCarMaterialList_result(");
      sb.Append("Success: ");
      sb.Append(Success);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class sendMaterialList_args : TBase
  {
    private List<string> _MaterialNos;

    public List<string> MaterialNos
    {
      get
      {
        return _MaterialNos;
      }
      set
      {
        __isset.MaterialNos = true;
        this._MaterialNos = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool MaterialNos;
    }

    public sendMaterialList_args() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 1:
            if (field.Type == TType.List) {
              {
                MaterialNos = new List<string>();
                TList _list4 = iprot.ReadListBegin();
                for( int _i5 = 0; _i5 < _list4.Count; ++_i5)
                {
                  string _elem6 = null;
                  _elem6 = iprot.ReadString();
                  MaterialNos.Add(_elem6);
                }
                iprot.ReadListEnd();
              }
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("sendMaterialList_args");
      oprot.WriteStructBegin(struc);
      TField field = new TField();
      if (MaterialNos != null && __isset.MaterialNos) {
        field.Name = "MaterialNos";
        field.Type = TType.List;
        field.ID = 1;
        oprot.WriteFieldBegin(field);
        {
          oprot.WriteListBegin(new TList(TType.String, MaterialNos.Count));
          foreach (string _iter7 in MaterialNos)
          {
            oprot.WriteString(_iter7);
          }
          oprot.WriteListEnd();
        }
        oprot.WriteFieldEnd();
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("sendMaterialList_args(");
      sb.Append("MaterialNos: ");
      sb.Append(MaterialNos);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class sendMaterialList_result : TBase
  {
    private string _success;

    public string Success
    {
      get
      {
        return _success;
      }
      set
      {
        __isset.success = true;
        this._success = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool success;
    }

    public sendMaterialList_result() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 0:
            if (field.Type == TType.String) {
              Success = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("sendMaterialList_result");
      oprot.WriteStructBegin(struc);
      TField field = new TField();

      if (this.__isset.success) {
        if (Success != null) {
          field.Name = "Success";
          field.Type = TType.String;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Success);
          oprot.WriteFieldEnd();
        }
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("sendMaterialList_result(");
      sb.Append("Success: ");
      sb.Append(Success);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class SendSetCarInfo_args : TBase
  {
    private string _carno;
    private string _materialno;
    private string _materialdesc;
    private string _locatorid;
    private string _outlocatorstate;
    private string _optdt;

    public string Carno
    {
      get
      {
        return _carno;
      }
      set
      {
        __isset.carno = true;
        this._carno = value;
      }
    }

    public string Materialno
    {
      get
      {
        return _materialno;
      }
      set
      {
        __isset.materialno = true;
        this._materialno = value;
      }
    }

    public string Materialdesc
    {
      get
      {
        return _materialdesc;
      }
      set
      {
        __isset.materialdesc = true;
        this._materialdesc = value;
      }
    }

    public string Locatorid
    {
      get
      {
        return _locatorid;
      }
      set
      {
        __isset.locatorid = true;
        this._locatorid = value;
      }
    }

    public string Outlocatorstate
    {
      get
      {
        return _outlocatorstate;
      }
      set
      {
        __isset.outlocatorstate = true;
        this._outlocatorstate = value;
      }
    }

    public string Optdt
    {
      get
      {
        return _optdt;
      }
      set
      {
        __isset.optdt = true;
        this._optdt = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool carno;
      public bool materialno;
      public bool materialdesc;
      public bool locatorid;
      public bool outlocatorstate;
      public bool optdt;
    }

    public SendSetCarInfo_args() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 1:
            if (field.Type == TType.String) {
              Carno = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          case 2:
            if (field.Type == TType.String) {
              Materialno = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          case 3:
            if (field.Type == TType.String) {
              Materialdesc = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          case 4:
            if (field.Type == TType.String) {
              Locatorid = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          case 5:
            if (field.Type == TType.String) {
              Outlocatorstate = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          case 6:
            if (field.Type == TType.String) {
              Optdt = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("SendSetCarInfo_args");
      oprot.WriteStructBegin(struc);
      TField field = new TField();
      if (Carno != null && __isset.carno) {
        field.Name = "carno";
        field.Type = TType.String;
        field.ID = 1;
        oprot.WriteFieldBegin(field);
        oprot.WriteString(Carno);
        oprot.WriteFieldEnd();
      }
      if (Materialno != null && __isset.materialno) {
        field.Name = "materialno";
        field.Type = TType.String;
        field.ID = 2;
        oprot.WriteFieldBegin(field);
        oprot.WriteString(Materialno);
        oprot.WriteFieldEnd();
      }
      if (Materialdesc != null && __isset.materialdesc) {
        field.Name = "materialdesc";
        field.Type = TType.String;
        field.ID = 3;
        oprot.WriteFieldBegin(field);
        oprot.WriteString(Materialdesc);
        oprot.WriteFieldEnd();
      }
      if (Locatorid != null && __isset.locatorid) {
        field.Name = "locatorid";
        field.Type = TType.String;
        field.ID = 4;
        oprot.WriteFieldBegin(field);
        oprot.WriteString(Locatorid);
        oprot.WriteFieldEnd();
      }
      if (Outlocatorstate != null && __isset.outlocatorstate) {
        field.Name = "outlocatorstate";
        field.Type = TType.String;
        field.ID = 5;
        oprot.WriteFieldBegin(field);
        oprot.WriteString(Outlocatorstate);
        oprot.WriteFieldEnd();
      }
      if (Optdt != null && __isset.optdt) {
        field.Name = "optdt";
        field.Type = TType.String;
        field.ID = 6;
        oprot.WriteFieldBegin(field);
        oprot.WriteString(Optdt);
        oprot.WriteFieldEnd();
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("SendSetCarInfo_args(");
      sb.Append("Carno: ");
      sb.Append(Carno);
      sb.Append(",Materialno: ");
      sb.Append(Materialno);
      sb.Append(",Materialdesc: ");
      sb.Append(Materialdesc);
      sb.Append(",Locatorid: ");
      sb.Append(Locatorid);
      sb.Append(",Outlocatorstate: ");
      sb.Append(Outlocatorstate);
      sb.Append(",Optdt: ");
      sb.Append(Optdt);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class SendSetCarInfo_result : TBase
  {
    private string _success;

    public string Success
    {
      get
      {
        return _success;
      }
      set
      {
        __isset.success = true;
        this._success = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool success;
    }

    public SendSetCarInfo_result() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 0:
            if (field.Type == TType.String) {
              Success = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("SendSetCarInfo_result");
      oprot.WriteStructBegin(struc);
      TField field = new TField();

      if (this.__isset.success) {
        if (Success != null) {
          field.Name = "Success";
          field.Type = TType.String;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Success);
          oprot.WriteFieldEnd();
        }
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("SendSetCarInfo_result(");
      sb.Append("Success: ");
      sb.Append(Success);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class SendCheckServerState_args : TBase
  {

    public SendCheckServerState_args() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("SendCheckServerState_args");
      oprot.WriteStructBegin(struc);
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("SendCheckServerState_args(");
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class SendCheckServerState_result : TBase
  {
    private string _success;

    public string Success
    {
      get
      {
        return _success;
      }
      set
      {
        __isset.success = true;
        this._success = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool success;
    }

    public SendCheckServerState_result() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 0:
            if (field.Type == TType.String) {
              Success = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("SendCheckServerState_result");
      oprot.WriteStructBegin(struc);
      TField field = new TField();

      if (this.__isset.success) {
        if (Success != null) {
          field.Name = "Success";
          field.Type = TType.String;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Success);
          oprot.WriteFieldEnd();
        }
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("SendCheckServerState_result(");
      sb.Append("Success: ");
      sb.Append(Success);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class GetReceiveCarNo_args : TBase
  {
    private string _carno;

    public string Carno
    {
      get
      {
        return _carno;
      }
      set
      {
        __isset.carno = true;
        this._carno = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool carno;
    }

    public GetReceiveCarNo_args() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 1:
            if (field.Type == TType.String) {
              Carno = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("GetReceiveCarNo_args");
      oprot.WriteStructBegin(struc);
      TField field = new TField();
      if (Carno != null && __isset.carno) {
        field.Name = "carno";
        field.Type = TType.String;
        field.ID = 1;
        oprot.WriteFieldBegin(field);
        oprot.WriteString(Carno);
        oprot.WriteFieldEnd();
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("GetReceiveCarNo_args(");
      sb.Append("Carno: ");
      sb.Append(Carno);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class GetReceiveCarNo_result : TBase
  {
    private string _success;

    public string Success
    {
      get
      {
        return _success;
      }
      set
      {
        __isset.success = true;
        this._success = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool success;
    }

    public GetReceiveCarNo_result() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 0:
            if (field.Type == TType.String) {
              Success = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("GetReceiveCarNo_result");
      oprot.WriteStructBegin(struc);
      TField field = new TField();

      if (this.__isset.success) {
        if (Success != null) {
          field.Name = "Success";
          field.Type = TType.String;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Success);
          oprot.WriteFieldEnd();
        }
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("GetReceiveCarNo_result(");
      sb.Append("Success: ");
      sb.Append(Success);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class GetLocatorInfoList_args : TBase
  {

    public GetLocatorInfoList_args() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("GetLocatorInfoList_args");
      oprot.WriteStructBegin(struc);
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("GetLocatorInfoList_args(");
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class GetLocatorInfoList_result : TBase
  {
    private string _success;

    public string Success
    {
      get
      {
        return _success;
      }
      set
      {
        __isset.success = true;
        this._success = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool success;
    }

    public GetLocatorInfoList_result() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 0:
            if (field.Type == TType.String) {
              Success = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("GetLocatorInfoList_result");
      oprot.WriteStructBegin(struc);
      TField field = new TField();

      if (this.__isset.success) {
        if (Success != null) {
          field.Name = "Success";
          field.Type = TType.String;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Success);
          oprot.WriteFieldEnd();
        }
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("GetLocatorInfoList_result(");
      sb.Append("Success: ");
      sb.Append(Success);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class GetOutLocatorList_args : TBase
  {

    public GetOutLocatorList_args() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("GetOutLocatorList_args");
      oprot.WriteStructBegin(struc);
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("GetOutLocatorList_args(");
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class GetOutLocatorList_result : TBase
  {
    private string _success;

    public string Success
    {
      get
      {
        return _success;
      }
      set
      {
        __isset.success = true;
        this._success = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool success;
    }

    public GetOutLocatorList_result() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 0:
            if (field.Type == TType.String) {
              Success = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("GetOutLocatorList_result");
      oprot.WriteStructBegin(struc);
      TField field = new TField();

      if (this.__isset.success) {
        if (Success != null) {
          field.Name = "Success";
          field.Type = TType.String;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Success);
          oprot.WriteFieldEnd();
        }
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("GetOutLocatorList_result(");
      sb.Append("Success: ");
      sb.Append(Success);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class SendOutLocatorBarcode_args : TBase
  {
    private string _barcode;

    public string Barcode
    {
      get
      {
        return _barcode;
      }
      set
      {
        __isset.barcode = true;
        this._barcode = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool barcode;
    }

    public SendOutLocatorBarcode_args() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 1:
            if (field.Type == TType.String) {
              Barcode = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("SendOutLocatorBarcode_args");
      oprot.WriteStructBegin(struc);
      TField field = new TField();
      if (Barcode != null && __isset.barcode) {
        field.Name = "barcode";
        field.Type = TType.String;
        field.ID = 1;
        oprot.WriteFieldBegin(field);
        oprot.WriteString(Barcode);
        oprot.WriteFieldEnd();
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("SendOutLocatorBarcode_args(");
      sb.Append("Barcode: ");
      sb.Append(Barcode);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class SendOutLocatorBarcode_result : TBase
  {
    private string _success;

    public string Success
    {
      get
      {
        return _success;
      }
      set
      {
        __isset.success = true;
        this._success = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool success;
    }

    public SendOutLocatorBarcode_result() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 0:
            if (field.Type == TType.String) {
              Success = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("SendOutLocatorBarcode_result");
      oprot.WriteStructBegin(struc);
      TField field = new TField();

      if (this.__isset.success) {
        if (Success != null) {
          field.Name = "Success";
          field.Type = TType.String;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Success);
          oprot.WriteFieldEnd();
        }
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("SendOutLocatorBarcode_result(");
      sb.Append("Success: ");
      sb.Append(Success);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class GetLineAreaList_args : TBase
  {
    private List<LineArea> _linearealist;

    public List<LineArea> Linearealist
    {
      get
      {
        return _linearealist;
      }
      set
      {
        __isset.linearealist = true;
        this._linearealist = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool linearealist;
    }

    public GetLineAreaList_args() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 1:
            if (field.Type == TType.List) {
              {
                Linearealist = new List<LineArea>();
                TList _list8 = iprot.ReadListBegin();
                for( int _i9 = 0; _i9 < _list8.Count; ++_i9)
                {
                  LineArea _elem10 = new LineArea();
                  _elem10 = new LineArea();
                  _elem10.Read(iprot);
                  Linearealist.Add(_elem10);
                }
                iprot.ReadListEnd();
              }
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("GetLineAreaList_args");
      oprot.WriteStructBegin(struc);
      TField field = new TField();
      if (Linearealist != null && __isset.linearealist) {
        field.Name = "linearealist";
        field.Type = TType.List;
        field.ID = 1;
        oprot.WriteFieldBegin(field);
        {
          oprot.WriteListBegin(new TList(TType.Struct, Linearealist.Count));
          foreach (LineArea _iter11 in Linearealist)
          {
            _iter11.Write(oprot);
          }
          oprot.WriteListEnd();
        }
        oprot.WriteFieldEnd();
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("GetLineAreaList_args(");
      sb.Append("Linearealist: ");
      sb.Append(Linearealist);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class GetLineAreaList_result : TBase
  {
    private string _success;

    public string Success
    {
      get
      {
        return _success;
      }
      set
      {
        __isset.success = true;
        this._success = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool success;
    }

    public GetLineAreaList_result() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 0:
            if (field.Type == TType.String) {
              Success = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("GetLineAreaList_result");
      oprot.WriteStructBegin(struc);
      TField field = new TField();

      if (this.__isset.success) {
        if (Success != null) {
          field.Name = "Success";
          field.Type = TType.String;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Success);
          oprot.WriteFieldEnd();
        }
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("GetLineAreaList_result(");
      sb.Append("Success: ");
      sb.Append(Success);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class GetCarAreaList_args : TBase
  {
    private List<CarArea> _cararealist;

    public List<CarArea> Cararealist
    {
      get
      {
        return _cararealist;
      }
      set
      {
        __isset.cararealist = true;
        this._cararealist = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool cararealist;
    }

    public GetCarAreaList_args() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 1:
            if (field.Type == TType.List) {
              {
                Cararealist = new List<CarArea>();
                TList _list12 = iprot.ReadListBegin();
                for( int _i13 = 0; _i13 < _list12.Count; ++_i13)
                {
                  CarArea _elem14 = new CarArea();
                  _elem14 = new CarArea();
                  _elem14.Read(iprot);
                  Cararealist.Add(_elem14);
                }
                iprot.ReadListEnd();
              }
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("GetCarAreaList_args");
      oprot.WriteStructBegin(struc);
      TField field = new TField();
      if (Cararealist != null && __isset.cararealist) {
        field.Name = "cararealist";
        field.Type = TType.List;
        field.ID = 1;
        oprot.WriteFieldBegin(field);
        {
          oprot.WriteListBegin(new TList(TType.Struct, Cararealist.Count));
          foreach (CarArea _iter15 in Cararealist)
          {
            _iter15.Write(oprot);
          }
          oprot.WriteListEnd();
        }
        oprot.WriteFieldEnd();
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("GetCarAreaList_args(");
      sb.Append("Cararealist: ");
      sb.Append(Cararealist);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class GetCarAreaList_result : TBase
  {
    private string _success;

    public string Success
    {
      get
      {
        return _success;
      }
      set
      {
        __isset.success = true;
        this._success = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool success;
    }

    public GetCarAreaList_result() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 0:
            if (field.Type == TType.String) {
              Success = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("GetCarAreaList_result");
      oprot.WriteStructBegin(struc);
      TField field = new TField();

      if (this.__isset.success) {
        if (Success != null) {
          field.Name = "Success";
          field.Type = TType.String;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Success);
          oprot.WriteFieldEnd();
        }
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("GetCarAreaList_result(");
      sb.Append("Success: ");
      sb.Append(Success);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class GetOrderList_args : TBase
  {
    private List<Order> _orderlist;

    public List<Order> Orderlist
    {
      get
      {
        return _orderlist;
      }
      set
      {
        __isset.orderlist = true;
        this._orderlist = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool orderlist;
    }

    public GetOrderList_args() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 1:
            if (field.Type == TType.List) {
              {
                Orderlist = new List<Order>();
                TList _list16 = iprot.ReadListBegin();
                for( int _i17 = 0; _i17 < _list16.Count; ++_i17)
                {
                  Order _elem18 = new Order();
                  _elem18 = new Order();
                  _elem18.Read(iprot);
                  Orderlist.Add(_elem18);
                }
                iprot.ReadListEnd();
              }
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("GetOrderList_args");
      oprot.WriteStructBegin(struc);
      TField field = new TField();
      if (Orderlist != null && __isset.orderlist) {
        field.Name = "orderlist";
        field.Type = TType.List;
        field.ID = 1;
        oprot.WriteFieldBegin(field);
        {
          oprot.WriteListBegin(new TList(TType.Struct, Orderlist.Count));
          foreach (Order _iter19 in Orderlist)
          {
            _iter19.Write(oprot);
          }
          oprot.WriteListEnd();
        }
        oprot.WriteFieldEnd();
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("GetOrderList_args(");
      sb.Append("Orderlist: ");
      sb.Append(Orderlist);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class GetOrderList_result : TBase
  {
    private string _success;

    public string Success
    {
      get
      {
        return _success;
      }
      set
      {
        __isset.success = true;
        this._success = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool success;
    }

    public GetOrderList_result() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 0:
            if (field.Type == TType.String) {
              Success = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("GetOrderList_result");
      oprot.WriteStructBegin(struc);
      TField field = new TField();

      if (this.__isset.success) {
        if (Success != null) {
          field.Name = "Success";
          field.Type = TType.String;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Success);
          oprot.WriteFieldEnd();
        }
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("GetOrderList_result(");
      sb.Append("Success: ");
      sb.Append(Success);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class GetOutCarLineList_args : TBase
  {
    private List<OutCarLine> _outcarlinelist;

    public List<OutCarLine> Outcarlinelist
    {
      get
      {
        return _outcarlinelist;
      }
      set
      {
        __isset.outcarlinelist = true;
        this._outcarlinelist = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool outcarlinelist;
    }

    public GetOutCarLineList_args() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 1:
            if (field.Type == TType.List) {
              {
                Outcarlinelist = new List<OutCarLine>();
                TList _list20 = iprot.ReadListBegin();
                for( int _i21 = 0; _i21 < _list20.Count; ++_i21)
                {
                  OutCarLine _elem22 = new OutCarLine();
                  _elem22 = new OutCarLine();
                  _elem22.Read(iprot);
                  Outcarlinelist.Add(_elem22);
                }
                iprot.ReadListEnd();
              }
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("GetOutCarLineList_args");
      oprot.WriteStructBegin(struc);
      TField field = new TField();
      if (Outcarlinelist != null && __isset.outcarlinelist) {
        field.Name = "outcarlinelist";
        field.Type = TType.List;
        field.ID = 1;
        oprot.WriteFieldBegin(field);
        {
          oprot.WriteListBegin(new TList(TType.Struct, Outcarlinelist.Count));
          foreach (OutCarLine _iter23 in Outcarlinelist)
          {
            _iter23.Write(oprot);
          }
          oprot.WriteListEnd();
        }
        oprot.WriteFieldEnd();
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("GetOutCarLineList_args(");
      sb.Append("Outcarlinelist: ");
      sb.Append(Outcarlinelist);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class GetOutCarLineList_result : TBase
  {
    private string _success;

    public string Success
    {
      get
      {
        return _success;
      }
      set
      {
        __isset.success = true;
        this._success = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool success;
    }

    public GetOutCarLineList_result() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 0:
            if (field.Type == TType.String) {
              Success = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("GetOutCarLineList_result");
      oprot.WriteStructBegin(struc);
      TField field = new TField();

      if (this.__isset.success) {
        if (Success != null) {
          field.Name = "Success";
          field.Type = TType.String;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Success);
          oprot.WriteFieldEnd();
        }
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("GetOutCarLineList_result(");
      sb.Append("Success: ");
      sb.Append(Success);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class GetMaterialList_args : TBase
  {
    private List<string> _MaterialNos;

    public List<string> MaterialNos
    {
      get
      {
        return _MaterialNos;
      }
      set
      {
        __isset.MaterialNos = true;
        this._MaterialNos = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool MaterialNos;
    }

    public GetMaterialList_args() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 1:
            if (field.Type == TType.List) {
              {
                MaterialNos = new List<string>();
                TList _list24 = iprot.ReadListBegin();
                for( int _i25 = 0; _i25 < _list24.Count; ++_i25)
                {
                  string _elem26 = null;
                  _elem26 = iprot.ReadString();
                  MaterialNos.Add(_elem26);
                }
                iprot.ReadListEnd();
              }
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("GetMaterialList_args");
      oprot.WriteStructBegin(struc);
      TField field = new TField();
      if (MaterialNos != null && __isset.MaterialNos) {
        field.Name = "MaterialNos";
        field.Type = TType.List;
        field.ID = 1;
        oprot.WriteFieldBegin(field);
        {
          oprot.WriteListBegin(new TList(TType.String, MaterialNos.Count));
          foreach (string _iter27 in MaterialNos)
          {
            oprot.WriteString(_iter27);
          }
          oprot.WriteListEnd();
        }
        oprot.WriteFieldEnd();
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("GetMaterialList_args(");
      sb.Append("MaterialNos: ");
      sb.Append(MaterialNos);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class GetMaterialList_result : TBase
  {
    private string _success;

    public string Success
    {
      get
      {
        return _success;
      }
      set
      {
        __isset.success = true;
        this._success = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool success;
    }

    public GetMaterialList_result() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 0:
            if (field.Type == TType.String) {
              Success = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("GetMaterialList_result");
      oprot.WriteStructBegin(struc);
      TField field = new TField();

      if (this.__isset.success) {
        if (Success != null) {
          field.Name = "Success";
          field.Type = TType.String;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Success);
          oprot.WriteFieldEnd();
        }
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("GetMaterialList_result(");
      sb.Append("Success: ");
      sb.Append(Success);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class GetUpDownMaterielNum_args : TBase
  {
    private string _siteno;

    public string Siteno
    {
      get
      {
        return _siteno;
      }
      set
      {
        __isset.siteno = true;
        this._siteno = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool siteno;
    }

    public GetUpDownMaterielNum_args() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 1:
            if (field.Type == TType.String) {
              Siteno = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("GetUpDownMaterielNum_args");
      oprot.WriteStructBegin(struc);
      TField field = new TField();
      if (Siteno != null && __isset.siteno) {
        field.Name = "siteno";
        field.Type = TType.String;
        field.ID = 1;
        oprot.WriteFieldBegin(field);
        oprot.WriteString(Siteno);
        oprot.WriteFieldEnd();
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("GetUpDownMaterielNum_args(");
      sb.Append("Siteno: ");
      sb.Append(Siteno);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class GetUpDownMaterielNum_result : TBase
  {
    private string _success;

    public string Success
    {
      get
      {
        return _success;
      }
      set
      {
        __isset.success = true;
        this._success = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool success;
    }

    public GetUpDownMaterielNum_result() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 0:
            if (field.Type == TType.String) {
              Success = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("GetUpDownMaterielNum_result");
      oprot.WriteStructBegin(struc);
      TField field = new TField();

      if (this.__isset.success) {
        if (Success != null) {
          field.Name = "Success";
          field.Type = TType.String;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Success);
          oprot.WriteFieldEnd();
        }
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("GetUpDownMaterielNum_result(");
      sb.Append("Success: ");
      sb.Append(Success);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class SendDeleteRelief_args : TBase
  {

    public SendDeleteRelief_args() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("SendDeleteRelief_args");
      oprot.WriteStructBegin(struc);
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("SendDeleteRelief_args(");
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class SendDeleteRelief_result : TBase
  {
    private string _success;

    public string Success
    {
      get
      {
        return _success;
      }
      set
      {
        __isset.success = true;
        this._success = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool success;
    }

    public SendDeleteRelief_result() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 0:
            if (field.Type == TType.String) {
              Success = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("SendDeleteRelief_result");
      oprot.WriteStructBegin(struc);
      TField field = new TField();

      if (this.__isset.success) {
        if (Success != null) {
          field.Name = "Success";
          field.Type = TType.String;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Success);
          oprot.WriteFieldEnd();
        }
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("SendDeleteRelief_result(");
      sb.Append("Success: ");
      sb.Append(Success);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class SendUpdateDownNum_args : TBase
  {

    public SendUpdateDownNum_args() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("SendUpdateDownNum_args");
      oprot.WriteStructBegin(struc);
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("SendUpdateDownNum_args(");
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class SendUpdateDownNum_result : TBase
  {
    private string _success;

    public string Success
    {
      get
      {
        return _success;
      }
      set
      {
        __isset.success = true;
        this._success = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool success;
    }

    public SendUpdateDownNum_result() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 0:
            if (field.Type == TType.String) {
              Success = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("SendUpdateDownNum_result");
      oprot.WriteStructBegin(struc);
      TField field = new TField();

      if (this.__isset.success) {
        if (Success != null) {
          field.Name = "Success";
          field.Type = TType.String;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Success);
          oprot.WriteFieldEnd();
        }
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("SendUpdateDownNum_result(");
      sb.Append("Success: ");
      sb.Append(Success);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class GetDownLineNum_args : TBase
  {
    private string _downnum;

    public string Downnum
    {
      get
      {
        return _downnum;
      }
      set
      {
        __isset.downnum = true;
        this._downnum = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool downnum;
    }

    public GetDownLineNum_args() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 1:
            if (field.Type == TType.String) {
              Downnum = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("GetDownLineNum_args");
      oprot.WriteStructBegin(struc);
      TField field = new TField();
      if (Downnum != null && __isset.downnum) {
        field.Name = "downnum";
        field.Type = TType.String;
        field.ID = 1;
        oprot.WriteFieldBegin(field);
        oprot.WriteString(Downnum);
        oprot.WriteFieldEnd();
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("GetDownLineNum_args(");
      sb.Append("Downnum: ");
      sb.Append(Downnum);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class GetDownLineNum_result : TBase
  {
    private string _success;

    public string Success
    {
      get
      {
        return _success;
      }
      set
      {
        __isset.success = true;
        this._success = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool success;
    }

    public GetDownLineNum_result() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 0:
            if (field.Type == TType.String) {
              Success = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("GetDownLineNum_result");
      oprot.WriteStructBegin(struc);
      TField field = new TField();

      if (this.__isset.success) {
        if (Success != null) {
          field.Name = "Success";
          field.Type = TType.String;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Success);
          oprot.WriteFieldEnd();
        }
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("GetDownLineNum_result(");
      sb.Append("Success: ");
      sb.Append(Success);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class GetMaterielNumByKBList_args : TBase
  {
    private List<MaterielNumKB> _materielnumlist;

    public List<MaterielNumKB> Materielnumlist
    {
      get
      {
        return _materielnumlist;
      }
      set
      {
        __isset.materielnumlist = true;
        this._materielnumlist = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool materielnumlist;
    }

    public GetMaterielNumByKBList_args() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 1:
            if (field.Type == TType.List) {
              {
                Materielnumlist = new List<MaterielNumKB>();
                TList _list28 = iprot.ReadListBegin();
                for( int _i29 = 0; _i29 < _list28.Count; ++_i29)
                {
                  MaterielNumKB _elem30 = new MaterielNumKB();
                  _elem30 = new MaterielNumKB();
                  _elem30.Read(iprot);
                  Materielnumlist.Add(_elem30);
                }
                iprot.ReadListEnd();
              }
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("GetMaterielNumByKBList_args");
      oprot.WriteStructBegin(struc);
      TField field = new TField();
      if (Materielnumlist != null && __isset.materielnumlist) {
        field.Name = "materielnumlist";
        field.Type = TType.List;
        field.ID = 1;
        oprot.WriteFieldBegin(field);
        {
          oprot.WriteListBegin(new TList(TType.Struct, Materielnumlist.Count));
          foreach (MaterielNumKB _iter31 in Materielnumlist)
          {
            _iter31.Write(oprot);
          }
          oprot.WriteListEnd();
        }
        oprot.WriteFieldEnd();
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("GetMaterielNumByKBList_args(");
      sb.Append("Materielnumlist: ");
      sb.Append(Materielnumlist);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class GetMaterielNumByKBList_result : TBase
  {
    private string _success;

    public string Success
    {
      get
      {
        return _success;
      }
      set
      {
        __isset.success = true;
        this._success = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool success;
    }

    public GetMaterielNumByKBList_result() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 0:
            if (field.Type == TType.String) {
              Success = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("GetMaterielNumByKBList_result");
      oprot.WriteStructBegin(struc);
      TField field = new TField();

      if (this.__isset.success) {
        if (Success != null) {
          field.Name = "Success";
          field.Type = TType.String;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Success);
          oprot.WriteFieldEnd();
        }
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("GetMaterielNumByKBList_result(");
      sb.Append("Success: ");
      sb.Append(Success);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class GetFaultList_args : TBase
  {
    private List<Fault> _faultlist;

    public List<Fault> Faultlist
    {
      get
      {
        return _faultlist;
      }
      set
      {
        __isset.faultlist = true;
        this._faultlist = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool faultlist;
    }

    public GetFaultList_args() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 1:
            if (field.Type == TType.List) {
              {
                Faultlist = new List<Fault>();
                TList _list32 = iprot.ReadListBegin();
                for( int _i33 = 0; _i33 < _list32.Count; ++_i33)
                {
                  Fault _elem34 = new Fault();
                  _elem34 = new Fault();
                  _elem34.Read(iprot);
                  Faultlist.Add(_elem34);
                }
                iprot.ReadListEnd();
              }
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("GetFaultList_args");
      oprot.WriteStructBegin(struc);
      TField field = new TField();
      if (Faultlist != null && __isset.faultlist) {
        field.Name = "faultlist";
        field.Type = TType.List;
        field.ID = 1;
        oprot.WriteFieldBegin(field);
        {
          oprot.WriteListBegin(new TList(TType.Struct, Faultlist.Count));
          foreach (Fault _iter35 in Faultlist)
          {
            _iter35.Write(oprot);
          }
          oprot.WriteListEnd();
        }
        oprot.WriteFieldEnd();
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("GetFaultList_args(");
      sb.Append("Faultlist: ");
      sb.Append(Faultlist);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class GetFaultList_result : TBase
  {
    private string _success;

    public string Success
    {
      get
      {
        return _success;
      }
      set
      {
        __isset.success = true;
        this._success = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool success;
    }

    public GetFaultList_result() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 0:
            if (field.Type == TType.String) {
              Success = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("GetFaultList_result");
      oprot.WriteStructBegin(struc);
      TField field = new TField();

      if (this.__isset.success) {
        if (Success != null) {
          field.Name = "Success";
          field.Type = TType.String;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Success);
          oprot.WriteFieldEnd();
        }
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("GetFaultList_result(");
      sb.Append("Success: ");
      sb.Append(Success);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class GetAreaPlcList_args : TBase
  {
    private List<AreaPlc> _areaplclist;

    public List<AreaPlc> Areaplclist
    {
      get
      {
        return _areaplclist;
      }
      set
      {
        __isset.areaplclist = true;
        this._areaplclist = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool areaplclist;
    }

    public GetAreaPlcList_args() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 1:
            if (field.Type == TType.List) {
              {
                Areaplclist = new List<AreaPlc>();
                TList _list36 = iprot.ReadListBegin();
                for( int _i37 = 0; _i37 < _list36.Count; ++_i37)
                {
                  AreaPlc _elem38 = new AreaPlc();
                  _elem38 = new AreaPlc();
                  _elem38.Read(iprot);
                  Areaplclist.Add(_elem38);
                }
                iprot.ReadListEnd();
              }
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("GetAreaPlcList_args");
      oprot.WriteStructBegin(struc);
      TField field = new TField();
      if (Areaplclist != null && __isset.areaplclist) {
        field.Name = "areaplclist";
        field.Type = TType.List;
        field.ID = 1;
        oprot.WriteFieldBegin(field);
        {
          oprot.WriteListBegin(new TList(TType.Struct, Areaplclist.Count));
          foreach (AreaPlc _iter39 in Areaplclist)
          {
            _iter39.Write(oprot);
          }
          oprot.WriteListEnd();
        }
        oprot.WriteFieldEnd();
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("GetAreaPlcList_args(");
      sb.Append("Areaplclist: ");
      sb.Append(Areaplclist);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class GetAreaPlcList_result : TBase
  {
    private string _success;

    public string Success
    {
      get
      {
        return _success;
      }
      set
      {
        __isset.success = true;
        this._success = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool success;
    }

    public GetAreaPlcList_result() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 0:
            if (field.Type == TType.String) {
              Success = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("GetAreaPlcList_result");
      oprot.WriteStructBegin(struc);
      TField field = new TField();

      if (this.__isset.success) {
        if (Success != null) {
          field.Name = "Success";
          field.Type = TType.String;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Success);
          oprot.WriteFieldEnd();
        }
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("GetAreaPlcList_result(");
      sb.Append("Success: ");
      sb.Append(Success);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class SendInsertFault_args : TBase
  {

    public SendInsertFault_args() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("SendInsertFault_args");
      oprot.WriteStructBegin(struc);
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("SendInsertFault_args(");
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class SendInsertFault_result : TBase
  {
    private string _success;

    public string Success
    {
      get
      {
        return _success;
      }
      set
      {
        __isset.success = true;
        this._success = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool success;
    }

    public SendInsertFault_result() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 0:
            if (field.Type == TType.String) {
              Success = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("SendInsertFault_result");
      oprot.WriteStructBegin(struc);
      TField field = new TField();

      if (this.__isset.success) {
        if (Success != null) {
          field.Name = "Success";
          field.Type = TType.String;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Success);
          oprot.WriteFieldEnd();
        }
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("SendInsertFault_result(");
      sb.Append("Success: ");
      sb.Append(Success);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class SendUpdateFault_args : TBase
  {

    public SendUpdateFault_args() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("SendUpdateFault_args");
      oprot.WriteStructBegin(struc);
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("SendUpdateFault_args(");
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class SendUpdateFault_result : TBase
  {
    private string _success;

    public string Success
    {
      get
      {
        return _success;
      }
      set
      {
        __isset.success = true;
        this._success = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool success;
    }

    public SendUpdateFault_result() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 0:
            if (field.Type == TType.String) {
              Success = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("SendUpdateFault_result");
      oprot.WriteStructBegin(struc);
      TField field = new TField();

      if (this.__isset.success) {
        if (Success != null) {
          field.Name = "Success";
          field.Type = TType.String;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Success);
          oprot.WriteFieldEnd();
        }
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("SendUpdateFault_result(");
      sb.Append("Success: ");
      sb.Append(Success);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class ShowUpBarcode_args : TBase
  {
    private string _barcode;
    private string _materialno;
    private string _message;
    private int _status;

    public string Barcode
    {
      get
      {
        return _barcode;
      }
      set
      {
        __isset.barcode = true;
        this._barcode = value;
      }
    }

    public string Materialno
    {
      get
      {
        return _materialno;
      }
      set
      {
        __isset.materialno = true;
        this._materialno = value;
      }
    }

    public string Message
    {
      get
      {
        return _message;
      }
      set
      {
        __isset.message = true;
        this._message = value;
      }
    }

    public int Status
    {
      get
      {
        return _status;
      }
      set
      {
        __isset.status = true;
        this._status = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool barcode;
      public bool materialno;
      public bool message;
      public bool status;
    }

    public ShowUpBarcode_args() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 1:
            if (field.Type == TType.String) {
              Barcode = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          case 2:
            if (field.Type == TType.String) {
              Materialno = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          case 3:
            if (field.Type == TType.String) {
              Message = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          case 4:
            if (field.Type == TType.I32) {
              Status = iprot.ReadI32();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("ShowUpBarcode_args");
      oprot.WriteStructBegin(struc);
      TField field = new TField();
      if (Barcode != null && __isset.barcode) {
        field.Name = "barcode";
        field.Type = TType.String;
        field.ID = 1;
        oprot.WriteFieldBegin(field);
        oprot.WriteString(Barcode);
        oprot.WriteFieldEnd();
      }
      if (Materialno != null && __isset.materialno) {
        field.Name = "materialno";
        field.Type = TType.String;
        field.ID = 2;
        oprot.WriteFieldBegin(field);
        oprot.WriteString(Materialno);
        oprot.WriteFieldEnd();
      }
      if (Message != null && __isset.message) {
        field.Name = "message";
        field.Type = TType.String;
        field.ID = 3;
        oprot.WriteFieldBegin(field);
        oprot.WriteString(Message);
        oprot.WriteFieldEnd();
      }
      if (__isset.status) {
        field.Name = "status";
        field.Type = TType.I32;
        field.ID = 4;
        oprot.WriteFieldBegin(field);
        oprot.WriteI32(Status);
        oprot.WriteFieldEnd();
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("ShowUpBarcode_args(");
      sb.Append("Barcode: ");
      sb.Append(Barcode);
      sb.Append(",Materialno: ");
      sb.Append(Materialno);
      sb.Append(",Message: ");
      sb.Append(Message);
      sb.Append(",Status: ");
      sb.Append(Status);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class ShowUpBarcode_result : TBase
  {
    private string _success;

    public string Success
    {
      get
      {
        return _success;
      }
      set
      {
        __isset.success = true;
        this._success = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool success;
    }

    public ShowUpBarcode_result() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 0:
            if (field.Type == TType.String) {
              Success = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("ShowUpBarcode_result");
      oprot.WriteStructBegin(struc);
      TField field = new TField();

      if (this.__isset.success) {
        if (Success != null) {
          field.Name = "Success";
          field.Type = TType.String;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Success);
          oprot.WriteFieldEnd();
        }
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("ShowUpBarcode_result(");
      sb.Append("Success: ");
      sb.Append(Success);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class DataForRestart_args : TBase
  {

    public DataForRestart_args() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("DataForRestart_args");
      oprot.WriteStructBegin(struc);
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("DataForRestart_args(");
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class DataForRestart_result : TBase
  {
    private string _success;

    public string Success
    {
      get
      {
        return _success;
      }
      set
      {
        __isset.success = true;
        this._success = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool success;
    }

    public DataForRestart_result() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 0:
            if (field.Type == TType.String) {
              Success = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("DataForRestart_result");
      oprot.WriteStructBegin(struc);
      TField field = new TField();

      if (this.__isset.success) {
        if (Success != null) {
          field.Name = "Success";
          field.Type = TType.String;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Success);
          oprot.WriteFieldEnd();
        }
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("DataForRestart_result(");
      sb.Append("Success: ");
      sb.Append(Success);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class MaterialRemove_args : TBase
  {
    private string _barcode;

    public string Barcode
    {
      get
      {
        return _barcode;
      }
      set
      {
        __isset.barcode = true;
        this._barcode = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool barcode;
    }

    public MaterialRemove_args() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 1:
            if (field.Type == TType.String) {
              Barcode = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("MaterialRemove_args");
      oprot.WriteStructBegin(struc);
      TField field = new TField();
      if (Barcode != null && __isset.barcode) {
        field.Name = "barcode";
        field.Type = TType.String;
        field.ID = 1;
        oprot.WriteFieldBegin(field);
        oprot.WriteString(Barcode);
        oprot.WriteFieldEnd();
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("MaterialRemove_args(");
      sb.Append("Barcode: ");
      sb.Append(Barcode);
      sb.Append(")");
      return sb.ToString();
    }

  }


  #if !SILVERLIGHT
  [Serializable]
  #endif
  public partial class MaterialRemove_result : TBase
  {
    private string _success;

    public string Success
    {
      get
      {
        return _success;
      }
      set
      {
        __isset.success = true;
        this._success = value;
      }
    }


    public Isset __isset;
    #if !SILVERLIGHT
    [Serializable]
    #endif
    public struct Isset {
      public bool success;
    }

    public MaterialRemove_result() {
    }

    public void Read (TProtocol iprot)
    {
      TField field;
      iprot.ReadStructBegin();
      while (true)
      {
        field = iprot.ReadFieldBegin();
        if (field.Type == TType.Stop) { 
          break;
        }
        switch (field.ID)
        {
          case 0:
            if (field.Type == TType.String) {
              Success = iprot.ReadString();
            } else { 
              TProtocolUtil.Skip(iprot, field.Type);
            }
            break;
          default: 
            TProtocolUtil.Skip(iprot, field.Type);
            break;
        }
        iprot.ReadFieldEnd();
      }
      iprot.ReadStructEnd();
    }

    public void Write(TProtocol oprot) {
      TStruct struc = new TStruct("MaterialRemove_result");
      oprot.WriteStructBegin(struc);
      TField field = new TField();

      if (this.__isset.success) {
        if (Success != null) {
          field.Name = "Success";
          field.Type = TType.String;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Success);
          oprot.WriteFieldEnd();
        }
      }
      oprot.WriteFieldStop();
      oprot.WriteStructEnd();
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder("MaterialRemove_result(");
      sb.Append("Success: ");
      sb.Append(Success);
      sb.Append(")");
      return sb.ToString();
    }

  }

}