通过代码进行映射的 Dapper：具有重复列名称的多重映射

问题描述 投票：0回答：3

我正在尝试执行一个简单的查询，结果数据几乎都是

null
。

我有这个表结构

表注册器

ID            |  Autonumeric
TareaM_Id     |  Numeric
Fecha         |  Date/Time

和 Macro_tareas 表

ID            |  Autonumeric
Nombre        |  Short Text

我在 C# 中映射了类，如下所示：

[Table("Registros")]
public class Registro
{
    [Column("ID")]
    public virtual int ID { get; set; }

    [Column("Fecha")]
    public virtual DateTime Fecha { get; set; }

    [Column("TareaM_Id")]
    public virtual int TareaM_Id { get; set; }

    public virtual MacroTarea MacroT { get; set; }
}

[Table("Macro_tarea")]
public class MacroTarea
{
    [Column("ID")]
    public virtual int ID { get; set; }

    [Column("Nombre")]
    public virtual string Nombre{ get; set; }

    public virtual ICollection<Registro> Registros { get; set; }

}

这是我正在尝试使用的查询

string sql = @"SELECT reg.ID, mac.ID 
    FROM Registros as reg INNER JOIN Macro_tarea as mac on reg.TareaM_Id = mac.ID
    WHERE Fecha = @Fecha";

using (IDbConnection db = new OleDbConnection(ConnectionString))
{
    var result = db.Query<Registro,MacroTarea, Registro>(sql, 
    (reg,mac) =>
    {
        reg.MacroTarea = mac;
        return reg;
    }
    ,new { @Fecha = new DateTime(2019, 1, 4).Date }
    , splitOn: "mac.ID")
    .AsList();                                            
}

我试图只检索 id，但两个 id 都变成空，为什么会发生这种情况？

问题是，如果我将 

Registros.Fecha
和 
Macro_tarea.Nombre
添加到查询中，它就会正确获取值。但 id 一直为空。

显然这个问题只发生在 ids 上。我怀疑这个问题是由于重复的列名造成的。

我正在与 Microsoft Access 合作，这只是重要的事情。

我的问题与可能的重复不相似，因为我定义了应该映射的类。

c# ms-access orm dapper
3个回答
6
投票

因为您的代码无法处理数据而重命名数据库列并不是一个好主意。在关注点分离的世界中，您的数据库为什么要关心？将 ID 列命名为“Id”有充分的数据库理由，您甚至可能没有更改它们的选项。

Dapper 映射还有另一个问题，即重命名列无法解决；重复类型。如果您尝试映射到类的多个实例，Dapper 会感到困惑，并且重命名列将不起作用，因为您将重命名两个实例。

这是我想出的解决方案。它与许多使用字典的示例类似，除了：

  • 它可以嵌套任意层数
  • 可以应对 Dappers 7 件物品限制
  • 可以处理同一个类的重复项
  • 可以重复使用，例如 Get、GetCurrent 和 GetAll

在此示例中，有一个包含许多批次的拍卖。每批可能有 1 件或多件物品。物品可能是物品包。物品来自有限的目录，我们喜欢关系数据，因此物品表包含每个物品的详细信息，例如颜色、尺寸等。这里我们只获得单个批次，但获得拍卖与其他级别相同在拍卖的顶部。

参数 1 - 一次性获取所有内容的 SQL

参数 2 - 我们将返回的每个对象的类型数组。因此，最好命令您的 SELECT 将字段分组到类中

参数3 - 使用SQL结果调用我们要编写的方法

参数 4 - SQL 的标准参数数组。 SQL 注入很糟糕，好吗？

public async Task<List<Lot>> GetAll(int auctionId)
{
    using (var connection = new SqlConnection(_appSettings.ConnectionString))
    {
        await connection.OpenAsync();
        var result = new List<Lot>();
        await connection.QueryAsync($@"
            SELECT [Lot].*, 
                [Item].[Id], 
                [Item].[LotId], 
                [Item].[Notes], 
                itemDetails.[Id],
                itemDetails.[ThingId],
                itemDetails.[Colour], 
                itemDetails.[Size], 
                [SubItem].[Id], 
                [SubItem].[ItemId], 
                [SubItem].[Notes], 
                subItemDetails.[Id],
                subItemDetails.[ThingId],
                subItemDetails.[Colour], 
                subItemDetails.[Size]
            FROM [Lot]
                INNER JOIN [Item] ON [Item].[LotId] = [Lot].[Id]
                    LEFT JOIN [Thing] AS itemDetails ON itemDetails.[Id] = [Item].[ThingId]
                LEFT JOIN [SubItem] ON [SubItem].[ItemId] = [Item].[Id]
                    LEFT JOIN [Thing] AS subItemDetails ON subItemDetails.[Id] = [SubItem].[ThingId]
            WHERE [AuctionId] = @{nameof(auctionId)}
            ORDER BY [Lot].[Id], [Item].[Id], [Expansion].[Id];",
            new Type[] {
                typeof(Lot),
                typeof(Item),
                typeof(Thing),
                typeof(Expansion),
                typeof(Thing)
            }, 
            MapResult(result),
            new
            {
                AuctionId = auctionId
            }
        );

        return result.ToList();
    }
}

