LINQ和EF Core基础

最新推荐文章于 2021-10-15 11:04:46 发布
最新推荐文章于 2021-10-15 11:04:46 发布
阅读量2.2k 收藏 9
点赞数 1
分类专栏： C#笔记 文章标签： linq 数据库 sqlite c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Plantarian/article/details/120667648
版权

文章目录

LINQ和EFCore基础

LINQ基础

语言集成查询（Language Integrated Query）是一组语言扩展，用于处理数据序列，然后对它们进行过滤、排序，并将它们投影到不同的输出。

LINQ查询语法是定义在Enumable里的，这就意味着LINQ不仅可以对内置序列进行操作，比如List，Dictionary，Stack等，也可以对Sqlite，MySql等数据库内容进行操作。仔细观察LINQ的方法，所有实现了IEnumerable的类型都可以被LINQ操作。

LINQ分为多个部分：

  • 扩展方法（必需）：Where，OrderBy，Select等，这些提供了基本操作；
  • LINQ提供程序（必需）：LINQ to Entities，LINQ to XML等，这些程序将LINQ指令转换为其特定操作；
  • Lambda表达式（可选）：简化LINQ操作数；
  • LINQ查询理解语法（可选）：where，in，from，orderby，descending，select。这些可以简化LINQ的查询。

LINQ处理数组

现在假设有一序列为

string[] names = {"Peter","Alice","Bob","John","Jim","Sam"};
Where过滤

在使用LINQ查询语法之前，要在代码顶部添加一行：

using System.Linq;

来引入LINQ命名空间。

首先观察Where方法：

Where<TSource>(this IEnumerable<TSource>, Func<TSource,Boolean>);

可以看到其参数中含有一个Func委托：

Func<T,bool>

这就要求必须编写一个方法，这个方法的入口参数为T，返回参数为bool。

那么假如想过滤出一些名字，这些名字的要求是字符长度大于等于4，那么就可以这样写：

首先写一个符合Func参数的方法：

bool GetNames(string name)
{
    return name.Length > 3;
}

然后写Where查询操作：

var query = names.Where(new Func<string,bool>(GetNames));

然后就能得到一个数组，里面包含符合要求的name了。

C#的编译器可以自动实例化委托，所以也可以把查询操作这样写：

var query = names.Where(GetNames);

在C#3.0引入了Lambda表达式之后，可以更进一步简化查询代码：

var query = names.Where(n => n.Length > 3);

这样就不需要再写一个GetNames方法了，简化了代码，提高了效率。

OrderBy排序

可以使用OrderBy和ThenBy来进行序列的排序。

假设要将names序列按照字符长度排序，那么可以这样写：

var query = names.OrderBy(n=>n.Length);

如果在此之上还想按照字典序排列，那么可以这样写：

var query = names.OrderBy(n=>n.Lngth).ThenBy(n=>n);

最后的输出结果就是这样的：

"Bob","Jim","Sam","John","Alice","Peter"
OfType过滤

假设有这么一个序列，存储了一些类型，这些类型遵从一定的继承层次，当想从中过滤出一些特定的类型来使用的话，OfType就很有用了。

现在有一异常序列：

var exceptions = new Exception[]
{
    new ArgumentException(),
    new SystemException(),
    new IndexOutOfRangeException(),
    new InvalidOperationException(),
    new NullRefrenceException(),
    new InvalidCastException(),
    new OverFlowException(),
    new DevideByZeroException(),
    new ApplicationException(),
};

如果想要从中筛选出和代数计算有关的异常，那么就可以这样写：

var query = exceptions.OfType<ArithmeticException>();

LINQ处理集合

在集合的处理中，除了上面的方法之外，还可以使用下面的方法。

创建三个数组：

var names1 = new string[]{"John","Machel","Bob","Dick"};
var names2 = new string[]{"Jack","Alice","Dinnis","Jack","Linus"};
var names3 = new string[]{"Jack","James","Jack","Stephen","Conor"};

