public abstract class ListRecordItem<T> : GridIBindingListRecordPrototype where T : EntityObject
    {
        T mappedobject;
        T fRecordCache;


        public virtual string ObjectContextName { get; set; }
        public ListRecordItem() : this(Activator.CreateInstance(typeof(T)) as T)
        {
            
        }
        public ListRecordItem(EntityObject eObj)
            : base(eObj)
        {
            Assign(eObj);
            Committed = (eObj.EntityKey != null);
        }
        public override void BeginEdit()
        {
            if (IsValidate())
            {
                MapObject(RecordCache as T, mappedobject);
            }
        }

        public override void CancelEdit()
        {
            if (Editing)
            {
                Assign(RecordCache);
                Editing = false;
            }
            base.CancelEdit();
        }
        public override void EndEdit()
        {
            base.EndEdit();
        }
        
        public override void Assign(EntityObject eObj)
        {
            if (eObj == null) return;
            Editing = false;
            if (mappedobject == null || mappedobject.EntityKey == null) { mappedobject = eObj as T; }
            else
            {
                MapObject(mappedobject, eObj as T);
            }
        }

        public abstract void MapObject(T to, T from);

        public override EntityObject RecordCache
        {
            get
            {
                if (fRecordCache == null) fRecordCache = Activator.CreateInstance(typeof(T)) as T;
                return fRecordCache;
            } 
        }

        public override bool CanDelete()
        {
            return true;
        }

        public override bool CanEdit()
        {
            throw new NotImplementedException();
        }

        public override bool IsNew()
        {
            return (mappedobject.EntityKey == null);
        }

        public override EntityObject MappedObject
        {
            get
            {
                return mappedobject;
            }
            set
            {
                mappedobject = value as T;
            }
        }

        public override void Commit()
        {
            if (Editing && IsValidate())
            {
                using (var context = Activator.CreateInstance(Type.GetType(this.ObjectContextName)) as ObjectContext)
                {
                    (context.Connection as EntityConnection).StoreConnection.ConnectionString = ConnectionStringState.GetEntityConnectionString();
                    T m = MappedObject as T;
                    if (IsNew())
                    {
                        context.AddObject(m.GetType().Name, m);
                        try
                        {
                            context.SaveChanges(SaveOptions.AcceptAllChangesAfterSave);
                            Committed = true;
                            Editing = false;
                            Console.WriteLine("Commit");
                            Assign(m);
                        }
                        catch (OptimisticConcurrencyException ex) { Console.WriteLine(ex.Message); }
                        catch (EntityCommandExecutionException ex) { Console.WriteLine(ex.Message); }
                        catch (Exception ex) { Console.WriteLine(ex.Message); }
                    }
                    else
                    {
                        try
                        {

                            context.AttachTo(m.EntityKey.EntitySetName, m);
                        }
                        catch (Exception ex)
                        { Console.WriteLine(ex.Message); }
                        context.ObjectStateManager.ChangeObjectState(m, EntityState.Modified);
                        try
                        {
                            context.SaveChanges(SaveOptions.AcceptAllChangesAfterSave);
                            System.Reflection.PropertyInfo propinfo = m.GetType().GetProperty("recaff");
                            if (propinfo != null)
                            {
                                object o = propinfo.GetValue(m, System.Reflection.BindingFlags.Public, null, null, null);
                                if (int.Parse(o.ToString()) == 0)
                                    UserMessanger.WarningUserConcurrencyWrite();
                            }
                            Assign(m);
                            Committed = true;
                            Editing = false;
                            Console.WriteLine("Commit");
                        }
                        catch (OptimisticConcurrencyException ex) { Console.WriteLine(ex.Message); }
                        catch (EntityCommandExecutionException ex) { Console.WriteLine(ex.Message); }
                        catch (Exception ex) { Console.WriteLine(ex.Message); }
                    }
                }
            }
        }

        public override void Remove()
        {
            if (!IsNew())
                using (var context = Activator.CreateInstance(Type.GetType(this.ObjectContextName)) as ObjectContext)
                {
                    (context.Connection as EntityConnection).StoreConnection.ConnectionString = ConnectionStringState.GetEntityConnectionString();
                    T m = MappedObject as T;
                    context.AttachTo(m.EntityKey.EntitySetName, m);
                    context.ObjectStateManager.ChangeObjectState(m, EntityState.Deleted);
                    try
                    {
                        context.SaveChanges(SaveOptions.AcceptAllChangesAfterSave);
                    }
                    catch (OptimisticConcurrencyException ex) { Console.WriteLine(ex.Message); }
                    catch (EntityCommandExecutionException ex) { Console.WriteLine(ex.Message); }
                    catch (Exception ex) { Console.WriteLine(ex.Message); }
                }
        }

        public override bool IsValidate()
        {
            return false;
        }

        public override void SetDefaultValues(params object[] args)
        {
            throw new NotImplementedException();
        }

        public override object ValidateRecord()
        {
            throw new NotImplementedException();
        }
    }

        public void Генерация_Нормативного_процесса_из_Структуры_изделия_и_Основного_поставщика(Guid contextId, YSBMESDataSet ds, DataTable dt, DataRow dr)
        {
            main.LoadMacroType("Процесс нормативный");

            t_sm = main.GetObjectIDByObjectName("Тип смещения", "Дни");
            t_po = main.GetObjectIDByObjectName("Тип потока", "Материальный");
            t_sv = main.GetObjectIDByObjectName("Тип связи", "КонецВНачало");

            DataRow tpr = ds.Tables["Процесс нормативный"].NewRow();
            tpr["РодительИД"] = DBNull.Value;
            tpr["Наименование"] = "Изготовление " + dr["Наименование"].ToString();
            tpr["Тип смещения"] = t_sm;
            //            tpr["Актуальность"] = true;
            ds.Tables["Процесс нормативный"].Rows.Add(tpr);

            var compozits = main.GetAgregatedTypesByName("Составное изделие");
            var matandpki = main.GetAgregatedTypesByName("Материалы и ПКИ");

            if (!matandpki.Contains("'" + dr["ТипИД"].ToString() + "'")) СоздатьНПизСтруктурыиОП(ds, dr, (Guid)tpr["ИД"], Guid.Empty);

            main.SaveDS();
        }

Activator.CreateInstance(typeof(T)) as T

return new T();