Laden...

Wie AutoMapper (Entity <--> Model) einbinden um IDataErrorInfo nutzen zu können?

Erstellt von Moritz83 vor 4 Jahren Letzter Beitrag vor 4 Jahren 1.060 Views
M
Moritz83 Themenstarter:in
50 Beiträge seit 2013
vor 4 Jahren
Wie AutoMapper (Entity <--> Model) einbinden um IDataErrorInfo nutzen zu können?

Nabend,

ich habe folgende Ausgangssituation:

Employee.cs (Model inkl. IDaraErrorInfo)

 using System;
using System.ComponentModel;

namespace Calendar.Models
{
    public class Employee : IDataErrorInfo, INotifyPropertyChanged
    {
        //Employee ID -- Auto Increment (Database)
        public int Id { get; set; }
        private string _firstName;
        public string FirstName
        {
            get => _firstName;
            set
            {
                if (_firstName != null && _firstName != value)
                {
                    _firstName = value;
                }
                NotifyPropertyChanged("FirstName");
            }
        }
        //more code
        #region IDataErorInfo Members
        string IDataErrorInfo.Error
        {
            get
            {
                return null;
            }
        }
        string IDataErrorInfo.this[string propertyName]
        {
            get
            {
                return GetValidationError(propertyName);
            }
        }
        #endregion

        #region Validation
        //more code
        #endregion

        #region INotifyPropertyChanged Members
        //more code
        #endregion
    }
}

EmployeeEntity (Entity Klasse)

namespace Calendar.Database.Entities
{
    [Dapper.Contrib.Extensions.Table("Employee")]
    public class EmployeeEntity : Entity
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
    }
}

und mein ViewModel

namespace Calendar.ViewModels
{
    internal class EmployeeViewModel : INotifyPropertyChanged
    {
        private RelayCommand command;
        private EmployeeEntity employee;
        /// <summary>
        /// Initializes a new instance of the EmployeeViewModel class.
        /// </summary>
        public EmployeeViewModel()
        {
            employee = new EmployeeEntity();
        }
        public EmployeeEntity Employee
        {
            get
            {
                return employee;
            }         
        }
        public RelayCommand AddNewEmployee
        {
            get
            {
                this.command = new RelayCommand(SaveChanges);
                return this.command;
            }
        }
        public void SaveChanges()
        {
            var container = ContainerConfig.Configure();
            using (var scope = container.BeginLifetimeScope())
            {
                var test = scope.Resolve<IEmployeeRepository>();
                employee.FirstName = this.Employee.FirstName;
                employee.LastName = this.Employee.LastName;
                test.Add(employee);
            }
        }
    }
}

Sodele, mein Problem ist dass das Model keinerlei Bezug zur Entity (und vice versa) hat und natürlich so auch keine Validation (die im Model definiert wurde) stattfinden kann. Gemäss Internet gibt es AutoMapper und der Code den ich bräuchte sähe etwa so aus

            var config = new MapperConfiguration(cfg => cfg.CreateMap<Employee, EmployeeEntity>());
            var mapper = config.CreateMapper();

Leider habe ich keinen Plan wie ich das einbauen kann, resp. beim letzten Versuch kam die Fehlermeldung das eine Konvertierung von EmployeeEntity in Employee nicht möglich sei. Der Vollständigkeitshalber noch ein Beispiel einer Textbox:

<TextBox Width="136" Text="{Binding Employee.FirstName, UpdateSourceTrigger=PropertyChanged, ValidatesOnDataErrors=True}" />

In einem anderen Beispiel das ich gemacht habe ging das einwandfrei, allerdings ohne Entity dazwischen.

PS: Sollten mehr Infos notwendig sein einfach melden

16.806 Beiträge seit 2008
vor 4 Jahren

Modellvalidierungen und Entitätsvalidierungen sind zwei verschiedene paar Stiefel.
Es ist absolut korrekt, dass sich Modell und Entität nicht kennen - gleiches _sollte _für die Validierungen der Fall sein:
Validierungen in Entitäten prüfen Struktur und ggfls. Relation.
Validierungen am Modell können jedoch auch logische Abhängigkeiten prüfen.

Wenn Du nicht weißt, wie man den AutoMapper integriert, dann schau Dir die Tutorials dazu an.

M
Moritz83 Themenstarter:in
50 Beiträge seit 2013
vor 4 Jahren

Habs nun umgedreht, View -> ViewModel -> neuer "Employee" (anstatt neue EmployeeEntity) -> Validation funktioniert -> Mapper -> Entity -> neuer Eintrag in der DB

Danke für den dezenten Hinweis bzgl. Modellvalidierung <-> Entitätsvalidierung

Thread kann zu