Variables de clase

las variables de clase , como su nombre lo dice son de la clase y no de la
instancia

su modificador en c# es "static"

para tu problema yo le pasaria como parametro el nombre del formulario como
string y crearia una instancia de esa clase utilizando reflection

saludos
daniel #

"Anticristo" wrote in message
news:bue7kd$gkpih$
Mostrar la cita

Quiero llamar a un metodo pasandole como parametro un descendiente de un
objeto para que ese metodo me cree el objeto del tipo que yo le paso como
parametro. En Object-Pascal a esto se le llama variable de clase. ¿Cómo se
hace esto en C#?

Ejemplo: Tengo varias clases descendientes de frmMDI y quiero crear desde
form1 esas ventanas mediante el siguiente código:

public virtual void form1.CrearMDI(frmMDI afrm)
{
new afrm();
afrm.MdiParent=this;
}


Espero que se haya entendio,
muchas gracias a todos :-))


Saludos

Las variables de clase, como su nombre indica, son variables que contienen
una clase y no una instancia, comunmente conocida como objeto.
En Object Pascal se declaran como type variabledeclase=class of TLoqueSea y
yo lo que quiero saber es como se puede, si es posible hacerlo, declarar
esto en C#.



Saludos

"Daniel Sharp" escribió en el mensaje
news:
Mostrar la cita

las variables de clase , como su nombre lo dice son de la clase y no de la
instancia

su modificador en c# es "static"

para tu problema yo le pasaria como parametro el nombre del formulario

como
Mostrar la cita

string y crearia una instancia de esa clase utilizando reflection

saludos
daniel #

"Anticristo" wrote in message
news:bue7kd$gkpih$
> Quiero llamar a un metodo pasandole como parametro un descendiente de un
> objeto para que ese metodo me cree el objeto del tipo que yo le paso

como
Mostrar la cita

> parametro. En Object-Pascal a esto se le llama variable de clase. ¿Cómo

se
Mostrar la cita

> hace esto en C#?
>
> Ejemplo: Tengo varias clases descendientes de frmMDI y quiero crear

desde
Mostrar la cita

> form1 esas ventanas mediante el siguiente código:
>
> public virtual void form1.CrearMDI(frmMDI afrm)
> {
> new afrm();
> afrm.MdiParent=this;
> }
>
>
> Espero que se haya entendio,
> muchas gracias a todos :-))
>
>
> Saludos
>
>

En C# no existe algo equivalente. Creo que la forma más conveniente y limpia
de resolverlo es usando el patron de Factory y que tu métodog en la clase
Form1 lo mande llamar para separar esa lógica de la forma.

Ejemplos de este patrón en C# los puedes encontrar en el sitio de
www.dofactory.com


Alberto Borbolla
Microsoft MVP
WebLog:
http://www.coatl.com


"Anticristo" wrote in message
news:bue7kd$gkpih$
Mostrar la cita

Quiero llamar a un metodo pasandole como parametro un descendiente de un
objeto para que ese metodo me cree el objeto del tipo que yo le paso como
parametro. En Object-Pascal a esto se le llama variable de clase. ¿Cómo se
hace esto en C#?

Ejemplo: Tengo varias clases descendientes de frmMDI y quiero crear desde
form1 esas ventanas mediante el siguiente código:

public virtual void form1.CrearMDI(frmMDI afrm)
{
new afrm();
afrm.MdiParent=this;
}


Espero que se haya entendio,
muchas gracias a todos :-))


Saludos

Hola...

Pienso que estás un poco confundido aún con los
conceptos, es posible que te sirva la respuesta que
publiqué para otra persona que preguntó que diferencia
existe entre this y Form1. Y si el confundido soy yo y lo
que deseas es crear instancias de objetos por medio del
nombre de la clase u otra característica que estará
disponible solo en tiempo de ejecución, lo que debes usar
es Reflection que es un tema más extenso pero disponible
(al menos lo básico) en la propia documentación del SDK.
Un buen punto para empezar sería examinar el namespace
System.Reflection, la clase Type (información de tipos),
la clase Assembly (carga de ensamblados y obtención de
tipos (objetos Type) contenidos en un ensamblado). Estas
clases proporcionan toda esta información en tiempo de
ejecución.

Como sea aqui va el texto:

