AutoMapper Ignora proprietà in C# con esempi
In questo articolo, parlerò di come utilizzare la proprietà Ignora di AutoMapper in C# con esempi. Leggi il nostro articolo precedente in cui abbiamo discusso di AutoMapper Mappatura condizionale in C# con alcuni esempi. Alla fine di questo articolo, capirai in dettaglio la necessità e l'uso della proprietà Ignore di AutoMapper in C#.
Perché abbiamo bisogno di AutoMapper Ignora proprietà in C#?
Per impostazione predefinita, AutoMapper tenta di mappare tutte le proprietà dal tipo di origine al tipo di destinazione quando entrambi i nomi delle proprietà del tipo di origine e di destinazione sono uguali. Se desideri che alcune delle proprietà non vengano mappate con la proprietà del tipo di destinazione, devi utilizzare la Proprietà Ignora AutoMapper in C#.
Nota: Se alcune delle proprietà non sono disponibili nel tipo di destinazione, l'AutoMapper non genererà alcuna eccezione durante l'esecuzione del mapping. Tuttavia, genererà un'eccezione quando utilizzi ValidateMapperConfiguration() di cui parleremo nei nostri prossimi articoli.
Esempio per comprendere la proprietà Ignora di AutoMapper in C#
Capiamo come utilizzare la proprietà Ignora di AutoMapper con un esempio. Utilizzeremo il seguente Dipendente e EmployeeDTO classi per questa demo.
Il nostro requisito aziendale non consiste nel mappare la proprietà dell'indirizzo cioè dobbiamo ignorare la proprietà Address durante la mappatura tra questi due oggetti. Per farlo, dobbiamo utilizzare Ignora proprietà con l'Indirizzo proprietà del tipo di destinazione durante la configurazione del mappatore come mostrato di seguito nell'immagine sottostante.
Come puoi vedere nell'esempio precedente, abbiamo aggiunto il metodo ForMember per ignorare la proprietà Address durante la mappatura.
Di seguito è riportato l'esempio completo.
using System;
using AutoMapper;
namespace AutoMapperDemo
{
class Program
{
static void Main(string[] args)
{
var mapper = InitializeAutomapper();
Employee employee = new Employee()
{
ID = 101,
Name = "James",
Address = "Mumbai"
};
var empDTO = mapper.Map<Employee, EmployeeDTO>(employee);
Console.WriteLine("After Mapping : Employee");
Console.WriteLine("ID : " + employee.ID + ", Name : " + employee.Name + ", Address : " + employee.Address);
Console.WriteLine();
Console.WriteLine("After Mapping : EmployeeDTO");
Console.WriteLine("ID : " + empDTO.ID + ", Name : " + empDTO.Name + ", Address : " + empDTO.Address);
Console.ReadLine();
}
static Mapper InitializeAutomapper()
{
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap<Employee, EmployeeDTO>()
//Ignoring the Address property of the destination type
.ForMember(dest => dest.Address, act => act.Ignore());
});
var mapper = new Mapper(config);
return mapper;
}
}
public class Employee
{
public int ID { get; set; }
public string Name { get; set; }
public string Address { get; set; }
}
public class EmployeeDTO
{
public int ID { get; set; }
public string Name { get; set; }
public string Address { get; set; }
}
}
Quando eseguiamo l'applicazione, ci darà l'output seguente.
Se guardi la finestra di output puoi vedere che il valore per la proprietà Address è vuoto anche se la proprietà Address per il tipo Source ha valore. Quindi, AutoMapper Ignore() viene utilizzato quando si desidera ignorare completamente la proprietà nella mappatura. La proprietà ignorata potrebbe trovarsi nell'oggetto di origine o di destinazione.
Il modo migliore per ignorare più proprietà:
Ma sarà una procedura noiosa se vuoi ignorare più proprietà dalla mappatura. Se questo è il tuo requisito, considera la creazione di una classe di estensione che ignorerà le proprietà in base all'attributo di dati specificato nel modello. Discutiamo la procedura passo passo per implementarlo.
Passaggio 1:crea un attributo NoMap
Crea una classe con il nome NoMapAttribute ereditando dalla classe System.Attribute in modo da poter utilizzare questa classe come attributo.
Fase 2:decora le proprietà con l'attributo NoMap
Ora devi decorare il NoMap attributo con le proprietà del tipo di origine che non si desidera mappare con il tipo di destinazione. Ad esempio, se non vuoi mappare la proprietà Indirizzo ed Email, devi decorare l'attributo NoMap con la proprietà Indirizzo ed Email della classe Dipendente come mostrato nell'immagine sottostante.
Passaggio 3:creazione di un metodo di estensione
Crea una classe di estensione come mostrato di seguito che ignorerà le proprietà che decoreranno con NoMap attributo. Qui devi importare il System.ComponentModel spazio dei nomi.
Passaggio 4:utilizzo del metodo di estensione IgnoreNoMap
Infine devi usare il metodo IgnoreNoMap mentre definisci la mappatura come mostrato di seguito.
Di seguito è riportato il codice completo.
using System;
using System.ComponentModel;
using AutoMapper;
namespace AutoMapperDemo
{
class Program
{
static void Main(string[] args)
{
var mapper = InitializeAutomapper();
Employee employee = new Employee()
{
ID = 101,
Name = "James",
Address = "Mumbai"
};
var empDTO = mapper.Map<Employee, EmployeeDTO>(employee);
Console.WriteLine("After Mapping : Employee");
Console.WriteLine("ID : " + employee.ID + ", Name : " + employee.Name + ", Address : " + employee.Address + ", Email : " + employee.Email);
Console.WriteLine();
Console.WriteLine("After Mapping : EmployeeDTO");
Console.WriteLine("ID : " + empDTO.ID + ", Name : " + empDTO.Name + ", Address : " + empDTO.Address + ", Email : " + empDTO.Email);
Console.ReadLine();
}
static Mapper InitializeAutomapper()
{
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap<Employee, EmployeeDTO>()
.IgnoreNoMap(); ;
});
var mapper = new Mapper(config);
return mapper;
}
}
public class NoMapAttribute : System.Attribute
{
}
public static class IgnoreNoMapExtensions
{
public static IMappingExpression<TSource, TDestination> IgnoreNoMap<TSource, TDestination>(
this IMappingExpression<TSource, TDestination> expression)
{
var sourceType = typeof(TSource);
foreach (var property in sourceType.GetProperties())
{
PropertyDescriptor descriptor = TypeDescriptor.GetProperties(sourceType)[property.Name];
NoMapAttribute attribute = (NoMapAttribute)descriptor.Attributes[typeof(NoMapAttribute)];
if (attribute != null)
expression.ForMember(property.Name, opt => opt.Ignore());
}
return expression;
}
}
public class Employee
{
public int ID { get; set; }
public string Name { get; set; }
[NoMap]
public string Address { get; set; }
[NoMap]
public string Email { get; set; }
}
public class EmployeeDTO
{
public int ID { get; set; }
public string Name { get; set; }
public string Address { get; set; }
public string Email { get; set; }
}
}
Quando eseguiamo l'applicazione, verrà visualizzato il seguente risultato
Nell'esempio sopra, abbiamo creato un attributo personalizzato con il nome NoMap ereditando dall'attributo classe. Quindi abbiamo decorato le proprietà che devono essere ignorate dal tipo di origine con il nuovo NoMap attributo. All'interno del metodo delle estensioni, abbiamo appena verificato se una proprietà ha questa NoMap attributo o meno. Se la proprietà è decorata con NoMap attributo, quindi abbiamo aggiunto quella proprietà all'elenco ignorato.
Nel prossimo articolo parlerò dell'uso di UseValue, ResolveUsing e Null Substitution usando AutoMapper in C# con esempi. Qui, in questo articolo, provo a spiegare la proprietà AutoMapper Ignore in C# con alcuni esempi. Spero che questo AutoMapper ignori la proprietà in C# l'articolo ti aiuterà con il tuo bisogno. Mi piacerebbe avere il tuo feedback. Pubblica il tuo feedback, domanda o commenti su questo articolo.