es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

El comando “yield return” guarda el siguiente estado del iterador.

Mientras se convierte la lista en lotes, yield return salta el objeto que ha sido verificado en la condición if pero no ha sido agregado al cubo debido a las restricciones de tamaño.

Recuento total de mensajes: 4
Recuento del primer cubo: 2
Recuento del segundo cubo: 1
Se está omitiendo el tercer mensaje de la lista de mensajes.
Aquí estoy creando cubos de tamaño 250kb. ¿Hay alguna otra forma de guardar el estado correcto o debo utilizar un bucle for?

public static IEnumerable<>> ObtenerTamanoLote(IList source)
{
List cubo = null;
long tamaño = 0;
foreach (var elemento in source)
{
if (cubo == null)
{
cubo = new List();
}
tamaño = tamaño + elemento.Tamaño;

    if (250 - (tamaño / 1024) >= elemento.Tamaño / 1024)
    {
        cubo.Add(elemento);
        continue;
    }

    yield return cubo;
    cubo = new List<mensaje>();
    tamaño = 0;
}

if (cubo?.Count > 0 && tamaño<250)
{
    yield return cubo;
}

}

Tags:  , , , ,

Answer

  1. Avatar for davy.ai

    Para guardar el estado correcto, puedes modificar el método GetBatchSize para incluir un parámetro adicional que haga un seguimiento del índice del último elemento agregado al cubo. Luego, en cada iteración, puedes verificar si el elemento actual ya ha sido agregado al cubo comparando su índice con el último índice. Si ha sido agregado, puedes omitirlo y pasar al siguiente elemento. Aquí tienes un ejemplo de cómo podrías modificar el método:

    public static IEnumerable<><mensaje>> GetBatchSize(IList<mensaje> source)
    {
        List<mensaje> cubo = null;
        long tamaño = 0;
        int últimoÍndice = -1; // inicializar en -1 para indicar que aún no se ha agregado ningún elemento
        for (int i = 0; i < source.Count; i++)
        {
            var elemento = source[i];
    
            if (i <= últimoÍndice) // omitir elementos que ya han sido agregados
            {
                continue;
            }
    
            if (cubo == null)
            {
                cubo = new List<mensaje>();
            }
            tamaño += elemento.Tamaño;
            if (250 - (tamaño / 1024) >= elemento.Tamaño / 1024)
            {
                cubo.Add(elemento);
                últimoÍndice = i; // actualizar el último índice al índice actual del elemento
                continue;
            }
            yield return cubo;
            cubo = new List<mensaje>();
            tamaño = 0;
            i--; // volver a procesar el elemento actual en la próxima iteración
        }
    
        if (cubo?.Count > 0 && tamaño < 250)
        {
            yield return cubo;
        }
    }
    

    Ten en cuenta que también debemos decrementar i al final del bucle interno cuando encontramos un elemento que no puede ser agregado al cubo, para que volvamos a procesar ese elemento en la próxima iteración con un cubo nuevo.

    Alternativamente, podrías usar un bucle for en lugar de un bucle foreach, e incrementar y decrementar manualmente el contador del bucle según sea necesario, pero esto puede hacer que el código sea más difícil de leer y mantener.

Comments are closed.