Hi all. I have the following problem: I'm using L2S for generating entity classes. All these classes share the same property ID which is autonumber. So I figured to put this property to base class and extend all entity classes from the base one. In order to be able to read the value I'm using the override modifier on this property in each and every entity class. Up to now it's live and kicking. Then I decided to introduce another tier - services using WCF approach. I've modified the Serialization mode to Unidirectional (and added the IsReference=true attribute to enable two directions), also added [DataContract] attribute to the BaseObject class. WCF is able to transport the whole object but one property , which is ID. Applying [DataMember] attribute on ID property at the base class resulted in nothing. Am I missing something? Is what I'm trying to achieve possible at all?

[DataContract()]
abstract public class BaseObject : IIccObject
public virtual long ID
        {
            get;
            set;            
        }
[Table(Name="dbo.Blocks")]
    [DataContract(IsReference=true)]
    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 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="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 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._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;
        }
    }