Empecemos fuerte con un ejemplo completo (y real) de un archivo de configuracion para requireJS.

require({
        // Aliases para nuestros archivos, esto quiere decir que cuando requiramos alguno de estos paquetes en alguno de nuestros modulos
        // podremos hacerlo escribiendo directamente el nombre de el paquete que especifiquemos aqui en vez de toda la ruta al paquete que tenemos
        // escrita en "location".
 "packages": [
  {
   "name": "bootstrap",
   "location": "bower_components/bootstrap/dist"
  },
  {
   "name": "jquery",
   "location": "bower_components/jquery/dist",
   "main": "jquery.min"
  },
  {
   "name": "poly",
   "location": "bower_components/poly",
   "main": "es5"
  },
  {
   "name": "when",
   "location": "bower_components/when",
   "main": "when"
  },
  {
   "name": "requirejs-text",
   "location": "bower_components/requirejs-text"
  },
  {
   "name": "require-css",
   "location": "bower_components/require-css"
  },
  {
   "name": "mu-template",
   "location": "bower_components/mu-template"
  },
  {
   "name": "jsonselect",
   "location": "bower_components/jsonselect/src",
   "main": "jsonselect"
  },
  {
   "name": "markdown",
   "location": "bower_components/markdown/src",
   "main": "markdown"
  },
  {
   "name": "moment",
   "location": "bower_components/moment",
   "main": "min/moment.min"
  },
  {
   "name": "audio5js",
   "location": "bower_components/audio5js",
   "main": "audio5.min"
  },
  {
   "name": "fastclick",
   "location": "bower_components/fastclick/lib",
   "main": "fastclick"
  },
  {
   "name": "query-string",
   "location": "bower_components/query-string",
   "main": "query-string"
  },
  {
   "name": "spin",
   "location": "bower_components/spin.js",
   "main": "spin"
  },
  {
   "name": "troopjs",
   "location": "bower_components/troopjs",
   "main": "maxi.min"
  },
  {
   "name": "troopjs-contrib-com",
   "location": "bower_components/troopjs-contrib-com"
  },
  {
   "name": "troopjs-contrib-audio5js",
   "location": "bower_components/troopjs-contrib-audio5js"
  },
  {
   "name": "troopjs-contrib-audio5js-player",
   "location": "bower_components/troopjs-contrib-audio5js-player"
  },
  {
   "name": "troopjs-contrib-markdown",
   "location": "bower_components/troopjs-contrib-markdown"
  },
  {
   "name": "troopjs-contrib-bootstrap",
   "location": "bower_components/troopjs-contrib-bootstrap"
  },
  {
   "name": "athena-client",
   "location": "."
  },
  {
   "name": "has",
   "location": "bower_components/has",
   "main": "has"
  },
  {
   "name": "jquery-cookie",
   "location": "bower_components/jquery-cookie",
   "main": "jquery.cookie"
  }
 ],
        // paquetes de configuracion
 "config": {
  "troopjs-contrib-com/config": {
   "type": "type",
   "children": "components",
   "completed": "completed",
   "component": "widget"
  },

  "athena-client/config": {
   "key": "value"
  }
 },

 "shim": {
  "bootstrap/js/bootstrap.min": {
   "deps": [ "jquery" ]
  },
  "jsonselect/jsonselect": {
   "deps": [ "poly/json" ],
   "exports": "JSONSelect"
  }
 },
        // Mapeando paquetes, esto es similar a package pero siendo mas restrictivo.
        // En el primer caso, con * decimos que podemos usar estos nombres en cualquiera de nuestros componentes
        // con el segundo ejemplo athena-client/component/signal/start decimos que solo podemos usar el mapeo 
        // "troopjs-contrib-com/signal/start": "troopjs-contrib-com/signal/start" en el componente "athena-client/component/signal/start"
 "map": {
  "*": {
   "json": "troopjs-requirejs/json",
   "shadow": "troopjs-requirejs/shadow",
   "text": "requirejs-text/text",
   "css": "require-css/css.min",
   "mu": "mu-template/plugin",
   "troopjs-contrib-com/signal/start": "athena-client/component/signal/start"
  },

  "athena-client/component/signal/start": {
   "troopjs-contrib-com/signal/start": "troopjs-contrib-com/signal/start"
  },

  "troopjs-contrib-com/loom/weave": {
   "audio-check": "athena-client/audio-check/widget",
   "audio-play": "athena-client/audio-play/widget",
   "carousel": "athena-client/carousel/widget",
   "dialog": "athena-client/dialog/widget",
   "instructions": "athena-client/instructions/widget",
   "module": "athena-client/module/widget",
   "multiple-choice": "athena-client/multiple-choice/widget",
   "multiple-choice-score-plain": "athena-client/multiple-choice-score-plain/widget",
   "placeholder-static": "athena-client/placeholder-static/widget",
   "placeholder-module": "athena-client/placeholder-path/widget",
   "placeholder-result": "athena-client/placeholder-path/widget",
   "placeholder-test": "athena-client/placeholder-test/widget",
   "page": "athena-client/page/widget",
   "poster": "athena-client/poster/widget",
   "progress": "athena-client/progress/widget",
   "result": "athena-client/nop/widget",
   "stimulus": "athena-client/stimulus/widget",
   "speaker-match": "athena-client/speaker-match/widget",
   "set": "athena-client/set/widget",
   "task": "athena-client/task/widget",
   "test": "athena-client/test/widget",
   "timer-persisted": "athena-client/timer-persisted/widget",
   "timer-transient": "athena-client/timer-transient/widget"
  }
 },

 "bundles": {
  "troopjs": [
   "troopjs-dom/application/widget",
   "troopjs-net/ajax/service"
  ]
 },

 "deps": [
  "require",
  "jquery",
  "fastclick",
  "bootstrap/js/bootstrap.min"
 ],

 "callback": function (localRequire, jQuery, FastClick) {
  // Add document ready handler
  jQuery(function ($) {
   var body = document.body;

   // Fix mobile touch
   FastClick.attach(body);

   // Chrome allows you to click `forbidden` elements inside buttons
   $(body).on("click", "button > span.glyphicon-play", function ($event) {

    return $($event.target)
     .parent()
     .click();
   });
  });

  // Require additional modules and start TroopJS
  localRequire([
   "troopjs-dom/application/widget",
   "troopjs-net/ajax/service"
  ], function (Application, Ajax) {
   jQuery(function ($) {
    Application($("html"), "bootstrap", Ajax()).start();
   });
  });
 }
});

