2

我有这样的课程： 

public class course   
{
        public int CourseID { get; set; }
        public string Name { get; set; }   
        public Event Schedule {get; set;} //Event is coming from library Dday.iCal  
}

实体框架无法正确理解如何保存此属性。（我想在保存时将其序列化为字符串，并在我的应用程序中使用它时将其保留为事件。）所以我有两种方法，例如 SerializeToString() 和 DeserializeFromString()。我希望仅在保存到数据库时应用这些方法。

我想出了以下内容。基本上我试图将一个单独的属性作为一个字符串保存在数据库中，并且 Event 将被忽略，但它现在不会将任何内容保存到数据库中。我什至不确定这是否是做事的好方法，或者可以做更好的事情。： 

 public class course   
    {
            public int CourseID { get; set; }
            public string Name { get; set; }  
            private Event _Schedule;
            [NotMapped]  
            public Event Schedule {  
            get
            {
                if (!String.IsNullOrEmpty(CourseSchedule))
                {
                    return DeserilizeFromString(CourseSchedule);
                }
                return new Event();
            }
            set
            {
                _schedule = value;
            }
            }  
            private string _courseSchedule;
            public string CourseSchedule { 
            get
            {
                return _courseSchedule;
            }
            private set
            {
                if (Schedule != null)
                {
                    _courseSchedule = SerializeToString(Schedule);
                }
                else
                {
                    _courseSchedule = null;
                }
            }   
 }
4

4 回答 4

1

asp.net 上的作者实际上已经实现了您尝试做的事情，几乎到了发球台。您可能需要遵循该项目中的几点来帮助您入门。该项目的链接在这里。

需要注意的一些事情是，它确实利用了DbContext Api在实体框架中实现的。上面提到的一些抽象是这样的：

您的解决方案：

  • 模型
  • 看法
  • 控制器
  • 数据访问层 (DAL)

本教程实际上将使用Course Controller、Unit Of Work Class和来完成实现Repositories。在本教程结束时，它将实现那些automatic properties看起来DbContext像这样的：

// Model:
public abstract class Person
    {
        [Key]
        public int PersonID { get; set; }

        [Required(ErrorMessage = "Last name is required.")]
        [Display(Name = "Last Name")]
        [MaxLength(50)]
        public string LastName { get; set; }

        [Required(ErrorMessage = "First name is required.")]
        [Column("FirstName")]
        [Display(Name = "First Name")]
        [MaxLength(50)]
        public string FirstMidName { get; set; }

        public string FullName
        {
            get
            {
                return LastName + ", " + FirstMidName;
            }
        }
    }

// Repository:
public class StudentRepository : IStudentRepository, IDisposable
    {
        private SchoolContext context;

        public StudentRepository(SchoolContext context)
        {
            this.context = context;
        }

        public IEnumerable<Student> GetStudents()
        {
            return context.Students.ToList();
        }

        public Student GetStudentByID(int id)
        {
            return context.Students.Find(id);
        }

        public void InsertStudent(Student student)
        {
            context.Students.Add(student);
        }

        public void DeleteStudent(int studentID)
        {
            Student student = context.Students.Find(studentID);
            context.Students.Remove(student);
        }

        public void UpdateStudent(Student student)
        {
            context.Entry(student).State = EntityState.Modified;
        }

        public void Save()
        {
            context.SaveChanges();
        }

        private bool disposed = false;

        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                if (disposing)
                {
                    context.Dispose();
                }
            }
            this.disposed = true;
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
    }

// Interface for Repository:
    public interface IStudentRepository : IDisposable
    {
        IEnumerable<Student> GetStudents();
        Student GetStudentByID(int studentId);
        void InsertStudent(Student student);
        void DeleteStudent(int studentID);
        void UpdateStudent(Student student);
        void Save();
    }

// Context to Generate Database:
    public class SchoolContext : DbContext
    {
        public DbSet<Course> Courses { get; set; }
        public DbSet<Department> Departments { get; set; }
        public DbSet<Enrollment> Enrollments { get; set; }
        public DbSet<Instructor> Instructors { get; set; }
        public DbSet<Student> Students { get; set; }
        public DbSet<Person> People { get; set; }
        public DbSet<OfficeAssignment> OfficeAssignments { get; set; }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
            modelBuilder.Entity<Instructor>()
                .HasOptional(p => p.OfficeAssignment).WithRequired(p => p.Instructor);
            modelBuilder.Entity<Course>()
                .HasMany(c => c.Instructors).WithMany(i => i.Courses)
                .Map(t => t.MapLeftKey("CourseID")
                    .MapRightKey("PersonID")
                    .ToTable("CourseInstructor"));
            modelBuilder.Entity<Department>()
                .HasOptional(x => x.Administrator);
        }
    }

