Recorrer Métodos

[mvazquez]

Hola estimados colegas y amigos…
Tengo una Interface iBase que tiene métodos, llamémoslos onExit, onNew, onNext, etc., etc. entonces cuando genero una pantalla pues heredo a esa interface e implemento sus métodos pero puede darse el caso que no todas las pantallas utilicen todos los métodos.

También tengo una pantalla que contiene todas las pantallas de la aplicaciones y desde ahí yo le doy permiso a los usuarios para que les aparezcan o no los botones del menú, digamos, para que les aparezcan los botones que ejecutan el método onExit, onNew o según sea el caso, pero como yo administrador no tengo manera de saber cuáles métodos se usaron entonces pues pueda darle permiso a TODO pero no todos los métodos se usan en todas las pantallas.

Entonces lo que quiero hacer es lo siguiente; tengo estos métodos;

Código:

public void onExit()
{
this.Close();
}

public void onNew()
{
throw new NotImplementedException();
}

public void onNext()
{
throw new NotImplementedException();
}

Como se darán cuenta solo estoy usando onExit, entonces yo quiero que recorrer todos eso métodos y saber cuales se usan en esa pantalla y cuáles no y una vez que yo sepa cuales se usan hacer algunas otras cosas.

En resumen, como puedo recorrer los métodos de una pantalla y determinar quienes dentro de su estructura tienen o no esta línea.

Código:

throw new NotImplementedException();

Espero haberme dado a entender y encontrar sigerencias.
Gracias.

[Peterpay]

el problema es que para buenas practicas una interfaz debe implementar todos los metodos, si tienes excepciones de estos metodos entonces no debe ser implementada la interfaz deberias usar entonces

eventos dentro de tu interfaz
http://msdn.microsoft.com/en-us/libr...(v=vs.80).aspx

[_Ruben_]

Yo estoy completamente de acuerdo con Peterpay, pero si quieres una solución a tu problema implementa en la interfaz métodos que devuelva un boleano indicando si el método esta implementado o no. Pero es mejor hacer las cosas bien.

[Peterpay]

inclusive un manejo parcial de implementaciones te llevaria a usar clases abstractas y no interfaces. pero depende mucho del contexto de tu modelado orientado a objetos

[bieres]

Hola, no entiendo bien lo que pides, pero a lo mejor te sirve esto.

Código:

using System.Reflection;

/// <summary>
        /// Para saber los Campos, metodos, propiedades y eventos de una clase
        /// </summary>
        /// <param name="t">Type</param>
        /// <param name="tipo">[Campos], [Metodos], [Propiedades], [Eventos]</param>
        /// <returns>string[]</returns>
        static internal string[] InfoTipo(Type t, string tipo)
        {
            string[] salida = new string[0];
            int n = 1;
            BindingFlags flags = BindingFlags.Instance
                | BindingFlags.Public
                | BindingFlags.DeclaredOnly
                | BindingFlags.Static;
            switch (tipo)
            {
                case "Campos":
                    {
                        FieldInfo[] cs = t.GetFields(flags);
                        foreach (FieldInfo m in cs)
                        {
                            Array.Resize(ref salida, n);
                            salida[n - 1] = m.Name;
                            n += 1;
                        }
                        break;
                    }
                case "Metodos":
                    {
                        MethodInfo[] mi = t.GetMethods(flags);
                        foreach (MethodInfo m in mi)
                        {
                            if (m.IsSpecialName == false)
                            {
                                Array.Resize(ref salida, n);
                                salida[n - 1] = m.Name;
                                n += 1;
                            }
                        }
                        break;
                    }
                case "Propiedades":
                    {
                        PropertyInfo[] pr = t.GetProperties(flags);
                        foreach (PropertyInfo m in pr)
                        {
                            Array.Resize(ref salida, n);
                            salida[n - 1] = m.Name;
                            n += 1;
                        }
                        break;
                    }
                case "Eventos":
                    {
                        EventInfo[] evs = t.GetEvents(flags);
                        foreach (EventInfo m in evs)
                        {
                            Array.Resize(ref salida, n);
                            salida[n - 1] = m.Name;
                            n += 1;
                        }
                        break;
                    }
            }
            return salida;
        }

[Peterpay]

bietes tecnicamente como lo propones es factible

pero si algo nos ha demostrado el trabajo del dia a dia es que para problemas simples soluciones simples, si la solucion es mas complicada que el problema hay que replantear el problema.

