Archive for the ‘programación’ Category

1 09
05
2011

Cómo integrar WSE 3.0 en Visual Studio 2008

Lunes, mayo 9th, 2011

Recientemente en el trabajo, estamos desarrollando un proyecto en el que interactuar con un web services con WSE 3.0 integrada.

Por lo tanto, el primer paso fue instalar Web Service Enhancements (WSE) 3.0 for Microsoft .NET descargando el instalable desde esta dirección Web Service Enhancements (WSE) 3.0 for Microsoft .NET.

Una vez finalizada la instalación, no dispondremos todavía de esta herramienta integrada dentro de Visual Studio 2008. Para incorporar WSE 3.0 a nuestro entorno de trabajo Visual Studio 2008, podemos realizar los siguientes pasos:

1. Acudimos al directorio de instalación, en mi caso por ejemplo C:\Documents and Settings\All Users\Datos de programa\Microsoft\MSEnvShared\Addins

2. Editamos con el notepad (o similar) el archivo WSESettingsVS3.Addin (veréis que tiene formato xml)

3. Buscamos y sustituimos <Version>8.0</Version> por <Version>9.0</Version>, y finalmente guardamos los cambios.

4. Para terminar, abrimos Visual Studio 2008 y accedemos a: Tools (Herramientas) > Options (Opciones) > Add-in/Macros Security (Seguridad de Macros/Complementos)

5. Y añadimos nuestro directorio de instalación indicado en el punto 1 tal y como muestra la siguiente imagen.

Integrar WSE 3.0 en Visual Studio 2008

Integrar WSE 3.0 en Visual Studio 2008

No olvides “reiniciar” Visual Studio para contemplar los cambios realizados.

Ya podemos trabajar con WSE 3.0 integrado en Visual Studio 2008.

Integrar WSE 3.0 en Visual Studio 2008 - WSE 3.0 Settings

Integrar WSE 3.0 en Visual Studio 2008 - WSE 3.0 Settings

1 08
05
2011

Comprobar si existe un elemento con jQuery

Domingo, mayo 8th, 2011

Comprobar si existe un elemento con jQuery es muy sencillo.

Simplemente tenemos que ejecutar el siguiente código indicando en el selector de jQuery el identificador, clase o condición del elemento que estamos buscando para conocer si existe.


// Comprueba si existe algún elemento con el identificador "identifier"

if ($('#identifier').length) {

// Do something

}


// Comprueba si existe algún elemento con la clase css "mycssclass" asociado

if ($('.mycssclass').length) {

// Do something

}


// Comprueba si existe algún elemento de tipo radio-button

if ($(':radio').length) {

// Do something

}

 

9 01
05
2011

Obtener el valor de un radio button con Javascript (con y sin jQuery)

Domingo, mayo 1st, 2011

Siempre se me olvida, no sé cómo lo hago pero cuando estoy programando y necesito recoger el valor del radio button seleccionado… me surge siempre la misma pregunta: ¿y esto cómo se hacía?

jQuery

jQuery

Así que comparto con vosotros y me lo anoto para mí mismo la forma de recoger el valor del radiobutton seleccionado con la ayuda de jQuery.

Disponemos del siguiente grupo de radio-buttons dentro de un formulario para indicar el género o sexo de un usuario, y deseamos conocer el valor del botón de tipo radio seleccionado:

</p>
<p><label><input type="radio" id="gender-male" name="gender" value="male"/> Hombre</label><br />
<label><input type="radio" id="gender-female" name="gender" value="female"/> Mujer</label></p>
<p>

Mediante jquery podemos obtener el valor actual del radio con cualquiera de las siguientes líneas:

</p>
<p>var gender = $("input:radio[name='gender']:checked'").val();<br />
var gender = $("input[@name='gender']:checked").val();</p>
<p>

Y para los nostálgicos, cómo recoger el valor del radiobutton con javascript, sin ayuda de la librería jQuery (ayns… que recuerdos me trae esta función…):

</p>
<p>function getValueRadio(nombreFormulario,nombreCampo){<br />
  var longitud = eval("document."+nombreFormulario+"."+nombreCampo+".length")<br />
  for (var l=0; l<longitud; l++){<br />
    if (eval("document."+nombreFormulario+"."+nombreCampo+"["+l+"].checked"))<br />
        return eval("document."+nombreFormulario+"."+nombreCampo+"["+l+"].value");<br />
  }<br />
  return null;<br />
}//getValueRadio<br />
0 21
04
2011

