DataGridView en un control de usuario

"José TH" MUCHAS GRACIAS POR TU ALTERNATIVA

Lo mismo que me has comentado tu me lo indicó un compañero del trabajo
que controla bastante del .NET... osea que tendré realmente en cuenta
vuestras soluciones.

Aun así hay algo en esa alternativa que no me termina de convencer:
La parte que intentamos solucionar por un lado (usar el diseñador -
el CollectionEditor- por defecto que sirva para añadir columnas)... la
complicamos por otro (añadir los controles que deseemos
programáticamente... evitando "verlos" en tiempo de diseño). Si a eso
le sumamos que, con la solución que propuse, sólo un elemento que se
modifica programáticamente (y al que no habrá que hacerle en principio
muchos cambios en diseño una vez realizados una sola vez) y que el
resto es mas "diseñable"... por ahora me quedaré con mi solución.

Además, tengo la idea de que la parte de diseño de los user control
sean definidas por personal especializado en diseño y usabildiad
(seasé ... diseñadores)... que después le pasarán esos diseños a
programadores que encapsulan una funcionalidad mínima (exposición de
propiedades, eventos internos, etc)... y que después ofrecerán los
UC's resultantes a los programadores que ensablarán dichos controles
en una o varias ventanas que las utilicen de forma mas
"específica" (para filtrar tantas tablas como se quieran y en tantas
ocasiones como se quieran).

Un saludo... y, repito, muchas gracias por la alternativa :-).

On 25 ene, 14:22, "Jose TH" <>>> wrote:

Si es para lo que me imagino,  otra opción que tienes es no usar un
UserControl sino simplemente heredar directamente de DataGridView y que sea
el propio DataGridView, en su constructor, que cree automáticamente los
demás controles fijos, es decir su label, su textbox y su button.  Creo que
debe ser más simple así.
Así podrás editar directamente las columnas del dgv en el designer.

Jose TH

"pvergara" escribió en el mensajenews:
Aquí hay dos posibilidades por las cuales no responde nadie:
  Una porque es demasiado trivial que pensáis que es fácil encontrarlo
en internet
  Porque es demasiado complejo que no muchos saben como hacerlo.

Sinceramente me gustaría pensar que es la primera opción... pero por
desgracia de los muchos años que llevo en la informática he aprendido
a buscar realmente bien y me he dado cuenta el problema que planteo
simple... lo que se dice simple no es... por lo tanto creo que me
tengo que decantar por la segunda opción... y empezar a plantearme que
en el foro... se responden temas muy triviales... pero si nos vamos a
lo complejo quizás no haya tanta suerte, una pena.

Aun así os(ME) responderé yo mismo al problema planteado con una
posible solución... que no es la ideal, pero si la mejor que se me
ocurrió... y si le apetece a alguien... que indique si a él se le
ocurrió otra... o si hay mejoras por encima de la mía:

  a) Crear el UserControl y añadir los controles que se deseen (en mi
caso eran un label, un textbox, un button, y un datagridview)... Y UN
COMPONENTE BindingSource... que se enlaza automáticamente en el
constructor del UC con el DataSource del DataGridView.
  b) Exponer (hacer publicos o protegidos o progegidos internal...
según el caso) las propiedades y los eventos que se deseen entre otros
(y aquí viene lo importante):
  * BindingSource (Lectura/Escritura -get y set-)
  * DataGridViewColumnCollection (Solo lectura...aunque ésto no nos
impedirá añadir columnas... al fin y al cabo devolvemos una
referencia :-) )
  c) Dado que hemos perdido la capacidad de trabajar con el diseñador
directamente (una put...que parece ser que tiene que ver con la forma
en la que se desarrolló el CollectionEditor de la adición de las
columnas)... creamos un método privado al que, por ejemplo, llamaremos
"InitializeComponentNoDesign" con las siguientes características:
    c.1) Se invocará en el constructor justo después del
"InitializeComponent"
    c.2) Se utilizará para crear los datagridviewcolumn de los tipos
que se deseen, añadirlos a la grid mediante el uso del método AddRange
de la propiedad "colums" expuesta por el UC y formatearlos como se
deseen (lo mismo que haría el diseñador... pero "a mano").
  d) En el constructor, justo después de la invocación del método
recién creado, podemos asignar el bindingsource a un datasource que,
por supuesto, cuente, como mínimo, con las mismas propiedades
indicadas en las columnas.

Estoy abierto a sugerencias.

On 23 ene, 07:39, pvergara wrote:

> Hola a todos/as.

> ¿Cómo solucionáis vosotros el tema de usar datagridview en un
> usercontrol?... ahora voy y me explico:

> Con la filosofía de "reaprovechamiento" del diseño, creo un
> UserControl para facilitar la tarea añadir filtros simples a mis
> proyectos... por lo tanto, añado un label, un textbox y un botón a la
> zona superior, y a la inferior un datagridview...exponiendo mediante
> propiedades públicas el "Columns" del datagridview... bueno, cual es
> mi sorpresa que cuando voy a utilizar la propiedad columns de mi UC me
> encuentro que el CollectionEditor que utiliza por defecto un
> datagridview enlazado a un bindingsource... no lo puedo utilizar... y
> es ahí donde surge mi duda...¿existe alguna forma de poder utilizarlo?
> o ¿el uso de un datagridview dentro de un usercontrol... ayuda por un
> lado... pero entorpece por otro? (porque claro... a ver cómo vendo yo
> la ventaja de usar un UC... con el inconveniente de tener que añadir
> los colums uno a uno por código).

> Un saludo.

Aun así hay algo en esa alternativa que no me termina de convencer:
La parte que intentamos solucionar por un lado (usar el diseñador -
el CollectionEditor- por defecto que sirva para añadir columnas)... la
complicamos por otro (añadir los controles que deseemos
programáticamente... evitando "verlos" en tiempo de diseño).
Si a eso
le sumamos que, con la solución que propuse, sólo un elemento que se
modifica programáticamente (y al que no habrá que hacerle en principio
muchos cambios en diseño una vez realizados una sola vez) y que el
resto es mas "diseñable"... por ahora me quedaré con mi solución.

Sí, puede ser, pero ese solo elemento que modificas programaticalmente (el
datagridview) envuelve columnas que pueden ser muy variables en cada
instancia de tu UC. Sólo pensar en los anchos de columnas, tipos de
columnas, ordenamiento, etc. Realmente se limita bastante el diseño
gráfico teniéndolo dentro del UC.
Eso no pasa con el resto de los controles (textbox, button, label) que por
su naturaleza serán más fijos. Con lo que yo te propongo, es asunto de
simplemente encapsular en la propia clase heredada de datagridview todo el
código y propiedades para crear, posicionar y manejar los otros controles
relacionados. Incluso, ese comportamiento podría ser opcional (una
extensión) a tu clase de dgv.
Conceptualmente es lo mismo y te da la ventaja de usar el designer visual
para configurar las columnas del grid, y poder reutilizar más fácilmente esa
clase de dgv.