I'm trying to take advantage of Bidirectional serialization of some relational Linq-2-Sql generated entity classes. When using Unidirectional option everything works just fine, bu the moment I add IsReferenceType=true, objects fail to get transported over the tcp binding. Sample code: Entity class:

[Table(Name="dbo.Blocks")]
    [DataContract()]
    public partial class Block : INotifyPropertyChanging, INotifyPropertyChanged
    {

        private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);

        private long _ID;

        private int _StatusID;

        private string _Name;

        private bool _IsWithControlPoints;

        private long _DivisionID;

        private string _SHAPE;

        private EntitySet<BlockByWorkstation> _BlockByWorkstations;

        private EntitySet<PlanningPointAppropriation> _PlanningPointAppropriations;

        private EntitySet<Neighbor> _Neighbors;

        private EntitySet<Neighbor> _Neighbors1;

        private EntitySet<Task> _Tasks;

        private EntitySet<PlanningPointByBlock> _PlanningPointByBlocks;

        private EntitySet<ControlPointByBlock> _ControlPointByBlocks;

        private EntityRef<Division> _Division;

        private bool serializing;

    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(System.Data.Linq.ChangeAction action);
    partial void OnCreated();
    partial void OnIDChanging(long value);
    partial void OnIDChanged();
    partial void OnStatusIDChanging(int value);
    partial void OnStatusIDChanged();
    partial void OnNameChanging(string value);
    partial void OnNameChanged();
    partial void OnIsWithControlPointsChanging(bool value);
    partial void OnIsWithControlPointsChanged();
    partial void OnDivisionIDChanging(long value);
    partial void OnDivisionIDChanged();
    partial void OnSHAPEChanging(string value);
    partial void OnSHAPEChanged();
    #endregion

        public Block()
        {
            this.Initialize();
        }

        [Column(Storage="_ID", AutoSync=AutoSync.OnInsert, DbType="BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true)]
        [DataMember(Order=1)]
        public override long ID
        {
            get
            {
                return this._ID;
            }
            set
            {
                if ((this._ID != value))
                {
                    this.OnIDChanging(value);
                    this.SendPropertyChanging();
                    this._ID = value;
                    this.SendPropertyChanged("ID");
                    this.OnIDChanged();
                }
            }
        }

        [Column(Storage="_StatusID", DbType="Int NOT NULL")]
        [DataMember(Order=2)]
        public int StatusID
        {
            get
            {
                return this._StatusID;
            }
            set
            {
                if ((this._StatusID != value))
                {
                    this.OnStatusIDChanging(value);
                    this.SendPropertyChanging();
                    this._StatusID = value;
                    this.SendPropertyChanged("StatusID");
                    this.OnStatusIDChanged();
                }
            }
        }

        [Column(Storage="_Name", DbType="NVarChar(255)")]
        [DataMember(Order=3)]
        public string Name
        {
            get
            {
                return this._Name;
            }
            set
            {
                if ((this._Name != value))
                {
                    this.OnNameChanging(value);
                    this.SendPropertyChanging();
                    this._Name = value;
                    this.SendPropertyChanged("Name");
                    this.OnNameChanged();
                }
            }
        }

        [Column(Storage="_IsWithControlPoints", DbType="Bit NOT NULL")]
        [DataMember(Order=4)]
        public bool IsWithControlPoints
        {
            get
            {
                return this._IsWithControlPoints;
            }
            set
            {
                if ((this._IsWithControlPoints != value))
                {
                    this.OnIsWithControlPointsChanging(value);
                    this.SendPropertyChanging();
                    this._IsWithControlPoints = value;
                    this.SendPropertyChanged("IsWithControlPoints");
                    this.OnIsWithControlPointsChanged();
                }
            }
        }

        [Column(Storage="_DivisionID", DbType="BigInt NOT NULL")]
        [DataMember(Order=5)]
        public long DivisionID
        {
            get
            {
                return this._DivisionID;
            }
            set
            {
                if ((this._DivisionID != value))
                {
                    if (this._Division.HasLoadedOrAssignedValue)
                    {
                        throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
                    }
                    this.OnDivisionIDChanging(value);
                    this.SendPropertyChanging();
                    this._DivisionID = value;
                    this.SendPropertyChanged("DivisionID");
                    this.OnDivisionIDChanged();
                }
            }
        }

        [Column(Storage="_SHAPE", DbType="Text", UpdateCheck=UpdateCheck.Never)]
        [DataMember(Order=6)]
        public string SHAPE
        {
            get
            {
                return this._SHAPE;
            }
            set
            {
                if ((this._SHAPE != value))
                {
                    this.OnSHAPEChanging(value);
                    this.SendPropertyChanging();
                    this._SHAPE = value;
                    this.SendPropertyChanged("SHAPE");
                    this.OnSHAPEChanged();
                }
            }
        }

        [Association(Name="Block_BlockByWorkstation", Storage="_BlockByWorkstations", ThisKey="ID", OtherKey="BlockID")]
        [DataMember(Order=7, EmitDefaultValue=false)]
        public EntitySet<BlockByWorkstation> BlockByWorkstations
        {
            get
            {
                if ((this.serializing 
                            && (this._BlockByWorkstations.HasLoadedOrAssignedValues == false)))
                {
                    return null;
                }
                return this._BlockByWorkstations;
            }
            set
            {
                this._BlockByWorkstations.Assign(value);
            }
        }

        [Association(Name="Block_PlanningPointAppropriation", Storage="_PlanningPointAppropriations", ThisKey="ID", OtherKey="MasterBlockID")]
        [DataMember(Order=8, EmitDefaultValue=false)]
        public EntitySet<PlanningPointAppropriation> PlanningPointAppropriations
        {
            get
            {
                if ((this.serializing 
                            && (this._PlanningPointAppropriations.HasLoadedOrAssignedValues == false)))
                {
                    return null;
                }
                return this._PlanningPointAppropriations;
            }
            set
            {
                this._PlanningPointAppropriations.Assign(value);
            }
        }

        [Association(Name="Block_Neighbor", Storage="_Neighbors", ThisKey="ID", OtherKey="FirstBlockID")]
        [DataMember(Order=9, EmitDefaultValue=false)]
        public EntitySet<Neighbor> Neighbors
        {
            get
            {
                if ((this.serializing 
                            && (this._Neighbors.HasLoadedOrAssignedValues == false)))
                {
                    return null;
                }
                return this._Neighbors;
            }
            set
            {
                this._Neighbors.Assign(value);
            }
        }

        [Association(Name="Block_Neighbor1", Storage="_Neighbors1", ThisKey="ID", OtherKey="SecondBlockID")]
        [DataMember(Order=10, EmitDefaultValue=false)]
        public EntitySet<Neighbor> Neighbors1
        {
            get
            {
                if ((this.serializing 
                            && (this._Neighbors1.HasLoadedOrAssignedValues == false)))
                {
                    return null;
                }
                return this._Neighbors1;
            }
            set
            {
                this._Neighbors1.Assign(value);
            }
        }

        [Association(Name="Block_Task", Storage="_Tasks", ThisKey="ID", OtherKey="BlockID")]
        [DataMember(Order=11, EmitDefaultValue=false)]
        public EntitySet<Task> Tasks
        {
            get
            {
                if ((this.serializing 
                            && (this._Tasks.HasLoadedOrAssignedValues == false)))
                {
                    return null;
                }
                return this._Tasks;
            }
            set
            {
                this._Tasks.Assign(value);
            }
        }

        [Association(Name="Block_PlanningPointByBlock", Storage="_PlanningPointByBlocks", ThisKey="ID", OtherKey="BlockID")]
        [DataMember(Order=12, EmitDefaultValue=false)]
        public EntitySet<PlanningPointByBlock> PlanningPointByBlocks
        {
            get
            {
                if ((this.serializing 
                            && (this._PlanningPointByBlocks.HasLoadedOrAssignedValues == false)))
                {
                    return null;
                }
                return this._PlanningPointByBlocks;
            }
            set
            {
                this._PlanningPointByBlocks.Assign(value);
            }
        }

        [Association(Name="Block_ControlPointByBlock", Storage="_ControlPointByBlocks", ThisKey="ID", OtherKey="BlockID")]
        [DataMember(Order=13, EmitDefaultValue=false)]
        public EntitySet<ControlPointByBlock> ControlPointByBlocks
        {
            get
            {
                if ((this.serializing 
                            && (this._ControlPointByBlocks.HasLoadedOrAssignedValues == false)))
                {
                    return null;
                }
                return this._ControlPointByBlocks;
            }
            set
            {
                this._ControlPointByBlocks.Assign(value);
            }
        }

        [Association(Name="Division_Block", Storage="_Division", ThisKey="DivisionID", OtherKey="ID", IsForeignKey=true, DeleteOnNull=true, DeleteRule="CASCADE")]
        public Division Division
        {
            get
            {
                return this._Division.Entity;
            }
            set
            {
                Division previousValue = this._Division.Entity;
                if (((previousValue != value) 
                            || (this._Division.HasLoadedOrAssignedValue == false)))
                {
                    this.SendPropertyChanging();
                    if ((previousValue != null))
                    {
                        this._Division.Entity = null;
                        previousValue.Blocks.Remove(this);
                    }
                    this._Division.Entity = value;
                    if ((value != null))
                    {
                        value.Blocks.Add(this);
                        this._DivisionID = value.ID;
                    }
                    else
                    {
                        this._DivisionID = default(long);
                    }
                    this.SendPropertyChanged("Division");
                }
            }
        }

        public event PropertyChangingEventHandler PropertyChanging;

        public event PropertyChangedEventHandler PropertyChanged;

        protected virtual void SendPropertyChanging()
        {
            if ((this.PropertyChanging != null))
            {
                this.PropertyChanging(this, emptyChangingEventArgs);
            }
        }

        protected virtual void SendPropertyChanged(String propertyName)
        {
            if ((this.PropertyChanged != null))
            {
                this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            }
        }

        private void attach_BlockByWorkstations(BlockByWorkstation entity)
        {
            this.SendPropertyChanging();
            entity.Block = this;
        }

        private void detach_BlockByWorkstations(BlockByWorkstation entity)
        {
            this.SendPropertyChanging();
            entity.Block = null;
        }

        private void attach_PlanningPointAppropriations(PlanningPointAppropriation entity)
        {
            this.SendPropertyChanging();
            entity.Block = this;
        }

        private void detach_PlanningPointAppropriations(PlanningPointAppropriation entity)
        {
            this.SendPropertyChanging();
            entity.Block = null;
        }

        private void attach_Neighbors(Neighbor entity)
        {
            this.SendPropertyChanging();
            entity.FirstBlock = this;
        }

        private void detach_Neighbors(Neighbor entity)
        {
            this.SendPropertyChanging();
            entity.FirstBlock = null;
        }

        private void attach_Neighbors1(Neighbor entity)
        {
            this.SendPropertyChanging();
            entity.SecondBlock = this;
        }

        private void detach_Neighbors1(Neighbor entity)
        {
            this.SendPropertyChanging();
            entity.SecondBlock = null;
        }

        private void attach_Tasks(Task entity)
        {
            this.SendPropertyChanging();
            entity.Block = this;
        }

        private void detach_Tasks(Task entity)
        {
            this.SendPropertyChanging();
            entity.Block = null;
        }

        private void attach_PlanningPointByBlocks(PlanningPointByBlock entity)
        {
            this.SendPropertyChanging();
            entity.Block = this;
        }

        private void detach_PlanningPointByBlocks(PlanningPointByBlock entity)
        {
            this.SendPropertyChanging();
            entity.Block = null;
        }

        private void attach_ControlPointByBlocks(ControlPointByBlock entity)
        {
            this.SendPropertyChanging();
            entity.Block = this;
        }

        private void detach_ControlPointByBlocks(ControlPointByBlock entity)
        {
            this.SendPropertyChanging();
            entity.Block = null;
        }

        private void Initialize()
        {
            this._BlockByWorkstations = new EntitySet<BlockByWorkstation>(new Action<BlockByWorkstation>(this.attach_BlockByWorkstations), new Action<BlockByWorkstation>(this.detach_BlockByWorkstations));
            this._PlanningPointAppropriations = new EntitySet<PlanningPointAppropriation>(new Action<PlanningPointAppropriation>(this.attach_PlanningPointAppropriations), new Action<PlanningPointAppropriation>(this.detach_PlanningPointAppropriations));
            this._Neighbors = new EntitySet<Neighbor>(new Action<Neighbor>(this.attach_Neighbors), new Action<Neighbor>(this.detach_Neighbors));
            this._Neighbors1 = new EntitySet<Neighbor>(new Action<Neighbor>(this.attach_Neighbors1), new Action<Neighbor>(this.detach_Neighbors1));
            this._Tasks = new EntitySet<Task>(new Action<Task>(this.attach_Tasks), new Action<Task>(this.detach_Tasks));
            this._PlanningPointByBlocks = new EntitySet<PlanningPointByBlock>(new Action<PlanningPointByBlock>(this.attach_PlanningPointByBlocks), new Action<PlanningPointByBlock>(this.detach_PlanningPointByBlocks));
            this._ControlPointByBlocks = new EntitySet<ControlPointByBlock>(new Action<ControlPointByBlock>(this.attach_ControlPointByBlocks), new Action<ControlPointByBlock>(this.detach_ControlPointByBlocks));
            this._Division = default(EntityRef<Division>);
            OnCreated();
        }

        [OnDeserializing()]
        [System.ComponentModel.EditorBrowsableAttribute(EditorBrowsableState.Never)]
        public void OnDeserializing(StreamingContext context)
        {
            this.Initialize();
        }

        [OnSerializing()]
        [System.ComponentModel.EditorBrowsableAttribute(EditorBrowsableState.Never)]
        public void OnSerializing(StreamingContext context)
        {
            this.serializing = true;
        }

        [OnSerialized()]
        [System.ComponentModel.EditorBrowsableAttribute(EditorBrowsableState.Never)]
        public void OnSerialized(StreamingContext context)
        {
            this.serializing = false;
        }
    }

App.config:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.web>
    <compilation debug="true" />
  </system.web>
  <!-- When deploying the service library project, the content of the config file must be added to the host's 
  app.config file. System.Configuration does not support config files for libraries. -->
  <system.serviceModel>
    <services>
      <service behaviorConfiguration="debugging"
        name="DBServicesLibrary.DBService">              
      </service>
    </services>
    <behaviors>
      <serviceBehaviors>
        <behavior name="DBServicesLibrary.DBServiceBehavior">
          <!-- To avoid disclosing metadata information, 
          set the value below to false and remove the metadata endpoint above before deployment -->
          <serviceMetadata httpGetEnabled="True"/>

          <!-- To receive exception details in faults for debugging purposes, 
          set the value below to true.  Set to false before deployment 
          to avoid disclosing exception information -->
          <serviceDebug includeExceptionDetailInFaults="False" />
        </behavior>
        <behavior name="debugging">
          <serviceDebug includeExceptionDetailInFaults="true"/>
        </behavior>
      </serviceBehaviors>
    </behaviors>
  </system.serviceModel>
</configuration>

Host part:

ServiceHost svh = new ServiceHost(typeof(DBService));
            svh.AddServiceEndpoint(
                typeof(DBServices.Contract.IDBService),
                new NetTcpBinding(),
                "net.tcp://localhost:8000");

Client part:

ChannelFactory<DBServices.Contract.IDBService> scf;
            scf = new ChannelFactory<DBServices.Contract.IDBService>(new NetTcpBinding(),"net.tcp://localhost:8000");


            _serv = scf.CreateChannel();
            ((IContextChannel)_serv).OperationTimeout = new TimeSpan(0, 5, 0);