Updating array, trouble with index

Question

I have a trouble with my code, using mongodb c# driver. This trouble looks like the one described here : http://www.ciiycode.com/0iiBNWWexjex/how-to-update-items-in-an-arraylist-with-mongo-c-driver.html which seems to have been solved.

I want to update a bi-dimensionnal array in my document. If I use

myarray[0,3] 

it works, however if I use variable like

int a = 0;
int b = 3;
myarray[a,b]

it gives me a "Unable to determine the serialization information for the expression ..." error

Full code :

int a = 0;
int b = 3;    
var update = Builders<sensorValuesDocument>.Update                  
                    .Set(e => e.values[a][b]
                    , new sensorValues()
                    {
                        v = 0,
                        t = 0,
                        h = 0,
                        c = 0,
                        l = 0
                    }) ...

and my document class :

public class sensorValuesDocument
    {
        ...
        public List<List<sensorValues>> values { get; set; }
        ...
    }

 public class sensorValues
    {
        [BsonRepresentation(BsonType.Double, AllowTruncation = true)]
        public float? t { get; set; }
        [BsonRepresentation(BsonType.Double, AllowTruncation = true)]
        public float? v { get; set; }
        [BsonRepresentation(BsonType.Double, AllowTruncation = true)]
        public float? h { get; set; }
        [BsonRepresentation(BsonType.Double, AllowTruncation = true)]
        public float? l { get; set; }
        [BsonRepresentation(BsonType.Double, AllowTruncation = true)]
        public float? c { get; set; }
    }

If I replace the previous code with .Set(e => e.values[0][3] It works just fine. Any idea/workaround please ? Thanks in advance

Julien

Answer 1

I guess it's some issue with MongoDB C# driver where it can't translate the whole .Set(...) expression tree when array access' indexes are variables.

Fortunately, C# is a very very powerful language and it supports expression trees which let you programatically-create expressions like a data structure.

At the end of the day, you need an expression like this: listOfLists => listOfLists [0][3] using integer literals, right?

See the following code:

int a = 0;
int b = 3;

// This is the input parameter for the expression (i.e. the (doc) => part of the expression)
ParameterExpression valuesDocumentParameter = Expression.Parameter(typeof(sensorValuesDocument));
// This is the "values" property access. Now we would have the following expression:
// (doc) => doc.values
MemberExpression listOfListPropertyAccess = Expression.Property(valuesDocumentParameter, "values");

// This is accessing the parent list: (doc) => doc.values[0]
IndexExpression parentListIndexerAccess = Expression.Property
(
    listOfListPropertyAccess, 
    "Item", 
    new Expression[] { Expression.Constant(a) }
);

// This is accessing the nested list: (doc) => doc.values[0][3]
IndexExpression nestedListIndexerAccess = Expression.Property
(
    parentListIndexerAccess, 
    "Item", 
    new Expression[] { Expression.Constant(b) }
);

// This builds the full expression tree!
Expression<Func<sensorValuesDocument, sensorValues>> setExpr =
    Expression.Lambda<Func<sensorValuesDocument, sensorValues>>
    (
        nestedListIndexerAccess,
        valuesDocumentParameter
    );

Now you can give setExpr to Update.Set(...): Update.Set(setExpr).

I believe that this should do the trick and workaround the MongoDB driver's issue, since you're giving what it really expects: an array access using literals instead of variables.