¿Ha cambiado el comportamiento de los threads en W2003?

Adolfo,

No tengo un W2K3 a mano para probar, pero te recomendaría crear un método
"intermedio" (que no fuera ni siquiera virtual):

public abstract class AbstractThreadClass
{
private Thread thread;
private void EntryPoint() {
ThreadControl(); // llama al método virtual redefinido
}
public AbstractThreadClass() {
this.thread = new Thread(
new ThreadStart(this.EntryPoint));
}
public abstract void ThreadControl(); // a redefinir
public void StartThread() {
this.thread.Start();
}
}

Slds - Octavio

"Adolfo López" escribió en el mensaje
news:cfbe01c4398f$f3a61170$
Hola,
¿conoceis si se ha producido algún cambio significativo en
el Framework o en el Windows 2003 con respecto al Windows
2000 para que cambie radicalmente el comportamiento de los
threads o de la tabla virtual de metodos o como se llame?

Me explico con la siguiente clase, fuente de mis problemas:

public abstract class AbstractThreadClass
{
private Thread thread;
public AbstractThreadClass()
{
this.thread = new Thread(new ThreadStart
(this.ThreadControl));
}

public abstract void ThreadControl();

public void StartThread(){
this.MsgInfo(String.Format("Estado del thread antes del
start: {0}",
this.thread.ThreadState.ToString() ) );
this.thread.Start();
Thread.Sleep(2000);
this.MsgInfo(String.Format("Estado del thread despues del
start: {0}",
this.thread.ThreadState.ToString() ) );
}
}

Este extracto de clase "delapraderar", pretende encapsular
todo el tema de manejo de threads, asi que es abstracta
por lo que las clases que deriven de ella deberán
implementar el método ThreadControl (la "chicha" del
thread ).
Bueno el caso es que el tema funciona muy bien en un
w2000 con Framework 1.1.4322, pero no en un w2003 con la
misma versión del Framework.
Como podeis ver le he metido un par de trazas para ver el
estado del thread antes y despues de arrancarlo.
Sorprendentemente despues de 2 segundos de arrancar el
thread, no lanza ninguna excepción y el estado es stopped.
Ya se que estais pensando, pero no, os aseguro que el
método que implementa la clase que deriva de ella no acaba
ni en 2 ni en un billon de segundos ya que tiene un bucle
infinito dentro de un "try catch" monitorizado donde va
leyendo registros de una bd.

Tengo la sospecha de que hacer un new ThreadStart con un
método abstracto no le gusta mucho al W2003.
Os imaginais, sería cojonudo, W2003 sería el primer
sistema capaz de ejecutar métodos virtuales puros que no
hacen nada; hum, no ... no creo que sea eso, se
me "caerian los palos del sombrajo".

Queria de todas formas, antes de desmontar todo
el "tinglao", comentar el problema en el foro por si
alguien ha tenido problemas con los threads o los metodos
abstractos en el W2003.

Un saludo,
Adolfo

Octavio,
he probado tu sugerencia la clase y el resultado es el
mismo al ya comentado.
Tambien he podido comprobar que cambiando el metodo de
abstract a virtual y añadiendo un poco de codigo de traza
como el siguiente, el resultado sigue siendo que no
ejecuta el metodo virtual:

private void EntryPoint()
{
this.MsgWarning("Este msg si sale" );
this.ThreadControl();
}