// Unit Of Work
public class UnitOfWork : IDisposable
    {
        private SchoolContext context = new SchoolContext();
        private GenericRepository<Department> departmentRepository;
        private CourseRepository courseRepository;

        public GenericRepository<Department> DepartmentRepository
        {
            get
            {

                if (this.departmentRepository == null)
                {
                    this.departmentRepository = new GenericRepository<Department>(context);
                }
                return departmentRepository;
            }
        }

        public CourseRepository CourseRepository
        {
            get
            {

                if (this.courseRepository == null)
                {
                    this.courseRepository = new CourseRepository(context);
                }
                return courseRepository;
            }
        }

        public void Save()
        {
            context.SaveChanges();
        }

        private bool disposed = false;

        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                if (disposing)
                {
                    context.Dispose();
                }
            }
            this.disposed = true;
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
    }

这是本课中的一些内容，我相信它会非常明确地回答您的问题，同时让您了解抽象为什么起作用，因为它确实实现了Fluent Api.

希望有帮助。

于 2013-02-05T20:39:40.367 回答
0

如果你有一个看起来像这样的模型

using (LolEntities context = new LolEntities)
{
...
}

在你的应用程序的某个地方，这个模型被定义了，通常是这样的：

public partial class LolEntities : ObjectContext

(1) 请注意，该类是部分类，因此您可以创建另一个具有相同名称的部分类并覆盖：

public override int SaveChanges(SaveOptions options)

(2) 或者您可以只捕获事件：

using (DemoAZ_8_0Entities context = new DemoAZ_8_0Entities())
{
    context.SavingChanges += ...
}

并在将其发送回数据库之前进行格式化。

在您的模型中，只需确保包含一个正确映射到数据库中列的属性。

于 2013-02-05T20:15:53.880 回答
0

也许在此逻辑上引入一些抽象，您可以重新创建工作单元和存储库模式，并以更方便的方式添加所需的逻辑。例如，在 Course 存储库类中，您可以自定义 add 和 find 方法序列化和反序列化事件字段。

我将重点介绍存储库模式，您可以在网络上找到很多关于整个数据访问层设计的信息。

例如，要管理课程，您的应用程序应该依赖于这样的 ICourseRepository 接口

interface ICourseRepository
{
    void Add(Course newCourse);
    Course FindByID(int id);
}

您提供以下实现：

class CourseRepository
{
    // DbContext and maybe other fields

    public void Add(Course c)
    {

        // Serialize the event field before save the object
        _courses.Add(c);   // calling entity framework functions, note  
                           // that '_courses' variable could be an DBSet from EF
    }

    public Course FindById(int id)
    {
       var course = /// utilize EF functions here to retrieve the object
       // In course variable deserialize the event field before to return it ...
    }
}

请注意，EF 中的 ObjectContext 是此模式的实现，如果您以后不想更改 ORM，则可以覆盖 EF 上的 Save 方法。

如果您想了解更多关于这种模式的信息，您可以访问 Martin Fowler 网站：

于 2013-02-05T20:20:37.010 回答
0

你应该让你的模型尽可能简单，只有自动属性和属性。对于更复杂的业务逻辑，最好在 MVC 模式中添加另一层。这通常称为存储库（尽管很难找到关于存储库模式的好教程.. :( ）并且位于模型和控制器控制器之间。

这对于执行单元测试也非常有用。如果正确实施，它允许您在测试期间用集合替换数据库依赖项。这种方法将需要对项目进行大量额外工作。

另一种方法（一种更简单的方法）是添加一个 ViewModel 层。这样做：

class MyModel
{
    public string Text { get; set; }
}

class MyViewModel : MyModel
{
    public new string Text
    {
        get { return base.Text; }
        set { base.Text =value.ToUpper(); }
    }
}

class Program
{
    static void Main(string[] args)
    {
        MyViewModel mvm = new MyViewModel();
        mvm.Text = "hello there";
        var s = ((MyModel) mvm).Text; // "HELLO THERE"
    }
}

在 DataContext 中使用 MyModel，在控制器中使用 MyViewModel。

于 2013-02-05T20:28:06.153 回答