Can I use AutoMapper with CSLA ?

[adrianwright109]

In the past I have used AutoMapper to automatically map properties from one class to another.

I was wondering whether it would be possible to use AutoMapper with CSLA or whether CSLA has its own built-in data mapper ?

My scenario is:
I have a Blazor WebAssembly project which I created using the CSLA Blazor Sample from this repo.

I have a Razor Component with the following code:

    private async Task compareButtonOnClickHandler()
    {
        Console.WriteLine($"{TickedCount} products to compare");

        SharedModelProductsCompareViewList results = await Csla.DataPortal.FetchAsync<SharedModelProductsCompareViewList>(paramsInfo.ClientId);

        CompareViewList = results;
    }

This then calls the method attributed with the [Fetch] attribute from the SharedModelProductsCompareViewList class.

using Csla;
using DataAccess.Interfaces;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using DataAccess;

namespace BlazorExample.Shared
{
    [Serializable]
    public class SharedModelProductsCompareViewList : ReadOnlyBase<SharedModelProductsCompareViewList>
    {
        public static readonly PropertyInfo<SharedModelCompareProductsViewResultHeader> HeaderProperty = RegisterProperty<SharedModelCompareProductsViewResultHeader>(nameof(Header));
        [Display(Name = "Header")]
        public SharedModelCompareProductsViewResultHeader Header
        {
            get => GetProperty(HeaderProperty);
            private set => LoadProperty(HeaderProperty, value);
        }

        public static readonly PropertyInfo<SharedModelCompareProductsViewResultRowList> RowsProperty = RegisterProperty<SharedModelCompareProductsViewResultRowList>(nameof(Rows));
        [Display(Name = "Rows")]
        public SharedModelCompareProductsViewResultRowList Rows
        {
            get => GetProperty(RowsProperty);
            private set => LoadProperty(RowsProperty, value);
        }

        [Fetch]
        private void Fetch([Inject] IProductsDal productsDal, int clientId)
        {
            DataAccessCompareProductsViewResult compareProducts = productsDal.CompareSelectedProducts(clientId);

            Header = compareProducts.Header.ToSharedViewModel();
            Rows = compareProducts.Rows.ToSharedViewModel();
        }
    }
}

The data is then populated into the DataAccessCompareProductsViewResult class by calling the CompareSelectedProducts method on the DAL. The DataAccessCompareProductsViewResultclass which sits in the DataAccess project, class looks like this:

using System;
using System.Collections.Generic;
using System.Linq;
using ProductCalculator;

namespace DataAccess
{
    [Serializable]
    public class DataAccessCompareProductsViewResult
    {
        public DataAccessCompareProductsViewResult(List<DataAccessCompareProductsViewResultRowComponentInfo> components,
            List<DataAccessCompareProductsViewResultHeaderProductInfo> products,
            List<CalcOutputRecord> calcResults)
        {
            Components = components ?? throw new ArgumentNullException(nameof(components));
            Products = products ?? throw new ArgumentNullException(nameof(products));
            CalcResults = calcResults ?? throw new ArgumentNullException(nameof(calcResults));

            Header = new DataAccessCompareProductsViewResultHeader(products);
            Rows = new List<DataAccessCompareProductsViewResultRow>(NumberOfComponents);

            PopulateRows();
        }

        public DataAccessCompareProductsViewResultHeader Header { get; }

        public List<DataAccessCompareProductsViewResultRow> Rows { get; }

        public int NumberOfComponents => Components.Count;

        public int NumberOfProducts => Products.Count;

        private List<DataAccessCompareProductsViewResultRowComponentInfo> Components { get; }

        private List<DataAccessCompareProductsViewResultHeaderProductInfo> Products { get; }

        private List<CalcOutputRecord> CalcResults { get; }

        private void PopulateRows()
        {
            const int subTotalCategoryId = 11;

            for (var i = 0; i < NumberOfComponents; i++)
            {
                var component = Components[i];

                var componentResult = new DataAccessCompareProductsViewResultRow(NumberOfProducts)
                {
                    Component = component
                };

                for (var j = 0; j < NumberOfProducts; j++)
                {
                    var showPercentageBar = component.CategoryId < subTotalCategoryId;
                    var subTotalExists = false;

                    var product = Products[j];
                    var productCalcs = CalcResults.Where(x => x.RecordKey == product.RecordKey).ToList();
                    var productCalcsExistForCategory = productCalcs.Any(x => x.CategoryId == component.CategoryId);

                    if (showPercentageBar)
                    {
                        subTotalExists = productCalcs.Any(x => x.CategoryId == subTotalCategoryId);
                    }

                    var productResult = new DataAccessCompareProductsViewResultRowProductInfo();

                    if (productCalcsExistForCategory)
                    {
                        var productCalcForCategory = productCalcs.Single(x => x.CategoryId == component.CategoryId);

                        productResult.RRPValue = $"{productCalcForCategory.RRPValue:N2}";
                        productResult.ShowPercentageBar = showPercentageBar;

                        if (showPercentageBar && subTotalExists)
                        {
                            var productSubTotal = productCalcs.Single(x => x.CategoryId == subTotalCategoryId);

                            var percentageOfSubTotal = Convert.ToDouble(decimal.Divide(productCalcForCategory.RRPValue, productSubTotal.RRPValue) * 100);

                            productResult.PercentageOfSubTotal = percentageOfSubTotal;
                        }
                    }

                    componentResult.Products.Add(productResult);
                }

                Rows.Add(componentResult);
            }
        }
    }

    [Serializable]
    public class DataAccessCompareProductsViewResultHeader
    {
        public DataAccessCompareProductsViewResultHeader(List<DataAccessCompareProductsViewResultHeaderProductInfo> products)
        {
            Products = products ?? throw new ArgumentNullException(nameof(products));
        }

        public string ComponentHeaderText => "Product";

        public List<DataAccessCompareProductsViewResultHeaderProductInfo> Products { get; }
    }

    [Serializable]
    public class DataAccessCompareProductsViewResultHeaderProductInfo
    {
        public string ProductId { get; set; }
        public string Make { get; set; }
        public string Model { get; set; }
        public string Spec { get; set; }
        public int RecordKey { get; set; }
        public int PackageTotal { get; set; }
        public int PackageMonths { get; set; }
    }

    [Serializable]
    public class DataAccessCompareProductsViewResultRow
    {
        public DataAccessCompareProductsViewResultRow(int numberOfSelectedProducts)
        {
            Component = new DataAccessCompareProductsViewResultRowComponentInfo();
            Products = new List<DataAccessCompareProductsViewResultRowProductInfo>(numberOfSelectedProducts);
        }

        public DataAccessCompareProductsViewResultRowComponentInfo Component { get; set; }

        public List<DataAccessCompareProductsViewResultRowProductInfo> Products { get; }
    }

    [Serializable]
    public class DataAccessCompareProductsViewResultRowComponentInfo
    {
        public decimal CategoryId { get; set; }
        public string CategoryName { get; set; }
        public int DisplaySeq { get; set; }
        public string RRPChart { get; set; }
        public bool CategoryGraph => RRPChart == "Y";
        public string CategoryColour { get; set; }
        public string ChartComponent { get; set; }
        public bool CategoryGraphComponent => ChartComponent == "Y";
    }

    [Serializable]
    public class DataAccessCompareProductsViewResultRowProductInfo
    {
        public string RRPValue { get; set; }
        public bool ShowPercentageBar { get; set; }
        public double? PercentageOfSubTotal { get; set; }
    }
}

When it comes to populating the Header and Rows properties on the SharedModelProductsCompareViewList class I have to transfer the data from the DataAccessCompareProductsViewResultclass which sits in the DataAccess project into the SharedModelCompareProductsViewResult class in the Shared project as the Blazor WebAssembly project only has a reference to the Shared project.

The SharedModelCompareProductsViewResult class in the Shared project looks like this:

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using Csla;
using Csla.Core;

namespace BlazorExample.Shared
{
    [Serializable]
    public class SharedModelCompareProductsViewResult : ReadOnlyBase<SharedModelCompareProductsViewResult>
    {
        public static readonly PropertyInfo<SharedModelCompareProductsViewResultHeader> HeaderProperty = RegisterProperty<SharedModelCompareProductsViewResultHeader>(nameof(Header));
        [Display(Name = "Header")]
        public SharedModelCompareProductsViewResultHeader Header
        {
            get => GetProperty(HeaderProperty);
            set => LoadProperty(HeaderProperty, value);
        }

        public static readonly PropertyInfo<SharedModelCompareProductsViewResultRowList> RowsProperty = RegisterProperty<SharedModelCompareProductsViewResultRowList>(nameof(Rows));
        [Display(Name = "Rows")]
        public SharedModelCompareProductsViewResultRowList Rows
        {
            get => GetProperty(RowsProperty);
            set => LoadProperty(RowsProperty, value);
        }
    }

    [Serializable]
    public class SharedModelCompareProductsViewResultHeader : ReadOnlyBase<SharedModelCompareProductsViewResultHeader>
    {
        [Create, RunLocal]
        private void Create() { }

        public static readonly PropertyInfo<string> ComponentHeaderTextProperty = RegisterProperty<string>(nameof(ComponentHeaderText));
        [Display(Name = "Component Header Text")]
        public string ComponentHeaderText
        {
            get => GetProperty(ComponentHeaderTextProperty);
            set => LoadProperty(ComponentHeaderTextProperty, value);
        }

        public static readonly PropertyInfo<SharedModelCompareProductsViewResultHeaderProductInfoList> ProductsProperty = RegisterProperty<SharedModelCompareProductsViewResultHeaderProductInfoList>(nameof(Products));
        [Display(Name = "Products")]
        public SharedModelCompareProductsViewResultHeaderProductInfoList Products
        {
            get => GetProperty(ProductsProperty);
            set => LoadProperty(ProductsProperty, value);
        }
    }

    [Serializable]
    public class SharedModelCompareProductsViewResultHeaderProductInfo : ReadOnlyBase<SharedModelCompareProductsViewResultHeaderProductInfo>
    {
        [Create, RunLocal]
        private void Create() { }

        public static readonly PropertyInfo<string> ProductIdProperty = RegisterProperty<string>(nameof(ProductId));
        [Display(Name = "Product Id")]
        public string ProductId
        {
            get => GetProperty(ProductIdProperty);
            set => LoadProperty(ProductIdProperty, value);
        }

        public static readonly PropertyInfo<string> MakeProperty = RegisterProperty<string>(nameof(Make));
        [Display(Name = "Make")]
        public string Make
        {
            get => GetProperty(MakeProperty);
            set => LoadProperty(MakeProperty, value);
        }

        public static readonly PropertyInfo<string> ModelProperty = RegisterProperty<string>(nameof(Model));
        [Display(Name = "Model")]
        public string Model
        {
            get => GetProperty(ModelProperty);
            set => LoadProperty(ModelProperty, value);
        }

        public static readonly PropertyInfo<string> SpecProperty = RegisterProperty<string>(nameof(Spec));
        [Display(Name = "Spec")]
        public string Spec
        {
            get => GetProperty(SpecProperty);
            set => LoadProperty(SpecProperty, value);
        }

        public static readonly PropertyInfo<int> RecordKeyProperty = RegisterProperty<int>(nameof(RecordKey));
        [Display(Name = "Record Key")]
        public int RecordKey
        {
            get => GetProperty(RecordKeyProperty);
            set => LoadProperty(RecordKeyProperty, value);
        }