Tengo una copia de seguridad del tema modificado en el disco duro.

Para modificarlo hay que modificar los dos plist que hay en la carpeta Current.plist y AsymmetricHD.plist, son exáctamente iguales y tienen que ser exáctamente iguales.

Si te fijas cada apartado (PHONE, MESSAGES) está formado por un IDBundle (si recibe notificaciones) y un Action que es el que hace el verdadero launch de la app.

el string del Bundle Id que está formado por 4 números (coordenadas), se corresponden con la posición del cuadradito rojo de la notificación de la app.

el string del Action que está formado por 4 números (coordenadas), se corresponden a las coordenadas de el cuadrado de texto (PHONE, MESSAGE).

Los valores del del Actión siempre son los mismos, independientemente de la página en la que se encuentre, solo varía la altura (segunda coordenada), veamos un ejemplo de la última columna:

SETTINGS -> 0,12,225,41
MAPS -> 0,56,225,41
YOUTUBE -> 0,100,225,41
PHOTOS -> 0,144,225,41
ADRESS -> 0,188,225,41
CALCULADORA -> 0,232,225,41
iBOOKS -> 0,276,225,41
COMPAS -> 0,320,225,41
SKYPE -> 0,364,225,41
NOTAS -> 0,408,225,41

Si fuese la segunda colúmna por ejemplo, los valores serían los mismos, ya que el lienzo está dividido en frames a los que se ajustan estas coordenadas.

para saber más o menos donde colocar el cuadradito de las notificaciones usar el segundo parametro igual al segundo parametro del Action e ir moviendo a partír de ahí.

El primer parametro es la altura y el segundo la anchura.

Todas las clases en C# heredan el método ToString de la clase Object (clase de la cual heredan todas las demás y de la cual hablaremos más adelante).

El método ToString convierte a la instancia que lo llama en una cadena de tipo string.

Si creamos una clase nueva, tenemos que sobrecargar la clase ToString para que el compilador sepa como devolverla como cadena.

Veamoslo con un ejemplo, tenemos la siguiente clase:

public class Person
{
   //CAMPOS
   string firstName;
   string lastName;
   DateTime birthDate;

   //METODOS

   //CONSTRUCTOR
   public Persona(string firstName, string lastName, DateTime birthDate)
   {
       this.firstName = firstName;
       this.lastName = lastName;
       this.birthDate = birthDate;
   }
}

Como vemos la clase solo tiene campos y un constructor, vamos a ver que ocurre en este caso si invocamos al método ToString:

static void Main(string args[])
{
    Person.friend = new Person("Mar", "Gil", new DateTime(1980, 10, 12));
    Console.WriteLine(friend.ToString());
    Console.ReadLine();
}

Pues lo que ocurre es que la salida del programa anterior es:

HumanResources.Person

(Lo de HumanResources es porque Person lo hemos creado en el namespace HumanResources, nada importante).

Esta salida nos está diciendo que el metodo ToString de HumanResources.Person no está sobrecargado y que el compilador no sabe como mostrarlo.

Realicemos pues, nosotros la sobrecarga:

