Yohan Jasdid's Blog & Stories » Bits

Suma de Riemann

yohan.jasdid — Sat, 29 Oct 2011 00:51:28 +0000

En matemáticas, la suma de Riemann es un método de integración numérica que nos sirve para calcular el valor de una integral definida es decir el área bajo una curva, este metodo es muy útil cuando no es posible utilizar el Teorema Fundamental del Cálculo. Estas sumas toman su nombre del matemático alemán Bernhard Riemann.

La suma de Riemann consiste básicamente en trazar un número finito de rectangulos dentro de un área irregular, calcular el área de cada uno de los rectangulos y sumarlos. El problema de este método de integración numérica es que al sumar las áreas se obtiene un margen de error muy grande.

Fuente: Wikipedia

Últimamente estuve trabajando en un programa para resolver cuestiones de integración numéricamente ya que fue una de las encomiendas de mi asesor el Dr. Jesus Manzanares creo que este es un “Baby Step” que nos llevara a resolver algo mucho mas complejo, creí que era relevante incluir la descripción de la integración numérica por lo que incluí la definición de wikipedia que es buena,

Cabe complementar un poco la definición y agregar que entre mas rectangulos se le agreguen al problema la aproximación de la solución es mucho mas exacta, y de acuerdo a pruebas hechas llegando a 100 ó poco mas de esa cantidad se logra tener una aproximación de la solución bastante aceptable

Bueno creo que ya fue demasiada teoría aunque realmente la teoría nunca es suficiente, a continuación se presenta una implementación en web de la Suma de Riemann, para tener información mas amplia de como realizar un programa en web puedes visitar el post ¿Como portar una aplicacion existente a una solucion web?

La aplicación esta diseñada para resolver 3 tipos de integrales, las siguientes:

Donde el rango de la integral es totalmente parametrizable en la implementacion, y en donde para realizar la integración numérica se deberá hacer una sumatoria, a continuación se enlista el código en C++ de la implementación, seguido de la aplicación en sí corriendo en web.

/*
 * File:   NumericalIntegral.cpp
 * Author: Yohan Jasdid
 *
 * Created on October 15, 2011, 4:36 PM
 */
#include
#include
#include
#include

#include
#include
#include
#include
#include
#include

#include "getpost.h"
#include "json/reader.h"
#include "json/writer.h"
#include "json/elements.h"

using namespace std;
using namespace json;

string exec(char* cmd);
void ReturnError(string error);

/**
 * Main function
 * @return
 */
