实体框架：如何在处理DbContext之前从其他方法查询模型？

Question

I have the following Method which accepts a DataTime argument when called and returns records according to the date passed.

Method:

    public static void GetVehicleByReleasedDate(DateTime parameter)
   {
       using (EntityDataModel context = new EntityDataModel())
       {
           var query =
           from vehicle in context.Catalog
           where vehicle.ReleaseDate  >= parameter.Date

           select new
           {
               VehicleMake = vehicle.VehicleMake,
               ManufactureID = vehicle.ManufactureID,
               ManufactureDate = vehicle.ManufacturedDate,
               VehicleIdentificationNumber = vehicle.VehicleIdentificationNumber
           };

           foreach (var vehicle in query)
           {
               Console.WriteLine("Format and write result to Console",
               vehicle.ManufactureID,
               vehicle.ManufactureDate,
               vehicle.VehicleIdentificationNumber,
               vehicle.VehicleMake);
           }
       }
   }

Instead of the above, I need to return the an IQueryable object or the Catalog so that I can perform the query outside of the method.

Like this:

    public static IQueryable<Catalog> GetVehicleByReleasedDate()
    {
        using (EntityDataModel context = new EntityDataModel())
        {
            return context.Catalog;
        }
    }

Then call the method like this:

    static void Main(string[] args)
    {

        var query = from vehicle in GetVehicleByReleasedDate()
                    where vehicle.ReleaseDate >= DateTime.Now
                    select new
                    {
                        VehicleMake = vehicle.VehicleMake,
                        ManufactureID = vehicle.ManufactureID,
                        ManufactureDate = vehicle.ManufacturedDate,
                        VehicleIdentificationNumber = vehicle.VehicleIdentificationNumber
                    };

        foreach (var vehicle in query)
        {
            Console.WriteLine("{0} {1:d} {2} {3}",
            vehicle.ManufactureID,
            vehicle.ManufactureDate,
            vehicle.VehicleIdentificationNumber,
            vehicle.VehicleMake);
        }

        Console.ReadKey();
    }

As you can tell, I get an error because the using in the GetVehicleByReleasedDate() disposes of the context.

Error message:

The operation cannot be completed because the DbContext has been disposed.

How do I write this so that I can simply pass queries to the method from another method using the return type before the Context is disposed?

Update:

Here is the EntityDataModel Class:

public partial class EntityDataModel : DbContext
    {
        public EntityDataModel()
            : base("name=EntityDataModel")
        {
        }

        public virtual DbSet<Catalog> Catalog { get; set; }
        public virtual DbSet<Model> Model { get; set; }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Catalog>()
                .Property(e => e.VehicleIdentificationNumber)
                .IsFixedLength();
        }
    }

Finally, here is the Catalog model.

[Table("Automobile.Catalog")]
public partial class Catalog
{
    [Key]
    public long ManufactureID { get; set; }

    [Required]
    [StringLength(100)]
    public string VehicleMake { get; set; }

    [Required]
    [StringLength(17)]
    public string VehicleIdentificationNumber { get; set; }

    [Column(TypeName = "date")]
    public DateTime ManufacturedDate { get; set; }

    [Column(TypeName = "date")]
    public DateTime ReleaseDate { get; set; }
}

Answer 1

The IQueryable interface is very lazy. It only evaluates the query when it really needs to. I would suggest using .ToList() on the end of your query to materialize it:

var query =
       (from vehicle in context.Catalog
       where vehicle.ReleaseDate  >= parameter.Date
       select new
       {
           VehicleMake = vehicle.VehicleMake,
           ManufactureID = vehicle.ManufactureID,
           ManufactureDate = vehicle.ManufacturedDate,
           VehicleIdentificationNumber = vehicle.VehicleIdentificationNumber
       }).ToList();

Otherwise, because of your using statement, the context will already have been disposed when IQueryable finally evaluates the query. With ToList() you force the query to be materialized and the result will be stored in memory.

UPDATE: To make the answer more complete, as Gert Arnold pointed out:

// YourStaticClass.cs
public static IEnumerable<Catalog> GetVehicleByReleasedDate(DateTime parameter)
{
    using (var context = new EntityDataModel())
    {
        return context.Catalog
            .Where(x => parameter.Date <= x.ReleaseDate)
            .ToList();
    }
}