public class Person
{
   //CAMPOS
   string firstName;
   string lastName;
   DateTime birthDate;

   //METODOS

   //CONSTRUCTOR
   public Persona(string firstName, string lastName, DateTime birthDate)
   {
       this.firstName = firstName;
       this.lastName = lastName;
       this.birthDate = birthDate;
   }

   //SOBRECARGA de ToString
   public override string ToString()
   {
       return firstName + " " + lastName + " " + "(" + birthDate.Day + "/" +
              birthDate.Month + "/" + birthDate.Year + ")";
   }
}

Ahora si que al repetir el código del Main que he puesto antes se imprimiría por pantalla lo siguiente:

Mar Gil (12/10/1980)

MUY IMPORTANTE: Fijemonos que en la sobrecarga del método ToString hemos puesto override, esto significa que, aunque Person ya tiene un método ToString predefinido (el que hereda de object), estamos sobrecargandolo y, a partir de ahora, el método utilizado por la clase será el definido por nosotros.

Los operadores (por ejemplo el operador resta operator -) son siempre métodos estáticos.

Veamos por ejemplo la definición del operador resta de la clase DateTime:

public static TimeSpan operator -(DateTime d1, DateTime d2);

Gracias a esta definición (en el ejemplo no se ve la implementación) podemos restar una fecha a otra del modo a - b y esto ns devuelve un TimeSpan.

En la ayuda se marcan con el simbolo de la S.

Elementos que pueden ser estáticos:

• CAMPOS ESTÁTICOS:
  
  Es como una variable global de un lenguaje procedimental (como por ejemplo C).
  
  Como ejemplos de campos estáticos tenemos, en la clase System.DateTime los campos estáticos MinValue y MaxValue.
  
  Un ejemplo de como llamamos a estos campos es el siguiente:
  

  static void Main(string[] args)
  {
      Console.WriteLine("Pasado: {0}", DateTime.MinValue);
      Console.WriteLine("Futuro: {0}", DateTime.MaxValue);
  }
  

  
  La salida que produce este fragmento de código es la siguiente:
  
  Pasado: 01/01/0001 0:00:00
  Futuro: 31/12/9999 23:59:59
  
  Como ya sabemos, cuando se crean objetos de una clase, todos los objetos de la misma comparten los métodos de la clase, pero no comparten sus campos y propiedades, es decir cada objeto posee sus propios campos y propiedades.
  
  Haciendo static a un campo lo que conseguimos es que sea compartido por todos los objetos de la clase.
  
  En el ejemplo de la clase DateTime, el valor del MinValue es para todos los objetos el 01/01/0001 0:00:00 y para el MaxValue el 31/12/9999 23:59:59
  
  Otra cosa importante que hay que tener muy en cuenta es que para llamar a un campo static no se hace a través de un objeto de la clase, sinó que se hace a través del nombre de la clase, seguido de un punto y el nombre del campo. En el caso de la clase DateTime, es Datetime.MinValue por ejemplo.
  
  Veamos ahora un ejemplo más elaborado, tenemos la siguiente clase:
  
  

  namespace Employee
  {
      public class Employee
      {
          public static int EmployeeCounter = 0;
  
          public Employee()
          {
              EmployeeCounter++;
          }
      }
  }
  

  
  Como vemos en esta clase tenemos un campo estático ( EmployeeCounter ) y un constructor que cada vez que se cree una instancia de Employee sumará 1 a nuestro campo estático.
  
  Como ya hemos comentado los campos estáticos son compartidos por todas las instancias de la clase por lo que todos tendrán el mismo valor a medida que se vayan creando instancias de la clase.
  
  Ejemplo de uso de esta clase:
  
  

  static void Main(string[] args)
  {
      Employee e1 = new Employee(); 
      Console.WriteLine("Numero de instancias: {0}", Employee.EmployeeCounter);
      //Devuelve  Numero de instancias: 1
      
      Employee e1 = new Employee();
      Console.WriteLine("Numero de instancias: {0}", Employee.EmployeeCounter);
      //Devuelve  Numero de instancias: 2
  }
  

• MÉTODOS ESTÁTICOS:
  
  Los métodos estáticos son como una función de un lenguaje procedimental (como por ejemplo C)
  
  
  Ejemplo:
  
  

  public class IsLeapYear
  {
     public static void Main()
     {
        for (int year = 1994; year <= 2014; year++)
        {
           if (DateTime.IsLeapYear(year))
           {
              Console.WriteLine("{0} is a leap year.", year);
              DateTime leapDay = new DateTime(year, 2, 29);
              DateTime nextYear = leapDay.AddYears(1);
              Console.WriteLine("   One year from {0} is {1}.", 
                                leapDay.ToString("d"), 
                                nextYear.ToString("d"));
           }         
        }
     }
  }
  // The example produces the following output:
  //       1996 is a leap year.
  //          One year from 2/29/1996 is 2/28/1997.
  //       2000 is a leap year.
  //          One year from 2/29/2000 is 2/28/2001.
  //       2004 is a leap year.
  //          One year from 2/29/2004 is 2/28/2005.
  //       2008 is a leap year.
  //          One year from 2/29/2008 is 2/28/2009.
  //       2012 is a leap year.
  //          One year from 2/29/2012 is 2/28/2013.
  
  