Character decoding failed

Jueves, abril 21st, 2011

Hace algunos días, programando unos scripts en los que enviaba una petición a un servlet de Java a través de AJAX, me encontré con el siguiente mensaje de error en la consola, en mi caso, de Apache Tomcat:

02-abr-2011 23:50:29 org.apache.tomcat.util.http.Parameters processParameters
ADVERTENCIA: Parameters: Character decoding failed.
Parameter skipped.{id=[Ljava.lang.String;@137c90d, id=[Ljava.lang.String;@1709902, nbsp; <span class=[Ljava.lang.String;@14d626e}java.io.CharConversionException: EOF

Lo que en un primer momento tenía pinta de ser uno de tantos problemas que te vuelven loco buscando soluciones por internet, pero sin embargo la solución era mucho más sencilla de lo esperado.

Dentro de la colección de parámetros que construía para enviar hacia el servlet de Java, podían existir en ocasiones caracteres especiales tales como ‘%’, ‘$’, etc, que generaban el error mencionado: Character decoding failed.

La solución a este problema pasaba simplemente por codificar la cadena a enviar por AJAX en formato unicode, y para ello utilizaremos la función de javascript escape.

El código quedaría parecido a estas líneas:

    var params = "id=" + textAreaName + "&value=" + escape(text);
    $.ajax({
        url: "/MyApp/ajax/http/edit?id=" + id,
        type: 'GET',
        data: params,
        success: function(){ // your code }
    });
0 30
01
2011

Internacionalización y localización en Java

Domingo, enero 30th, 2011

Hoy vamos a comprobar cómo conocer la cultura en la que se está ejecutando tu programa Java.

Pero, ¿qué es esto de la cultura?

El poder conocer la cultura en la que se está ejecutando un programa, nos permitirá acercarnos a construir un programa más agradable para el usuario final.

Además de las diferencias evidentes de idiomas, la cultura nos permitirá mostrar otros datos como fechas y números en los formatos correctos según la cultura y/o localización del cliente.

Un europeo, entenderá perfectamente la fecha 30/03/1983 como 30 de Marzo de 1983, mientras que un norte-americano esperaría 3/30/1983.

Nos permitirá la cultura por lo tanto internacionalizar nuestras aplicaciones de una forma más sencilla y elegante.

Para ello vamos a utilizar la clase Locale de java dentro del paquete java.util.

Según la propia definición de la clase Locale en la página de Sun… digo de Oracle: un objeto Locale representa una región geográfica, política y cultural específica.

Probemos con el siguiente código Java que utiliza la clase Locale de Java:

        Locale myLocale = Locale.getDefault();
        System.out.println("My country (ISO): " + myLocale.getCountry());
        System.out.println("My country name: " + myLocale.getDisplayCountry());

        System.out.println("My language (code): " + myLocale.getLanguage());
        System.out.println("My language (name): " + myLocale.getDisplayLanguage());

        System.out.println(myLocale.getDisplayName());

Este sencillo código nos permite conocer la cultura/localización de nuestra aplicación Java. Adicionalmente, estamos mostrando por pantalla algunas características del mismo como el país o el lenguaje actual.

La salida será la siguiente:

My country (ISO): ES
My country name: España
My language (code): es
My language (name): español
español (España)
My country (ISO): GB
My country name: United Kingdom
My language (code): en
My language (name): English
English (United Kingdom)

En futuros artículos veremos cómo seguir internacionalizando nuestras aplicaciones en Java.

0 28
11
2010

Reflexión: la gran desconocida en la programación

Domingo, noviembre 28th, 2010

“En informática, reflexión (o reflexión computacional) es la capacidad que tiene un programa de ordenador para observar y opcionalmente modificar su estructura de alto nivel.”

Esta es la definición que aparece en wikipedia en referencia al concepto de reflexión en el mundo de la informática y la programación.

Es una definición un tanto abstracta, pero que nos permite intuir en qué consiste todo esto de la reflexión.

Siendo más concretos y prácticos, el uso de la reflexión a nivel de programación, nos permitirá, entre muchas otras cosas, crear instancias u objetos de dinámicamente de tipos concretos a partir del nombre de su clase. Podremos además, acceder a la información de los objetos, conociendo y/o ejecutando sus atributos y métodos públicos; y todo ello en tiempo de ejecución.

Vamos a plantear un pequeño ejemplo práctico de introducción al uso de reflexión en el lenguaje de programación Java.

Imaginemos la siguiente estructura de clases definida en el diagrama UML que se muestra a continuación.

Diagrama UML Reflexión

Reflexión en Java

Definiremos en primer lugar una clase abstracta denominada Vehicle. Esta clase padre define 2 métodos abstractos (acelerar/speedUp y frenar/brake) que deberán ser implementados por todas aquellas clases hijas que deseen heredar de Vehicle.

Clase (padre) Vehicle

package es.v3.test.reflection;

/**
 * Clase abstracta padre
 * @author v3rgu1.com
 */
public abstract class Vehicle {

    public String name;

    public abstract void speedUp();

    public abstract void brake();

}//Vehicle

A continuación crearemos 2 clases hijas que implementarán la clase abstracta padre Vehicle

Clase (hija) Car


package es.v3.test.reflection;

/**
 * Clase hija que hereda de Vehicle y representa un vehículo de tipo coche.
 * @author v3rgu1.com
 */
public class Car extends Vehicle {

    @Override
    public void speedUp() {
        System.out.println("Me llamo " + this.name + " y soy un coche que está acelerando");
    }

    @Override
    public void brake() {
        System.out.println("Me llamo " + this.name + " y soy un coche que está frenando");
    }

}//Car

Clase (hija) Motorcycle


package es.v3.test.reflection;

/**
 * Clase hija que hereda de Vehicle y representa un vehículo de tipo motocicleta.
 * @author v3rgu1.com
 */
public class Motorcycle extends Vehicle {

    @Override
    public void speedUp() {
        System.out.println("Me llamo " + this.name + " y soy una moto que está acelerando");
    }

    @Override
    public void brake() {
        System.out.println("Me llamo " + this.name + " y soy una moto que está frenando");
    }

}//Motorcycle

Una vez creadas estas 3 clases con las que llevaremos a cabo nuestros próximos ejemplos relacionados con la reflexión en programación, vamos a crear una clase ejecutable (main) con la que crearemos instancias en tiempo de ejecución de las clases hijas definidas anteriormente. Recuperaremos además la información de cada una de ellas y ejecutaremos sus métodos públicos sin previo conocimiento de ellos.

Pasaremos 2 argumentos a nuestra clase ejecutable por línea de comandos: el nombre de la clase a instanciar (“Car” o “Motorcycle”) y el nombre de nuestro vehículo.
Vamos a crear una instancia en tiempo de ejecución del tipo indicado en el primer argumento, para utilizar después sus métodos implementados speedUp & brake.

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {

        String nameClass = args[0];
        String nameVehicle = args[1];
        try {
            Class vehicleClass = Class.forName("es.v3.test.reflection." + nameClass);
            Field[] fields = vehicleClass.getFields();
            Method[] methods = vehicleClass.getDeclaredMethods();
            try {
                Vehicle vehicle = (Vehicle) vehicleClass.newInstance();
                vehicle.name = nameVehicle;
                vehicle.speedUp();
                vehicle.speedUp();
                vehicle.brake();
                for (int i=0; i<fields.length; i++) {
                    Field field = fields[i];
                    System.out.println("Campo '" + field.getName() + "': " + field.get(vehicle));
                }//for i
                for (int i=0; i<methods.length; i++) {
                    Method method = methods[i];
                    System.out.println("Voy ejecutar el método: '" + method.getName() + "'");
                    method.invoke(vehicle);
                }//for i
            } catch (IllegalArgumentException ex) {
                Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
            } catch (InvocationTargetException ex) {
                Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
            } catch (InstantiationException ex) {
                Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
            } catch (IllegalAccessException ex) {
                Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
            }
        } catch (ClassNotFoundException ex) {
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
        }

    }//main

Con la ayuda del API reflect de Java, hemos instanciado una clase sin conocer a priori el tipo de la misma y únicamente a partir de su nombre, pero veamos más en detalle las funciones utilizadas en el ejemplo.

java.lang.Class forName(String className) javadoc
Devuelve el objeto Class asociado a la clase o interface indicada en el nombre que recibe por parámetro.

java.lang.Object newInstance() javadoc
Crea una nueva instancia del objeto representado por la clase actual.

java.lang.reflect.Field[] getFields() javadoc
Retorna un array con todos los atributos con acceso público de la clase o interfaz representada.

java.lang.reflect.Method[] getMethods() javadoc
Devuelve un array que contiene todos los métodos públicos de la clase o interfaz representada.

java.lang.reflect.Method[] getDeclaredMethods() javadoc
Devuelve un array que contiene todos los métodos declarados en la clase o interfaz representada.

En próximo artículos, veremos cómo realizar este mismo ejemplo de reflexión en otros lenguajes de programación, así como el uso técnicas de reflexión más avanzadas.

9 11
11
2010

DateDiff en C#

Jueves, noviembre 11th, 2010

Una de las funciones de Visual Basic que más echamos de menos a la hora de programar en C# es DateDiff.

Para aquellos que no la conozcan, la función DateDiff de Visual Basic (probablemente también os sonará de DateDiff de SQL Server) devuelve un valor numérico que especifica el número de intervalos de tiempo entre 2 fechas; o traducido al castellano, nos devuelve la diferencia entre 2 fechas.

Pues bien, ya que la función DateDiff no existe en sí en C#, vamos a proponer a continuación una alternativa a la misma:

/// <summary>
/// Demo DateTime.DateDiff
/// </summary>
public class DateTimeExtension
{

    /// <summary>
    /// Devuelve un valor Long que especifica el número de
    /// intervalos de tiempo entre dos valores Date.
    /// </summary>
    /// <param name="interval">Obligatorio. Valor de enumeración
    /// DateInterval o expresión String que representa el intervalo
    /// de tiempo que se desea utilizar como unidad de diferencia
    /// entre Date1 y Date2.</param>
    /// <param name="date1">Obligatorio. Date. Primer valor de
    /// fecha u hora que se desea utilizar en el cálculo.</param>
    /// <param name="date2">Obligatorio. Date. Segundo valor de
    /// fecha u hora que se desea utilizar en el cálculo.</param>
    /// <returns></returns>
    public static long DateDiff(DateInterval interval, DateTime date1, DateTime date2)
    {
        long rs = 0;
        TimeSpan diff = date2.Subtract(date1);
        switch (interval)
        {
            case DateInterval.Day:
            case DateInterval.DayOfYear:
                rs = (long)diff.TotalDays;
                break;
            case DateInterval.Hour:
                rs = (long)diff.TotalHours;
                break;
            case DateInterval.Minute:
                rs = (long)diff.TotalMinutes;
                break;
            case DateInterval.Month:
                rs = (date2.Month - date1.Month) + (12*DateTimeExtension.DateDiff(DateInterval.Year, date1, date2));
                break;
            case DateInterval.Quarter:
                rs = (long)Math.Ceiling((double)(DateTimeExtension.DateDiff(DateInterval.Month, date1, date2) / 3.0));
                break;
            case DateInterval.Second:
                rs = (long)diff.TotalSeconds;
                break;
            case DateInterval.Weekday:
            case DateInterval.WeekOfYear:
                rs = (long)(diff.TotalDays/7);
                break;
            case DateInterval.Year:
                rs = date2.Year - date1.Year;
                break;
        }//switch
        return rs;
    }//DateDiff
}

/// <summary>
/// Enumerados que definen los tipos de
/// intervalos de tiempo posibles.
/// </summary>
public enum DateInterval
{
    Day,
    DayOfYear,
    Hour,
    Minute,
    Month,
    Quarter,
    Second,
    Weekday,
    WeekOfYear,
    Year
}

Una vez que tengáis implementada vuestra función DateDiff en C#, podéis realizar alguna pequeña prueba comparativa con la función original DateDiff de Visual Basic para verificar que los resultados son los esperados en vuestras operaciones con fechas.

27 09
11
2010

Eliminar acentos y caracteres especiales en Java

Martes, noviembre 9th, 2010

En ocasiones nos puede resultar útil eliminar de una cadena de texto caracteres especiales, acentos o diacríticos (tíldes, diéresis, eñes, cedillas, etc).

Por ejemplo, en algunos sistemas de reservas aéreas o GDSs, como es el caso de Amadeus, necesitamos limpiar todos los textos que hacen referencia a nombres de pasajeros, direcciones y demás, de aquellos caracteres especiales no soportados por el sistema.

Vamos a ver 2 formas diferentes de eliminar estos caracteres especiales y acentos con 2 técnicas distintas:

1. Reemplazando cadenas de caracteres

    /**
     * Función que elimina acentos y caracteres especiales de
     * una cadena de texto.
     * @param input
     * @return cadena de texto limpia de acentos y caracteres especiales.
     */
    public static String remove1(String input) {
        // Cadena de caracteres original a sustituir.
        String original = "áàäéèëíìïóòöúùuñÁÀÄÉÈËÍÌÏÓÒÖÚÙÜÑçÇ";
        // Cadena de caracteres ASCII que reemplazarán los originales.
        String ascii = "aaaeeeiiiooouuunAAAEEEIIIOOOUUUNcC";
        String output = input;
        for (int i=0; i<original.length(); i++) {
            // Reemplazamos los caracteres especiales.
            output = output.replace(original.charAt(i), ascii.charAt(i));
        }//for i
        return output;
    }//remove1

2. Normalización Unicode. Descomposición canónica

Partamos en primer lugar del hecho de que un carácter puede ser representado de formas diferentes.
Visualicemos con un ejemplo estas diferentes formas de representar un mismo carácter:

        // Representación normal
        char c1 = 'í';
        // Representación UNICODE
        char c2 = '\u00ed';
        // Representación UNICODE en forma canónica
        char[] c3 = {'\u0069', '\u0301'};

¿En qué consiste la representación canónica?

La representación o descomposición canónica consiste simplemente (de forma muy resumida) en la descomposición del carácter en 2 partes:

– Parte 1: Letra base
– Parte 2: Acento

De esta forma, hemos podido representar el carácter i compuesto por la letra i (0x0061) y su acento (0x0301).

Una vez entendido el concepto de descomposición canónica, es hora de ponerlo en práctica para nuestro cometido: limpiar un texto de acentos y caracteres especiales obteniendo de esta manera un texto sólo de caracteres ASCII.

    /**
     * Función que elimina acentos y caracteres especiales de
     * una cadena de texto.
     * @param input
     * @return cadena de texto limpia de acentos y caracteres especiales.
     */
    public static String remove2(String input) {
        // Descomposición canónica
        String normalized = Normalizer.normalize(input, Normalizer.Form.NFD);
        // Nos quedamos únicamente con los caracteres ASCII
        Pattern pattern = Pattern.compile("\\p{ASCII}+");
        return pattern.matcher(normalized).replaceAll("");
    }//remove2

Comprobemos el resultado final de nuestras 2 técnicas:

        System.out.println("1. " + RemoveAccents.remove1("Mañana será un día mejor"));
        System.out.println("2. " + RemoveAccents.remove1("Mañana será un día mejor"));
0 01
11
2010

Bordes redondeados con CSS

Lunes, noviembre 1st, 2010

Vale, lo reconozco, me encanta plantar bordes redondeados en las páginas que desarrollo.

Sin embargo, es una propiedad la de los bordes redondeados en CSS que todavía no es soportada de forma nativa en todos los navegadores del mercado.

Vamos a ver a continuación un resumen rápido de cómo trabajar con esta propiedad de bordes redondeados con CSS en aquellos navegadores que ejecutan este efecto de forma nativa: border-radius.

¿Qué navegadores lo soportan?

Como siempre, hay un navegador que se queda por el camino, y éste no podía ser otro que Internet Explorer.

El resto de navegadores, Firefox (Gecko), Safari, Chrome o incluso Opera (más recientemente) han incorporado ya el soporte de bordes redondeados con css, aunque bien es cierto que cada uno usando nombres diferentes para la propiedad.

¿Cómo se implementa?

Utiliza border-radius para versiones recientes de Opera y Chrome

Ejemplo:

border-radius: 5px;

Utiliza -moz-border-radius para Firefox (motor Gecko)

Ejemplo:

-moz-border-radius: 5px;

Utiliza -webkit-border-radius para Safari o Chrome

Ejemplo:

-webkit-border-radius: 5px;

¿Qué ocurre entonces en Internet Explorer?

Nada, simplemente volverás al mundo de las esquinas.

¿Todas las esquinas llevan el mismo radio?

No tiene porqué. Al igual que pasa con propiedades como padding o margin, border-radius cuenta también con 4 valores posibles, comenzando por el valor superior izquierdo, y siguiendo según el sentido de las agujas del reloj.

Por lo tanto, podremos generar efectos como estos:

        .sample {
            width: 250px;
            height: 100px;
            background-color: #CDEB8B;
            border: solid 1px #008C00;
            margin-top: 25px;
            margin-bottom: 25px;
        }
        .rounded {
            -moz-border-radius: 50px;
            -webkit-border-radius: 50px;
            -ms-border-radius: 50px;
            border-radius: 50px;
        }
        .rounded2 {
            -moz-border-radius: 50px 50px 0px 0px;
            -webkit-border-radius: 50px 50px 0px 0px;
            -ms-border-radius: 50px 50px 0px 0px;
            border-radius: 50px 50px 0px 0px;
        }
        .rounded3 {
            -moz-border-radius: 50px 0px 50px 0px;
            -webkit-border-radius: 50px 0px 50px 0px;
            -ms-border-radius: 50px 0px 50px 0px;
            border-radius: 50px 0px 50px 0px;
        }

Vaya coñazo

Pues sí, para qué negarlo. Aún así, si te apetece puedes darte una vuelta por el servicio web border-radius.com que te permite de forma visual generar el código CSS que necesites para el resultado que desees.

0 30
10
2010

Propiedades autoimplementadas en C#

Sábado, octubre 30th, 2010

A partir de C# 3.0 nos encontramos con una nueva forma de implementar las propiedades de nuestras clases con las propiedades autoimplementadas.

Las propiedades autoimplementadas nos permiten escribir la declaración de la propiedad de forma más concisa y sencilla cuando no es necesaria ninguna lógica adicional en los descriptores de acceso a la propiedad, o en otras palabras, cuando no se requiere personalizar los bloques Set y/o Get.

Para verlo de forma más clara, mostraremos a continuación un ejemplo de la declaración de propiedades clásica, y la declaración de propiedades autoimplementadas:

Sin Propiedades Autoimplementadas

/// <summary>
/// Car class
/// </summary>
public class Car
{

    #region "Attributes"

    /// <summary>Brand car</summary>
    private string brand;
    /// <summary>Model car</summary>
    private string model;
    /// <summary>Vehicle registration plate</summary>
    private string plate;

    #endregion

    #region "Properties"

    /// <summary>Gets & sets the brand of car</summary>
    public string Brand
    {
        get { return brand; }
        set { brand = value; }
    }

    /// <summary>Gets & sets the brand of car</summary>
    public string Model
    {
        get { return model; }
        set { model = value; }
    }

    /// <summary>Vehicle registration plate</summary>
    /// <remarks>read-only property</remarks>
    public string Plate
    {
        get { return plate; }
    }

    #endregion

    /// <summary>Constructor</summary>
    /// <param name="plate"></param>
    public Car(string plate)
    {
        this.plate = plate;
    }
}

En el código anterior, hemos creado una simple clase de ejemplo Car con 3 atributos privados, y sus correspondientes 3 propiedades públicas, siendo la tercera de ellas (platepropiedad de sólo lectura.

Comprobemos a continuación cómo declarar el código con propiedades autoimplementadas sobre la misma clase de ejemplo.

Con Propiedades Autoimplementadas

/// <summary>
/// Car class
/// </summary>
public class Car
{

    #region "Attributes"

    /// <summary>Brand car</summary>
    private string brand;
    /// <summary>Model car</summary>
    private string model;
    /// <summary>Vehicle registration plate</summary>
    private string plate;

    #endregion

    #region "Properties"

    /// <summary>Gets & sets the brand of car</summary>
    public string Brand { get; set; }

    /// <summary>Gets & sets the brand of car</summary>
    public string Model { get; set; }

    /// <summary>Vehicle registration plate</summary>
    /// <remarks>read-only property</remarks>
    public string Plate { get; private set; }

    #endregion

    /// <summary>Constructor</summary>
    /// <param name="plate"></param>
    public Car(string plate)
    {
        this.plate = plate;
    }
}