        public static readonly PropertyInfo<int> PackageTotalProperty = RegisterProperty<int>(nameof(PackageTotal));
        [Display(Name = "Package Total")]
        public int PackageTotal
        {
            get => GetProperty(PackageTotalProperty);
            set => LoadProperty(PackageTotalProperty, value);
        }

        public static readonly PropertyInfo<int> PackageMonthsProperty = RegisterProperty<int>(nameof(PackageMonths));
        [Display(Name = "Package Months")]
        public int PackageMonths
        {
            get => GetProperty(PackageMonthsProperty);
            set => LoadProperty(PackageMonthsProperty, value);
        }
    }

    [Serializable]
    public class SharedModelCompareProductsViewResultRow : ReadOnlyBase<SharedModelCompareProductsViewResultRow>
    {
        [Create, RunLocal]
        private void Create() { }

        public static readonly PropertyInfo<SharedModelCompareProductsViewResultRowComponentInfo> ComponentProperty = RegisterProperty<SharedModelCompareProductsViewResultRowComponentInfo>(nameof(Component));
        [Display(Name = "Component")]
        public SharedModelCompareProductsViewResultRowComponentInfo Component
        {
            get => GetProperty(ComponentProperty);
            set => LoadProperty(ComponentProperty, value);
        }

        public static readonly PropertyInfo<SharedModelCompareProductsViewResultRowProductInfoList> ProductsProperty = RegisterProperty<SharedModelCompareProductsViewResultRowProductInfoList>(nameof(Products));
        [Display(Name = "Products")]
        public SharedModelCompareProductsViewResultRowProductInfoList Products
        {
            get => GetProperty(ProductsProperty);
            set => LoadProperty(ProductsProperty, value);
        }
    }

    [Serializable]
    public class SharedModelCompareProductsViewResultRowComponentInfo : ReadOnlyBase<SharedModelCompareProductsViewResultRowComponentInfo>
    {
        [Create, RunLocal]
        private void Create() { }

        public static readonly PropertyInfo<decimal> CategoryIdProperty = RegisterProperty<decimal>(nameof(CategoryId));
        [Display(Name = "Category Id")]
        public decimal CategoryId
        {
            get => GetProperty(CategoryIdProperty);
            set => LoadProperty(CategoryIdProperty, value);
        }

        public static readonly PropertyInfo<string> CategoryNameProperty = RegisterProperty<string>(nameof(CategoryName));
        [Display(Name = "Category Name")]
        public string CategoryName
        {
            get => GetProperty(CategoryNameProperty);
            set => LoadProperty(CategoryNameProperty, value);
        }

        public static readonly PropertyInfo<int> DisplaySeqProperty = RegisterProperty<int>(nameof(DisplaySeq));
        [Display(Name = "Display Seq")]
        public int DisplaySeq
        {
            get => GetProperty(DisplaySeqProperty);
            set => LoadProperty(DisplaySeqProperty, value);
        }

        public static readonly PropertyInfo<string> RRPChartProperty = RegisterProperty<string>(nameof(RRPChart));
        [Display(Name = "RRP Chart")]
        public string RRPChart
        {
            get => GetProperty(RRPChartProperty);
            set => LoadProperty(RRPChartProperty, value);
        }

        public bool CategoryGraph => RRPChart == "Y";

        public static readonly PropertyInfo<string> CategoryColourProperty = RegisterProperty<string>(nameof(CategoryColour));
        [Display(Name = "Category Colour")]
        public string CategoryColour
        {
            get => GetProperty(CategoryColourProperty);
            set => LoadProperty(CategoryColourProperty, value);
        }

        public static readonly PropertyInfo<string> ChartCompProperty = RegisterProperty<string>(nameof(ChartComponent));
        [Display(Name = "Chart Component")]
        public string ChartComponent
        {
            get => GetProperty(ChartCompProperty);
            set => LoadProperty(ChartCompProperty, value);
        }