private Func<object[], Lot> MapResult(List<Lot> result)
{
    return (obj) =>
    {
        Lot lot = (Lot)obj[0];
        Item item = (Item)obj[1];
        Thing itemDetails = (Thing)obj[2];
        SubItem subItem = (SubItem)obj[3];
        Thing subItemDetails = (Thing)obj[4];
        if (lot != null)
        {
            if (result.Any(a => a.Id == lot.Id))
            {
                lot = result.First(a => a.Id == lot.Id);
            }
            else
            {
                result.Add(lot);
            }
        }
        if (item != null)
        {
            if (lot.Items.Any(i => i.Id == item.Id))
            {
                item = lot.Items.First(i => i.Id == item.Id);
            }
            else
            {
                lot.Items.Add(item.FromThing(itemDetails));
            }
        }
        if (subItem != null)
        {
            if (item.SubItems.Any(e => e.Id == subItem.Id) == false)
            {
                item.SubItems.Add(subItem.FromThing(subItemDetails));
            }
        }
            return null;
    };
}

MapResult 是代码的核心。它返回一个具有两种类型的 Func，即我们上面定义的 Type 数组和返回 Type，并采用顶级对象的 List。 然后，我将对象数组中的每个项目映射到另一个实际类型。这使代码更易于阅读，并且可以毫无问题地访问对象的属性和方法。

然后是一种逐步向下层次结构的情况，在每一步检查是否已经存在具有匹配 id 的迭代器，如果存在，则将迭代器交换为对其的引用。这意味着以下代码将添加到现有项目中。

在这种特殊情况下，我还添加了 FromThing 函数，以便更轻松地组合对象属性。

1
投票

正如我们在评论中讨论的那样，这是由于两个表中重复的列名造成的问题。 这里可以找到类似的问题和解决方案。 但是，它不包括您所说的“通过代码映射”。所以它不完全重复。

我建议您更改表中

ID
字段的名称，以避免它们发生冲突。当然，您还应该相应地更改 POCO 属性和映射的名称。

如果无法更改表中的列名称，请更改 POCO 属性名称，并在 SQL 查询中使用列别名来匹配这些新属性名称。

希望这对您有帮助。

1
投票

问题实际上是属性的名称。

我使用自定义列映射解决了这个问题，我得到了两种可能的解决方案：

无扩展

首先，我们定义一个字典，以列名作为键，属性名作为值

IDictionary<string, string> columnMaps = new Dictionary<string, string>()
            {
                { "Macro_tarea.ID", "ID" },
                { "Registros.ID", "ID" }
            };

然后，我们定义一个委托来获取我们要为其分配前一个字典的别名的属性的PropertyInfo对象

var mapper = new Func<Type, string, PropertyInfo>((type, columnName) =>
            {
                if (columnMaps.ContainsKey(columnName))
                    return type.GetProperty(columnMaps[columnName]);
                else
                    return type.GetProperty(columnName);
            });

现在，我们定义一个使用 

ITypeMap
实现实现 
CustomPropertyTypeMap
接口的对象

ITypeMap MacroTareaMapper = new CustomPropertyTypeMap(typeof(Macro_tarea),
                (type, columnName) => mapper(type, columnName));

ITypeMap RegistrosMapper = new CustomPropertyTypeMap(typeof(Registros),
                (type, columnName) => mapper(type, columnName));

然后我们注册他们

SqlMapper.SetTypeMap(typeof(Macro_tarea), MacroTareaMapper);
SqlMapper.SetTypeMap(typeof(Registros), RegistrosMapper);

使用 Dapper.FluentMap

更简单的解决方案

实现如下：

我们创建一个继承自 

EntityMap<T>
的类，并使用 Map 方法定义每个属性对应的列。例如，

internal class Macro_tareaMap : EntityMap<Macro_tarea>
{
       internal Macro_tareaMap()
       {
            //Mi propiedad ID esta asociada a la columna Macro_tarea.ID
            Map(x => x.ID).ToColumn("Macro_tarea.ID");
       }
}

然后注册即可

FluentMapper.Initialize((config) => 
{
    config.AddMap(new Macro_tareaMap());
});

希望它能帮助别人！

来源：https://medium.com/dapper-net/custom-columns-mapping-1cd45dfd51d6

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.