如果想要获取关于names2的集合的话，一般情况下是要用循环去解决。现在用LINQ的**Distinct()**方法就能解决这个问题：

var query = names2.Distinct();

求集合的并集可以用下面的方法：

var query = names2.Union(names3);

求交集可以这样写：

var query = names2.Intersect(names3);

求差集：

var query = names2.Except(names3);

连接两个数组：

var query = names2.Concat(names3);

Entity Framework Core

实体框架核心是微软开发的开源对象关系映射框架，可以用来读写数据库。

EFCore不仅支持传统关系数据库管理系统RDBMS，也支持现代数据库，比如MongoDB，CosmosDB等NoSQL，有时甚至可以支持第三方程序，这都得益于其开源性。EFCore和.Net Core一样，都可以跨平台使用。

设置EFcore

在使用EF Core之前，需要先设置EF Core的使用环境。

首先要根据使用的目的数据库下载不同的NuGet包，这里使用SQLite为例子。

然后安装dotnet-ef工具，使用指令：

dotnet tool install --global dotnet-ef

最后在csproj文件中添加对应NuGet包的依赖，完成导入。

定义EFCore模型

EF Core使用约定，注解和Fluent API组合，在运行时构建实体模型。实体类表示表的结构，类的实例表示表中的一行。

约定

一般来说，编写EF的代码要遵守下面的约定：

  • 表名和DbContext类中DbSet的属性名匹配；

  • 列名和类中的属性名匹配；

  • string类型和nvarchar匹配

  • 名为ID的属性，可以将其重命名为类名+ID，然后假定这个是主键。如果这个属性是整数或者Guid类型，那就可以假定为IDENTITY类型。

当然，可以不局限于这些约定，创造自己的约定也是可以的。

注解特性

只有约定还不足以完成对映射的搭建，借助C#的特性可以进一步帮助构建模型：

比如在数据库中，产品名称要求限制40字符并且不能为空，那么就可以这样定义：

[Required]
[StringLength(40)]
public string ProductName {get;set;}

如果没有明显映射的时候，可以用特性手动添加：

[Column(TypeName = "money")]
public decimal? UnitPrice {get;set;}

如果有项的长度超过nvarchar的800字符长度的时候，就需要手动映射到ntext。

Fluent API

Fluent API不仅可以用来替代特性，也可以进行特性的补充。

例如上面的ProductName，如果不使用特性而使用Fluent API的话，可以在DbContext类的OnModelCreating方法中写成下面的格式：

modelBuilder.Entity<Product>()
    .Property(p => p.ProductName)
    .IsRequired()
    .HasMaxLength(40);

注意： Fluent API 配置具有最高优先级，并将替代约定和数据注释。

new一个数据库

如果手头上没有数据库，就需要创建一个新数据库。通常情况下，可以使用对应的SQL工具来创建一个空的数据库，以SQLite为例，首先需要安装好使用SQLite的相关工具，然后在命令行中执行下面的操作：

sqlite3
.open DBname.db
.quit

或者是这样写：

sqlite3 DBname.db
.quit

也可以通过写C#代码的方式创建数据库。

首先是添加工具：

dotnet add package Microsoft.EntityFrameworkCore.Design

假设要创建这样一个数据库：数据库名字是ProductDB，有一个Product表，表中有ProductID和ProductName两个行，那么就要在.cs文件中这样写：

class Product {
    
    [Required]
    public int ProductID {get;set;}
    public string ProductName{get;set;}
}

class ProductContext : DbContext {
    public DbSet<Product> Products {get;set;}
    string DBPath = "./Product.db";
    
    protected override void OnConfiguring(DbContextOptionsBuilder options)
            => options.UseSqlite($"Data Source={DbPath}");
    
}

注意到，在方法OnConfiguring中，使用了Lambda表达式。方法的原始写法是这样的：

 protected override void OnConfiguring(DbContextOptionsBuilder options){
     	options.UseSqlite($"Data Source={DbPath}");
 }