• PROPIEDADES ESTÁTICAS:
  
  Ocurre exáctamente lo mismo que con los campos.
  
• CLASES ESTÁTICAS:
  
  Son clases que se definen solo para agrupar miembros estáticos, no para crear instancias. System.Math (la que hemos usado en uno de los ejemplos anteriores) es un buen ejemplo de una clase de la que nunca se crean instancias porque sus métodos son estáticos.
  
  Las clases estáticas se deben marcar con la palabra static para que el compilador pueda asegurar que no se crean instancias suyas.
  
• CONSTRUCTORES ESTÁTICOS:
  
  Podemos definir constructores estáticos (sin parámetros) para inicializar campos estáticos.
  
  Un constructor estático se marca con la palabra static y no se invoca nunca explicitamente. El entorno de ejecución se asegura de que se ejecute el constructor estático antes de que usemos cualquiera de sus campos o métodos y antes de que se instancie ningún obeto de la clase (si es que la clase no es estática).
  
  Usar un constructor estático es útil, cuando queremos inicializar variables (tipicamente de solo lectura) cuyo valor no se puede conocer en tiempo de compilación, bien porque depende del estado del entorno de ejecución o bien porque requieren de la ejecución de funciones o métodos que solo pueden invocarse en ejecución.
  
  

CONST

Por último, muy interesante e importante, un tipo de campo estático especial que no se marca con la palabra static son las constantes. Cuando quieres dfinir un valor que no puede cambiar en tiempo de ejecución en vez de usar static se utiliza const, esto es porque como no van a variar es tonteria guardar una copia de esta variable en cada instancia (ahorrando memória). Ejemplo de campos const son por ejemplo los que encontramos en la clase Math para definir algunas constantes como por ejemplo el número E o PI:

public static class Math
{
   public const double E = 2.71828;
   public const double PI = 3.14159;
}

Para imprimir en nuestro programa el valor de  PI  por ejemplo haríamos;

Console.WriteLine(Math.PI);

MUY IMPORTANTE: Saber que los métodos, campos y propiedades estáticos no participan en la herencia, por lo que, por ejemplo los operadores sobrecargados de una clase, no son heredados por otra hija de esta.

¿Por qué debería interesarme el MVVM?

¿Qué razón hay, como desarrolladores, para siquiera poner atención al Modelo-Vista-Modelo de Vista? El patrón aporta varios beneficios tanto a WPF como a Silverlight. Antes de continuar, vale preguntarse:

• ¿Necesito compartir mi proyecto con un diseñador y tener la flexibilidad de que ambos aspectos de diseño y desarrollo se lleven a cabo casi simultáneamente?
• ¿Requiero pruebas unitarias comprensivas para mis soluciones?
• ¿Es importante para mí el tener componentes reutilizables tanto dentro de un proyecto como a través de mi organización?
• ¿Desearía yo tener mayor flexibilidad para poder cambiar la interfase al usuario en una aplicación sin tener que reorganizar su lógica?

MVVM a grandes rasgos

Examinemos las partes principales de MVVM, empezando con un fundamento esencial para toda aplicación: los datos. Estos son contenidos en el modelo.

El Modelo

El modelo representa los datos o información con la que trabajamos y por eso me gusta llamarlo el objeto del dominio. Un ejemplo de modelo puede ser un contacto (con su nombre, número de teléfono, dirección y demás) o la descripción de un punto de publicación para un medio audiovisual transmitido en vivo.

La clave para recordar el modelo es que contiene la información, pero no las acciones o servicios que la manipulan. No es responsable de darle forma para que se vea bien en la pantalla, o de obtener una lista de elementos de un servidor remoto (de hecho, en tal lista cada elemento sería a su vez un modelo). La lógica de la aplicación o “reglas empresariales” son generalmente mantenidas en clases separadas del modelo y actúan en él. Aunque no siempre es cierto, a veces el modelo puede validar la información.

No es fácil mantener el modelo nítido, especialmente al representar entidades del mundo real. Por ejemplo, el registro de un contacto puede que incluya la fecha en que fue modificado por última vez junto con la identidad de quien hizo la modificación (para efectos de auditoría), demás de identificador único (usado en la base de datos o similar). La fecha de modificación no tiene ninguna conexión con el contacto en la vida real, pero es un efecto secundario asociado con la forma en la utilizamos, le damos seguimiento, y la almacenamos en el sistema.