// Main.cs
static void Main(string[] args)
{
    var vehicles = YourStaticClass.GetVehicleByReleasedDate(DateTime.Today);

    foreach (var vehicle in vehicles)
    {
        Console.WriteLine("{0} {1:d} {2} {3}",
        vehicle.ManufactureID,
        vehicle.ManufactureDate,
        vehicle.VehicleIdentificationNumber,
        vehicle.VehicleMake);
    }

    Console.ReadKey();
}

Like this, you materialize the query when the context is still 'undisposed'. You can spit out the data to wherever you need it and process it.

Answer 2

UPDATED :

If you want to remain coupled to EF and static methods, try a callback setup like this:

    public static void GetVehicleByReleasedDate(Func<DbSet<Catalog>, IQueryable<dynamic>> query, Action<IQueryable<dynamic>> useQuery)
    {
        using (EntityDataModel context = new EntityDataModel())
        {
            useQuery(query(context.Catalog));
        }
    }

    public static T GetVehicleByReleasedDate<T>(Func<DbSet<Catalog>, IQueryable<dynamic>> query, Func<IQueryable<dynamic>, T> useQuery)
    {
        using (EntityDataModel context = new EntityDataModel())
        {
            return useQuery(query(context.Catalog));
        }
    }

and call it like this:

static void Main(string[] args)
{

    GetVehicleByReleasedDate
    (
        catalog=>
        from vehicle in catalog
        where vehicle.ReleaseDate >= DateTime.Now
        select new
        {
            VehicleMake = vehicle.VehicleMake,
            ManufactureID = vehicle.ManufactureID,
            ManufactureDate = vehicle.ManufacturedDate,
            VehicleIdentificationNumber = vehicle.VehicleIdentificationNumber
        },
        query=>
        {
            foreach (var vehicle in query)
            {
                Console.WriteLine("{0} {1:d} {2} {3}",
                vehicle.ManufactureID,
                vehicle.ManufactureDate,
                vehicle.VehicleIdentificationNumber,
                vehicle.VehicleMake);
            }
        }
    );

    Console.ReadKey();
}

UPDATE 2 :

If you are interested in decoupling from EF, then try this:

public class IEntityRepository : IDisposable
{
    IQueryable<Catalog> GetVehicleByReleasedDate();
}

public class EFEntityRepository : IEntityRepository
{
    private EntityDataModel context = new EntityDataModel():
    public IQueryable<Catalog> GetVehicleByReleasedDate()
    {
        return this.context.Catalog;
    }
    public void Dispose()
    {
        this.context.Dispose();
        this.context = null;
    }
}

public class Consumer
{
    private Func<IEntityRepository> createRepository;
    public Consumer(Func<IEntityRepository> createRepository) { this.createRepository = createRepository; }
    public void OutputData()
    {
        using (var repository = this.createRepository())
        {
            var query = from vehicle in repository.GetVehicleByReleasedDate()
                where vehicle.ReleaseDate >= DateTime.Now
                select new
            {
                VehicleMake = vehicle.VehicleMake,
                ManufactureID = vehicle.ManufactureID,
                ManufactureDate = vehicle.ManufacturedDate,
                VehicleIdentificationNumber = vehicle.VehicleIdentificationNumber
            };

            foreach (var vehicle in query)
            {
                Console.WriteLine("{0} {1:d} {2} {3}",
                vehicle.ManufactureID,
                vehicle.ManufactureDate,
                vehicle.VehicleIdentificationNumber,
                vehicle.VehicleMake);
            }

        }
    }
}

public class Program
{
    static void Main(string[] args)
    {
        var consumer = new Consumer(()=>new EFEntityRepository());
        consumer.OutputData();
    }
}   

Answer 3

GetVehicleByReleaseDate can take a context as a parameter, so it doesn't control the lifetime of the context, just how the model is manipulated before it is returned. I would strongly recommend still keeping the lifetime of the context short.

public static IQueryable<Catalog> GetVehicleByReleasedDate(EntityDataModel context)
{
    //Do whatever data manipulations you need here.
}

However, if GetVehcileByReleaseDate doesn't do much besides return entities from the context, do you even need it?

Have you checked out the repository pattern? You can create the context for the lifetime of the repository object. Something along the lines of this:

http://blogs.msdn.com/b/wriju/archive/2013/08/23/using-repository-pattern-in-entity-framework.aspx

Answer 4

You need a dependency injecttion library that controls this for you. Look at Autofac and its life time. I use it for web applications and set the life time of objects created (eg DbContext) to the lifetime of the whole HTTP request and it works fine.

http://docs.autofac.org/en/stable/lifetime/index.html http://www.codeproject.com/Articles/25380/Dependency-Injection-with-Autofac#scope