然后在命令行中输入：

dotnet ef migrations add ProductDB
dotnet ef database update

这样，一个新数据库就迁移完成了，也能立即使用LINQ对数据库进行一系列的操作。

实际上，EF Core的迁移不仅可以用来创建数据库，它最主要的用途是更新数据库架构以符合当前的模型，并且不会消除原来的数据。

用一个现有的数据库

如果手头上有一个现成的数据库，比如NorthWind——微软提供的一个示例数据库。下面的所有操作都会针对NorthWind这个数据库。

现在让来构建EF Core模型。

在大致观察过WorthWind数据库之后，选择Category和Product表。

建立实体

在EF Core模型中，需要用到一些数据实体，这些实体都是以类的形式表示的，其中类表示表，类属性表示行。

建立关于这两个表的类：

class Category {
    public int CategoryID {get;set;}
    
    public string CategoryName {get;set;}
    
    [Column(TypeName = "ntext")]
    public string Description {get;set;}
    
    //导航属性，用于关联不同的行
    public virtual ICollection<Product> Products {get;set;}
    
    public Category(){
        this.Products = new HashSet<Product>();
    }
}

class Product {
    public int ProductID {get;set;}
    
    [Required]
    [StringLength(40)]
    public string ProductName {get;set;}
    
    [Column("UnitPrice",TypeName = "money")]
    public decimal? Cost {get;set;}
    
    [Column("UnitsInStock")]
    public short? Stock {get;set;}
    
    public bool Discontinued {get;set;}
    
    //2个被关联的属性
    public int CategoryID {get;set;}
    public virtual Category Category {get;set;}
}

注意到这两个类中都有一项被virtual修饰的关联属性，这可以让EF Core继承和覆盖这些属性来提供额外的特性，比如延迟加载。

建立DbContext类

DbContext类在C#中用于表示数据库，这个类知道怎么样和数据库通信，并且将C#代码转化为SQL语句，以便查询和操作数据。

在DbContext类里，必须有一些DbSet<T>属性，这些属性表示数据库中的表。为了表示每个表有哪些类，DbSet使用泛型来指明表类，这些类表示表中的一行，类的属性表示表中的类。例如：

//             ↓表示表的行 
public DbSet<Product> Products {get;set;}
//        ↑表示一个表    ↑C#中代表的表名

如果不想让表公共可写，那么可以设置成只读：

public DbSet<Product> Products {
    get{
        return Set<Product>();
    }
}

DbContext类里应该还包括OnConfiguring方法来链接数据库。OnModelCreating方法可以用来编写Fluent API语句来替代特性修饰实体类。

最终得到DbContext类的大概内容如下：

class Northwind : DbContext {
    private string DBPath = "./Northwind.db";
    
    public DbSet<Category> Categories {get;set;}
    public DbSet<Product> Products {get;set;}
    
    protected override void OnConfiguring(DbContextOptionsBuilder options)
            => options.UseSqlite($"Data Source={DBPath}");
	
    //覆盖并实现OnModelCreating方法
    protected override void OnModelCreating(ModelBuilder model)
    {
        model.Entity<Category>()
            .Property(c => c.CategoryName)
            .IsRequired()
            .HasMaxLength(15);
        model.Entity<Product>()
            .Property(p => p.Cost)
            .HasConversion<double>();
    }
}

注意：在EF Core 3.0及以上版本，decimal不再支持排序和其他操作。因此可以告诉SQLite将decimal转换成double值，但是在运行时并不会执行转换。

自动生成模型

上面的所有操作都是由人工手动进行的，但是这些操作也可以让程序自动生成。

首先应安装好EF Core的设计包：

dotnet add package Microsoft.EntityFrameworkCore.Design

选定一个存放模型的文件夹，例如AutoModel，并且输入下面的指令：

dotnet ef DbContext scaffold "Filename=Northwind.db" Microsoft.EntityFrameworkCore.Sqlite --table Categories --table Products --output-dir AutoModel --namespace AutoModel --data-annotations --context Northwind

