zoukankan      html  css  js  c++  java
  • EV: Working with Proxies

    Keywords: Entity Framework, EF, Proxy, Dynamic class, Entity Type


    When creating instances of POCO entity types, the Entity Framework often creates instances of a dynamically generated derived type that acts as a proxy for the entity. This proxy overrides some virtual properties of the entity to insert hooks for performing actions automatically when the property is accessed. For example, this mechanism is used to support lazy loading of relationships. The techniques shown in this topic apply equally to models created with Code First and the EF Designer.

    Disabling proxy creation

    Sometimes it is useful to prevent the Entity Framework from creating proxy instances. For example, serializing non-proxy instances is considerably easier than serializing proxy instances. Proxy creation can be turned off by clearing the ProxyCreationEnabled flag. One place you could do this is in the constructor of your context. For example:

    1. public class BloggingContext : DbContext
    2. {
    3.     public BloggingContext()
    4.     {
    5.         this.Configuration.ProxyCreationEnabled = false;
    6.     } 
    8.     public DbSet Blogs { get; set; }
    9.     public DbSet Posts { get; set; }
    10. }

    Note that the EF will not create proxies for types where there is nothing for the proxy to do. This means that you can also avoid proxies by having types that are sealed and/or have no virtual properties.

    Explicitly creating an instance of a proxy

    A proxy instance will not be created if you create an instance of an entity using the new operator. This may not be a problem, but if you need to create a proxy instance (for example, so that lazy loading or proxy change tracking will work) then you can do so using the Create method of DbSet. For example:

    1. using (var context = new BloggingContext())
    2. {
    3.     var blog = context.Blogs.Create();
    4. }

    The generic version of Create can be used if you want to create an instance of a derived entity type. For example:

    1. using (var context = new BloggingContext())
    2. {
    3.     var admin = context.Users.Create();
    4. }

    Note that the Create method does not add or attach the created entity to the context.

    Note that the Create method will just create an instance of the entity type itself if creating a proxy type for the entity would have no value because it would not do anything. For example, if the entity type is sealed and/or has no virtual properties then Create will just create an instance of the entity type.

    Getting the actual entity type from a proxy type

    Proxy types have names that look something like this:


    You can find the entity type for this proxy type using the GetObjectType method from ObjectContext. For example:

    1. using (var context = new BloggingContext())
    2. {
    3.     var blog = context.Blogs.Find(1);
    4.     var entityType = ObjectContext.GetObjectType(blog.GetType());
    5. }

    Note that if the type passed to GetObjectType is an instance of an entity type that is not a proxy type then the type of entity is still returned. This means you can always use this method to get the actual entity type without any other checking to see if the type is a proxy type or not.

  • 相关阅读:
    MVC模式 与 Model2模型 介绍
    《算法竞赛入门经典》学习笔记 2.3 文件操作
    《C++ Primer Plus》学习笔记 2.1.1 main()函数
    Codeforces Round #359 (Div. 2) C. Robbers' watch 搜索
    Github Pages建立个人博客
    《算法竞赛入门经典》第一章 程序设计入门 习题
    《C++ Primer Plus》学习笔记 第1章 预备知识
  • 原文地址:https://www.cnblogs.com/weihongji/p/3493262.html
Copyright © 2011-2022 走看看