Question

我正在尝试执行一个简单的查询，结果数据几乎全部为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保持为空。

显然，此问题仅发生在id上。我怀疑此问题是由于列名重复造成的。

我正在以重要的方式使用Microsoft Access。

我的问题与possible duplicate不同，因为我已经定义了应该映射的类。

Answer 1

正如我们在评论中讨论的，这是一个问题，这是由于两个表中的列名重复。 This是可以找到类似问题和解决方案的地方。 但是，它不包括您所说的“按代码映射” 。因此，它不是精确的重复项。

我建议您更改表中ID字段的名称，以避免冲突。当然，您还应该相应地更改POCO属性和映射的名称。

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

希望对您有帮助。

Answer 2

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

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

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

它可以嵌套到任意多个级别
可以应付Dappers 7件物品的限制
可以处理相同类别的重复项
可以重复使用，例如用于Get，GetCurrent和GetAll

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

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

参数2 -我们将返回的每个对象的Type数组。因此，最好命令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.[ThinId],
                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 (expansion != 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函数，以更轻松地组合对象属性。

Answer 3

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

我使用“自定义列映射”解决了它，得到了两种可能的解决方案：

无扩展名

首先，我们定义一个Dictionary，将列的名称作为键，并将属性的名称作为值

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

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

3 个答案: