Cambiar de tamaño automaticamente la imagen de un Gtk.Image

A continuación les pongo el código de una clase que cambia estomáticamente el tamaño de un Gtk.Image al crear o cambiar el tamaño del objeto, es decir el equivalente a la propiedad zoom de un PictureBox de Windows.Forms.
El proceso es captar el evento expose que ocurre al cambiar de tamaño del objeto y ahí escalar la imagen usando la clase Gdk.Pixbuf para mantener la proporción de la imagen se crea el objeto dentro de un AspectFrame.

El código:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using Gtk;

using Gdk;

namespace Test {

    internal class ImageResize {

        private Gtk.Image _Wrapped = null;

        private Pixbuf original = null;

        private string _File = null;

        public ImageResize(Gtk.Image wrapped) {

            _Wrapped = wrapped;

            _Wrapped.ExposeEvent += new ExposeEventHandler(ImageResize_ExposeEvent);

        }

        void ImageResize_ExposeEvent(object o, ExposeEventArgs args) {

            Pixbuf newPix = new Pixbuf(original.Colorspace, original.HasAlpha, original.BitsPerSample, _Wrapped.Allocation.Width, _Wrapped.Allocation.Height);

            double zoom = (double)((double)_Wrapped.Allocation.Width / (double)((double)original.Width));

            original.Scale(newPix, 0, 0, _Wrapped.Allocation.Width, _Wrapped.Allocation.Height, 0, 0, zoom, zoom, InterpType.Nearest);

            _Wrapped.Pixbuf = newPix;

        }

        public string File {

            get {

                return _File;

            }

            set {

                _File = value;

                original = new Pixbuf(_File);

                ImageResize_ExposeEvent(this, null);

            }

        }

    }

}

Creación de eventos en c#

En c# hay varias formas de declarar un evento cada una de diferente complejidad según lo que queramos hacer, lo forma mas simple es marcar el miembro con la palabra clave event y de tipo que sea una de las múltiples clases que hay para manejar eventos puede ser interconstruida o propia de la aplicación.
Como vemos en el siguiente ejemplo también debemos declarar las clases para los argumentos si queremos pasar un valor especial al evento.

public event MyEventHandler PropertyChanged;

public delegate void MyEventHandler(Object sender

        , MyEventArgs e);

    public class MyEventArgs

        : System.ComponentModel.PropertyChangedEventArgs {

        public object Value { get; private set; }

        public MyEventArgs(string propertyName, object value)

            : base(propertyName) {

            Value = value;

        }

    }

Las otras formas de declarar eventos son para casos mas complejos como "eventos read only" y por lo general no se usan.

Ejecutar programas desde .Net Framework

La funcionalidad para ejecutar un programa desde .Net Framework se encuentra en el espacio de nombres System.Diagnostics y es a través de las clases Process y ProcessStartInfo.
La clase Process representa un programa en ejecución y ProcessStartInfo los parámetros con que se ejecuta el proceso entre otros: el nombre del programa, si se redirecciona la entrada y salida estándar, si se va a crear una ventana para el programa, el directorio de trabajo etc.
La forma en que se crea un proceso es usar el método  Start de la clase Process, ya sea el miembro estático con alguna de sus sobrecargas, para crear un nuevo objeto, o el miembro de instancia para usar un objeto construido previamente.
Las diferente sobrecargas nos sirven para ejecutar un programa indicando sus opciones directamente o usando un ProcessStartInfo para indicarlas, esta opción es la que nos permite mas flexibilidad.
En particular la opción  UseShellExecute es ideal para programas de linea de comandos.

A continuación el ejemplo:

using System;

using System.Diagnostics;

public class Class1

{

    public void StarP() {

        ProcessStartInfo stInfo = new ProcessStartInfo("prog.exe");

        stInfo.UseShellExecute = false;

        Process proc = Process.Start(stInfo);

        proc.WaitForExit();

    }

}

Gestionar excepciones de manera global en Asp.Net

Asp.Net tiene una forma de pescar cualquier excepción que ocurra en el sitio de forma centralizada.
En efecto lo único que tenemos que hacer es implementar el metodo Application_Error del archivo Global.asax en un sitio web y este se ejecutara cada vez que ocurra una excepción no controlada en la aplicación.
La excepción que ocurrió esta disponible accesando la función Server.GetLastError().
Por ejemplo podemos capturar la excepción y reportarla usando nlog, mandarla por email, etc.

Agregar Web Services en Visual Studio 2008 en adelante