        public bool CategoryGraphComponent => ChartComponent == "Y";
    }

    [Serializable]
    public class SharedModelCompareProductsViewResultRowProductInfo : ReadOnlyBase<SharedModelCompareProductsViewResultRowProductInfo>
    {
        [Create, RunLocal]
        private void Create() { }

        public static readonly PropertyInfo<string> RRPValueProperty = RegisterProperty<string>(nameof(RRPValue));
        [Display(Name = "RRP Value")]
        public string RRPValue
        {
            get => GetProperty(RRPValueProperty);
            set => LoadProperty(RRPValueProperty, value);
        }

        public static readonly PropertyInfo<bool> ShowPercentageBarProperty = RegisterProperty<bool>(nameof(ShowPercentageBar));
        [Display(Name = "Show Percentage Bar")]
        public bool ShowPercentageBar
        {
            get => GetProperty(ShowPercentageBarProperty);
            set => LoadProperty(ShowPercentageBarProperty, value);
        }

        public static readonly PropertyInfo<double?> PercentageOfSubTotalProperty = RegisterProperty<double?>(nameof(PercentageOfSubTotal));
        [Display(Name = "Percentage of Sub Total")]
        public double? PercentageOfSubTotal
        {
            get => GetProperty(PercentageOfSubTotalProperty);
            set => LoadProperty(PercentageOfSubTotalProperty, value);
        }
    }

    [Serializable]
    public class SharedModelCompareProductsViewResultRowList : MobileList<SharedModelCompareProductsViewResultRow>
    {
        public SharedModelCompareProductsViewResultRowList()
            : base()
        {
        }

        public SharedModelCompareProductsViewResultRowList(int capacity)
            : base(capacity)
        {
        }

        public SharedModelCompareProductsViewResultRowList(IEnumerable<SharedModelCompareProductsViewResultRow> collection)
            : base(collection)
        {
        }
    }

    [Serializable]
    public class SharedModelCompareProductsViewResultHeaderProductInfoList : MobileList<SharedModelCompareProductsViewResultHeaderProductInfo>
    {
        public SharedModelCompareProductsViewResultHeaderProductInfoList()
            : base()
        {
        }

        public SharedModelCompareProductsViewResultHeaderProductInfoList(int capacity)
            : base(capacity)
        {
        }

        public SharedModelCompareProductsViewResultHeaderProductInfoList(IEnumerable<SharedModelCompareProductsViewResultHeaderProductInfo> collection)
            : base(collection)
        {
        }
    }

    [Serializable]
    public class SharedModelCompareProductsViewResultRowProductInfoList : MobileList<SharedModelCompareProductsViewResultRowProductInfo>
    {
        public SharedModelCompareProductsViewResultRowProductInfoList()
            : base()
        {
        }

        public SharedModelCompareProductsViewResultRowProductInfoList(int capacity)
            : base(capacity)
        {
        }

        public SharedModelCompareProductsViewResultRowProductInfoList(IEnumerable<SharedModelCompareProductsViewResultRowProductInfo> collection)
            : base(collection)
        {
        }
    }
}

I have had to write some clunky extension methods to take the data from the DataAccess class into the Shared class and these methods look like this:

using Csla;
using DataAccess.Interfaces;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using DataAccess;

namespace BlazorExample.Shared
{
    public static class ExtensionMethods
    {
        public static SharedModelCompareProductsViewResultHeader ToSharedViewModel(this DataAccessCompareProductsViewResultHeader header)
        {
            var newHeader = DataPortal.Create<SharedModelCompareProductsViewResultHeader>();
            newHeader.ComponentHeaderText = header.ComponentHeaderText;

            newHeader.Products = new SharedModelCompareProductsViewResultHeaderProductInfoList(header.Products.Select(x =>
            {
                var product = DataPortal.Create<SharedModelCompareProductsViewResultHeaderProductInfo>();

                product.ProductId = x.ProductId;
                product.Make = x.Make;
                product.Model = x.Model;
                product.Spec = x.Spec;
                product.RecordKey = x.RecordKey;
                product.PackageTotal = x.PackageTotal;
                product.PackageMonths = x.PackageMonths;

                return product;
            }));

            return newHeader;
        }

