Algo de fundamentos teóricos

Hola Hugo:

"Hugo Nugra" escribió en el mensaje de
noticias:

Gacias por responder.

Expresado en código C#, este sería el caso:

class MiFormulario : Form
{
MiDataSet miDataSet;
TextBox textBox1;

MiFormulario()
{
MiDataSet miDataSet = new MiDataSet();

BindingSource datosBindingSource = new BindingSource();
datosBindingSource.DataSource = miDataSet;
datosBindingSource.DataMember = "Datos"; // nombre de una tabla
definida en MiDataSet

TextBox textBox1 = new TextBox();
textBox1.Top = 10;
textBox1.Left = 10;
textBox1.DataBindings.Add("Text", miDataSet, "Nombre");

this.Controls.Add(textBox1);
}

public void PresentarDatos(MiDataSet otrosDatos)
{
// En este punto me gustaría saber si puedo hacer
// que todo lo que hacía referencia a miDataSet,
// ahora hiciera referencia a otrosDatos.
}
}

Si te he entendido bien, lo que quieres hacer es algo similar a una pequeña
ñapa que suelo usar yo para cambiar Datatables "visuales" por otros
generados por código.

En tu caso, sería tan simple como cambiar el datasource del bindingsource:

datosBindingSource.DataSource=otrosDatos;
datosBindingSource.DataMember="Datos"; //O lo que sea, pero que conserve la
estructura de columnas del anterior datatable

Aunque así, a bote pronto, lo que no creo que tengas bien es el databinding.
En todo caso, deberías usar el bindingsource en vez del dataset.

Yo lo uso cuando quiero hacer databinding pero lo más visual posible. Me
explico: VS a la hora de asignar los enlaces a controles, sólo permite
datasets fuertemente tipados como los que tú usas, o datasets sin tipar,
pero los que son componentes insertables (dentro de los cuales se definen
los datatables y dentro de ellos su esquema de columnas).
Esto se traduce en que cuando intentamos cambiar las propiedades del
databinding del control visualmente, sí podemos darle la columna a la que
enlazamos de una forma más o menos sencilla. Si en cambio el datatable se
genera por código y su esquema se rellena en el crítico momento que hacemos
un fill o fillschema, no podemos hacer esta asignación visual que es tan
cómoda. Igual cuando queremos diseñar un datagridview de forma rápida. Lo
que yo hago es visualmente asignar esos bindings a un dataset tipado o
insertable, y después del InitializeComponent() cambiar el origen de datos
del datasource por el que he generado dinámicamente. De esta forma "puenteo"
ese dataset que sólo uso para ayudarme a diseñar el formulario. Para mi es
la forma más sencilla de hacerlo visualmente sin tirar líneas y líneas de
código (que obviamente, tirará el diseñador por mi).

Un saludo

El Sat, 25 Oct 2008 21:51:00 -0700, Hugo Nugra escribió:

Te estás haciendo un lío. ObjA contiene una referencia y no hay ninguna
referencia hacia ObjA. Las referencias no apuntan a otras referencias. A no
ser que te pongas a trabajar con punteros de bajo nivel.

Precisamente me refiero a eso al decir "En concepto". si bien nosotros no
trabajamos a bajo nivel, pero C# sí lo hace por nosotros.

Pero C# nunca hace eso.

No se si
técnicamente no estoy utilizando el término apropiado al decir "referencia",
pero quiero hacer alusión a que otros objetos "apuntan" a ObjA para utilizar
sus propiedades y métodos.

La terminología de la POO no es técnicamente apropiada, en especial la
palabra "objeto" que es la confusión de varios conceptos diferentes. Por
eso es tan difícil hablar sobre estas cosas.

ObjA es una variable de tipo referencia y nadie apunta hacia ella. Y por
otra parte los métodos y propiedades (operadores) no son de los "objetos"
(variables o valores o punteros) sino de las clases, que a su vez no son
más que tipos de datos.

Cuando haces:

ObjA = ObjB;

Lo que haces es que la variable de tipo puntero de ObjA apunte a la
variable que está siendo apuntada por la variable de tipo puntero ObjB.


Saludos

Gracias Juan Diego

En la primera pregunta que lancé, indiqué que el problema lo tenía resueldo.
En realidad la solución es la misma que tu planteas.

El caso es que (necio como soy) quería preguntar si existía otra alternativa
con el enfoque que di al inicio.

Para hacerlo un poquito más complicado, en un formulario algo complejo,
pueden existir varios ComboBox, y otros controles que requieren objetos
BindingSource. La solución de cambiar el DataSource de cada BindingSource
resulta más conplicada que:

ObjA = ObjB (si funcionara por supuesto).

Gracias

Gracias Alfredo

Cuando haces:

ObjA = ObjB;

Lo que haces es que la variable de tipo puntero de ObjA apunte a la
variable que está siendo apuntada por la variable de tipo puntero ObjB.

Suena muy fácil. Pero en la realidad, todos los objetos DataBinding que
(discúlame si no uso el término correcto) "apuntaban" a ObjA, dejan de
existir.

Gracias por tu interés

Hola Hugo:


"Hugo Nugra" escribió en el mensaje de
noticias:

Gracias Juan Diego

En la primera pregunta que lancé, indiqué que el problema lo tenía
resueldo.
En realidad la solución es la misma que tu planteas.

El caso es que (necio como soy) quería preguntar si existía otra
alternativa
con el enfoque que di al inicio.

Para hacerlo un poquito más complicado, en un formulario algo complejo,
pueden existir varios ComboBox, y otros controles que requieren objetos
BindingSource. La solución de cambiar el DataSource de cada BindingSource
resulta más conplicada que:

ObjA = ObjB (si funcionara por supuesto).

Perdona entonces porque me perdí en el texto y no vi todo lo que pusiste.

Eso debería funcionar si nos atenemos a la teoría, pero para eso habría que
profundizar más en como funciona el databinding.

Como curiosidad, comentar otro caso que me ocurrió, pero que si que tiene
más sentido que lo que planteas.

Tengo una clase que tiene una propiedad datatable que se llena mediante un
método. El caso es que inicialmente, yo llenaba dicho datatable mediante un
DAL que tengo por ahí. Lo que hacía era cambiar su referencia con la de una
copia del datatable que dicho DAL me devolvía. El caso es que eso da
problemas con el databinding, porque a pesar de que yo desde que construyo
el formulario le digo que el datasource es el de MiObjeto.DataTable (y eso
no cambia en ningún momento) sí que cambia la referencia al datatable dentro
de la clase. Al final lo resolví manteniendo siempre el mismo datatable y
haciendo un merge con el datatable que me devolvía el DAL (espero haberme
explicado bien).

El caso es que, lo primero que uno piensa es que, aunque cambie la
referencia dentro de un objeto, el bindingsource debería enterarse que esta
ha cambiado, pero no lo hace, de forma que ya no enlaza correctamente. Todo
esto dicho desde mis conocimientos justitos de POO y del funcionamiento
interno de .NET. Es probable que lo que haya intentado hacer sea una
barbaridad a esos efectos y de ahí el fallo.

Un saludo