Implicit conversion between types in C#

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 - ProductForExpo开发者_开发百科rt1 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.

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();

I would create light objects specifically for returning through the service with only the required fields. Then use Automapper or something like that to map them.

I don't recommend using operator overloading if you can avoid it. I have seen many issues where a developer didn't realize when the operator overload was being called and something unexpected happened.

If you are using WCF, you can apply the IgnoreDataMemberAttribute to properties you wish not to serialize.

Have a look at the ScriptIgnoreAttribute to exclude properties from json serialization.

It took me a few reads but I don't think your problem is about implicit conversion as much as how to send data via json right?

If you have your object collections of Import or Export object you can use the JavaScriptSerilizer and some anonymous types to slice and dice what data you send.

You can use Linq to select specific properties of your object in a collection, and define an anonymous type "on-the-fly" to serialize out as a json string like this:

List<ProductForExport> exportList; //the list to export
JavaScriptSerializer jss = new JavaScriptSerializer();
string output = string.Empty;

output = jss.Serialize(new
    {
        isExportable = True,                //static named properties
        iTotalProducts = exportList.Count,  //dynamic values
        productDataArray = exportList       //all data in an array object
    });

//Or build the result using just a few properties of the collection:

foreach (ExportProduct exProd in exportList)
{
    output += jss.Serialize(new
    {
        exProd.IsExportable,
        exProd.ExportID
    });
}