¿Cómo realizar múltiples hallazgos () con $ slice?

Question

Tengo el requisito de sacar muchas partes de $ porción de muchos documentos.

En este momento, no puedo ver cómo hacerlo, por lo que tengo un bucle paralelo que me presenta estos datos, sin embargo, ahora quiero recuperar más de 1000 nodos a la vez, y esto no se está desempeñando, especialmente como El controlador de MongoDB C Sharp no admite las consultas de Async.

Esta es la estructura (ejemplo pero similar):

{ Transacciones: Bindata, Salidas: [{DATA: Bindata}, {DATOS: Bindata}] }

Mi código en este momento se obtiene cada uno individualmente, de la siguiente manera:

var outputs = new SpendableOutput[inputArray.Length];

Parallel.ForEach(inputArray, (input, s, i) =>
{
    var transactionQuery = Transactions.Find(Query<TransactionInfo>.EQ(x => x.Hash, input.PrevTxHash))
                                .SetFields(new FieldsBuilder().Slice("o", (int)input.PrevTxOutputIndex, 1)
                                                                .Include("_id"));
    var transaction = transactionQuery.ToArray();
    if (transaction.Length != 0)
    {
        outputs[i] = new SpendableOutput
        {
            TxHash = inputArray[i].PrevTxHash,
            Index = (int)inputArray[i].PrevTxOutputIndex,
            Output = transaction[0].Outputs[0]
        };
    }
});

Como puede ver, estoy consultando la colección de transacciones, "O", el campo, que es una variedad de salidas. De esto quiero una serie de salidas. Me doy cuenta de que podría pedir todas las transacciones basadas en el estado _ID en mi lista, y obtener las salidas después de que se hayan recuperado, pero muchas transacciones tienen listas de salida muy grandes de las que solo necesito generalmente uno o dos elementos.

La primera forma de mejorar esto es obtener muchas rebanadas de un documento, como esto (no funciona).

var transactionQuery = Transactions.Find(Query<TransactionInfo>.EQ(x => x.Hash, input.PrevTxHash))
                            .SetFields(new FieldsBuilder().Slice("o", itemNeededIndex1, 1)
                                                          .Slice("o", itemNeededIndex2, 1)
                                                          .Slice("o", itemNeededIndex3, 1).Include("_id"));

En segundo lugar (debe preferirse) es para mí enviar un lote de objetos de consulta <>, ya que tengo muchos objetos de transacción (más de 1000 generalmente) (con salidas asociadas para recuperar).

¿Hay algún experto en consultas de MongoDB que pueda sugerir un enfoque para lograrlos, o sugerir un enfoque alternativo en el que no he pensado?

Editar:

La fuente del IDENTE PADRE y el índice infantil es una entrada externa que está definiendo qué elementos podrían requerirse para borrar un saldo en particular. Tienen la identificación del padre y el índice del niño solamente. Esto consiste en una matriz de una matriz de bytes (ID de padre / hash) e INT (índice infantil).

Answer 1

He determinado que no hay forma de lograr esto, en lugar de eso, debe haber muchas consultas inventadas y disparadas en Mongodb.

Además, debido a que las matrices son grandes, vale la pena normalizar estos datos en una nueva colección, sin embargo, eso le duele el tamaño de los datos.