What is the best way to keep track of relational lists of objects

Question

Hypothetical example: I have a list of customers and a list of products in memory. I want to be able to access the products that each customer has bought as well as the customers who bought a specific product:

class Customer
{
    public List<Product> Products { get; set; }
}
class Product
{
    public List<Customer> CustomersWhoBoughtThis { get; set; }
}


var customers = new List<Customer>();
var products = new List<Product>();

//add the customers
var customer1 = new Customer();
customers.Add(customer1);
var customer2 = new Customer();
customers.Add(customer2);

//add the products
var product1 = new Product();
products.Add(product1);
var product2 = new Product();
products.Add(product2);

//add a purchased product for customer1
customer1.Products.Add(product1);

//How do I get customer1 from product1?
foreach (var customerWhoBoughtProduct1 in product1.CustomersWhoBoughtThis)
{
    //do something
}

I could just manually add the customer to the product's CustomersWhoBoughtThis list, but I feel like this is prone to errors since you may forget to do it somewhere.

Is there a better implementation to this? Maybe some sort of wrapper class that handles the functionality, but I'm not sure how it would be implemented. Any advice?

Thanks

Answer 1

You can define some wrapper class, or implement your own IList interface, then you can implement your own event supporting notification. However it's much simpler to use built-in stuff. I would use a BindingList<T>, it has an event called ListChanged which allows you to get some notifications including item added notification. Try the following code:

class Customer {
  public Customer(){
    Products = new BindingList<Product>();
    Products.ListChanged += (s,e) => {
       if(e.ListChangedType == ListChangedType.ItemAdded){
         Products[e.NewIndex].CustomersWhoBoughtThis.Add(this);
       }
    };
  }
  public BindingList<Product> Products { get; set; }
}

Answer 2

Usually when I have a circular relationship, I designate one of the entities as the "owner" of the relationship. The owner is responsible for managing the relationship, so any code for that management, should be encapsulated within it.

In this case, since the customer actually does the action (A Customer buys a Product), it's best if the Customer class is the relationship owner.

So, the Product class will be:

public class Product
{
  //other product properties

  //field for the customers list
  private List<Customer> customers = new List<Customer>();

  //read-only property for outside access
  public IEnumerable<Customer> Customers 
  {
    get { return customers; }
  }

  //internal method that will only be called by the customer class
  internal void AddCustomer(Customer customer)
  {
    customers.Add(customer);
  }

  //internal method that will only be called by the customer class
  internal void RemoveCustomer(Customer customer)
  {
    customers.Remove(customer);
  }
}

and the Customer will be:

public class Customer
{
  //other customer properties

  //field for the product list
  private List<Product> products = new List<Product>();

  //read-only property for outside access
  public IEnumerable<Product> Products
  {
    get { return products; }
  }

  //public method, open to the world
  public void BuyProduct(Product product)
  {
    products.Add(product);
    product.AddCustomer(this);
  }

  //public method, open to the world
  public void RemoveProduct(Product product)
  {
    products.Remove(product);
    product.RemoveCustomer(this);
  }        
}

Now you just do:

customer1.BuyProduct(product1);

and the references are set correctly. Additionally, an outside user (from another assembly) will be unable to call product1.AddCustomer.

Also, it always important to note that serialization (to XML or to JSON) of circular references is a bitch, as the customer has a product that has a customer that has a product that has a stack overflow exception.

Answer 3

Create a method that will do both operations

void PairCustomerWithProduct(Customer customer, Product product)
{
    customer.Products.Add(product);
    product.CustomersWhoBoughtThis.Add(customer);
}

And whenever you need to pair a product with a customer, call this method.

Answer 4

I will not expose List<T> as public, Instead return a array or sequence. Expose methods to add/remove product that's it.

class Customer
{
    private List<Product> Products { get; set; }
    public void AddProduct(Product product)
    {
       Products.Add(product);
       if(!product.CustomersWhoBoughtThis.Contains(this))
           product.CustomersWhoBoughtThis.Add(this);
    }

    public void RemoveProduct(Product product)
    {
       Products.Remove(product);
       if(product.CustomersWhoBoughtThis.Contains(this))
           product.CustomersWhoBoughtThis.Remove(this);
    }

    public IEnumerable<Product> GetProducts()
    {
       return Products;
    }
}

Answer 5

You can try this way,

Class Customer{listCustomer>} 

- Holds Customer Info Class Product {list} - Holds Product Info

Add one more class to maintain the combination

Class Sale{ public Customer, public Product }

One more class to have the list of SoldProducts

Class SoldProduct{ list<Sale> }

Answer 6

Do a relationship class.

Note: I haven't included error handling, just the basic idea. Note also that the Relationship class (for a one to many relationship) can easily be made generic and be reused for any kind of relationship. I left it concrete to make it more clear.

class Customer
{
  public List<Products> Products 
  { 
     get { return CustomerProductRelationship.CustomerProducts[this];}
     set 
     {
        CustomerProductRelationship.AddPair(value, this);
     }
}

class Product
{
  public List<Products> Products 
  { 
     get { return CustomerProductRelationship.ProductCustomers[this];}
     set 
     {
        CustomerProductRelationship.AddPair(this, value);
     }
  }
}

static class CustomerProductRelationship
{
  public static Dictionary<Customer, List<Product>> CustomerProducts;
  public static Dictionary<Product, List<Customer> ProductCustomers;

  public static AddPair(Product product, Customer customer)
  {
       if (!CustomerProducts.Contains(customer))
          CustomerProducts.Add(customer, new List<Product>);

       CustomerProducts[customer].Add(product);

       if (!ProductCustomers.Contains(product))
          ProductCustomers.Add(product, new List<Customers>);

       CustomerProducts[product].Add(customer);
   }
}