La diferencia entre this y Form1 es que this es una
referencia a la instancia actual de la clase Form1 y
Form1 es solo una clase. Digamos que la clase es un molde
del que se obtendrán una o mas copias (instancias) que
tendrán disponible una serie de métodos y propiedades,
por lo tanto, la lista de miembros que ves al
escribir 'this.' son miembros de instancia, es decir,
existe una copia de cada miembro para cada instancia de
la clase; mientras que los que ves al escribir 'Form1.'
son miembros de clase o estáticos, es decir, existe una
sola copia de cada miembro de forma única y global, algo
parecido a funciones y variables globales. Aqui va un
ejemplo, por si te enredé un poco:

class Class1
{
public static string DatabasePath=@"C:\MyDatabase.mdb";
public string FirstName;
public string LastName;

// Constructor de la clase
public Class1()
{
// Lo siguiente hace referencia a instancia actual
// e inicializa la variables de instancia
this.FirstName = "Nombre";
this.LastName = "Apellido";
// Por lo tanto cualquier instancia que se obtenga
// de Class1 tendra sus miembros FirstName y LastName
// inicializados con los mismos valores, ya que este
// código se ejecutará para cada instancia y 'this'
// será una referencia a la instancia correspondiente
}
}

class Class2
{
public static void Main(string[] args)
{
Class1 c1 = new Class1();
Class2 c2 = new Class1();

//Lo siguiente es valido
//porque FirstName es una variable de instancia
c1.FirstName = "Un nombre";

// Lo siguiente no afecta el contenido de c1.FirstName
c2.FirstName = "Otro nombre";
// porque c2 es otra copia distinta de la clase Class1

// Por lo tanto lo siguiente NO es válido
Class1.LastName = "Un apellido";
// porque existe una copia de LastName para cada
// instancia de Class1

// Mientras que si lo es
string dbPath = Class1.DatabasePath;
// porque DatabasePath es una variable estática
// es decir, existe de forma única y global y se
// accede a ella mediante Class1.DatabasePath
}
}

Lo anterior se aplica a cualquier tipo de miembro
(métodos, propiedades, variables, etc.).

Espero que ayude...

Saludos...

Mostrar la cita

Las variables de clase, como su nombre indica, son

variables que contienen
Mostrar la cita

una clase y no una instancia, comunmente conocida como

objeto.
Mostrar la cita

En Object Pascal se declaran como type

variabledeclase=class of TLoqueSea y
Mostrar la cita

yo lo que quiero saber es como se puede, si es posible

hacerlo, declarar
Mostrar la cita

esto en C#.



Saludos

"Daniel Sharp" escribió en el mensaje
news:
Mostrar la cita

las variables de clase , como su nombre lo dice son de

la clase y no de la
Mostrar la cita

Mostrar la cita

instancia

su modificador en c# es "static"

para tu problema yo le pasaria como parametro el

nombre del formulario
Mostrar la cita

como
Mostrar la cita

string y crearia una instancia de esa clase utilizando

reflection
Mostrar la cita

Mostrar la cita

saludos
daniel #

"Anticristo" wrote in message
news:bue7kd$gkpih$
> Quiero llamar a un metodo pasandole como parametro

un descendiente de un
Mostrar la cita

Mostrar la cita

> objeto para que ese metodo me cree el objeto del

tipo que yo le paso
Mostrar la cita

como
Mostrar la cita

> parametro. En Object-Pascal a esto se le llama

variable de clase. ¿Cómo
Mostrar la cita

se
Mostrar la cita

> hace esto en C#?
>
> Ejemplo: Tengo varias clases descendientes de frmMDI

y quiero crear
Mostrar la cita

desde
Mostrar la cita

> form1 esas ventanas mediante el siguiente código:
>
> public virtual void form1.CrearMDI(frmMDI afrm)
> {
> new afrm();
> afrm.MdiParent=this;
> }
>
>
> Espero que se haya entendio,
> muchas gracias a todos :-))
>
>
> Saludos
>
>

.

No estoy seguro de haberte entendido bien, pero si es
así, creo que la solución es reflection.

En c# existe un tipo "clase" que es System.Type. Puedes
crear una instancia de dicho tipo mediante reflection:

public Form CrearForm(Type tipoForm)
{
return (Form) Activator.CreateInstance(tipoForm);
}


Form f = CrearForm(typeof(Form2));
f.Show();


Aunque tiene razón Daniel, al decir que en terminología
c#, y en general OOP, las variables de clase son las
variables comunes a todas las instancias de la clase
(static), como oposición a las variables de instancia.