看起来很长一串指令，将逻辑理清后是这样的：

  • 使用dotnet-ef工具：dotnet ef
  • 需要执行的dotnet-ef工具指令：DbContext scaffold
  • 链接的数据库：“Filename=Northwind.db”
  • 使用的数据库提供者：Microsoft.EntityFrameworkCore.Sqlite
  • 需要用到的表：–table Categories --table Products
  • 输出文件夹：–output-dir AutoModel
  • 类的名称空间：–namespace AutoModel
  • 使用Fluent API和数据注解：–data-annotations
  • XXContext中的XX：–context Northwind

打开自动生成的文件，会发现和手动创建的有一些不同，比如：

  • Index特性：用来指明应该含有索引的属性
  • CategoryID是被Key特性修饰，说明它是主键
  • Category类中的Products被InverseProperty特性修饰，这个特性用来定义Product类中Category的外键属性
  • Northwind被声明为partial，这允许了在未来的类扩展，并且不会被抹除
  • Northwind类中含有两个构造方法，这对于想自定义链接字符串的程序很有用
  • OnConfiguring方法中，如果构造方法的options没有指定，那么将使用链接字符串在当前文件夹查找数据库。但是应该指定options，硬编码数据库连接字符串是不安全的。
  • 含有一个OnModelCreatingPartial的partial方法，这可以让程序员额外添加新的模型，并且不会被抹除

对EF Core模型进行查询

前面说过，LINQ是可以对数据库进行操作的，所以可以编写一些简单的LINQ语句来查询Northwind数据库。

由于DbContext是通过转化SQL语句和db文件进行通信，这和对文件的读写是一样的，所以要用try块或者using包裹。

获取一些数据

假如要查询每一个Category里Product的数量，那我们可以这样写：

using (var db = new Northwind())
{
    IQueryable<Category> cats = db.Categories.Include(c => c.Products);
    
   foreach(var c in cats)
   {
       Console.WriteLine($"{c.CategoryName} has {c.Products.Count} products.");
   }
}

在这里，Include(c => c.Products)语句将Category和Product关联了起来，前面在Category类中写的virtual的Products属性得到了应用。

不仅可以提取所有的Category，还可以进行筛选提取。比如提取库存大于100的Category：

using (var db = new Northwind())
{
    IQueryable<Category> cats = db.Categories.Include(c => c.Products.Where(p.Stock > 100));
    
   foreach(var c in cats)
   {
       Console.WriteLine($"{c.CategoryName} has {c.Products.Count} prodcts.");
   }
}

只需要在c.Products后面添加Where筛选语句就可以了。

查看SQL语句

可以在程序中查看DbContext对数据库进行的SQL操作。假如对上面的Include操作进行查看，只需要添加这样一行：

Console.WriteLine(cats.ToQueryString());
筛选和排列

假设要筛选价格超过100的Product，并且按照价格从低到高排序，可以这样写：

using var db = new Northwind();
var products = db.Products.Where(p => p.Cost > 100).OrderBy(p => p.Cost);
foreach(var p in products)
{
    Console.WriteLine(p.ProductName);
}
模式匹配和Like

EF Core也支持模式匹配Like。假设想查询含有某个字符串中字符的Product，那么可以这样写：

using var db = new Northwind();
var query = db.Products.Where(p => EF.Functions.Like(p.ProductName,"%che%"));
foreach(var p in query)
{
    Console.WriteLine(p.ProductName);
}
全局过滤器

在示例数据库，Products表中，有些Product已经停产，为了确保不会被检索到，那么就可以确定一个全局过滤器，在Northwind类的OnModelCreating方法中添加这样一句：

model.Entity<Product>()
    .HasQueryFilter(p => !p.Discontinued);

此后不论是程序员是否忘记过滤掉停产产品，程序也能自动过滤掉。

记录EF Core

如果想要监视EF Core和数据库之间的交互，可以用日志记录功能。

注册日志提供程序

首先是编写一个Provider用来提供一个Logger，这个类必须实现ILoggerProvider，并且有一个方法会返回一个Logger实例。由于不使用任何非托管资源，因此Dispose方法不需要做任何事情，但是必须存在。

class DBLoggerProvider : ILoggerProvider
{
    public ILogger CreateLogger(string categoryName)
    {
        return new DBLogger();
    }
    
    public void Dispose(){}
}
实现日志程序

日志类必须实现ILogger接口，并且当日志级别是None、Trace和Infomation时，禁用这个Logger。其余的级别均要启用。

注意：这里的ILogger接口源自Microsoft.Extensions.Logging。

class DBLogger : ILogger
{
    //如果有非托管资源要使用，这里要返回一个实现IDisposable的类
    public IDisposable BeginScope<TState>(TState state)
    {
        return null;
    }
    
    public bool IsEnabled(LogLevel level)
    {
        switch(level)
        {
            case LogLevel.Trace:
            case LogLevel.Information:
            case LogLevel.None:
                return false;
            default:
                return true;
        }
    }
    
    public void Log<TState>(LogLevel level, EventId id, TState state, Exception e,
                           Func<TState, Exception, string> formatter)
    {
        Write($"Level: {level}, Event ID: {id}");
        if(state != null)
        {
            Write($", State: {state}");
        }
        if(e != null)
        {
            Write($", Exception: {e.Message}");
        }
        WriteLine();
    }
}

然后在主程序的using块中注册一个日志记录器：

using var db = new Northwind();
var loggerFactory = db.GetService<ILoggerFactory>();
loggerFactory.AddProvider(new DBLoggerProvider());

这样，一个日志记录器就注册完成并且可以立即使用了。

在EF Core的日志记录器中，如果想要知道每一条LINQ查询语句是怎样转化为SQL语句的话，那么就可以抓取特定Event ID的事件，这个ID是20100。对Log方法的修改如下：

public void Log<TState>(LogLevel level, EventId id, TState state, Exception e,
                           Func<TState, Exception, string> formatter)
    {
        if(id == 20100){
            Write($"Level: {level}, Event ID: {id}");
        	if(state != null)
        	{
            	Write($", State: {state}");
        	}
        	if(e != null)
        	{
            	Write($", Exception: {e.Message}");
        	}
        	WriteLine();
        }
    }
}
查询Tag

在复杂的场景进行日志记录的时候，往往会有大量的日志，如果想要查找某些特定操作的日志是比较困难的。EF Core2.2引入了查询标记，允许向日志添加SQL注释：

using var db = new Northwind();
var query = db.Products.TagWith("Cost larger than 100").Where(p => p.Cost > 100);

EF Core的加载模式

EF Core有三种加载模式：立即加载，延迟加载和显示加载。

立即加载

在前面的获取数据中，去掉Include方法，然后运行程序，发现Stock那里均是0，这是因为Category的每个实例的Product都是Null，原始查询只在Category表里进行。

延迟加载

延迟加载能很好地解决上面立即加载产生的问题。

首先添加Microsoft.EntityFrameworkCore.Proxies包，然后在Northwind类中的OnConfiguring方法里，进行下面的修改：

Onconfiguring(DbContextOptionsBuilder options) =>
    options.UseLazyLoadingProxies().UseSqlite($"{DBPath}");

然后再进行立即加载所描述的操作，就会发现打印出来的结果就正常了。

但是，延迟加载所带来的缺点就是，每次读取Product属性的时候，都要检查是否被加载了，如果没有加载，就要去加载它们，导致返回结果时，要进行大量的数据库的交互，造成性能损失。这可以通过前面的日志记录器中查询到。

显式加载

显式加载和延迟加载类似，但是可以控制特定的数据和时间进行加载。

使用DbContext中的Entry方法就可以实现显式加载：