En las versiones mas recientes de Visual Studio no se tiene la opción directa para añadir Web Services al proyecto, lo que se tiene es la opción de agregar referencias de servicios, estos servicios son los creados con WCF y aunque se puede usar un Web Service antiguo con WCF en ocasiones podemos necesitar un Web Service sin usar WPF por ejemplo si no queremos incluir la referencia a esos componentes en el proyecto.
En estos casos podemos incluir el Web Service siguiendo estos pasos.
Se selecciona agregar referencia de servicio como si fuéramos a agregar un servicio WCF.
En esta ventana seleccionamos el botón "Avanzadas..."

En la ventana que aparece seleccionamos "Agregar referencia web..."

Y finalmente nos aparece la pantalla para agregar un Web Service "clásico"

Obteniendo el texto de un PDF en .Net

PdfBox es una librería que permite entre otras cosas obtener el texto de un pdf, este software es para java pero se puede usar en gracias a IKVM que permite convertir archivos de java en dlls.

El ejemplo:

using org.pdfbox.pdmodel;

using org.pdfbox.util;

using System;

public class GetText() {

    public string Retrieve(string fileName) {

        PDDocument doc = PDDocument.load(fileName);

        PDFTextStripper stripper = new PDFTextStripper();

        return stripper.getText(doc);

    }

}

PDFBox se puede obtener en esta página: http://www.squarepdf.net/pdfbox-in-net/

Gtk Builder en .Net

Gtk Builder es la forma mas moderna de crear interfaces en gtk por medio de un editor WYSIWYG, es mas completo que stetic y el editor no truena en cada paso.
Es posible usar GTK.Builder en proyectos .Net o Mono pero la documentación es practicamente inexistente de hecho yo aprendi a usarlo en un sitio de Python pues como siempre la gente de mono tiene el proyecto completamente descuidado.
Lo básico es crear el objeto cargar el archivo xml que creamos con el programa Glade (que también funciona en Windows) obtener la ventana que queremos usar y mostrarla, es mejor crear una ventana por archivo pues despues nos puede dar problemas encontrar objetos con el mismo identificador.
Tambien debemos escribir un poco de código para poder usar los objetos que contiene el archivo ya que no hay forma de cargarlos automaticamente, solo buscamos el objeto dentro del Builder y lo asignamos a una variable de la clase.
Para las señales (eventos) lo mejor es usar las referencias que encontramos en el paso anterior y asignar los eventos directamente ya que aunque hay una función para conectar los eventos es complicada y de todos modos ya tenemos las referencias así que es más facil hacerlo de esta manera.
A continuación el codigo de ejemplo:

<?xml version="1.0"?>

<interface>

  <requires lib="gtk+" version="2.16"/>

  <!-- interface-naming-policy toplevel-contextual -->

  <object class="GtkWindow" id="window1">

    <child>

      <object class="GtkVBox" id="vbox1">

        <property name="visible">True</property>

        <property name="orientation">vertical</property>

        <child>

          <object class="GtkLabel" id="label1">

            <property name="visible">True</property>

            <property name="xalign">0</property>

            <property name="label" translatable="yes">label</property>

          </object>

          <packing>

            <property name="expand">False</property>

            <property name="fill">False</property>

            <property name="position">0</property>

          </packing>

        </child>

        <child>

          <object class="GtkButton" id="button1">

            <property name="label" translatable="yes">button</property>

            <property name="visible">True</property>

            <property name="can_focus">True</property>

            <property name="receives_default">True</property>

            <property name="yalign">0</property>

          </object>

          <packing>

            <property name="expand">False</property>

            <property name="fill">False</property>

            <property name="position">1</property>

          </packing>

        </child>

      </object>

    </child>

  </object>

</interface>

using System;

using Gtk;

namespace GTKBuilder {

    class MainClass {

        Window thisWnd = null;

        Builder thisObject = null;

        Button button1 = null;

        Label label1 = null;

        public static void Main (string[] args) {

            Application.Init ();

            MainClass tester = new MainClass();

            tester.Show();

            Application.Run ();

        }

        MainClass() {

            InitializeComponent();

        }

        private void InitializeComponent(){

            thisObject = new Gtk.Builder();

            thisObject.AddFromFile("tester.glade");

            thisWnd = (Window)thisObject.GetObject("window1");

            label1 = (Label)thisObject.GetObject("label1");

            button1 = (Button)thisObject.GetObject("button1");

            button1.Clicked += (object sender, EventArgs e) => {

                label1.Text = "Hello";

            };

            thisWnd.DeleteEvent += (o, args) => {

                Application.Quit();

            };

        }

        public void Show() {

            thisWnd.ShowAll();

        }

    }

}