es solo una opinion y claro usar reflection le puede dar exactamente lo que quiere pero quiza no es lo que necesita

[mvazquez]

Hola, estoy totalmente de acuerdo con Peter...
Tengo un MDI con botones, entonces para que esos botones puedan interactuar con los formularios cree la interface para que los formularios la hereden e implementen los métodos pero no siempre se usan todos pero independientemente pues se tienen que implementar.

Asi es como tengo declarados mis metodos en mi Interface:

Código:

void onPrint();

void onSave();

void onDelete();

void onRefresh();

Asi es como los uso desde mi Menu (MDI), segun la pantalla hijo que este activa

Código:

((IBase)this.ActiveMdiChild).onPrint();

((IBase)this.ActiveMdiChild).onSave();

((IBase)this.ActiveMdiChild).onDelete();

Así heredo en mis pantallas a mi Interface

Código:

 public partial class frmNiveles : Form, IBase

Así se implementan en mis pantallas

Código:

        public void onRefresh()
        {
            throw new NotImplementedException();
        }

        public void onDelete()
        {
            throw new NotImplementedException();
        }

        public void onSave()
        {
            int m = -1;
            try
            {
            }
            catch (Exception ex)
            { }                    
        }

Si se fijan de lo que se implemento solo utilizo la de onSave, eso es lo que quiero saber pero dinamicamente.

En un inicio cree una clase Abtsractra con algunos métodos Virtuales pero me daba mucho lío cuando quería ver el diseño de mis pantallas y pues opte por la interface.

Yo lo que quiero saber es......... de todos los métodos de la Interface cuales son los que se están utilizando....

estaba pensando que en cada pantalla crear variables publicas según la cantidad de métodos y luego cuando yo abra mi pantalla de permisos yo leo pantalla por pantalla, leo esas variables y según el valor que tenga pues pongo habilitado o des habilitado el check de permisos.

Espero darme a antender

[Peterpay]

yo tambien he tenido ese problema de la clase abstracta al momento de ver el diseniador

pero eso lo puede solucionar siguiendo este tutorial

http://www.codeproject.com/KB/dotnet...ctclasses.aspx

[mvazquez]

Si, lo intente y no me funciono, ya no puedo regresar, ya libere aplicaciones con la Interfase

Ahora necesito lo que abajo comento.... seguiré buscándole

[Peterpay]

pues como te mostraron el ejemplo de reflection con el Type.GetMethods puedes sacar los metodos e intentar ejecutarlos si no tienen implementacion pues puedes capturarlos y ya.

y usar un set de bloques try catch para manejar los que no esten implementados porque al ser metodos no tienes otra opcion, si fueran eventos otro gallo cantaria.

[bieres]

Hola, la verdad es que no me he enterado aun lo que quieres hacer, pero por lo que deduzco, una opcion es usar Reflection, que sea peor el remedio que la enfermedad, ese no es mi problema, yo solo lo expongo, por si lo quieres usar.

[Peterpay]

bieres no es el punto , tu aporte se agradece pero la situacion de que ya estaba en ambiente productivo gira a ese lado, digo no sabiamos que ya estaba liberado, que si no implementar la clase abstracta pudo haber solucionado todo sin tantos problemas.

gracias por el aporte y manuel pues a darle con el reflection que la opcion

[mvazquez]

Gracias Peter. si, intentare implementar el Reflection.

Pregunta, usando un clase Abstracta, la cBase hereda a Form y mi formulario hereda a cBase?

Ejemplo:

Código:

//Mi clase abstracta
abstract class cBase: Form
{

}

Código:

//mi formulario
public partial class frmDatos : cBase
{
public frmDatos()
{
       	InitializeComponent();
}
}

Es correcto vdd?


Tengo dudas de donde va esto:

Código:

    #if DEBUG
        public class AbstractForm : Form
        {
    #else
        public abstract class AbstractForm: Form
        {
    #endif

si va en la clase abstracta pero por método o a nivel general, osea así?

Código:

 #if DEBUG
    public class cBase: Form
    {
        //Aqui mis metodos
    }
#else
    abstract class cBase: Form
    {
        //Aqui mis metodos
    }
#endif

Es correcto?

[Peterpay]

las directivas de preprocesador son solo para la definicion del abstract class y que en design time no te salte el error de que no puede virtualizar nada.

asi que eso solo ba en la definicion de tu clase abstracta