public virtual void ThreadControl()
{
this.MsgWarning("Este msg no sale pero sería peor que
saliera" );

}

Realmente hay algún tipo de problema relacionado con los
threads y con la tabla virtual de metodos, que no sabría
explicar mejor.

Gracias por tu ayuda
Un saludo
Adolfo

Adolfo,

No tengo un W2K3 a mano para probar, pero te recomendaría

crear un método

"intermedio" (que no fuera ni siquiera virtual):

public abstract class AbstractThreadClass
{
private Thread thread;
private void EntryPoint() {
ThreadControl(); // llama al método virtual redefinido
}
public AbstractThreadClass() {
this.thread = new Thread(
new ThreadStart(this.EntryPoint));
}
public abstract void ThreadControl(); // a redefinir
public void StartThread() {
this.thread.Start();
}
}

Slds - Octavio

"Adolfo López" escribió en el

mensaje

news:cfbe01c4398f$f3a61170$
Hola,
¿conoceis si se ha producido algún cambio significativo en
el Framework o en el Windows 2003 con respecto al Windows
2000 para que cambie radicalmente el comportamiento de los
threads o de la tabla virtual de metodos o como se llame?

Me explico con la siguiente clase, fuente de mis

problemas:

public abstract class AbstractThreadClass
{
private Thread thread;
public AbstractThreadClass()
{
this.thread = new Thread(new ThreadStart
(this.ThreadControl));
}

public abstract void ThreadControl();

public void StartThread(){
this.MsgInfo(String.Format("Estado del thread antes del
start: {0}",
this.thread.ThreadState.ToString() ) );
this.thread.Start();
Thread.Sleep(2000);
this.MsgInfo(String.Format("Estado del thread despues del
start: {0}",
this.thread.ThreadState.ToString() ) );
}
}

Este extracto de clase "delapraderar", pretende encapsular
todo el tema de manejo de threads, asi que es abstracta
por lo que las clases que deriven de ella deberán
implementar el método ThreadControl (la "chicha" del
thread ).
Bueno el caso es que el tema funciona muy bien en un
w2000 con Framework 1.1.4322, pero no en un w2003 con la
misma versión del Framework.
Como podeis ver le he metido un par de trazas para ver el
estado del thread antes y despues de arrancarlo.
Sorprendentemente despues de 2 segundos de arrancar el
thread, no lanza ninguna excepción y el estado es stopped.
Ya se que estais pensando, pero no, os aseguro que el
método que implementa la clase que deriva de ella no acaba
ni en 2 ni en un billon de segundos ya que tiene un bucle
infinito dentro de un "try catch" monitorizado donde va
leyendo registros de una bd.

Tengo la sospecha de que hacer un new ThreadStart con un
método abstracto no le gusta mucho al W2003.
Os imaginais, sería cojonudo, W2003 sería el primer
sistema capaz de ejecutar métodos virtuales puros que no
hacen nada; hum, no ... no creo que sea eso, se
me "caerian los palos del sombrajo".

Queria de todas formas, antes de desmontar todo
el "tinglao", comentar el problema en el foro por si
alguien ha tenido problemas con los threads o los metodos
abstractos en el W2003.

Un saludo,
Adolfo


.

Adolfo,

Trataré de instalar un W2K3 para ver qué tal. No veo por qué eso no
funciona... Tu idea desde luego creo que es excelente.

Slds - Octavio

"Adolfo López" escribió en el mensaje
news:de4a01c43be1$cc56d6a0$
Octavio,
he probado tu sugerencia la clase y el resultado es el
mismo al ya comentado.
Tambien he podido comprobar que cambiando el metodo de
abstract a virtual y añadiendo un poco de codigo de traza
como el siguiente, el resultado sigue siendo que no
ejecuta el metodo virtual:

private void EntryPoint()
{
this.MsgWarning("Este msg si sale" );
this.ThreadControl();
}

public virtual void ThreadControl()
{
this.MsgWarning("Este msg no sale pero sería peor que
saliera" );

}

Realmente hay algún tipo de problema relacionado con los
threads y con la tabla virtual de metodos, que no sabría
explicar mejor.

Gracias por tu ayuda
Un saludo
Adolfo

Adolfo,

No tengo un W2K3 a mano para probar, pero te recomendaría

crear un método

"intermedio" (que no fuera ni siquiera virtual):

public abstract class AbstractThreadClass
{
private Thread thread;
private void EntryPoint() {
ThreadControl(); // llama al método virtual redefinido
}
public AbstractThreadClass() {
this.thread = new Thread(
new ThreadStart(this.EntryPoint));
}
public abstract void ThreadControl(); // a redefinir
public void StartThread() {
this.thread.Start();
}
}

Slds - Octavio

"Adolfo López" escribió en el

mensaje

news:cfbe01c4398f$f3a61170$
Hola,
¿conoceis si se ha producido algún cambio significativo en
el Framework o en el Windows 2003 con respecto al Windows
2000 para que cambie radicalmente el comportamiento de los
threads o de la tabla virtual de metodos o como se llame?

Me explico con la siguiente clase, fuente de mis

problemas:

public abstract class AbstractThreadClass
{
private Thread thread;
public AbstractThreadClass()
{
this.thread = new Thread(new ThreadStart
(this.ThreadControl));
}

public abstract void ThreadControl();

public void StartThread(){
this.MsgInfo(String.Format("Estado del thread antes del
start: {0}",
this.thread.ThreadState.ToString() ) );
this.thread.Start();
Thread.Sleep(2000);
this.MsgInfo(String.Format("Estado del thread despues del
start: {0}",
this.thread.ThreadState.ToString() ) );
}
}

Este extracto de clase "delapraderar", pretende encapsular
todo el tema de manejo de threads, asi que es abstracta
por lo que las clases que deriven de ella deberán
implementar el método ThreadControl (la "chicha" del
thread ).
Bueno el caso es que el tema funciona muy bien en un
w2000 con Framework 1.1.4322, pero no en un w2003 con la
misma versión del Framework.
Como podeis ver le he metido un par de trazas para ver el
estado del thread antes y despues de arrancarlo.
Sorprendentemente despues de 2 segundos de arrancar el
thread, no lanza ninguna excepción y el estado es stopped.
Ya se que estais pensando, pero no, os aseguro que el
método que implementa la clase que deriva de ella no acaba
ni en 2 ni en un billon de segundos ya que tiene un bucle
infinito dentro de un "try catch" monitorizado donde va
leyendo registros de una bd.

Tengo la sospecha de que hacer un new ThreadStart con un
método abstracto no le gusta mucho al W2003.
Os imaginais, sería cojonudo, W2003 sería el primer
sistema capaz de ejecutar métodos virtuales puros que no
hacen nada; hum, no ... no creo que sea eso, se
me "caerian los palos del sombrajo".

Queria de todas formas, antes de desmontar todo
el "tinglao", comentar el problema en el foro por si
alguien ha tenido problemas con los threads o los metodos
abstractos en el W2003.

Un saludo,
Adolfo


.

Octavio,
No te instales un W2K3 sólo por probar éste tema.
He dado con el problema, y no está precisamente en la
tabla virtual de metodos, sino en las excepciones que
debería haber atrapado y "loggeado" el método que
sobreescribia al abstracto en la clase derivada.

El método en cuestión es algo asi, y el problema era una
mala instalación (o configuración) de un producto de un
tercero; no se encontraban los ensamblados de dicho
producto.

public class EncoladorClass : AbstractThreadClass
{
override public void ThreadControl()
{
this.MsgInfo("Started");
DataBaseClass dataBase = null;
LicenseChecker license = null;
try
{
license = new LicenseChecker();
if( !license.IsLicensed )
{
this.MsgError( "No hay licencias disponibles" );
this.parar();
return;
}

dataBase = new DataBaseClass();
while( true ){
// operaciones varias
}
}
catch(Exception e )
{
this.MsgError(e.GetType().ToString() +": " + e.Message );
this.MsgError( e.StackTrace );
}
finally
{
if( license != null )
license.Dispose();
if( dataBase != null )
dataBase.Dispose();
this.parar();
}
}
}

Un saludo, y gracias por tu ayuda.

Adolfo

Adolfo,

Trataré de instalar un W2K3 para ver qué tal. No veo por

qué eso no

funciona... Tu idea desde luego creo que es excelente.

Slds - Octavio

"Adolfo López" escribió en el

mensaje

news:de4a01c43be1$cc56d6a0$
Octavio,
he probado tu sugerencia la clase y el resultado es el
mismo al ya comentado.
Tambien he podido comprobar que cambiando el metodo de
abstract a virtual y añadiendo un poco de codigo de traza
como el siguiente, el resultado sigue siendo que no
ejecuta el metodo virtual:

private void EntryPoint()
{
this.MsgWarning("Este msg si sale" );
this.ThreadControl();
}

public virtual void ThreadControl()
{
this.MsgWarning("Este msg no sale pero sería peor que
saliera" );

}

Realmente hay algún tipo de problema relacionado con los
threads y con la tabla virtual de metodos, que no sabría
explicar mejor.

Gracias por tu ayuda
Un saludo
Adolfo

Adolfo,

No tengo un W2K3 a mano para probar, pero te recomendaría

crear un método

"intermedio" (que no fuera ni siquiera virtual):

public abstract class AbstractThreadClass
{
private Thread thread;
private void EntryPoint() {
ThreadControl(); // llama al método virtual

redefinido

}
public AbstractThreadClass() {
this.thread = new Thread(
new ThreadStart(this.EntryPoint));
}
public abstract void ThreadControl(); // a redefinir
public void StartThread() {
this.thread.Start();
}
}

Slds - Octavio

"Adolfo López" escribió en el

mensaje

news:cfbe01c4398f$f3a61170$
Hola,
¿conoceis si se ha producido algún cambio significativo

en

el Framework o en el Windows 2003 con respecto al Windows
2000 para que cambie radicalmente el comportamiento de

los

threads o de la tabla virtual de metodos o como se llame?

Me explico con la siguiente clase, fuente de mis

problemas:

public abstract class AbstractThreadClass
{
private Thread thread;
public AbstractThreadClass()
{
this.thread = new Thread(new ThreadStart
(this.ThreadControl));
}

public abstract void ThreadControl();

public void StartThread(){
this.MsgInfo(String.Format("Estado del thread antes del
start: {0}",
this.thread.ThreadState.ToString() ) );
this.thread.Start();
Thread.Sleep(2000);
this.MsgInfo(String.Format("Estado del thread despues del
start: {0}",
this.thread.ThreadState.ToString() ) );
}
}

Este extracto de clase "delapraderar", pretende

encapsular

todo el tema de manejo de threads, asi que es abstracta
por lo que las clases que deriven de ella deberán
implementar el método ThreadControl (la "chicha" del
thread ).
Bueno el caso es que el tema funciona muy bien en un
w2000 con Framework 1.1.4322, pero no en un w2003 con la
misma versión del Framework.
Como podeis ver le he metido un par de trazas para ver el
estado del thread antes y despues de arrancarlo.
Sorprendentemente despues de 2 segundos de arrancar el
thread, no lanza ninguna excepción y el estado es

stopped.

Ya se que estais pensando, pero no, os aseguro que el
método que implementa la clase que deriva de ella no

acaba

ni en 2 ni en un billon de segundos ya que tiene un bucle
infinito dentro de un "try catch" monitorizado donde va
leyendo registros de una bd.

Tengo la sospecha de que hacer un new ThreadStart con un
método abstracto no le gusta mucho al W2003.
Os imaginais, sería cojonudo, W2003 sería el primer
sistema capaz de ejecutar métodos virtuales puros que no
hacen nada; hum, no ... no creo que sea eso, se
me "caerian los palos del sombrajo".

Queria de todas formas, antes de desmontar todo
el "tinglao", comentar el problema en el foro por si
alguien ha tenido problemas con los threads o los metodos
abstractos en el W2003.

Un saludo,
Adolfo


.

.