/// <summary>
        /// Updates a MediaType
        /// </summary>
        /// <param name="mediaType">MediaType Entity</param>
        [OperationBehavior(TransactionScopeRequired=false)]
        public void UpdateMediaType(MediaType mediaType)
        {
            // a local instance of the related data context
            InformationDataContext context;
 
            // if the entity is NOT contained in the table
            // of an instance-level property initialized on first get
            if (!this.InformationDataContext. 
                MediaType.Contains(mediaType))
            {
                // it is OK to set the local instance
                // to the instance-level variable
                context = this.InformationDataContext;
            }
            else
            {
                // if the item IS found it needs to be managed
                // using a new instance of the data context
                context = new InformationDataContext(
                    ConfigurationProvider.ConnectionString);
            }

            // Only with the following implementation
            // Does this line or calls to any of the overloads
            // Successfully persist changes in the manner intended
            context.MediaType.Attach(mediaType, true);

            // Oh, but hooray! We can call "Submit Changes"
            // and experience an abstraction-level once removed 
            // from our dreaded database platform
            context.SubmitChanges();
        }

        /// <summary>
        /// Save the product group and return a new copy with updated values.
        /// </summary>
        /// <param name="group">Product group to save.</param>
        /// <returns>Product group with new saved state.</returns>
        public ProductGroup UpdateProductGroup(ProductGroup group) {
            using (FilmLibraryDataContext ctx
                = new FilmLibraryDataContext(connectionString)) {

                // Attach the group to the newly formed context as modified.
                ctx.ProductGroups.Attach(group, true);
                
                // May raise an exception upon a conflict if the row has been
                // modified or deleted.
                ctx.SubmitChanges();

                return group;
            }
        }

public void AddNewSupportingDocument(IEnumerable<tblSupportingDocument>     
                                                       objSupportingDocument ,int intStatusId)
{
            if (objSupportingDocument != null)
            {
                DeleteDocuments(intStatusId);
                foreach (var SupportDocument in objSupportingDocument)
                {
                    objTimeManagerDataAccessDataContext = new 
                                                                        TimeManagerDataAccessDataContext();
                   objTimeManagerDataAccessDataContext.GetTable<tblSupportingDocument>
                              ().InsertOnSubmit(SupportDocument);
                    objTimeManagerDataAccessDataContext.SubmitChanges();
                }
            }
        }

public bool Update(tt_customer customer)
{
     context = new TimeTrakkerContext();
     //tt_customer Tcust = context.tt_customers.Single(c => c.Pk == customer.Pk);
     //create a new instance to avoid object tracking
     tt_customer Tcust = new tt_customer { Pk = customer.Pk };
     context.tt_customers.Attach(customer, Tcust);
     context.SubmitChanges();
     return true;
}

            using (var context = GetContext())
            {
                Company company = new Company(companyId);
                context.Companies.Attach(company);
                company.UserName = userName;
                company.Password = password; 
                company.EMail = email;
                company.Notes = notes;
                context.SubmitChanges();
            }

    partial class Company
    {
        public Company(int companyName)
        {
            _CompanyId = companyName;
        }
    }

tt_customer Tcust = context.tt_customers.Single(c => c.Pk == customer.Pk);

        private YourDataContext _context;
 
        /// <summary>
        /// Used to extend all entities in the datacontext
        /// </summary>
        public interface IBaseEntity
        {
            /// <summary>
            /// Expected to be tables primary key
            /// </summary>
            int ID { get; set; }
        }
 
        /// <summary>
        /// Saves an entity to the database. 
        /// </summary>
        /// <returns>-1 = Failed. 0 = Update Ok, otherwise it returns the ID of the object</returns>
        public int SaveEntity<TEntity>(TEntity entity) where TEntity : class, IBaseEntity
        {
            var original = _context.GetTable<TEntity>().FirstOrDefault(p => p.ID == entity.ID);
            if (original != null)
            {
                return UpdateEntity(entity, original);
            }
            
            try
            {
                _context.GetTable<TEntity>().InsertOnSubmit(entity);
                _context.SubmitChanges();
                return entity.ID;
            }
            catch
            {
                return -1;
            }
        }
 
        public int UpdateEntity<TEntity>(TEntity source, TEntity original) where TEntity : class, IBaseEntity
        {
            using (var saveContext = new YourDataContext(ConnectionString))
            {
                saveContext.GetTable<TEntity>().Attach(source, original);
                try
                {
                    saveContext.SubmitChanges();
                    return 0;
                }
                catch
                {
                    return -1;
                }
            }
        }

// this
context.GetTable<TType>().First(p=>p.ID == 1);
// is the same as this
context.TType.First(p=>p.ID == 1);

        public static void Main(string[] args)
        {
            using(var context = new DataContext())
            {
                // Sets the context to show every query done to the console window
                context.Log = Console.Out;
 
                // this wil generate a sql like: select top(1) from table where id = 1
                context.GetTable<TEntity>().First(p => p.ID == 1);
 
                // this wil generate a sql like: select * from table
                // and then perform a normal linq query on the object collection. 
                context.GetTable<TEntity>().ToList().First(p => p.ID == 1);
            }
        }

        static void CopyProperties<T>(ref T Target, T Source)
        {
            foreach (PropertyInfo PI in Target.GetType().GetProperties())
            {
                if (PI.CanWrite && PI.CanRead)
                {
                    PI.SetValue(Target, PI.GetValue(Source, null), null);
                }
            }
        }

        static void Save(Test_TableData ChangedData)
        {
            using (DataClasses1DataContext D = new DataClasses1DataContext())
            {
                Test_TableData UpdateTarget = D.Test_TableDatas.SingleOrDefault(i => i.ID == ChangedData.ID);
                if (UpdateTarget != null)
                {
                    CopyProperties<Test_TableData>(ref UpdateTarget, ChangedData);
                }
                else
                {
                    D.Test_TableDatas.InsertOnSubmit(ChangedData);
                }
                D.SubmitChanges();
            }
        }