        public static SharedModelCompareProductsViewResultRowList ToSharedViewModel(this List<DataAccessCompareProductsViewResultRow> rows)
        {
            var newRows = new SharedModelCompareProductsViewResultRowList(rows.Select(x => x.ToSharedViewModel())); 
            
            return newRows;
        }

        private static SharedModelCompareProductsViewResultRow ToSharedViewModel(this DataAccessCompareProductsViewResultRow row)
        {
            var newRow = DataPortal.Create<SharedModelCompareProductsViewResultRow>();

            newRow.Component = row.Component.ToSharedViewModel();

            newRow.Products = new SharedModelCompareProductsViewResultRowProductInfoList(row.Products.Select(x =>
            {
                var value = DataPortal.Create<SharedModelCompareProductsViewResultRowProductInfo>();

                value.RRPValue = x.RRPValue;
                value.ShowPercentageBar = x.ShowPercentageBar;
                value.PercentageOfSubTotal = x.PercentageOfSubTotal;

                return value;
            }));

            return newRow;
        }

        private static SharedModelCompareProductsViewResultRowComponentInfo ToSharedViewModel(this DataAccessCompareProductsViewResultRowComponentInfo componentInfo)
        {
            var newComponentInfo = DataPortal.Create<SharedModelCompareProductsViewResultRowComponentInfo>();

            newComponentInfo.CategoryId = componentInfo.CategoryId;
            newComponentInfo.CategoryName = componentInfo.CategoryName;
            newComponentInfo.DisplaySeq = componentInfo.DisplaySeq;
            newComponentInfo.RRPChart = componentInfo.RRPChart;
            newComponentInfo.CategoryColour = componentInfo.CategoryColour;
            newComponentInfo.ChartComponent = componentInfo.ChartComponent;

            return newComponentInfo;
        }
    }
}

Is there an easy way to do this without doing this hacky extension methods, something like AutoMapper ?

[rockfordlhotka]

I moved this to Discussions, as it isn't really a work item for the backlog.

I think you can use AutoMapper. You can absolutely use the DataMapper built into CSLA.

In either case, keep in mind that these work on public properties, so can't set non-public values. Also, setting a property will trigger business rules (authorization, validation, etc.) unless wrapped in a BypassPropertyChecks block.

[kcabral817]

Yes. I use Automapper with CSLA for all of my mapping needs. There are some caveats. Automapper will automatically create a new object when mapping. This makes it difficult to call a specific method for class initiation especially for child objects. You'll have to set those properties after the mapper is done. Each child list must be marked as old via a Foreach loop for each of the items in the list. I use automapper in my factory classes. Hope this helps.

[saulyt]

I'm using Automapper without issue. The only thing I see in my mapping configuration that looks particular to CSLA is:

AddGlobalIgnore("BrokenRulesCollection");

I use it like this:

	[Fetch]
        private async Task FetchAsync(int Id, [Inject] IRepository dal,[Inject] IMapper mapper)
        {
            var entity = await dal.FetchAsync(Id);
            mapper.Map(entity , this);
        }

If the entity returns the child object as well I do something like this:

	[Fetch]
        private async Task FetchAsync(int Id, [Inject] IRepository dal,[Inject] IMapper mapper)
        {
            var entity = await dal.FetchAsync(Id);
            mapper.Map(entity, this);
            this.Child =  DataPortal.FetchChild<ChileType>(entity.childEntity);
        }

Otherwise I'll pass whatever parameter is necessary in the child fetch to load itself. I haven't come across an instance yet, where I had to mark a child as dirty as @kcabral817 mentioned.