MongoDB Linq OfType（）在字段上

Question

This is my MongoDB document structure:

{
    string _id;
    ObservableCollection<DataElement> PartData;
    ObservableCollection<DataElement> SensorData;
    ... 
    other ObservableCollection<DataElement> fields
    ...
    other types and fields
    ...
}

Is there any possibility to retrieve a concatenation of fields with the type ObservableCollection<DataElement> ? Using LINQ I would do something like

var query = dbCollection
  .AsQueryable()
  .Select(x => new { 
     data = x
       .OfType(typeof(ObservableCollection<DataElement>))
       .SelectMany(x => x)
       .ToList()
   });

or alternatively

data = x.Where(y => typeof(y) == typeof(ObservableCollection<DataElement>)
.SelectMany(x => x).ToList()

Unfortunately .Where() and .OfType() do not work on documents, only on queryables/lists, so is there another possibility to achieve this? The document structure must stay the same.

Edit: After dnickless answer I tried it with method 1b), which works pretty well for getting the fields thy way they are in the collection. Thank you!

Unfortunately it wasn't precisely what I was looking for, as I wanted to be all those fields with that specific type put together in one List, at it would be returned by the OfType or Where(typeof) statement.

eg data = [x.PartData , x.SensorData, ...] with data being an ObsverableCollection<DataElement>[] , so that I can use SelectMany() on that to finally get the concatenation of all sequences.

Sorry for asking the question unprecisely and not including the last step of doing a SelectMany()/Concat()

Finally I found a solution doing this, but it doesn't seem very elegant to me, as it needs one concat() for every element (and I have more of them) and it needs to make a new collection when finding a non-existing field:

query.Select(x => new
          {
            part = x.PartData ?? new ObservableCollection<DataElement>(),
            sensor = x.SensorData ?? new ObservableCollection<DataElement>(),
          }
      )
      .Select(x => new
          {
             dataElements = x.part.Concat(x.sensor)                                 
           }
      ).ToList()

Answer 1

In order to limit the fields returned you would need to use the MongoDB Projection feature in one way or the other.

There's a few alternatives depending on your specific requirements that I can think of:

Option 1a (fairly static approach): Create a custom type with only the fields that you are interested in if you know them upfront. Something like this:

public class OnlyWhatWeAreInterestedIn
{
    public ObservableCollection<DataElement> PartData { get; set; }
    public ObservableCollection<DataElement> SensorData { get; set; }
    // ...
}

Then you can query your Collection like that:

var collection = new MongoClient().GetDatabase("test").GetCollection<OnlyWhatWeAreInterestedIn>("test");
var result = collection.Find(FilterDefinition<OnlyWhatWeAreInterestedIn>.Empty);

Using this approach you get a nicely typed result back without the need for custom projections.

Option 1b (still pretty static): A minor variation of Option 1a, just without a new explicit type but a projection stage instead to limit the returned fields. Kind of like that:

var collection = new MongoClient().GetDatabase("test").GetCollection<Test>("test");
var result = collection.Find(FilterDefinition<Test>.Empty).Project(t => new { t.PartData, t.SensorData }).ToList();

Again, you get a nicely typed C# entity back that you can continue to operate on.

Option 2: Use some dark reflection magic in order to dynamically create a projection stage. Downside: You won't get a typed instance reflecting your properties but instead a BsonDocument so you will have to deal with that afterwards. Also, if you have any custom MongoDB mappings in place, you would need to add some code to deal with them.

Here's the full example code:

First, your entities:

public class Test
{
    string _id;
    public ObservableCollection<DataElement> PartData { get; set; }
    public ObservableCollection<DataElement> SensorData { get; set; }
    // just to have one additional property that will not be part of the returned document
    public string TestString { get; set; }
}

public class DataElement
{
}

And then the test program:

public class Program
{
    static void Main(string[] args)
    {
        var collection = new MongoClient().GetDatabase("test").GetCollection<Test>("test");

        // insert test record
        collection.InsertOne(
            new Test
            {
                PartData = new ObservableCollection<DataElement>(
                    new ObservableCollection<DataElement>
                    {
                        new DataElement(),
                        new DataElement()
                    }),
                SensorData = new ObservableCollection<DataElement>(
                    new ObservableCollection<DataElement>
                    {
                        new DataElement(),
                        new DataElement()
                    }),
                TestString = "SomeString"
            });

        // here, we use reflection to find the relevant properties
        var allPropertiesThatWeAreLookingFor = typeof(Test).GetProperties().Where(p => typeof(ObservableCollection<DataElement>).IsAssignableFrom(p.PropertyType));

        // create a string of all properties that we are interested in with a ":1" appended so MongoDB will return these fields only
        // in our example, this will look like
        // "PartData:1,SensorData:1"
        var mongoDbProjection = string.Join(",", allPropertiesThatWeAreLookingFor.Select(p => $"{p.Name}:1"));

        // we do not want MongoDB to return the _id field because it's not of the selected type but would be returned by default otherwise
        mongoDbProjection += ",_id:0";

        var result = collection.Find(FilterDefinition<Test>.Empty).Project($"{{{mongoDbProjection}}}").ToList();

        Console.ReadLine();
    }
}