Question

I’m working on a problem that’s making my brain melt although I don’t think it should be this hard. My example is long so I’ll try to keep my question short!

I have an Array object that contains some elements that are also Arrays. For example:

customerAddresses = new customer_address[]
{
  new    // address #1
  {
    customer_id = 6676979,
    customer_address_seq = 1,
    customer_address_match_codes = new []
    {
      new
      {
        customer_address_seq = 1,
        customer_id = 6676979,
        customer_match_code_id = 5
      }
    }
  },
  new    // address #2
  {
    customer_id = 6677070,
    customer_address_seq = 1,
    customer_address_match_codes = new []
    {
      new
      {
        customer_address_seq = 1,
        customer_id = 6677070,
        customer_match_code_id = 4
      },
      new
      {
        customer_address_seq = 1,
        customer_id = 6677070,
        customer_match_code_id = 5
      },
      new
      {
        customer_address_seq = 1,
        customer_id = 6677070,
        customer_match_code_id = 3
      }
    }
  },
  new    // address #3
  {
    customer_id = 6677070,
    customer_address_seq = 2,
    customer_address_match_code = new []
    {
      new
      {
        customer_address_seq = 2,
        customer_id = 6677070,
        customer_match_code_id = 4
      },
      new
      {
        customer_address_seq = 2,
        customer_id = 6677070,
        customer_match_code_id = 5
      }
    }
  }
};

As you can see, the Array contains a number of address records, with one record per combination of customer_id and customer_address_seq. What I’m trying to do is find the best matching customer_address according to the following rules:

• There must be customer_match_code_id equal to 4 and there must be one equal to 5
• If there is a customer_match_code_id equal to 3, then consider that customer_address a stronger match.

According to the above rules, the 2nd customer_address element is the “best match”. However, the last bit of complexity in this problem is that there could be multiple “best matches”. How I need to handle that situation is by taking the customer_address record with the minimum customer_id and minimum customer_address_seq.

I was thinking that using LINQ would be my best bet, but I’m not experienced enough with it, so I just keep spinning my wheels.

Answer 1

Had to make a change to your class so that you are actually assigning your one collection to something:

customer_address_match_codes = new customer_address_match_code[]
{
  new
  {
    customer_address_seq = 1,
    customer_id = 6676979,
    customer_match_code_id = 5
  }
}

And then here is the LINQ that I’ve tested and does what you specify:

var result = (from c in customerAddresses
    let isMatch = c.customer_address_match_codes
                     .Where (cu => cu.customer_match_code_id == 4).Any () &&
                  c.customer_address_match_codes
                     .Where (cu => cu.customer_match_code_id == 5).Any ()
    let betterMatch = isMatch && c.customer_address_match_codes
                  .Where (cu => cu.customer_match_code_id == 3).Any () ? 1 : 0
    where isMatch == true
    orderby betterMatch descending, c.customer_id, c.customer_address_seq
    select c)
    .FirstOrDefault ();

I’ve worked up an example using your data with anonymous types here: http://ideone.com/wyteM