[ Foro de C# ]

ayuda con propiedades automaticas

09-Apr-2015 20:46
Invitado (Fernando)
7 Respuestas

no puedo recuperar el valor almacenado en esta propiedad, lo que me manda es esto

"System.Collections.Generic.List`1[Default2+Bloque]"

en lugar de eso deberia de mostrarme el numero "1" pero no es asi
que tendria que hacer para que me muestre lo que quiero?
   class Bloque
   {
       public int tamaño  { get ;set; }
       }
       protected void Page_Load(object sender, EventArgs e)
       {
           var lista = new List<Bloque>();
           Bloque b = new Bloque();
           b.tamaño = 1;
           lista.Add(b);
           Response.Write(lista);
         
         


10-Apr-2015 09:55
Nacho Cabanes (+31)

Claro.  No puedes mostrar toda una lista en pantalla. Tendrás que recorrer sus elementos uno a uno (con "for" o "foreach", por ejemplo), para mostrarlos uno a uno (para eso, necesitarás que cada elemento tenga definido un "ToString").

Aparte de eso, en tu programa veo otra cosa peligrosa: dentro de un método de la clase Bloque estás creando un objeto de la clase Bloque (realmente una lista de Bloques)... eso puede dar lugar a recursividad indirecta y bloquear el programa o hacerlo fallar.


10-Apr-2015 20:35
Invitado (Fernando)

hola, pude sacarlo pero no estoy seguro si esto me sirva para lo que quiero
es la misma temática de un tema que hice referente a lo mismo que intento hacer
hay datos almacenados mayores a cero e iguales a cero
y lo que quiero es almacenar en bloques los valores almacenados mayores a cero y los iguales para hacer un estilo de barra de progreso donde mostrare en rojo los que están en cero y en verde los que son mayores,
y estoy utilizando un while para esto :
mientras el valor que se esta leyendo sea mayor a cero que almacene +1 que significa que un intervalo sera en verde y no se si pueda hacer otro while donde haga lo mismo pero en ceros
la idea es que estos bloques representen lo que quiero lograr a hacer ya tengo mas de 3 semanas estudiando, leyendo y encontré esta manera lo cual lo veo mas viable para poder dar fin a mi proyecto
dejo el codigo en donde no logré hacer lo que quiero

MIENTRAS  "n" sea menor a 50 hará lo que viene dentro de la instruccion y fuera muestra las acumulaciones

public class Bloque
   {
       public int Medida { get; set; }
   }
   protected void Page_Load(object sender, EventArgs e)
   {
       var Lista = new List<Bloque>();
       int n = 1;
       while (n < 50)
       {
           n++;
           Bloque bloque = new Bloque();
           bloque.Medida = n;
           Lista.Add(bloque);
       }
   //    Image1.Width = Lista.Count;
       Response.Write(Lista.Count);
         
   }



solo que al integrarlo a mi proyecto no me funciona marca un error en "Lista.add(bloque);
 while (cliente.Intervalos > 0) intervalos es el campo en una tabla donde se almacenan los valores a evaluar mientras ellos sean mayores a cero harán lo que se le pide

var Lista = new List<Bloque>();
           int n = 1;
           foreach (var cliente in Factory.Clientes.GetDetalles(IdCliente, Mes))
           {
               while (cliente.Intervalos > 0)
               {
                   n++;
                   Bloque bloque = new Bloque();
                   bloque.Medida = n;
                   Lista.Add(bloque);
               }
           }
           Image1.Width = Lista.Count;
           Response.Write(Lista.Count);


12-Apr-2015 17:28
Nacho Cabanes (+31)

La línea del Add no debería dar error, la sintaxis parece correcta.

Lo que no entiendo es la lógica que le rodea: eso de que un bloque contenga una lista de bloques, no eso de añadir exactamente 50 elementos y aun así hacer un contador y usar eso para saber la anchura de la imagen (que siempre será 50)


13-Apr-2015 08:34
Invitado (Fernando)

hola lo que intento hacer es que cada bloque se almacene una cantidad de numeros enteros lo cual seran los pixeles de la barra, y lo que intento hacer es que cada numero mayor a cero valga un +1 y se sume a un bloque e cuando valga 0 se sume a otro bloque cada bloque representara un valor que hara que la barra se llene y cuando el valor sea mayor a cero se marcara en verde y cuando sea igual a cero se marcara en rojo

aqui dejo el codigo e avanzado poco, los valores de la tabla los estoy representando como si fuera una matriz en este ejemplo: aqui se ve que hay almacenados varios en cero y mayores a cero lo cual lo que deceo hacer es que cuando el valor sea igual a cero se haga otro bloque en donde se almacene un +1 en ese bloque mientras dure los numeros en cero y asi continuaria el ciclo dejo la matriz
  int[] numbers = { 4, 5, 6, 6,0,0,0,1,0,2,0,2 };
entonces asi seria como al inicio hay 4 numeros mayores a cero seria +1 en cada uno lo que daria 4 y los otros que estan en cero serian 3 y asi sucecibamente entonces quedaria algo como esto: 4,(3),1,(1),1,(1),1.

los que estan entre parentecis representarian los valores menores a cero lo que equivaldria a el numero de pixeles que abarcaran en la barra que quiero hacer y en representacion grafica seria
4 verdes,(3rojos),1verde,(1rojo),1verde,(1rojo),1verde y lo que continue
dejo lo que llevo no se si voy por buen camino o de plano no...
y dejo un enlace de una imagen de como quiero representarlo dejare el enlace al final


public class Bloque
        {
            public int Medida { get; set; }
            public int Medida2 { get; set; }
        }
   
       private void ejemplo (int IdCliente,int Mes)
       {
var Lista = new List<Bloque>();
           var Lista2 = new List<Bloque>();

       
           int[] numbers = { 4, 5, 6, 6,0,0,0,1,0,2,0,2 };
           int n = 0;
           int m = 0;
           foreach (int i in numbers)
           {
               if(i>0){
                   n++;
                   Bloque Tamaño = new Bloque();
                   Tamaño.Medida = n;
                   Lista.Add( new Bloque());
           }
               else
               {
                   m++;
                   Bloque Tamaño2 = new Bloque();
                   Tamaño2.Medida2 = m;
                   Lista2.Add(Tamaño2);
               }

           }





https://fbcdn-sphotos-e-a.akamaihd.net/hphotos-ak-xfa1/v/t1.0-9/11070961_1093378520688652_6232044927797627459_n.jpg?oh=0e7ab66d82d06f77a2989a6be0fba032&oe=55ACE57F&__gda__=1441066228_90677fde6c7d5d940babd326b60ac89b


17-Apr-2015 18:01
Nacho Cabanes (+31)

Vale, creo que ahora entiendo a lo que te refieres.

Se trata de ver el tamaño de secuencias. Cuando haya varios números positivos seguidos, eso es una secuencia, y quieres ver cuántos números la forman. Cuando encuentras un cero, pasa a ser una nueva secuencia, de la que también querrás ver cuántos números la forman (la cantidad de ceros que hay seguidos), y así sucesivamente.

¿Es así?


17-Apr-2015 18:39
Invitado (Fernando)

es correcto, es lo que intento hacer


19-Apr-2015 20:56
Nacho Cabanes (+31)

En ese caso, vamos a simplificar el problema primero.

Vamos a olvidar por un momento tu clase "Bloque" y vamos a centrarnos en crear un programa que te muestre cuantos positivos y cuantos ceros va encontrando, para que veas cómo podría ser la lógica de un contador doble si tienes dos estados posible.

Podría ser así:

 
using System;
 
public class ContarPositivosYCeros
{
    public static void Main()
    {
        int[] numbers = { 4, 5, 6, 6, 0, 0, 0, 1, 0, 2, 3, 0, 2 }; 
 
        bool enCeros = false;
        bool enPositivos = false;
        int contadorPositivos = 0;
        int contadorCeros = 0;
 
        // Miramos el primer valor
        if (numbers[0] > 0)
            enPositivos = true;
        else
            enCeros = false;
 
        // Y recorremos todos ellos
        foreach (int n in numbers)
        {
            // Si estamos con positivos y llega otro, contamos
            if (enPositivos && (n > 0))
            {
                contadorPositivos ++;
            }
            // Lo mismo si estamos con ceros y llega otro cero
            else if (enCeros && (n == 0))
            {
                contadorCeros++;
            }
            // Si cambia de positivos a cero, mostramos y cambiamos estado
            else if (enPositivos && (n == 0))
            {
                Console.WriteLine("P"+contadorPositivos+" ");
                enPositivos = false;
                enCeros = true;
                contadorPositivos = 0;
                contadorCeros = 1;
            }
            // Y similar si cambia de ceros a positivos
            else if (enCeros && (n > 0))
            {
                Console.WriteLine("C"+contadorCeros+" ");
                enPositivos = true;
                enCeros = false;
                contadorCeros = 0;
                contadorPositivos = 1;
            }
        }
        // Finalmente, faltará mostrar el último bloque
        if (contadorCeros > 0)
            Console.WriteLine("C"+contadorCeros+" ");
        else
            Console.WriteLine("P"+contadorPositivos+" ");
    }
}
 


Se podría simplificar un poco, usando un único booleano (porque son excluyentes: o estás recorriendo un bloque de positivos o uno de ceros), pero esto debería ayudarte a entender una lógica que luego adaptar a tu programa concreto.






(No se puede continuar esta discusión porque tiene más de dos meses de antigüedad. Si tienes dudas parecidas, abre un nuevo hilo.)