int main()
{
    map  Post;
    initializePost(Post);   //notice that the variable are passed by reference!

    cout << "content-type: application/json" << endl << endl;

    string userData;
    string message = "";
    if (Post.find("UserData") != Post.end())
    {
        userData = Post["UserData"].c_str();
    }
    else
    {
        ReturnError("Some requiered parameters were not provided, try again.
");
        return 1;
    }

    Object objDocument;
    try
    {
        std::istringstream jsonData(userData);
        Reader::Read(objDocument, jsonData);

        // Get and parse parameters
        String jsonSX = objDocument["SX"];
        String jsonEX = objDocument["EX"];
        String jsonN = objDocument["N"];
        String jsonFnc = objDocument["Fnc"];

        double start_x = atof(jsonSX.Value().c_str());
        double end_x = atof(jsonEX.Value().c_str());
        double interval = end_x - (start_x);
        double max_n = atof(jsonN.Value().c_str());
        int fnction = atoi(jsonFnc.Value().c_str());

        // We must generate a unique ID for naming our data graph file
        char uuidgen[] = "uuidgen";
        string uuid = exec(uuidgen);

        // Define files and folders
        string gpFolder = "../gnuplot/";
        string gpDataFile = gpFolder + uuid + ".dat";          // data file
        string gpGraphFile =  gpFolder + uuid + ".png";        // graph file
        string gpCommandFile =  gpFolder + uuid + ".gnuplot";  // gnuplot command file

        // Create data file
        ofstream gpData;
        gpData.open((gpDataFile).c_str());
        if(!gpData)
        {
            ReturnError("** Failed to create the graph file.
");
            return 1;
        }

        // search for all n..
        stringstream data;
        for (double i = 1; i         {
            double n = i;
            double delta_x = interval / n;
            double x_i = start_x;
            double total = 0.0;
            double function = 0.0;

            for (double j = 1; j             {
                x_i = x_i + delta_x;
                switch (fnction)
                {
                    case 1:
                        function = x_i * x_i;
                        break;
                    case 2:
                        function = x_i * x_i * x_i;
                        break;
                    case 3:
                        function = cos(x_i);
                        break;
                }
                total = total + ((function) * delta_x);
            }

            data << data << i << " " << total << endl;
            gpData << i << " " << total << "\n";
        }
        gpData.close();

        // We must build a gnuplot commands file
        ofstream gpCommands;
        gpCommands.open((gpCommandFile).c_str());
        if(!gpCommands)
        {
            ReturnError("** Failed to create the graph file.
");
            return 1;
        }

        gpCommands << "set title 'Integral Numerica'" << "\n";
        gpCommands << "set term png small" << "\n";
        gpCommands << "set output " << "'" << gpGraphFile << "'" << "\n";
        gpCommands << "set nokey" << "\n";
        gpCommands << "plot '" << gpDataFile << "' using 1:2 with lines" << "\n";
        gpCommands.close();

        // Execute gnuplot and generate graph
        string commds = "gnuplot '" + gpCommandFile + "'";
        char *cmds = (char*)commds.c_str();
        exec(cmds);

        // Results ***
        // Build a json object to return as response of the request
        message += "Calculations finished without errors.
";
        Object objResponse;
        objResponse["Error"] = String("");
        objResponse["Message"] = String(message.c_str());
        objResponse["DataFile"] = String(gpDataFile.c_str());
        objResponse["CommandFile"] = String(gpCommandFile.c_str());
        objResponse["GraphFile"] = String(gpGraphFile.c_str());
        objResponse["PlainData"] = String(data.str());

        std::stringstream jsonStream;
        Writer::Write(objResponse, jsonStream);
        cout << jsonStream.str();
    }
    catch (exception& e)
    {
        ReturnError("** Something went wrong, please report this problem to the system administrator.
");
        return 1;
    }
    return 0;
}

/**
 * @brief Returns an error in json format
 * @error The error description to be returned
 *
 * This method executes a bash command using a pipe and a buffer to capture the
 * result of the execution, then return the execution to client code.
 */
void ReturnError(string error)
{
  Object objResponse;
  objResponse["Error"] = String(error.c_str());

  std::stringstream jsonStream;
  Writer::Write(objResponse, jsonStream);
  cout << jsonStream.str();
}

/**
 * @brief Executes a shell command
 * @param cmd The command to execute
 * @return The result of the execution
 *
 * This method executes a bash command using a pipe and a buffer to capture the
 * result of the execution, then return the execution to client code.
 */
string exec(char* cmd)
{
    FILE* pipe = popen(cmd, "r");
    if (!pipe)
        return "ERROR";

    char buffer[128];
    string result = "";
    while(!feof(pipe))
    {
        if(fgets(buffer, 128, pipe) != NULL)
            result += buffer;
    }
    pclose(pipe);

    // remove carriage return (new lines)
    result.erase(std::remove(result.begin(), result.end(), '\n'), result.end());
    return result;
}

Los resultados del programa muestran la resolución de la integral numérica para un numero de particiones (n) dado, que son los rectángulos a resolver y sumar, entre mayor sea el número de rectángulos mayor sera la exactitud del resultado, a continuación se muestran los resultados para n=5, n=50 y n=100.

N=5

N=50

N=100

Como se puede ver en los resultados anteriores el resultado converge rápidamente con el resultado real lo cual es bueno ya que se puede obtener una aproximación muy decente utilizando el poder de procesamiento y la fuerza bruta de la computadora..

Como punto final se anexa a continuación la implementación de dicha integral numérica donde se puede jugar con los parámetros de entrada para obtener un resultado deseado y su gráfica correspondiente.

Get a better browser!

enjoy!

Silverlight Firestarter

yohan.jasdid — Thu, 02 Dec 2010 18:52:32 +0000

Un post rapido solo para recomendar que si pueden ver el dia de hoy el Silverlight Firestarter entren al stream esta muy interesante estara todo el dia y es en vivo tocando temas de nuevas tecnologias aqui les dejo el enlace para los interesados..

http://www.silverlight.net/news/events/firestarter/

Y por ultimo es raro trabajar en media pantalla pero no tengo de otra jajaj asi luce mi desktop el dia de hoy..

Saludos!

Extraño comportamiento usando yield y manejo de exceptiones

yohan.jasdid — Tue, 30 Nov 2010 19:11:13 +0000

Trabajando en un proyecto y de alguna manera llegue a ver el escenario que a continuacion describo al momento de utilizar el operaror yield y manejo de excepciones con PostSharp..

Resulta que cuando utilizas yield para regresar una lista tipo IEnumerable y en el metodo hijo en el cual utilizas yield ocurre una exception hay un comportamiento un tanto raro o al menos para mi que no soy un experto en C#, quise hacer un proyecto de ejemplo para ilustrar mejor el comportamiento que describo, a continuacion pongo la clase de un proyecto de consola que hice:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace PostSharpYieldSample
{
    public class Program
    {
        public static void Main(string[] args)
        {
            ParentMethod();
            Console.WriteLine("press any key to end.");
            Console.ReadLine();
        }

        private static IEnumerable _myList;

        /// 
        /// Parent
        /// 
        [ExceptionHandlerAspect]
        public static void ParentMethod()
        {
            Console.WriteLine("In parent Method.");
            _myList = ChildYieldMethod();

            // comment the lines below to "EAT" the exception message
            foreach (string str in _myList)
                Console.Write(str);
        }

        /// 
        /// Child method using yield
        /// 
        /// 
        public static IEnumerable ChildYieldMethod()
        {
            Console.WriteLine("In child Method.");
            String[] data = { "Item 1", "Item 2", "Item 3" };

            foreach (string myString in data)
            {
                yield return myString;
                throw new Exception("Some exception happen here");
            }
        }
    }
}

Como se puede ver estoy utilizando un Aspecto de PostSharp en el metodo ParentMethod() para “cachar” todas las excepciones que pudieran ocurrir en el metodo, a continuacion enlisto el aspecto que estoy utilizando:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using PostSharp.Aspects;
using System.Diagnostics;

namespace PostSharpYieldSample
{
    /// 
    /// Aspect class that handles errors using postsharp
    /// 
    [Serializable]
    public sealed class ExceptionHandlerAspect : OnExceptionAspect
    {
        /// 
        /// The flow behavior to use.
        /// 
        private FlowBehavior flowBehavior;

        /// 
        /// Default Constructor
        /// 
        public ExceptionHandlerAspect()
            : this(FlowBehavior.Return)
        {
        }

        /// 
        /// Creates an instance specifying the flow behavior to use
        /// 
        /// The flow behavior
        public ExceptionHandlerAspect(FlowBehavior flowBehavior)
        {
            this.flowBehavior = flowBehavior;
        }

        /// 
        /// Method invoked upon failure of the method to which the current
        /// aspect is applied.
        /// 
        /// Information about the method being executed.
        public override void OnException(MethodExecutionArgs args)
        {
            string errorInfo = string.Format("{0}() {1} - PostSharp message.", args.Method.Name, args.Exception.Message);
            Console.WriteLine(errorInfo);
            args.FlowBehavior = flowBehavior;
        }

    }
}

Este aspecto es muy sencillo y lo utilice solo para fines de la demostracion y lo unico que hace es que me regresa un mensaje personalizado de la excepcion que ocurrio en el metodo donde se definio el aspecto (atributo), al ejecutar la aplicacion de ejemplo se vera la siguiente pantalla:

Cosa que tiene sentido ya que el flujo del programa entro en el metodo donde utilizo yield y solo regreso el primer elemento para despues lanzar la excepcion especificada, en este caso PostSharp “atrapa” correctamente la excepcion y la muestra en pantalla, este es el comportamiennto esperado, El problema viene cuando comentamos las lineas del parent method donde se hace referencia a la lista que se lleno mediante yield, estas lineas comentadas son las siguientes:

            // comment the lines below to "EAT" the exception message
            //foreach (string str in _myList)
            //    Console.Write(str);

Al momento de comentar estas lineas y volver a ejecutar el programa algo “raro” ocurre con la excepcion, lo que ocurre es que practicamente la excepcion es omitida o practicamente nuca llegamos a ejecutar el metodo donde utilizamos yield, el resultado luciria algo como lo siguiente:

Habra que investigar mas sobre lo que la palabra reservada yield hace en este caso internamente ya que a mi punto de vista no es un comportamiento obvio al que uno concluiria facilmente, a continuacion pongo el enlace del codigo fuente de la aplicacion ejemplo..

PostSharpYieldSample

Pd. Creo que se me olvido hablar un poco mas acerca de PostSharp y programacion orientada a aspectos, es buen tema para un post que publicare mas adelante en estos dias por si te interesa saber mas sobre el tema de todos modos en la red hay mucha informacion sobre ello..

Saludos!

Caliburn y Silverlight ejemplo sencillo..

yohan.jasdid — Fri, 18 Jun 2010 22:34:02 +0000

Estos ultimos dias he estado checando Caliburn (MVVM framework) debido a la posibilidad de trabajar con el en un futuro cercano, asi que he decidido postear un muy parecido ejemplo al que publique hace poco donde trabajaban un expander y un splitter de manera conjunta, ahora como estoy utilizando Silverlight pues voy a deberles el expander ya que al parecer ese control no es soportado por esta tecnologia tal vez en el Silverlight Toolkit venga uno pero ese sera un tema para despues..

Caliburn me ha dejado impresionado con la cantidad de cosas que puedes hacer con tan poco codigo debido a la manera que esta diseniado el framework practicamente te permite enlazar controles y eventos y un monton de cosas que hace por ti detras del telon, lo unico malo es que la documentacion no es muy extensa y no existen tantas aplicaciones como ejemplo o quickstarts (como PRISM por ejemplo) asi que habra que contribuir con un granito de arena en la promocion de este excelente framework.

Bueno para empezar debemos crear un nuevo proyecto de tipo Silverlight, yo estoy utilizando el VS2010 y el Silverlight 4 que es una instalacion separada, una vez creado este proyecto y configurado automaticamente por Visual Studio removemos el control MainWindow.xaml y lo reemplazamos por ShellView.xaml que sera nuestro contenedor de contenido, a continuacion lo configuramos de la siguiente manera en el App.xaml principal para soportar Caliburn,

App.xaml

Y a continuacion modificamos el code behind para que derive de la clase CaliburnApplication,
App.xaml.cs

using ExpanderAndSplitter.Caliburn.ViewModels;
using Caliburn.PresentationFramework.ApplicationModel;

namespace ExpanderAndSplitter.Caliburn
{
     public partial class App :  CaliburnApplication
    {

        public App()
        {
            InitializeComponent();
        }

        /// 
        /// Creating the root view model of the app, the shell
        /// 
        /// Root view model (shell)
        protected override object CreateRootModel()
        {
            return new ShellViewModel();
        }

     }
}

En los pasos anteriores definimos la applicacion como un applicacion Caliburn y a continuacion hacemos Override al CreatRootModel() donde le diremos a Caliburn cual es el objeto de la vista que queremos como Root object o sea como contenedor principal de la aplicacion, cabe mencionar que caliburn es orientado a modelos y majena mucho el concepto de convenciones por lo que el framework detras del telon hara una serie de comprobaciones para ubicar la vista que pertenece al “ViewModel” que especificamos como contenedor principal en el Override por lo que no tendremos que hacer nada especial para que la vista de tal modelo este bindeada al modelo, MAGIA PURA!!!

ShellViewModel.cs

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using Caliburn.Core;
using System.Collections.ObjectModel;
using ExpanderAndSplitter.Caliburn.Models;

namespace ExpanderAndSplitter.Caliburn.ViewModels
{
    public class ShellViewModel : PropertyChangedBase
    {

        #region Fields

        private GridLength _masterRowHeight = new GridLength(1, GridUnitType.Star);
        private GridLength _splitterRowHeight = new GridLength(0);
        private GridLength _detailRowHeight = new GridLength(1, GridUnitType.Auto);

        public ObservableCollection _masterItems = null;
        public ObservableCollection _detailItems = null;

        #endregion // Fields

        public ShellViewModel()
        {
            MasterRowHeight = new GridLength(1, GridUnitType.Star);
            SplitterRowHeight = new GridLength(20);
            DetailRowHeight = new GridLength(1, GridUnitType.Star);

            MasterItems = new ObservableCollection();
            DetailItems = new ObservableCollection();

            for (int i = 0; i < 1000; i++)
            {
                ItemModel masterIM = new ItemModel("Master Item Dummy " + i.ToString(), i.ToString());
                ItemModel detailIM = new ItemModel("Detail Item Dummy " + i.ToString(), i.ToString());

                ItemViewModel masterIVM = new ItemViewModel(masterIM);
                ItemViewModel detailIVM = new ItemViewModel(detailIM);

                MasterItems.Add(masterIVM);
                DetailItems.Add(detailIVM);
            }

        }

        #region Properties

        public GridLength MasterRowHeight
        {
            get { return _masterRowHeight; }
            set
            {
                _masterRowHeight = value;
                NotifyOfPropertyChange("MasterRowHeight");
            }
        }

        public GridLength SplitterRowHeight
        {
            get { return _splitterRowHeight; }
            set
            {
                _splitterRowHeight = value;
                NotifyOfPropertyChange("SplitterRowHeight");
            }
        }

        public GridLength DetailRowHeight
        {
            get { return _detailRowHeight; }
            set
            {
                _detailRowHeight = value;
                NotifyOfPropertyChange("DetailRowHeight");
            }
        }

        public ObservableCollection MasterItems
        {
            get { return _masterItems; }
            set
            {
                _masterItems = value;
                NotifyOfPropertyChange("MasterItems");
            }
        }

        public ObservableCollection DetailItems
        {
            get { return _detailItems; }
            set
            {
                _detailItems = value;
                NotifyOfPropertyChange("DetailItems");
            }
        }

        #endregion // Properties

    }
}

Siguiendo las convenciones definidas por el framework por default sabemos que las vistas deberan estar situadas en una carpeta llamada Views, los ViewModels al igual deberan estar en su carpeta llamada ViewModels, siendo todo esto configurable, ademas con el codigo fuente podemos definir nuestras propias convenciones

ShellView.xaml

ItemModel.cs

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

namespace ExpanderAndSplitter.Caliburn.Models
{
    public class ItemModel
    {

        public ItemModel(string name, string id)
        {
            this.Name = name;
            this.ID = id;
        }

        public string Name
        {
            get;
            set;
        }

        public string ID
        {
            get;
            set;
        }

    }
}

Al final la aplicacion luce casi igual que la del post pasado solo que utilizando Caliburn y Silverlight y a excepcion que no se tuvo que utilizar codigo para especificar la relacion entre vista y view model ya que caliburn se encarga de todo esto y muchisimo mas.

Mas adelante si tengo tiempo publicare algo relacionado con los Comandos, Triggers, Efectos y un monton de cosas que puedes aprovechar con caliburn de una manera sencilla, espero les haya gustado y no duden en dejar un comentario pues tal vez hize algo mal ya que apenas son mis inicios con Caliburn.

Puedes bajar el codigo fuente completo y el proyecto del siguiente enlace: ExpanderAndSplitter.Caliburn

Saludos!
YR

WPF Expander y Splitter trabajando juntos..

yohan.jasdid — Fri, 11 Jun 2010 23:19:40 +0000

Bueno aqui dejo publicado la solucion de un problemita que recientemente tuve haciendo que funcionarian juntos un Expander y un splitter bueno la meta final era tener 2 expanders separados por 1 splitter y que cada expander contuviera algun tipo de grids o incluso una vista con este aproach ya se puede jugar con lo que uno quiera poner en cada region,

Yo anduve buscando algo similar y no pude encontrar mucho al respecto asi que aqui dejo mi solucion y espero que a alguien pueda servirle..

Aqui tenemos el XAML con el codigo que contiene al expander y al splitter o mas bien dos expander conteniendo un grid cada uno separados por un splitter..

Y su respectivo code behind que se encarga de hacer las operaciones correspondientes de tamanio para que estos controles funcionen armoniosamente uno con el otro..

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Collections.ObjectModel;

namespace ExpanderAndSplitter
{
    /// 
    /// Interaction logic for MainWindow.xaml
    /// 
    public partial class MainWindow : Window
    {

        #region Fields

        private static double _oldMasterHeight = 1;
        private static double _oldDetailHeight = 1;

        #endregion // Fields

        #region Properties

        public GridLength MasterRowHeight
        {
            get { return (GridLength)GetValue(MasterRowHeightProperty); }
            set { SetValue(MasterRowHeightProperty, value); }
        }

        // Using a DependencyProperty as the backing store for MasterRowHeight.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty MasterRowHeightProperty =
            DependencyProperty.Register("MasterRowHeight", typeof(GridLength), typeof(MainWindow), new UIPropertyMetadata(new GridLength(1, GridUnitType.Star)));

        public GridLength SplitterRowHeight
        {
            get { return (GridLength)GetValue(SplitterRowHeightProperty); }
            set { SetValue(SplitterRowHeightProperty, value); }
        }

        // Using a DependencyProperty as the backing store for SplitterRowHeight.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty SplitterRowHeightProperty =
            DependencyProperty.Register("SplitterRowHeight", typeof(GridLength), typeof(MainWindow), new UIPropertyMetadata(new GridLength(0)));

        public GridLength DetailRowHeight
        {
            get { return (GridLength)GetValue(DetailRowHeightProperty); }
            set { SetValue(DetailRowHeightProperty, value); }
        }

        // Using a DependencyProperty as the backing store for DetailRowHeight.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty DetailRowHeightProperty =
            DependencyProperty.Register("DetailRowHeight", typeof(GridLength), typeof(MainWindow), new UIPropertyMetadata(new GridLength(1, GridUnitType.Auto)));

        public ObservableCollection MasterItems
        {
            get;
            set;
        }

        public ObservableCollection DetailItems
        {
            get;
            set;
        }

        #endregion // Properties

        #region Constructors

        public MainWindow()
        {
            InitializeComponent();

            MasterItems = new ObservableCollection();
            DetailItems = new ObservableCollection();

            for (int i=0; i<1000; i++)
            {
                MasterItems.Add(new DummyItem("Master Dummy " + i.ToString(), i.ToString()));
                DetailItems.Add(new DummyItem("Detail Dummy " + i.ToString(), i.ToString()));
            }
        }

        #endregion // Constructors

        #region Events

        private void MasterExpander_Expanded(object sender, RoutedEventArgs e)
        {
            DoHandleExpandCollapse();
        }

        private void MasterExpander_Collapsed(object sender, RoutedEventArgs e)
        {
            if (DetailExpander.IsExpanded)
            {
                _oldMasterHeight = MasterRowHeight.Value;
                _oldDetailHeight = DetailRowHeight.Value;
            }
            DoHandleExpandCollapse();
        }

        private void DetailExpander_Expanded(object sender, RoutedEventArgs e)
        {
            DoHandleExpandCollapse();
        }

        private void DetailExpander_Collapsed(object sender, RoutedEventArgs e)
        {
            if (MasterExpander.IsExpanded)
            {
                _oldMasterHeight = MasterRowHeight.Value;
                _oldDetailHeight = DetailRowHeight.Value;
            }
            DoHandleExpandCollapse();
        }

        private void MasterGrid_Loaded(object sender, RoutedEventArgs e)
        {
            if (MasterGrid.ItemsSource == null)
                MasterGrid.ItemsSource = MasterItems;
        }

        private void DetailGrid_Loaded(object sender, RoutedEventArgs e)
        {
            if (DetailGrid.ItemsSource == null)
                DetailGrid.ItemsSource = DetailItems;
        }

        private void MainContainer_Loaded(object sender, RoutedEventArgs e)
        {
            MainContainer.DataContext = this;
        }

        #endregion // Events

        #region Helpers

        private void DoHandleExpandCollapse()
        {
            if (MasterExpander == null || DetailExpander == null)
                return;

            SplitterRowHeight = new GridLength(0);
            if (MasterExpander.IsExpanded && DetailExpander.IsExpanded)
            {
                MasterRowHeight = new GridLength(_oldMasterHeight, GridUnitType.Star);
                DetailRowHeight = new GridLength(_oldDetailHeight, GridUnitType.Star);
                SplitterRowHeight = new GridLength(20);
                return;
            }

            if (MasterExpander.IsExpanded)
                MasterRowHeight = new GridLength(1, GridUnitType.Star);
            else
                MasterRowHeight = new GridLength(1, GridUnitType.Auto);

            if (DetailExpander.IsExpanded)
                DetailRowHeight = new GridLength(1, GridUnitType.Star);
            else
                DetailRowHeight = new GridLength(1, GridUnitType.Auto);
        }

        #endregion // Helpers

    }

    public class DummyItem
    {
        public DummyItem(string name, string id)
        {
            this.Name = name;
            this.ID = id;
        }
        public string Name
        {
            get;
            set;
        }
        public string ID
        {
            get;
            set;
        }
    }
}

Al final asi es como luce la solucion:

La solucion ejemplo esta hecha con Visual Studio 2010 y el codigo fuente lo puedes bajar del siguiente link ExpanderAndSplitter.

Enjoy!
Yohan Rodriguez

OutOfMemory exception

yohan.jasdid — Mon, 12 Oct 2009 19:37:28 +0000

Bueno, pues ultimamente he estado perdiendo mucho tiempo en mi trabajo por este tipo de errores, que mas que error pues creo que es un poco obvio que necesito mas memoria en mi PC,

Bueno tal vez se deba a que tengo siempre abierto 3 o 4 instancias del Visual Studio 2008, itunes, Google Chrome (unas 5 instancias), Messenger, Skype, Sql Server 2005, Blend 3, Outlook, y el antivirus chafa que me pusieron que se pone a escanear la computadora como burro sin mecate!

Pues yo la verdad considero que lo que regularmente tengo abierto al mismo tiempo cualquier programador podria usar esa misma cantidad de programas al mismo tiempo si no es que mucho mas pero bueno, por lo visto estoy corriendo vista y casi cada vez que compilo sale este error molesto el cual desaparece si cierro y vuelvo a abrir el proyecto en VS2008

Saludos!

Primeros pasos con WPF,

yohan.jasdid — Sun, 09 Nov 2008 03:48:42 +0000

Hoy sabado me di un tiempo para investigar un poco sobre WPF ya que me acaban de asignar a un proyecto bastannnnnte interesante y estare utilizando tecnologias mas nuevas como el framework 3.0 y 3.5 por lo que me di un espacio para investigar un poco,

Al final del dia (bueno todavia no se acaba jejej) he logrado comprender en un buen porcentaje el manejo de XAML asi como la creacion del mismo desde dentro de C# y la flexibilidad que esto significa, proximamente espero darme otro tiempo para hacer unas pruebas de estos mismos XAML’s con Silverlight y colgarlos a la web esperemos que tenga un tiempesillo jej..

No podia faltar el clasico hello WPF

Cabe mencionar que estos ejemplos los lei en un buen libro que me encontre por ahi llamado windows presentation foundation unleashed

Y el ejemplo que alimenta a mi ego jejej la verdad que estos combos enriquecidos y en general cualquier tipo de control son tremendamente flexibles!