Question

I have the following business objects:

    public abstract class Product
    {
        public int Id { get; set; }
        public bool OnStock { get; set; }
    }

    public class ProductForImport : Product
    {
        public int ImportId { get; set; }
    }

    public class ProductForExport : Product
    {
        public int ExportId { get; set; }
        public bool IsExportable { get; set; }
        public bool IsUsable { get; set; }
        public string OtherParam {get; set;}

        public static implicit operator ProductForExport(ProductForImport pfi)
        {
            ProductForExport p = new ProductForExport();
            p.Id = pfi.Id;
            p.IsExportable = true;
            p.ExportId = 0;
            return p;
        }
    }

so I can convert between the two types:

    static void Main(string[] args)
    {
        ProductForExport pfe = new ProductForExport();
        pfe.Id = 1;
        pfe.OnStock = true;

        ProductForImport pfi = new ProductForImport();
        pfi.ImportId = 200;

        ProductForExport pfe2 = (ProductForExport)pfi;
    }

this works OK.

I have 100.000 ProductsForImport items.
If I understand correctly, if I convert them to ProductsForExport items, I’ll have 100.000 +100.000 items in memory – that’s reasonable.

My problem is: I have to send these “ProductForExport” objects through JSON services, each service just need some subset of the properties of each type:

servicecall1 should return ProductForExport1{ExportId,IsExportable}

servicecall2 should return ProductForExport2{ExportId,IsUsable}

Question: should I write an implicit conversion similar to the above example for these new types – ProductForExport1 and ProductForExport2 (so basically create 100.000+100.000 new objects)

or

somehow can I just “hide” the unwanted properties with some magic from the original type without the need to create new instances?

thanks,

b.

Answer 1

If you ned such kind of decoupling and separation of entities – you can create DTO object along with each business object and use DTO to communicate with Service.
But if you have a lot of business entities consider an other approach to avoid maintenance hell.

public sealed class ExportProductDto
{
   public(ProductForExport exportProduct)
   {
       // initialize fields
       this.ExportId = exportProduct.ExportId;
   } 

   public int ExportId { get; private set; }
}

BTW,
An overkill solution with operator overload, use Adapter pattern to convert between product types

To decouple adapting from entities itself implement following interface your self:

public interface IProductAdapter<TImport, TExport>
{
    TImport ToImportProduct(TExport exportProduct);
    TExport ToExportProduct(TImport importProduct);
}

Or an other adapter approach:

// Implement this interface for ProductForImport class
// public class ProductForImport : IExportProductAdapter, Product
public interface IExportProductAdapter
{
    ProductForExport ToExportProduct();
}

// Implement this interface for ProductForExport class
// public class ProductForExport : IImportProductAdapter, Product
public interface IImportProductAdapter
{
    ProductForImport ToImportProduct();
}

EDIT: Answer to comments

// An example of IExportProductAdapter adapter implementation
public sealed class ProductForImport : Product, IExportProductAdapter
{
     public int ImportId { get; set; }

     public ProductForExport ToExportProduct()
     {
        ProductForExport p = new ProductForExport();
        p.Id = this.Id;
        p.IsExportable = true;
        p.ExportId = 0;
        return p;
     }
}

And then instead of:

 ProductForExport pfe2 = (ProductForExport)pfi;

You can do:

 ProductForExport pfe2 = pfi.ToExportProduct();