29

How can I ignore a property on my model using dapper/dapper extensions/dapper rainbow or any

of those dapper libraries?

Elisabeth
  • 20,496
  • 52
  • 200
  • 321
  • For Insert(person). person has kind of computed property. Which does not belong to the database. – Elisabeth Nov 01 '13 at 13:09
  • 1
    Since non of the answers below provide a solution for a Dapper.Rainbow based project, I am adding this comment. Dapper Rainbow has an IgnoreProperty Attribute that can be used. Your POCO class has to reference Dapper.Rainbow.{SQL} and then you can use [IgnoreProperty(true)] for properties that you wish to exclude – Vishnoo Rath Nov 24 '15 at 11:15
  • Related for Dapper.Contrib: https://stackoverflow.com/q/57673107/5779732 – Amit Joshi May 28 '20 at 08:47

5 Answers5

31

Dapper.Contrib has built-in support for marking a column as computed: add ComputedAttribute to allow support for computed columns on Insert. Here's how it works:

class MyModel
{
  public string Property1 { get; set; }

  [Computed]
  public int ComputedProperty { get; set; }
}

Properties marked with the Computed attribute will be ignored on inserts.

Ben Collins
  • 20,538
  • 18
  • 127
  • 187
  • There is also `[Write(false)]` attribute. Can anyone tell what is the difference between `[Computed]` and `[Write(false)]`? – vaheeds Apr 04 '17 at 06:36
  • 2
    @vaheeds my best guess is that they were added at different times by different people who may not have been aware of the other. I added the `Computed` attribute and wasn't aware of any `Write` attribute at the time. – Ben Collins May 09 '17 at 17:28
  • 6
    They mean something different in my opinion - `[Computed]` means "this column is in the database but is a [Computed column](https://learn.microsoft.com/en-us/sql/relational-databases/tables/specify-computed-columns-in-a-table?view=sql-server-2017)" but `[Write(false)]` means "this column is not in the database" – stuartd Dec 05 '18 at 15:57
  • For details about `[Write(false)]` and `[Computed]`, refer to [this](https://stackoverflow.com/q/57673107/5779732) question. – Amit Joshi Oct 06 '20 at 14:07
17

Dapper creator Sam Saffron has addressed this requirement in response to another SO user's questions here. Check it out.

Also, if you want to use the Dapper Extensions library that Sam has mentioned in his answer, you can get it from Github or via Nuget.

Here's an example of ignoring properties from the Library's Test Project.

using System;
using System.Collections.Generic;
using DapperExtensions.Mapper;

namespace DapperExtensions.Test.Data
{
    public class Person
    {
        public int Id { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public DateTime DateCreated { get; set; }
        public bool Active { get; set; }
        public IEnumerable<Phone> Phones { get; private set; }
    }

    public class Phone
    {
        public int Id { get; set; }
        public string Value { get; set; }
    }

    public class PersonMapper : ClassMapper<Person>
    {
        public PersonMapper()
        {
            Table("Person");
            Map(m => m.Phones).Ignore();
            AutoMap();
        }
    }
}
Community
  • 1
  • 1
Shiva
  • 20,575
  • 14
  • 82
  • 112
  • 2
    Where/When do you instantiate the PersonMapper class ? Is dapper extensions looking for Mapper class by taking the entityname + "Mapper" string and trying to instantiate it? – Elisabeth Nov 02 '13 at 15:49
  • 2
    Yes, I believe the AutoMapper feature of Dapper Extensions looks for singular entity name + "Mapper" suffix to automap fields to ignore, fields with different names etc. In other words, I think (haven't tried it) you should be ok with just defining this PersonMapper class and ignoring the fields you want to ignore from the POCO. See the documentation here: https://github.com/tmsmith/Dapper-Extensions/wiki/AutoClassMapper – Shiva Nov 02 '13 at 23:18
  • Fine it worked for me. My XXXMapper class has the same namespace. – Elisabeth Nov 03 '13 at 14:36
11

In my case I used Dapper.Contrib.
Using [Write(false)] attribute on any property should solve the problem. Some also suggest using [Computed] attribute.

public class Person
{        
    [Key]
    public int Id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }

    [Write(false)]
    public IEnumerable<Email> Emails { get; }
}
Ariful Islam
  • 664
  • 8
  • 12
5

You can design a base class without the computed property and use that for your inserts.

  class BasePerson
    {
      public String Name {get;set;}
    }

    class Person: BasePerson
    {
     public String ComputedProperty {get;set;}
    }

    Insert<BasePerson>(person);
Alex
  • 7,901
  • 1
  • 41
  • 56
4

For those not wanting to include DapperExtensions, DatabaseGenerated from the standard System.ComponentModel.DataAnnotations.Schema can be used also.

[DatabaseGenerated(DatabaseGeneratedOption.Computed)]
davidmdem
  • 3,763
  • 2
  • 30
  • 33