using var db = new Northwind();
var category = db.Categories.Single(c => c.CategoryID == 2);
var products = db.Entry(category).Collection(c => c.Products).Load();

在这里，获取了一个CategoryID为2的category，然后用Entry方法进行显式加载。很明显有一个Load()方法，这就体现了显式。

EF Core操作数据

使用EF Core对数据进行增删改是一件比较简单的事情，DbContext能够自动维护更改跟踪。当准备将更改发送到数据库的时候，调用SaveChanges()方法。这个方法返回成功更改的实体数量。

插入

使用Add方法添加一个实体：

using var db = new Northwind();
db.Products.Add(new Product(){CategoryID = 1,ProductName = "apple",Cost = 10});
db.SaveChanges();
更新

获取特定实体并且更改数据：

using var db = new Northwind();
var product = db.Products.Single(p => p.ProductID == 1);
product.Cost += 10;
db.SaveChanges();
删除

使用Remove删除单个实体，RemoveRange来删除多个实体：

using var db = new Northwind();
db.Products.Remove(db.Products.Single(p => p.ProductID == 2));
db.SaveChanges();

数据库的池化

为了提高EF Core查询模型的性能，并且在Web服务中尽可能汇集数据库来提高效率，那么就可以使用数据库池来进行。在Startup类中的ConfigureServices方法里添加：

service.AddDbContextPool<Northwind>(options => options.UseSqlite("Data Source = path"))

事务

每次调用SaveChanges时，都会启动一个隐藏的事务，以便在出现问题时执行回滚操作。如果一个事务中多个操作都成功了，那么就会提交事务和所有更改。

事务通过应用锁来防止在提交更改的时候读写，从而维护了数据库的稳定性。

事务有四个基本特性：

  • 原子性：即不可分割性。要么都提交，要么都不提交。
  • 一致性：事务必须使数据库从一个一致性状态变到另一个一致性状态。
  • 隔离性：在事务的处理期间，会对其他进程隐藏修改。
  • 持久性：事务在提交之后，对系统的影响是永久的。
定义显式事务

在程序中，我们可以使用DbContext的Database属性建立一个显式的事务：

using var db = new Northwind();
using var t = db.Database.BeginTransaction();
var product = db.Products.Single(p => p.ProductID == 2);
product.Cost += 10;
db.SaveChanges();
t.Commit();

LINQ进阶

这一部分讨论LINQ比较进阶一些的内容。

语法糖

C#3.0引入了查询理解语法，可以让有SQL经验的程序员更容易编写LINQ语句。使用前面提到的数组names：

var query = from name in names
    where name.Length > 3
    select name;

这和前面的结果是一样的。

创建自己的LINQ扩展方法

可以通过扩展方法的形式创建一个自定义的LINQ语句。自定义方法可以放在单独的类库里，也可以附加在Linq命名空间里。假设要附加一个中位数方法：

public static class NewLinqExtensions
{

    public static int Midian(this IEnumerable<int> sequence)
    {
        var ordered = sequence.OrderBy(item => item);
        var midianNum = ordered.Count() / 2;
        return ordered.ElementAt(midianNum);
    }

    public static int Midian<T>(this IEnumerable<T> sequence, Func<T, int> selector)
    {
        return sequence.Select(selector).Midian();
    }
}

LINQ To XML

LINQ可以对XML进行查询和操作。

写入XML

假设要将Northwind数据库中的Category表做成xml文件，那么就要理清xml树的结构：

<Categories>
    <category>
    	<ID />
        <Name></Name>
        <description></description>
    </category>
</Categories>

大致是这样的。

接下来就可以写代码来进行转换：

using var db = new Northwind();
//首先进行转换，将数据库内容转为数组
var cats = db.Categories.ToArray();
//开始创建xml树
var xmlTree = new XElement("Categories",  //xml树根
                          from c in cats  //用LINQ理解语法遍历cats创建树
                          select new XElement("category",
                                             new XAttribute("ID", c.CategoryID),
                                             new XElement("Name", c.CategoryName),
                                             new XElement("description", c.Description)));