La Vista

La vista es la parte con la que estamos más familiarizados y la que ve el usuario. Su papel es representar la información, tomándose a veces ciertas libertades con el fin de hacerla más clara o presentable. Por ejemplo, una fecha podría ser representada en el modelo como el número de segundos contados desde la medianoche del primero de enero de 1970 (Tiempo Unix). Sin embargo, el número es presentado al usuario en forma de día, mes y año en su zona horaria local. Una vista puede también contener ciertos comportamientos, como el aceptar la entrada de datos. La vista se encarga de esta faceta (teclas presionadas, movimientos del ratón, gestos en una pantalla táctil, y así por el estilo) que eventualmente ejerce influencia en las propiedades del modelo.

En MVVM la vista es activa. A diferencia de una vista pasiva sin conocimiento del modelo, y bajo el manejo total de un controlador o presentador, la vista en MVVM contiene comportamientos, eventos y enlaces a datos que, hasta cierto punto, necesitan saber sobre el modelo subyacente y el modelo de vista. Aunque tales eventos y comportamientos son asociados a propiedades, métodos y comandos, la vista es aún responsable de manejar sus propios eventos y no pasa esta tarea al modelo de vista.

Algo digno de recordar sobre la vista es que no es responsable de llevar cuenta de su estado. El modelo de vista se encarga de ello y mantiene la vista al tanto de los cambios.

El modelo de vista (Nuestro controlador o presentador)

El modelo de vista introduce el concepto de Separación de la Presentación, es decir, mantiene al modelo separado y protegido de los minuciosos detalles de la vista. Por eso es que el modelo de vista es la pieza clave del trío. Esta separación permite que el modelo se limite a contener los datos, en vez de verse obligado a saber la forma en que se presenta una fecha al usuario y tener que hacer la conversión de formato. De igual manera, la vista sólo tiene que presentar la fecha. El controlador trabaja como intermediario entre ambos, recibiendo información de la vista e insertándola en el modelo, o actuando con un servidor para obtener datos del modelo y luego convertirlos en propiedades que pueden ser usadas en la vista.

El modelo de vista también hace disponibles métodos, comandos y otros puntos de acceso que ayudan a mantener el estado de la vista, manipular el modelo en respuesta a acciones de la vista y disparar eventos en la misma.

link MVVM EXPLICADO

El degradado radial para safari es dificil de entender, lo mejor es coger y probarlo.

Poner este código donde quiera probarlo:

