## Is there a good LINQ way to do a cartesian product?

I have a class structure like so:

``````Person
Dogs (dog 1, dog 2, etc)
Puppies (puppy A, puppy B, etc)
``````

There is one person. He has 1..n dogs. Each dog has 1..n puppies.

I want a list of all the possible combination of puppies, taking 1 puppy from each dog. Eg:

dog 1 puppy A, dog 2 puppy A dog 1 puppy A, dog 2 puppy B dog 1 puppy B, dog 2 puppy A dog 1 puppy B, dog 2 puppy B

If it was in sql tables, i'd do something like the following to 'multiply' the tables:

``````select * from puppies a, puppies b where a.parent='dog1' and b.parent='dog2'
``````

Is there some linq-ish way to do this kinda thing???

Thanks so much

If I understand the question, you want the Cartesian Product of n sets of puppies.

It is easy to get the Cartesian Product if you know at compile time how many sets there are:

``````from p1 in dog1.Puppies
from p2 in dog2.Puppies
from p3 in dog3.Puppies
select new {p1, p2, p3};
``````

Suppose dog1 has puppies p11, p12, dog2 has puppy p21, and dog3 has puppies p31, p32. This gives you

``````{p11, p21, p31},
{p11, p21, p32},
{p12, p21, p31},
{p12, p21, p32}
``````

Where each row is an anonymous type. If you do not know at compile time how many sets there are, you can do that with slightly more work. See my article on the subject:

http://blogs.msdn.com/b/ericlippert/archive/2010/06/28/computing-a-cartesian-product-with-linq.aspx

and this StackOverflow question:

http://stackoverflow.com/questions/3093622

Once you have the method `CartesianProduct<T>` then you can say

``````CartesianProduct(from dog in person.Dogs select dog.Puppies)
``````

to get

``````{p11, p21, p31},
{p11, p21, p32},
{p12, p21, p31},
{p12, p21, p32}
``````

Where each row is a sequence of puppies.

Make sense?

## Is it smart to output data from embedded device in xml format?

Our company makes many embedded devices that communicate with PC's via applications that I write in C#.net. I have been considering different ways of improving the data transfer so that the PC application can be more easily synchronized with the devices current state (which in some cases is continually changing).

I have been thinking about an approach where the device formats it's description and state messages into an xml formatted message before sending them across either the serial port, USB, Ethernet Socket, etc. I was thinking that it may make the process of getting all of this data into my C# classes more simple.

The alternative is an approach where the host application sends a command like GETSTATUS and the device responds with an array of bytes, each representing a different property, sensor reading, etc.

I don't have a great deal of experience with xml but from what I have seen can be done with LINQ to XML it seems like it might be a good idea. What do you guys think? Is this something that is done commonly? Is it a horrible idea?!?

First, which ever way you go, make sure the returned data has a version number embedded so that you can revise the data structure.

Is both an option? Seriously, there are always situations where sending data in a more readable form are preferable, and others where a more dense representation is best (these are fewer than most people think, but I don't want to start a religious war about it). People will passionately argue for both, because they are optimizing for different things. Providing both options would satisfy both camps.

A nice, clear XML status could definitely lower the bar for people who are starting to work with your devices. You could also build a C# object that can be deserialized from the binary data that is returned.