基于C# EF/SQL Server计算数据匹配度及匹配字段数统计

我来给你分享两种实用的方案，分别用SQL Server直接查询和C# Entity Framework来实现这个字段匹配数统计与匹配百分比计算的需求：

SQL Server 实现方案 #

直接用SQL查询就能完成计算，我们可以通过参数化的方式传入测试数据，用CASE语句逐个字段对比，累加匹配的字段数，再计算百分比。

通用查询示例 #

-- 定义测试数据参数
DECLARE @TestName NVARCHAR(50) = 'Peter',
        @TestCity NVARCHAR(50) = 'Brussels',
        @TestCountry NVARCHAR(50) = 'Belgium',
        @TestYear INT = 2013,
        @TestColor NVARCHAR(50) = 'blue',
        @TestAge INT = 19;

SELECT 
    -- 输出原始行数据
    name, city, country, year, color, age,
    -- 统计匹配字段的数量
    (CASE WHEN name = @TestName THEN 1 ELSE 0 END +
     CASE WHEN city = @TestCity THEN 1 ELSE 0 END +
     CASE WHEN country = @TestCountry THEN 1 ELSE 0 END +
     CASE WHEN year = @TestYear THEN 1 ELSE 0 END +
     CASE WHEN color = @TestColor THEN 1 ELSE 0 END +
     CASE WHEN age = @TestAge THEN 1 ELSE 0 END) AS MatchedFieldsCount,
    -- 计算匹配百分比（取整，如需保留小数可调整ROUND参数）
    ROUND(
        (CASE WHEN name = @TestName THEN 1 ELSE 0 END +
         CASE WHEN city = @TestCity THEN 1 ELSE 0 END +
         CASE WHEN country = @TestCountry THEN 1 ELSE 0 END +
         CASE WHEN year = @TestYear THEN 1 ELSE 0 END +
         CASE WHEN color = @TestColor THEN 1 ELSE 0 END +
         CASE WHEN age = @TestAge THEN 1 ELSE 0 END) * 100.0 / 6,
        0
    ) AS MatchPercentage
FROM Foo;

切换测试数据 #

如果要计算测试数据2的匹配结果，只需要修改开头的参数值即可：

DECLARE @TestName NVARCHAR(50) = 'Peter',
        @TestCity NVARCHAR(50) = 'Paris',
        @TestCountry NVARCHAR(50) = 'France',
        @TestYear INT = 2011,
        @TestColor NVARCHAR(50) = 'green',
        @TestAge INT = 36;

这个方案的优势是直接在数据库端计算，性能高效，适合数据量较大的场景。

C# Entity Framework 实现方案 #

如果你的项目已经在用EF（不管是EF Core还是EF6），可以用Linq查询来实现，逻辑和SQL类似，代码更贴合业务逻辑层。

第一步：定义实体类与DbContext #

首先确保你已经有了对应Foo表的实体类和DbContext：

public class Foo
{
    public string Name { get; set; }
    public string City { get; set; }
    public string Country { get; set; }
    public int Year { get; set; }
    public string Color { get; set; }
    public int Age { get; set; }
}

public class AppDbContext : DbContext
{
    public DbSet<Foo> Foo { get; set; }

    // 根据你的EF版本配置连接字符串，比如EF Core可以用OnConfiguring方法
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer("你的数据库连接字符串");
    }
}

第二步：编写匹配计算方法 #

我们可以封装一个通用的计算方法，返回包含匹配结果的列表：

using System.Collections.Generic;
using System.Linq;
using System;

public class MatchCalculator
{
    private const int TotalFields = 6; // 固定总字段数

    public static List<MatchResult> CalculateMatchResults(AppDbContext context, Foo testData)
    {
        return context.Foo.Select(foo => new MatchResult
        {
            OriginalRow = foo,
            MatchedFieldsCount = 
                (foo.Name == testData.Name ? 1 : 0) +
                (foo.City == testData.City ? 1 : 0) +
                (foo.Country == testData.Country ? 1 : 0) +
                (foo.Year == testData.Year ? 1 : 0) +
                (foo.Color == testData.Color ? 1 : 0) +
                (foo.Age == testData.Age ? 1 : 0),
            MatchPercentage = Math.Round(
                ((foo.Name == testData.Name ? 1 : 0) +
                 (foo.City == testData.City ? 1 : 0) +
                 (foo.Country == testData.Country ? 1 : 0) +
                 (foo.Year == testData.Year ? 1 : 0) +
                 (foo.Color == testData.Color ? 1 : 0) +
                 (foo.Age == testData.Age ? 1 : 0)) * 100.0 / TotalFields,
                0)
        }).ToList();
    }

    // 用于存储匹配结果的DTO类
    public class MatchResult
    {
        public Foo OriginalRow { get; set; }
        public int MatchedFieldsCount { get; set; }
        public double MatchPercentage { get; set; }
    }
}

第三步：调用示例 #

在业务代码中可以这样使用：

using (var dbContext = new AppDbContext())
{
    // 测试数据1
    var testData1 = new Foo
    {
        Name = "Peter",
        City = "Brussels",
        Country = "Belgium",
        Year = 2013,
        Color = "blue",
        Age = 19
    };

    var results1 = MatchCalculator.CalculateMatchResults(dbContext, testData1);
    foreach (var result in results1)
    {
        Console.WriteLine($"原始行：{result.OriginalRow.Name}, {result.OriginalRow.City}, {result.OriginalRow.Country}, {result.OriginalRow.Year}, {result.OriginalRow.Color}, {result.OriginalRow.Age}");
        Console.WriteLine($"匹配字段数：{result.MatchedFieldsCount} | 匹配百分比：{result.MatchPercentage}%\n");
    }

    // 测试数据2
    var testData2 = new Foo
    {
        Name = "Peter",
        City = "Paris",
        Country = "France",
        Year = 2011,
        Color = "green",
        Age = 36
    };

    var results2 = MatchCalculator.CalculateMatchResults(dbContext, testData2);
    foreach (var result in results2)
    {
        Console.WriteLine($"原始行：{result.OriginalRow.Name}, {result.OriginalRow.City}, {result.OriginalRow.Country}, {result.OriginalRow.Year}, {result.OriginalRow.Color}, {result.OriginalRow.Age}");
        Console.WriteLine($"匹配字段数：{result.MatchedFieldsCount} | 匹配百分比：{result.MatchPercentage}%\n");
    }
}

这个方案的优势是代码更易维护，和业务逻辑整合度高，EF会自动把Linq查询转换成对应的SQL语句，同样能保证数据库端的计算性能。

内容的提问来源于stack exchange，提问作者juFo