如果对理解查询语法不熟悉的话，可以这样写：

var xmlTree = new XElement("Categories",
                xmlContents.Select(c => new XElement("category",
                    new XAttribute("ID", c.CategoryID),
                    new XElement("Name", c.CategoryName),
                    new XElement("description", c.Description))));

最后得出的结构是一样的。

读取XML

使用LINQ可以轻松查询或处理XML文件。

假设要读取上面xml中的ID为2的category，并将Name修改为HiXML，那么就可以这样写：

//首先将上面的xml存到一个文件中，读取文件
var xml = XDocument.Load("e:/Northwind.xml");
//获取所有的category
var categories = xml.Descendants("Categories").Descendants("category");
//找到ID为2的category
var c = categories.Single(c => Convert.ToInt32(c.Attribute("ID").Value) == 2);
//修改
c.SetElementValue("Name","HiXML");
//保存
xml.Save("e:/Northwind.xml");

最后可以在文件中看到Name被修改了。

废料P
关注
专栏目录
EF Core中的Group By查询：如何用LINQ轻松分组数据？
java专栏
10-02 614
通过上述步骤，我们已经成功地使用EF Core和LINQ实现了基本的Group By查询，并且探索了一些更高级的功能。从简单的分组到包含HAVING子句的查询，再到复杂的嵌套分组和聚合操作，EF Core为我们提供了强大的数据处理能力。希望本文能够帮助你快速掌握EF Core中的Group By查询技巧，并激发你在实际项目中灵活运用这些知识。记得，实践是最好的老师，多动手练习才能真正掌握这些技能！
C#使用LINQ和EF Core
最新发布
qq_42497776的博客
03-17 1647
用 LINQ 查询 EF Core 和 LINQ to XML 进行数据操作
Java进击C#——应用开发之Linq和EF
weixin_30772105的博客
10-21 169
本章简言 上一章笔者对于WinForm开发过程用到的几个知识点做了讲解。笔者们可以以此为开端进行学习。而本章我们来讲一个跟ORM思想有关的知识点。在讲之前让我们想一下关于JAVA的hibernate知识点。hibernate也是ORM框架。记得hibernate里面有一个叫HQL。先不管HQL的好与坏。主要是明白HQL的目地是什么。ORM的思想就是为了让用户在操作数据的时...
应用开发之linq和ef_应用开发
cusi77914的博客
06-28 168
与蒂姆联系 蒂姆是我们最受欢迎和最多产的作家之一。 在developerWorks上浏览Tim的所有文章 。 查看Tim的个人资料，并与他，其他作者以及My developerWorks中的其他读者建立联系。 本系列的前两篇文章重点介绍了针对单节点和多节点集群的Hadoop的安装和配置。 这篇最后的文章探讨了Hadoop中的编程-特别是Ruby语言中的map和reduce应用程序的...
Linq与EF(Entity Framework)
stickking的专栏
12-25 1524
Linq已经用了好久了，其便捷自不待言，带来的web数据库编程体验也很独特，直接将数据查询语言集成到C#编程语言中。曾经使用过很多方式来构建网站的数据访问层，手动编码、NHibernate、Iron Speed等，用过了Linq之后才发现构建数据访问层还可以如此容易，数据库完成了，数据访问层也就基本完成了，剩下的就是专注于业务层和表现层就可以了。 前几天，网上看到消息说Linq将会被ADO.NE
EF与LINQ
akmm640266的博客
01-05 408
1. EF跟LINQ不是一码事儿。 2. LINQ to EF是LINQ的一个provider，LINQ to SQL也是LINQ的一个provider。LINQ to EF是LINQ to SQL的替代产品，目前微软已经停止开发LINQ to SQL了，但是LINQ to SQL仍然有其用武之地。 3. LINQ是C#最优雅的特性，微软不可能放弃LINQ，除非开发出更优雅的可以替代...
linq2db.EntityFrameworkCore：将Linq To DB的功能带到Entity Framework Core项目
01-30
之后，您只需调用LINQ To DB提供的DbContext和IQueryable扩展方法即可。 香草EF中缺少许多CRUD操作扩展（请）： // fast insert big recordsets ctx . BulkCopy ( new BulkCopyOptions {...}, items );
try.elinq:用于关系数据库和 EF Core 的语言集成查询 (LINQ) 技术
05-29
ELINQ 是一种用于关系 (SQL) 数据库和 EF Core 的语言集成查询 (LINQ) 技术。 它允许您使用 C#（或您选择的 .NET 语言）编写强类型 SQL 查询。 难道我们没有LINQ的EF？ ELINQ通过新功能增强了 LINQ： 用于创建...
EF中Linq的用法
fisea的专栏
12-23 2272
Linq用法举例1.In操作2.分页3.Like4.Join5.LeftJoin6.UpdateInfoBySql7.QueryDataBySql8.Sub Query9.Group by10.Max11.Min12.Avg13.Count14.Group by 带有Where条件15.多列Group by16.Group by expression17.Any18.Any中带有where条件19.All20.Not Contain21.Group by后，求Min值总结 用法举例 1.In操作 代码如下（
linq和EF查询的用法和区分
weixin_30639719的博客
04-02 370
我们做项目时，难免会遇到用的不知道是啥，及把linq和EF搞混了 今天我带领大家梳理下思路: 首先说linq查询，然后介绍EF查询 1.linq查询 当我们使用linq查询时，转到定义会调到Queryable 类， 那么也就是说，这个类封装了linq所有查询的方法，那么我们来研究研究这个类 MSDN上是这样解释的:提供一组用于查询实现IQueryable<T>的数据结构...
EF架构+Linq
11-23
C# CS、BS的EF+Linq开发架构，支持三种：SQLServer\Oracle\MySql数据库，可以结合MVC使用。
LINQ_to_EF语法及实例大全
07-14
LINQ_to_EF语法及实例大全
EF core 中用lambda表达式和Linq的一些区别
abxdd2015的博客
08-29 685
转眼一看，又过了10几天没有写博客了，主要还是没有什么可以写的，因为遇到的问题都不是很有价值。不过最近发现用lambda表达式，比用Linq的代码量会少一些，而且也方便一些。不过两者都差不多，相差不是特别大。 在EF core中，表和表之中都有对应的关系，例如一对一，一对多，还有多对多。要实现一对一，一对多加上主外键，实现多对多则需要加上一个中间表，这样结构清晰，维护也非常的方便。 ...
Linq基础知识小记四之操作EF
weixin_33832340的博客
09-28 120
1、EF简介 EF之于Linq,EF是一种包含Linq功能对象关系映射技术.EF对数据库架构和我们查询的类型进行更好的解耦,使用EF,我们查询的对象不再是C#类,而是更高层的抽象:Entity Data Model,这提供了额外的灵活性,但在性能和简单性上面也会有所损失. EF的优点:在数据库架构和实体类之间的映射提供了更好的灵活性,还通过程序支持除了SqlServer之外的数据库. Linq T...
Asp.net Core使用EFCore+Linq从头开始步骤创建
小菜鸟的博客
10-15 1291
EF的增删改查从头创建，linq的写法以及注意点
Linq To EF简单的增、删、查、改
惟楚有才
08-13 7022
新增 //新增 T_Teacher tt1 = new T_Teacher() { Name = "路人丁", Address = "宰相府55栋", Phone = "13725256545",
EF,Linq
qq_16882597的博客
11-19 348
EF,Linq
EFCore LINQ查询（笔记）
qq_45433707的博客
05-29 2341
{ var idlist = new int[] { 1, 2, 3, 5, 7, 8, 9, 10, 11, 12, 14, 17 };//in查询 var list = dbContext.SysUsers.Where(u => idlist.Contains(u.Id));//in查询 foreach (var user in list) .
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值