background: -webkit-gradient(radial, 500 25%, 0, 500 25%, 40, from(#E5E5E5), to(#919191));

Después modificar uno a uno los parámetros para ver como lo maneja, tiene muchas mas opciones que el de firefox.

Buena web para ver los degradados para varios exploradores:

http://css-tricks.com/5700-css3-gradients/

Tanto las clases como sus métodos y campos pueden ser publicos o privados (más adelante veremos que existen dos casos más, protected e internal) pero por ahora lo más interesante es diferenciar entre public y private.

Public: Permite el acceso a la clase metodo o campo desde fuera de la propia clase.

EJEMPLO DEFINICIÓN CLASE PUBLICA:

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

namespace Fechas
{
    public class Program
    {
    }
}

EJEMPLO METODO Y CAMPO PUBLIC:

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

namespace Personas
{
    public class Person
    {
        //CAMPOS
        string firstName;
        string lastName;
        DateTime birthDate;
        public int contador;

        //CONSTRUCTOR DE LA CLASE
        public Persona(string firstName, string lastName, DateTime birthDate)
        {
            this.firstName = firstName;
            this.lastName = lastName;
            this.birthDate = birthDate;
        }
    }
}

Private: El elemento solo es accesible desde la propia clase.

Todo lo que no ponemos que sea public, es privated por defecto, es decir, como habitualmente los campos de una clase son privados, no necesitamos poner private ya que al no poner public, nadie podrá acceder a el desde fuera de la clase.

Para cada objeto declarado de una clase se mantiene una copia de sus campos, pero todos comparten la misma copia de los métodos de la clase.

Cada método de una clase puede hacer referencia a los campos de un objeto, modificarlos o leerlos, pero si sólo hay una copia del método y varios objetos de esa clase, ¿cómo hace el método para referirse a un dato de un objeto en concreto?

La respuesta es: usando el puntero especial llamado this.
Se trata de un puntero que tiene asociado cada objeto y que apunta a si mismo. Ese puntero se usa para acceder a sus miembros.

El puntero this nos permite acceder a los campos del objeto que llama al método.

EJEMPLO EN C++:

En este ejemplo se ilustra una forma de saber si el objeto que se pasa como parámetro es el mismo que el que hace la llamada (comprueba si ambos apuntan al mismo sitio).

using namespace std;

class clase {
  public:
   clase() {}
   void EresTu(clase& c) {
      if(&c == this) cout << "Sí, soy yo." << endl;
      else cout << "No, no soy yo." << endl;
   }
};
   
int main() {
   clase c1, c2;
   
   c1.EresTu(c2);
   c1.EresTu(c1);
}

OTRO EJEMPLO EN C++: Tenemos la siguiente clase pareja.

class pareja {
   public:
      // Constructor
      pareja(int a2, int b2);
      // Funciones miembro de la clase "pareja"
      void Lee(int &a2, int &b2);
      void Guarda(int a2, int b2);
   private:
      // Datos miembro de la clase "pareja"
      int a, b; 
};

Con la clase Guarda, asignamos los enteros que le pasamos al método como parámetros a los campos del objeto que ha hecho la llamada. La forma más sencilla de hacer esto sería así:

void pareja::Guarda(int a2, int b2) {
   a = a2;
   b = b2;
}

Pero para ver el funcionamiento del this, tambien lo podriamos hacer así:

void pareja::Guarda(int a2, int b2) {
   this->a = a2;
   this->b = b2;
}

En .NET el uso es el mismo pero cambiando el this-> por this. EJEMPLO EN .NET:

public class Person
{
   string firstName;
   string lastName;
   DateTime birthDate;

   public Persona(string firstName, string lastName, DateTime birthDate)
   {
       this.firstName = firstName;
       this.lastName = lastName;
       this.birthDate = birthDate;
   }
}

En las clases de C# podemos distinguir 3 tipos de elementos.

- Campos: Se refiere a lo que en C++ llamamos atributos de la clase, es decir, un campo es un dato común a todos los objetos de una determinada clase.

EJEMPLO:

class Persona

{
    string Nombre;     // Campo de cada objeto Persona que almacena su nombre
    int Edad;          // Campo de cada objeto Persona que almacena su edad
    string NIF;        // Campo de cada objeto Persona que almacena su NIF
}

- Métodos: Son "funciones" que nos permiten realizar determinadas cosas relacionadas con la clase.


EJEMPLO:

class Persona

{
    //CAMPOS CLASE PERSON
    string Nombre;     // Campo de cada objeto Persona que almacena su nombre
    int Edad;          // Campo de cada objeto Persona que almacena su edad
    string NIF;        // Campo de cada objeto Persona que almacena su NIF

    //ESTE ES EL MÉTODO CUMPLEAÑOS
    void Cumpleaños()  // Incrementa en uno de la edad del objeto Persona
    {
       Edad++;
    }
}

- Propiedades: Una propiedad es una mezcla entre el concepto de campo y el concepto de método.

Se parecen a un campo porque se usan como un campo al que se le puede asignar o acceder a un valor.

Se parecen a un método porque pueden ejecutar código como por ejemplo comprobaciones y cálculos.

Aunque se asemejen a un método, el acceso a las propiedades no utiliza un () al final, es decir, por ejemplo, tenemos un objeto Datetime d y queremos hacer uso de la propiedad Year de la clase para mostrar el año por pantalla pues haríamos: Console.WriteLine(d.Year)

A continuación un ejemplo mas elaborado haciendo uso de las propiedades Year, Month y Day de la clase DateTime.

EJEMPLO:

static void Main(string[] args)
{
    DateTime d = new DateTime(2011, 10, 18, 13, 30, 0);
    Console.WriteLine("Año: {0}", d.Year);
    Console.WriteLine("Mes: {0}", d.Month);
    Console.WriteLine("Dia: {0}", d.Day);
    Console.ReadLine();
}

Más adelante dedicaré un post entero para profundizar en el uso de las propiedades.

Seguimos con el recordatorio de C++ comparando la forma en que le pasamos los parametros a una función o procedimiento.

Hay dos formas:

Por VALOR

Los parámetros de entrada (valor) se usan para proporcionar información de entrada a un
procedimiento. Dentro de éste pueden considerarse como variables cuyo valor inicial es el resultado de
evaluar los parámetros actuales. Como parámetro actual debe aparecer una expresión cuyo resultado
sea un valor de un tipo asignable al correspondiente parámetro formal. Puesto que las variables usadas
como parámetros formales de entrada no sirven para cambiar a los parámetros actuales (sólo para
conocer su valor en el momento de la llamada y asignarle un nombre a ese valor dentro del
procedimiento) se les suele denominar Parámetros por valor.

Ejemplo:

void dibLineas( int anchura, int altura )
{
int nFila;
int nColumna;
for( nFila = 1 ; nFila <= altura; ++nFila )
{
for( nColumna = 1; nColumna <= anchura; ++nColumna )
{
cout << "-";
}
cout << endl;
}
}

Por REFERENCIA

Para usar parámetros de entrada/salida, el parámetro formal debe estar precedido por el símbolo & y el parámetro actual debe ser una variable (no una expresión cualquiera). Los parámetros de entrada/salida se usan cuando se desea que un procedimiento MODIFIQUE el contenido de la variable actual. El hecho de definir estos parámetros explícitamente como variables hace consciente al programador de los lugares donde un procedimiento cambia a una variable que se le pase como parámetro. El funcionamiento de los parámetros de entrada/salida está basado en pasar al procedimiento una referencia a la variable actual en lugar de su valor.

Ejemplo:

void raices( double a, double b, double c, double &R1, double &R2 )
{
   double DiscriminanteS;
   // Se supone un discriminante positivo
   DiscriminanteS = sqrt( b*b-4.0*a*c );
   R1 = (-b + DiscriminanteS) / (2.0*a);
   R2 = (-b - DiscriminanteS) / (2.0*a);
}

Hagamos un breve recordatorio de C++.

En C++ no hay diferencias entre procedimientos y funciones: todo son funciones, con la diferencia de que un procedimiento es una función que no devuelve nada (void).

Es decir:

Función: Devuelven resultado en el return.

Ejemplo:

int mi_funcion( int x)
{
return 0;
}

Procedimiento: No devuelven resultado.

Ejemplo:

void dibLineas( int anchura, int altura )
{
  int nFila;
  int nColumna;

  for( nFila = 1 ; nFila <= altura; ++nFila )
  {
    for( nColumna = 1; nColumna <= anchura; ++nColumna )
    {
      cout << "-";
    }
    cout << endl;
  }
}

Hay dos formas bastante interesantes y potentes para acceder a la documentación de clases que ofrece .NET como por ejemplo la clase DateTime.

Si queremos acceder a la definición de las cabeceras de los métodos de la clase, podemos hacerlo colocando el cursor sobre la palabra DateTime, haciendo click en el botón secundario y dandole a Ir a definición F12.

Otra forma de acceder a la información de la clase mucho más descriptiva y atractiva es poniendonos encima del nombre DateTime con el cursor y pulsando F1.

La segunda opción será la que más se utilice.

Para empezar con la programación en .NET haremos uso de una Clase (la clase DateTime) que forma parte de la libreria System que se incluye por defecto en todos los proyectos de .NET.

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

namespace Fechas
{
    class Program
    {
        static void Main(string[] args)
        {
            DateTime d;
            d = new DateTime(2011, 10, 18);
            Console.WriteLine(d.ToString());
            Console.ReadLine();
        }
    }
}

Lo interesante de este codigo es:

Los using son como los include de C y C++, nos permite añadir bibliotecas a nuestro proyecto.

Al hacer DateTime d estamos creando una instancia u objeto de la clase System.DateTime, realmente para crearla deberíamos o podríamos haber puesto System.DateTime d pero como tenemos el using System ya nos declara en nuestro proyecto que estamos haciendo uso del espacio de nombres (namespace) System por lo que no es estrictamente necesario añadirlo.

NEW: La palabra reservada new invoca al constructor de la clase, en nuestro caso al constructor de la clase se le pasan 3 parametros - año, mes y dia -

Console.WriteLine(): Permite escribir una linea por consola y añade un retorno de carro al final, si no se quiere que se introduzca dicho retorno de carro se ha de utilizar Console.Write()

Console.ReadLine(): Permite leer lo que se escriba en la consola en el momento en que se ejecuta esta instrucción.

En este ejemplo solo la utilizamos para que el programa no termine sin esperar a que el usuario realice alguna acción.

d.ToString(): El método ToString es heredado de la Clase Object (hablaré en otro post de ello) y permite convertir a string algunos tipos de datos como por ejemplo DateTime, no es necesario invocarlo explicitamente en este caso ya que el método Console.ReadLine() requiere un tipo string y por ello el toString es invocado automáticamente, es decir, si hacemos Console.WriteLine(d) nos devuelve lo mismo que en el ejemplo.

Aunque existan cientos de lenguajes diferentes, estos se pueden agrupar segun las distintas filosofías que han seguido y la forma de trabajar que implican.

Lenguajes procedimentales o imperativo

El paradigma por procedimientos, representa el enfoque tradicional del proceso de programación.
Se define el proceso de programación como el desarrollo de procedimientos que, al seguirse, manipulan los datos para producir el resultado deseado. Así, el paradigma por procedimientos nos dice que abordemos un problema tratando de hallar un método para resolverlo, es decir, se pregunta ¿Qué procedimiento necesitamos para resolver el problema?  (uso de funciones)

EJEMPLO: Ansi-C

Lenguajes declarativos

En contraste, consideremos el paradigma declarativo que hace hincapié en la pregunta ¿Cuál es el problema? en vez de ¿Qué procedimiento necesitamos para resolver el problema?. Lo importante aquí es descubrir e implantar un algoritmo general para la resolución de problemas, después de lo cual se podrán resolver éstos con sólo expresarlos en una forma compatible con dicho algoritmo y aplicarlo. En este contexto, la tarea del programador se reduce a crear un enunciado preciso del problema, más que a descubrir un algoritmo para resolverlo.

Desde luego, el principal obstáculo para crear un lenguaje de programación basado en el paradigma declarativo es el descubrimiento del algorimo básico para resolver problemas. Por esta razón, los lenguajes declarativos tienden a ser de propósito específico, diseñados para usarse en aplicaciones particulares.

EJEMPLO: SQL

Lenguajes funcionales

la programación funcional es un paradigma de programación declarativa basado en la utilización de funciones aritméticas que no maneja datos mutables o de estado.
Enfatiza la aplicación de funciones, en contraste con el estilo de programación imperativa, que enfatiza los cambios de estado.

En la práctica, la diferencia entre una función matemática y la noción de una "función" utilizada en la programación imperativa es que las funciones imperativas pueden tener efectos secundarios, al cambiar el valor de calculos realizados previamente. Por esta razón carecen de transparencia referencial, es decir, la misma expresión lingüística puede resultar en valores diferentes en diferentes momentos dependiendo del estado del programa siendo ejecutado. Con código funcional, en contraste, el valor generado por una función depende exclusivamente de los argumentos alimentados a la función. Al eliminar los efectos secundarios se puede entender y predecir el comportamiento de un programa mucho más fácilmente, y esta es una de las principales motivaciones para utilizar la programación funcional.

EJEMPLO: R, Mathematica.

Se usan sobre todo en programas matemáticos

Programación con lenguajes Orientados a Objetos

El término programación orientada a objetos se refiere a un estilo de programación por lo que un lenguaje orientado a objetos puede ser tanto imperativo como declarativo; lo que los caracteriza es la forma de manejar la información: clase, objeto y herencia. En este enfoque, las unidades de datos se consideran objetos activos, en vez de las unidades pasivas contempladas por el paradigma por procedimientos tradicional.

Para aclarar esto, consideremos una lista de nombres.

En el paradigma por procedimientos, esta lista no es más que una colección de datos, y cualquier programa que quiera trabajar con ella deberá incluir los algoritmos para realizar las manipulaciones requeridas. Así, la lista es pasiva en el sentido de que la mantiene un programa controlador, en vez de tener la responsabilidad de mantenerse ella misma.

En el enfoque orientado a objetos la lista se considera como un objeto formado por la lista misma y por una serie de rutinas para manipularla. Por ejemplo, pueden ser rutinas para insertar una nueva entrada en la lista, para detectar si la lista está vacía o para ordenar la lista. De este modo, un programa que obtiene acceso a esta lista no necesita contener algoritmos para efectuar esas tareas; simplemente aprovecha las rutinas suministradas en el objeto.

EJEMPLO: C++

En caso de que cambie o pierda el tema de este blog, recordar que para que funcione el sistema para mostrar codigo fuente como si de un IDE se tratase, hay que poner dentro del head las siguientes instrucciones:

<link href='http://alexgorbatchev.com/pub/sh/current/styles/shCore.css' rel='stylesheet' type='text/css'/>
<link href='http://alexgorbatchev.com/pub/sh/current/styles/shThemeDefault.css' rel='stylesheet' type='text/css'/>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shCore.js' type='text/javascript'/>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushCpp.js' type='text/javascript'/>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushCSharp.js' type='text/javascript'/>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushCss.js' type='text/javascript'/>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushJava.js' type='text/javascript'/>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushJavaFX.js' type='text/javascript'/>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushJScript.js' type='text/javascript'/>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushPhp.js' type='text/javascript'/>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushSql.js' type='text/javascript'/>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushXml.js' type='text/javascript'/>
<script language='javascript'>
SyntaxHighlighter.config.bloggerMode = true;
SyntaxHighlighter.config.clipboardSwf = "http://alexgorbatchev.com/pub/sh/current/scripts/clipboard.swf";
SyntaxHighlighter.all();
</script>

Para usarlo con C# por ejemplo hay que hacerlo de la siguiente manera:

<pre class="brush: csharp">

//Codigo fuente

</pre>

Para que marque la sintaxis de otros lenguajes solo tenemos que cambiarle el brush al pre class.

Para ver todos los brushes y más opciones:

blog de Jorge Alfonso García

Este es un blog personal pensado para mantener subidos a la red pequeños resúmenes de mis apúntes de informática, para tenerlos a mano desde cualquier ordenador en cualquier momento.

Voy a Empezar con apuntes de .NET programando en C#  aunque realmente los primeros posts son aplicables a cualquier lenguaje de programación moderno.

Aquí mi primer código fuente.

int main(string[] args)
{
Console.WriteLine("Hello, World!");
}