Pues eso que ya está disponible para descarga la RC 1 de Composite WPF, más información aquí.
Los próximos dias estaré liado leyendo documentación tanto de LLBLGen Pro, como del Composite WPF para intentar ver como hacer algunas cosas, así que posiblemente tarde un poco en postear algo nuevo, pero sigo en ello … aunque no lo parezca xD
… me está pareciendo muy fácil de usar de momento ( si bien no he hecho nada complicado ), el código lo voy a generar usando el modelo Adapter, además he encontrado plantillas para generar DTO’s en los foros de LLBLGen, si bien las he modificado para que los DTO’s generados no tengan dependencia alguna de LLGLGen y además implementen INOtifyPropertyChanged y las relaciones que sean colecciones como ObservableCollection.
Si puedo haré también una plantilla para generar de forma automática los mappers para los DTO’s, aunque sean un poco básicos, me valdrían para ahorrarme un poco de trabajo 
… es lo que voy a usar finalmente para la parte de persistencia, usando Data Transfer Objects ( DTO’s ) para pasar datos entre el cliente y los servicios de datos.
Ahora solo me queda definir todo el modelo en LLBLGen Pro antes de seguir …
… con WPF y el CompositeWPF, definiendo la estructura del Shell de la aplicación, de momento se ve así:
Tiene zonas para:
Para la carga del shell me he creado una pequeña clase base:
1: public abstract class SmartClientApplication<TShell, TPresenter> : UnityBootstrapper
2: where TShell : IShellView
3: where TPresenter: IShellPresenter
4: {
5: #region · Protected Methods ·
6:
7: protected override void ConfigureContainer()
8: {
9: Container.RegisterType<IShellView, TShell>();
10:
11: base.ConfigureContainer();
12: }
13:
14: protected override DependencyObject CreateShell()
15: {
16: TPresenter presenter = Container.Resolve<TPresenter>();
17: presenter.ShowView();
18:
19: IShellView view = presenter.View;
20:
21: return view as DependencyObject;
22: }
23:
24: #endregion
25: }
Se limita a configurar el container de Unity (DI) y mostrar la ventana del Shell de la aplicación.
La interface utilizada para la vista del Shell dispone de un único método para visualizar la ventana:
1: public interface IShellView
2: {
3: #region · Methods ·
4:
5: void ShowView();
6:
7: #endregion
8: }
La interface para el presenter del Shell, que dispone de una propiedad para la vista asociada al presenter y un método para mostrar la ventana:
1: public interface IShellPresenter
2: {
3: #region · Properties ·
4:
5: IShellView View
6: {
7: get;
8: }
9:
10: #endregion
11:
12: #region · Methods ·
13:
14: void ShowView();
15:
16: #endregion
17: }
Y por último la implementación concreta de SmartClientApplication para la aplicación, que está definida con un Singleton y solo necesita implementar ( por el momento ) la carga de los módulos de la aplicación, que de momento se hará de forma estática.
Tiene además métodos para el manejo de la excepciones no controladas que por el momento están sin implementar correctamente.
1: public class ShellApplication : SmartClientApplication<ShellWindow, ShellPresenter>
2: {
3: #region · Singleton Instance ·
4:
5: public static readonly ShellApplication Instance = new ShellApplication();
6:
7: #endregion
8:
9: #region · Constructors ·
10:
11: private ShellApplication() : base()
12: {
13: }
14:
15: #endregion
16:
17: #region · Protected Methods ·
18:
19: protected override IModuleEnumerator GetModuleEnumerator()
20: {
21: return new StaticModuleEnumerator().AddModule(typeof(ModuloConfiguracion));
22: }
23:
24: #endregion
25:
26: #region · Unhandled Exception ·
27:
28: public void OnUnhandledException(object sender, UnhandledExceptionEventArgs e)
29: {
30: Exception ex = e.ExceptionObject as Exception;
31:
32: if (ex != null)
33: {
34: // MessageBox.Show(this.BuildExceptionString(ex));
35: throw ex;
36: }
37: else
38: {
39: throw new Exception("An Exception has occured, unable to get details");
40: // MessageBox.Show("An Exception has occured, unable to get details");
41: }
42:
43: Environment.Exit(0);
44: }
45:
46: private string BuildExceptionString(Exception exception)
47: {
48: StringBuilder messageBuilder = new StringBuilder();
49:
50: messageBuilder.AppendFormat("{0}{1}{2}", exception.Message, Environment.NewLine, exception.StackTrace);
51:
52: while (exception.InnerException != null)
53: {
54: messageBuilder.Append(BuildInnerExceptionString(exception.InnerException));
55:
56: exception = exception.InnerException;
57: }
58:
59: return messageBuilder.ToString();
60: }
61:
62: private string BuildInnerExceptionString(Exception innerException)
63: {
64: StringBuilder messageBuilder = new StringBuilder();
65:
66: messageBuilder.AppendFormat("{0}{1}", Environment.NewLine, " InnerException ");
67: messageBuilder.AppendFormat("{0}{1}{2}{3}", Environment.NewLine, innerException.Message, Environment.NewLine, innerException.StackTrace);
68:
69: return messageBuilder.ToString();
70: }
71:
72: #endregion
73: }
Ya tengo casi decidida la estructura de los proyectos en la solución para el proyecto ( el nombre … terriblemente original 
del proyecto es … VisualPyme … ante lo original del mismo … se aceptan sugerencias 
), sería mas o menos la siguiente:
Una parte de los proyectos son de la aplicación en sí (VisualPyme.*) y otra para un pequeño Framework (Framework.*) que tendrá los proyectos que sean genéricos ( o sea, de uso en cualquier aplicación ).
Los proyectos de la aplicación, se dividen en :
). Los proyectos del Framework, se dividen en :
). ).Y eso es todo, por el momento, que no es poco, lo más probable es que tenga una solución paralela para los test unitarios ( los haré con Nunit los más probable ), exactamente con la misma estructura.
Ah ! de control de versiones subversion con TortoiseSVN.
Ando a la busqueda de información de ineteres sobre WPF, en el camino de momento me encontrado con 2 links muy interesantes ( entre otros muchos, por que hay bastante información online )
… finalmente voy a usar WPF para la UI he estado buscando un poco más de información entre otras cosas he encontrado un post muy interesante, 10 reasons you should consider WPF for your next desktop application, algunas de las razones son realmente interesantes ( aunque seguro que hay quien podría dar otras 10, o más, para no usarlo XD ).
Dos de mis razones son que no tengo problemas de tiempo y que así aprendo WPF que tenia muchas ganas
Con respecto a lo que comentaba en el anterior post del Expression blend, bueno no creo que me llegue a hacer mucha falta, ni soy diseñador ( jejeje ), ni voy a usar ni animaciones, ni 3D, …
Si hay alguna cosa que no se solucione con el soporte de tiempo de diseño, pues me queda la opción de modifcar el XAML a mano
Voy a usar el Composite WPF ( aka Prism ), seguramente echaré en falta alguna de las cosas de CAB, pero siempre me queda la opción de implementarlo a mano ( hay una serie de artículos muy interesante sobre esto en el blog de Jeremy D. Miller )
En el último año la verdad es que no había tenido muchas ganas de gastar mi tiempo libre delante del ordenador programando … de hecho en los ultimos 6 meses apenas he hecho un par de cosillas en el cliente de XMPP pero parece que poco a poco las voy recuperando … eso si .. muy poco a poco
Como tengo interés en ver algunas de las cosas “nuevas” de .NET, como Windows Presentation Foundation y Windows Communication Foundation, ultimamente he estado pensando en retomar la idea de portar una aplicación antigua ( de Gestión y Contabilidad ) a .NET.
Algunas cosas las tengo claras otras no tanto jejeje Las dos grandes dudas que tengo ahora mismo son.
, gracias a la generosidad de Frans Bouma ( gracias Frans ), tiene una buena cantidad de posibilidades, es fácil de aprender ( por lo que llevo visto ) y tiene la gran ventaja de tener un IDE muy bueno, la única pega es que quiero usar MVP en la UI y WCF para acceder a la capa de negocios ( no tendría por que usar WCF … pero me apetece ), y no quiero dejar atada la UI a las entidades generadas por LLBLGen, y tampoco quiero usar unas entidades para la UI y otras para la parte de persistencia ( si puedo evitarlo claro ) si alguién sabe de alguna que lo diga xDSi finalmente me decido a llevar a delante el tema iré contando en el blog como lo llevo xD
