[EF + Oracle] Entidades

Prologo

Continuando con la serie que comencé ayer sobre Entity Framework contra Oracle, voy a comenzar a hablar sobre las Entidades.

¿Qué es una Entidad?

Una entidad es un tipo de objeto del modelo de EF que se corresponde con una registro de una tabla de la Base de Datos. Como ejemplo, vamos a ver, la siguiente imagen donde aparece una entidad de nuestro modelo (Imagen 1) y en la siguiente imagen donde se ve el mapeo que sea realiza entre columnas de la Tabla de BD con las propiedades del objeto (Imagen2).

(Imagen1)

(Imagen2)

A continuación vamos a ver más en profundidad que es una entidad, internamente.

Es una clase que hereda de la Clase Abstracta “EntityObject” perteneciente al espacio de Nombres “System.Data.Objects.DataClasses”. A su vez esta clase hereda de los siguientes objetos:

  • StructuralObject: Es una clase abstracta que implementa las interfaces INotifyPropertyChanging, INotifyPropertyChanged (Propiedades que nos permiten detectar cambios en una clase). y donde se definen los eventos encargados de determinar los cambios y las funciones encargadas de verificar los tipos de datos de las propiedades de nuestra Entidad.
  • IEntityWithKey: Interfaz que va a servir para exponer la Clave de la Entidad.
  • IEntityWithChangeTracker: Interfaz que va a servir para indicar que estado tiene la entidad(Añadido, Modificado…)
  • IEntityWithRelationships: Interfaz que va a servir para indicar las relaciones de la entidad.

 

¿Qué Contiene una Entidad?

Una entidad está formada por propiedades, propiedades de Navegación y métodos.

¿Qué es una Propiedad?

Una propiedad es un objeto Mapeado con una columna de una tabla de la Base de Datos. Presenta un tipo de dato el cual es el equivalente en .Net Framework con respecto de la Base de datos.

Cuando generamos nuestro modelo de Entity Framework, Visual Studio internamente genera el código de todas las entidades, así como los métodos que veremos en posteriores episodios de la serie.

Para cada propiedad, se genera una estructura como la siguiente:

  • Variable privada del tipo indicado en las propiedades de Mapeo de la columna.
  • Función del tipo On{Nombre_Propiedad}Changing({tipoDato} value): Encargada de manejar el evento de cambio del valor de la propiedad
  • Función del tipo On{Nombre_Propiedad}Changed: Encargada de manejar el evento que indica que la propiedad ha cambiado su valor
  • Propiedad con los métodos Get y Set.
    • El método Set, que es el encargado de almacenar el valor en la variable privada, va a efectuar los siguientes pasos:
      • Invocar el evento Changing.
      • Indicar en la entidad que la propiedad está cambiando.(ReportPropertyChanging)
      • Establecer el valor en la Variable Privada. Para ello va a hacer uso de la función SetValidValue, de la clase StructuralObject. Existe una función para cada tipo de dato. Recibe el valor obtenido en el SET y envía un parámetro que indica si la propiedad admite valores Nulos o no. Si el valor no es válido se provocará una excepción.
      • Invoca a ReportPropertyChanged, para indicar que la propiedad ha cambiado.
      • Invoca al evento Changed de la Propiedad.

Cabe destacar que los eventos ReportPropertyChanging y ReportPropertyChanged, sirven respectivamente para indicar que hay cambios pendientes en la entidad, y que los cambios se han llevado a cabo. Durante la invocación a ReportPropertyChanged, se cambia el estado de la Entidad a Modificado.

¿Qué es una Propiedad de Navegación?

Una Propiedad de Navegación, es una propiedad del tipo EntityCollection<TEntity> donde TEntity será un tipo de Entidad del modelo de EF que tenga relación con la Entidad que estamos utilizando, es decir, es una tabla de la Base de Datos con lo que existe una relación.

La clase Entitycollection<TEntity> hereda de los siguientes elementos:

  • RelatedEnd: Clase abstracta que aporta la funcionalidad necesaria para obtener los datos relacionados.
  • ICollection<TEntity>
  • IEnumerable<TEntity>
  • IEnumerable
  • IListSource

Para las interfaces indicadas os recomiendo que leáis este post de José Miguel Torres en el que habla de las colecciones.

Gracias a las Propiedades de Navegación, vamos a poder ver los datos relacionados con una entidad y consultarlos de forma muy sencilla.

¿Métodos?

Existe un único método estático, del tipo Create{Entidad}, el cual recibiendo como parámetros todos las propiedades de la Entidad, genera un nuevo objeto de la Entidad y lo devuelve al método que lo invocó.

 

Conclusiones

Después de este capítulo entenderemos que son las Entidades, su relación con la Base de Datos y la relación con otras entidades del modelo.

En próximos capítulos, veremos como realizar las operaciones CRUD(Inserción, Lectura, Actualización y Borrado).

[EF + ORACLE] Introducción

Prologo

Llevo un tiempo en el que he estado bastante liado laboral y personalmente, y ahora que empiezo a tener algo más de tiempo, me he decidido a comenzar una serie de post sobre Entity Framework contra Oracle.

Hace algún tiempo comente mi primera experiencia, bastante poco satisfactoria, puesto que no conseguí hacer funcionar el entorno. Trate de hacer funcionar el driver de ODP (Oracle) con VS 2010 Ultimate y Oracle 10 g / Oracle 10 g Express, sin ningún éxito.

Ahora que he sacado algo de tiempo, he decidido probar contra Oracle 11 g.

 

Herramientas Necesarias

Para poder empezar a utilizar EF contra Oracle necesitaremos lo siguiente:

  1. Visual Studio 2010, con una versión no Express.
  2. Oracle 11 g.
  3. Driver de Oracle para EF de Oracle (ODAC).

 

Nota: El Driver es una versión beta, como recomendación no lo instaleis en vuestro equipo de desarollo.

Introducción

Para la gente que empieza con el desarrollo con Entity Framework le recomiendo que visiten el Blog de Unai Zorrilla donde vais a encontrar mucha información relacionada.

Para esta serie de POST’s vamos a definir la “BD” desde el propio administrador de Oracle 11g. Para ello, seguiremos los siguientes pasos:

  1. Crearemos un Usuario y una contraseña asociada. En mi caso el usuario es JTorrecilla.
  2. Crearemos un TableSpace.
  3. Definiremos unas tablas de ejemplo:

 

(Imagen1)

Una vez creada nuestra Base de Datos en Oracle, vamos a abrir Visual Studio 2010 y crearemos un nuevo proyecto. En mi caso voy a crear un proyecto en C#.

Para comenzar a trabajar con Entity Framework, vamos a agregar un nuevo elemento a nuestro Proyecto del tipo “ADO .NET Entity Data Model»

(Imagen2)

A continuación, será necesario que indiquemos que vamos a crear el modelo desde una Base de Datos existente y que configuremos el Origen de Datos, es decir, la conexión contra la Base de Datos (Como se puede ver en las imágenes 2 y 3):

 

 

(Imagen3)

(Imagen4)

 

Una vez seleccionada la conexión, será necesario que indiquemos que en la cadena de Conexión se almacenen los datos “sensibles” (Imagen 5), y presionemos en siguiente para indicar aquellos objetos de Base de Datos que vamos a utilizar(Imagen 6).

 

(Imagen5)

(Imagen6)

 

 

Una vez seleccionados todos los objetos que vamos a utilizar (en el ejemplo de momento solo vamos a utilizar Tablas), presionaremos en finalizar. Esto generará un fichero “.EDMX”, que se agregará a nuestra solución, y se mostrará en el apartado de visualización de VS el esquema de las tablas y relaciones existentes en la BD.

(Imagen7)

El esquema que se muestra en la imagen 7, es una representación de los distintos objetos y relaciones de la Base de Datos. A partir de ahora, cada uno de esos objetos vamos a denominarlo Entidad.

Una entidad está compuesta por un conjunto de propiedades (se corresponden con los campos de la Tabla representada en la Base de Datos) y Propiedades de Navegación que van a servir para relacionar contra otras Entidades.

Conclusiones

En este primer episodio de la Serie hemos instalado el entorno, definido una Base de Datos y configurado una solución para comenzar a utilizar Entity Framework contra Oracle 11g.

En el próximo capitulo vamos a ver internamente que es una Entidad y como funciona.

Espero que os guste la serie!

[LINQ] Maestro – Detalle en un mismo Registro (2)

Ayer os hablaba de la necesidad de mostrar en una misma línea los datos de Cabecera y Detalle asociados.

Para solventarlo estuve probando con una clase y con una consulta de LINQ, ya que no podía probarlo el proyecto de EF donde quería aplicarlo.

Cuando me disponía a implementarlo en el proyecto bueno, me encontré con el siguiente mensaje de error:

LINQ to Entities no reconoce el método ‘System.String Join(System.String, System.Collections.Generic.IEnumerable`1[System.String])’ del método, y este método no se puede traducir en una expresión de almacén.

La consulta que ha provocado este error ha sido:

   1: var consulta = (from TCabecera cab in 

   2:                  contexto_local.TCabecera  

   3:    let Detalle = (from TDetalle detalle 

   4:                    in cab.TDetalle 

   5:    select detalle.Nombre)    

   6:    let Nombres = string.Join(",",Detalle )     

   7:    select new   

   8:       {  

   9:        cab.Campo1, 

  10:        cab.Campo2, 

  11:        Nombres

  12:        }).ToList();

  13: grid.DataSource=consulta;

 

¿Por qué se produce este error?

El error se produce al intentar asignar a Nombres la unión de Detalle. Este se debe a que no se puede convertir en un primer momento, la consulta a TSQL.

¿Cómo Solucionarlo?

Para poder solucionarlo vamos a necesitar ejecutar la consulta en 2 pasos:

   1: var consulta = (from TCabecera cab in   

   2:                 contexto_local.TCabecera    

   3:       let Detalle = (from TDetalle detalle   

   4:                      in cab.TDetalle   

   5:                      select detalle.Nombre)      

   6:      select new     

   7:       {    

   8:         cab.Campo1, 

   9:         cab.Campo2,  

  10:         Detalle 

  11:         }).ToList();  

  12: var consulta2 = (from dato in consulta

  13:             let Nombes = string.Join(",",dato.Detalle)

  14:             select new 

  15:             {

  16:             dato.Campo1,

  17:             dato.Campo2,

  18:             Nombres

  19:             };

  20:         grid.DataSource=consulta2.ToList();

CURIOSIDAD

Esto me ha sucedido al hacer la consulta contra Entidades de EF (LINQ-To-Entities). Decidí probarlo contra LINQ-to-SQL y cual fue mi sorpresa:

Funcionó en un único Paso!

Saludos, y espero que os sea de utilidad.

[LINQ] Maestro – Detalle en un mismo Registro (1)

Problema

Lo primero, voy a exponer el problema que me han planteado:

Dada una tabla, digamos, “Cabecera”, con una tabla relacionada de “Detalle” con una relación 1 a N. Necesitamos mostrar todos los datos del detalle, asociados a una fila de la cabecera sin repetir los datos de la cabecera.

Digamos que la representación Sería algo así:

Cabecera
C1 C2 C3
1 P1 01/01/2011
2 P2 01/02/2011
Detalle
1 1 D1
2 1 D2
3 1 D3
4 2 D1
5 2 D4

 

RESULTADO A OBTENER
1 P1 01/01/2011 D1, D2, D3
2 P2 01/02/2011 D1,D4

 

Enfoques

Así a bote pronto, se me ocurren 3 posibles enfoques:

  1. Hacerlo desde la BD.
  2. Hacerlo desde Código .NET con bucles…
  3. Hacerlo con LINQ

¿Hacerlo desde la BD?

La primera opción que se me ha ocurrido (por eso de que me gustan bastante las BD), ha sido: Esto se podría resolver creando un SP, Función y a través de un cursor devolver el dato separado por el carácter indicado.

Es una opción que he descartado porque no siempre tenemos la opción de modificar la BD a nuestro gusto.

¿Hacerlo desde Código .NET?

La siguiente alternativa sería, obtener los datos desde la BD con una consulta “JOIN” entre las tablas de Cabecera y Detalle, recorrer las filas, y generar un “nuevo DataTable”…

Descartada….

¿Hacerlo con  LINQ?

La opción de LINQ, nos va a permitir que no solamente lo podamos hacer contra la BD (ya sea con EF o con LINQTOSQL), sino también contra Objetos o XML…

Para demostrarlo voy a mostrar un pequeño Ejemplo con una Clase y Listas.

EJEMPLO

Dada una clase Empleado:

   1: public class Empleado

   2: {

   3:     public Empleado() { }

   4:     public Int32 ID { get; set; }

   5:     public String Nombre { get; set; }

   6:     public String Apellido { get; set; }

   7:     public List<string> Numeros { get; set; }

   8: }

La clase Empleado se va a corresponder con la tabla “Cabecera” y la lista Números  se va a corresponder con la tabla “Detalles”.

A continuación, para obtener el resultado indicado arriba, voy a realizarlo a través de una consulta LINQ:

   1: List<Empleado> listado = new List<Empleado>();

   2: //Rellenar Listado

   3: var consulta = from Empleado em in listado

   4:     let Numeros = string.Join(";", em.Numeros)

   5:     select new { 

   6:     em.Nombre,

   7:     Numeros

   8:     };

En la consulta estoy empleado el Operador LET, el cual va a permitir “almacenar” una expresión, en este caso el resultado de la función Join de la clase String, la cual se encarga de unir, un conjunto de datos, separándolos por el carácter indicado.

Os dejo el enlace al proyecto de ejemplo que he utilizado para que lo comprobéis con vuestros ojos. 😀

 

Saludos

Problemas con Oracle ODP.NET para EF

Tengo la suerte o desgracia (después de más de 3 años trabajando contra Oracle, todavía no me decanto), de trabajar contra ORACLE.

Este fin de semana he visto publicado en el Blog de Unai Zorrilla, que Oracle había anunciado una beta para poder conectarse a Oracle con Entity Framework.

Bueno, pese a ser una Beta, he decidido descargarlo y probarlo con VS2010, para ver que tal funciona, y de esa manera intentar empezar a usar EF en nuevos proyectos contra ORACLE si me dejan.

El primer problema que me he encontrado, ha sido muy rápido, a la hora de instalar ODAC. A la hora de definir las rutas de instalación se observan 2 cajas de texto, y una tercera se observa ligeramente, pero cual es mi sorpresa, "No hay Scroll” por lo que la he dejado con el valor que tenía…..

Bueno, finalizada la instalación, configuro los ficheros SQLNET.ORA y TNSNAMES.ORA para definir mis BD’s.

Una vez configurados, arranco VS2010, y me digo, “Vamos a probar si el driver conecta correctamente”.

Para ello, presiono Ctrl + Alt + S, lo que hace que aparezca el Explorador de Servidores de VS. Agrego una nueva conexión, selecciono “Oracle Provider for .NET”. selecciono mi cadena de conexión, establezco usuario y contraseña, y le doy a “Test Connection”. Conexión perfecta. En el explorador de Servidores puedo ver todos los objetos de mi BD: Tablas, Vistas, Procedimientos….

Digo, que bien, y funciona muy bien el explorador ver los datos y tal…

Bueno vamos a probar con un proyecto y con EF. Creo un nuevo proyecto. Presiono “Agregar Nuevo Objeto” Selecciono “Entity Framework Data Model”, indico la Base de Datos, y voy al paso siguiente donde vamos a elegir los objetos de la BD que vamos a utilizar, donde me encuentro el problema nº 2.

Esto provoca que no pueda seguir probando!!!

Por lo que, tras un rato buscando información de manera poco satisfactoria decidí publicar un mensaje en el foro de Oracle, a ver si el equipo de desarrollo puede darme más detalles para poder seguir probando.

Continuara…

[Aplicación] WMI Info and Code Example

A raíz del post de WMI que escribí el otro día, empecé a crear una pequeña aplicación para obtener Información del Sistema con WMI.

He publicado la Aplicación en Code MSDN.

 

El funcionamiento de la aplicación es bastante sencillo. Al iniciar la aplicación, el Nombre del PC aparecerá reflejado en la caja de Texto de “Computer Name”, pero es un dato modificable.

Si pulsamos el Botón “GET”, va a obtener el Listado de Clases “consultables” a través de WMI, respecto del equipo indicado, quedando reflejadas en el combo.

Si tratamos de  consultar un equipo sobre el que no tenemos permisos, o un equipo apagado, la aplicación nos va a lanzar un aviso indicándolo.

Cada vez, que se seleccione una clase en el Combo, vamos a poder observar el listado de propiedades asociadas a la clase y los valores de cada una de ellas. Además, también aparecerán los métodos disponibles.

Para cada uno de los métodos disponibles, también se va a visualizar los parámetros de entrada y de salida asociados.

Por último, existe un botón el cual va a generar una clase de Ejemplo en C#, que podréis utilizar en vuestros proyectos para consultar los objetos de WMI.

Espero que os guste y sobretodo que os resulte útil.

Un saludo

[Tip] Exportación de Plantillas en VS

¿En cuantas ocasiones os habéis encontrado haciendo formularios muy similares, en distintos proyectos?

A mi al menos me ha pasado en muchas ocasiones.

Visual Studio, posee una herramienta para exportar plantillas predefinidas, como las que se muestran al agregar un nuevo elemento a un proyecto.

Podemos llevar a cabo dos tipos de Exportaciones:

– Por Elemento:

Como ejemplo podemos crear un formulario y añadirle una serie de controles comunes. El típico formulario de Alta de Registros con un botón guardar y otro de cancelar, y un panel con cajas de texto.

– Por Proyecto:

Podemos definir la estructura base que vamos a aplicar a nuestros proyectos, Carpetas, Clases con funcionalidades típicas, Splash Screen…

¿Que pasos son necesarios para definir una plantilla de un elemento?

En primer lugar, dentro de Visual Studio, vamos a crear un nuevo proyecto (aplica tanto a C# como a VB).

A continuación vamos a agregar un nuevo formulario, al que vamos a llamar formularioAlta.

Dentro de dicho botón vamos a incorporar los botones de Guardar y Cancelar.

Antes de poder realizar la exportación del formulario, será necesario que guardemos el proyecto.

A continuación a través del menú Archivo de Visual Studio, pulsaremos sobre la opción “Exportar Plantilla” y se abrirá un pequeño asistente para guiarnos en el proceso de Exportación.

El primer paso será para indicar si queremos realizar una exportación de una plantilla de Proyecto o de un elemento.

 

Después de indicar que vamos a exportar un Elemento, aparecerá un Árbol con los distintos elementos disponibles en nuestro proyecto, para que indiquemos los que van a ser exportados.

 

 

El siguiente paso, será indicar las referencias necesarias para el correcto funcionamiento de nuestra plantilla.

El último paso, nos va a permitir indicarle un nombre a la plantilla, así como una descripción y un icono para su posterior visualización.

Una vez que finalicemos con la exportación,  Gracias al check de “importación automática” Visual Studio, lo detectará y si pulsamos en “Agregar nuevo Elemento” a nuestra solución podremos ver la nueva Plantilla que hemos generado.

¿Que pasos son necesarios para definir una plantilla de un Formulario?

De los pasos indicados anteriormente serán necesarios el primero, en el que elegimos la forma de exportación, en este caso, será una Plantilla de Proyecto, y el último paso donde se definen el nombre y la descripción de la plantilla.

En este caso, para ver el resultado, cuando realicemos una exportación de un proyecto, será necesario crear un nuevo proyecto en Visual Studio, y dentro de las plantillas disponibles podremos encontrar la plantilla que hemos predefinido.

Espero que os sea de utilidad y si tenéis cualquier duda, podéis preguntarla por aquí o en Twitter.

 

Saludos

Utilización de WMI en VS 2010

¿Qué es WMI?

WMI son las siglas de “Windows Management Instrumentation” (Instrumentación de la Administración de Windows.)

WMI nos va a permitir obtener información representativa de grandes partes de un Ordenador como pueden ser el SO, Aplicaciones instaladas, o incluso el Hardware de la maquina.

WMI no solo aporta datos del ordenador donde lo estamos utilizando, también podemos acceder de manera remota a otros ordenadores.

¿Cómo podemos empezar a utilizar WMI en nuestros proyectos?

Para poder utilizar WMI, necesitamos agregar a nuestro proyecto la referencia “System.Management”

 

 

A continuación será necesario incluir el namespace en la clase donde vayamos a trabajar con WMI:

using System.Management;

o
imports System.Management

El Framework nos va a aportar las siguientes clases para poder trabajar con WMI:

ManagementObjectSearcher:

Esta clase se va a encargar de realizar una consulta determinada a WMI, y devolver un conjunto de ManagementObject’s.

   1: ManagementObjectSearcher searcher = 

   2:     new ManagementObjectSearcher("Select * from Win32_Desktop");

   3: var query = from ManagementObject managedObject

   4:  in searcher.Get().Cast<ManagementObject>()

   5:             select managedObject;

A través del constructor de la clase, indicamos la sentencia WMI que vamos a utilizar (más adelante veremos mas información sobre ellas).

La sentencia que utilizo en el ejemplo es una Query de LINQ to Objects sobre el método Get del objeto que estamos utilizando.

El método GET va a devolver una colección objetos del tipo ManagementObjectCollection.

ManagementObject:

La clase ManagementObject va a almacenar una serie de datos relativos cada registro de una consulta sobre WMI.

Los datos que vamos a poder consultar son los siguientes:

– Scope:

Es el ámbito de realización de la Administración. Esta propiedad es del Tipo ManagementScope.

– Path:

Es la ruta relativa al objeto dentro de la consulta WMI.

– Options:

Aporta información adicional acerca del objeto.

– ClassPath:

Es la ruta relativa del Objeto.

– Properties:

Son las características de cada uno de nuestros Objetos. Un poco mas adelante se verá en la clase PropertyData.

– SystemProperties:

Propiedades del sistema relativas a la consulta que hemos realizado.

– Qualifiers

Van a proporcionar mas información acerca de nuestro Objeto.

PropertyData

Esta clase nos va a indicar información relativa a cada propiedad de una consulta realizada.

Lo más interesante de está clase es que nos va a indicar el Nombre (Name) y el valor (Value) concreto de una propiedad. Por ejemplo:

Para la clase “Win32_Desktop” que nos da información relativa a la pantalla, una propiedad es: “ScreenServerActive”, que indicará si el SalvaPantallas está activado o no.

   1: ManagementObjectSearcher searcher = 

   2:     new ManagementObjectSearcher("Select * from Win32_Desktop");

   3:  

   4:  

   5: var query = from ManagementObject managedObject 

   6:                 in searcher.Get().Cast<ManagementObject>()

   7:             from PropertyData prop 

   8:                 in managedObject.Properties.Cast<PropertyData>()

   9:  

  10:             select prop;

El código que he puesto en el bloque nos va a devolver una lista de las propiedades de “todos” los objetos existentes que respondan a la consulta.

 

¿Cómo podemos empezar a utilizar WMI para conectarnos a otros equipos?

Hasta el momento hemos visto la posibilidad de obtener información del equipo “Local”, pero, ¿y si necesitamos información de un equipo en red?.

Lo que hemos explicado anteriormente es totalmente aplicable para obtener información de un equipo remoto, pero necesitamos indicarle de alguna manera el equipo cuya información queremos consultar.

   1: ManagementScope scope =

   2: new ManagementScope(

   3:     @"\NBEQUIPorootcimv2");

   4: scope.Connect();

   5: ManagementObjectSearcher searcher =

   6:  new ManagementObjectSearcher(scope, 

   7: new ObjectQuery("Select * from Win32_Desktop"));

   8:  var query = from ManagementObject managedObject 

   9:              in searcher.Get().Cast<ManagementObject>()

  10:              from PropertyData prop 

  11:              in managedObject.Properties.Cast<PropertyData>()

  12:  

  13:             select prop;

Para indicarle a la consulta donde tiene que ejecutarse necesitamos un objeto de tipo ManagementScope.

ManagementScope:

Esta clase va a permitir definir el ámbito de una consulta.

El constructor de la clase, nos va a permitir indicar el Nombre del equipo a consultar.

¿Qué datos podemos obtener utilizando WMI?

Gracias a la utilización de los objetos antes mencionados, podemos obtener información, tanto de nuestro ordenador, como de una maquina remota.

Pero, ¿Dónde puedo saber que datos puedo consultar con WMI?. La respuesta es corta: MSDN.

En el enlace, nos vamos a encontrar diversas categorías de información que podemos obtener a través de WMI.

¿Hasta aquí hemos llegado con WMI?

No. WMI no solo nos permite visualizar información, también nos permite hacer algunas tareas propias de la administración, como podrían ser, copia de ficheros, iniciar un Servicio, parar una impresión…

Algunas de las clases que aparecen en el enlace que os indicaba anteriormente a parte de tener propiedades, también poseen ciertos métodos que nos permite realizar tareas administrativas.

Para poder obtener los métodos de un objeto, tenemos que apoyarnos en la clase: ManagementClass.

ManagementClass

Esta clase es similar a ManagementObject, y nos permite obtener todo el conjunto de propiedades y métodos, simplemente especificando en el nombre de la consulta.

   1: ManagementClass clase = 

   2:        new ManagementClass("Win32_Process");

Puesto que anteriormente estabamos trabajando objetos de tipo ManagementObjet, podríamos utilizar el siguiente código:

   1: ManagementObjectSearcher searcher =

   2:  new ManagementObjectSearcher("Select * from Win32_Process");

   3:  var query = from ManagementObject managedObject 

   4:              in searcher.Get().Cast<ManagementObject>()

   5:              from PropertyData prop 

   6:              in managedObject.Properties.Cast<PropertyData>()

   7:  

   8:              select managedObject;

   9:  ManagementObjectSearcher s = new ManagementObjectSearcher();

  10:  

  11:  ManagementClass clase = 

  12:   new ManagementClass(query.FirstOrDefault().ClassPath);

Con el snippet anterior, obtendríamos el primer objeto devuelto por la consulta WMI.

Una vez que tenemos nuestro objeto, podemos consultar las Propiedades, o los métodos a través de las propìedades de la clase.

La propiedad Metods: va a devolver un objeto de tipo MethodDataCollection que es un conjunto de objetos del tipo MethoData.

MethodData

Este objeto va a almacenar las propiedades relativas a cada método:

– Nombre

– Parámetros de Entrada

– Parámetros de Salida

– Origen

– Calificadores

Si conocemos el método que queremos ejecutar, que parámetros necesita para ser ejecutado y la clase a la que pertenece, podemos ejecutarlo:

   1: clase.InvokeMethod("Create", 

   2: new object[] { "calc.exe" });

 

El método InvokeMethod, va a ejecutar el método que recibe como primer parámetro, utilizando el array de objetos que se le envía como argumentos para la ejecución.

El ejemplo es muy sencillo, lo que hace sobre la clase “Process” es ejecutar la calculadora de Windows.

 

Conclusiones

WMI nos va a permitir “jugar” y “cacharrear” con la información del Sistema así como hacer ciertas operaciones.

Mientras redactaba este artículo me tope con una herramienta que me pareció muy interesante. Se llama WMI Code Creator. Os animo a que la descarguéis y juguéis un poco con WMI y el código generado. Os aviso que la parte de código en C# contiene algunos errores al generar los ejemplos.

 

Bibliografía

La base fundamental de este artículo es la documentación MSDN:

http://msdn.microsoft.com/en-us/library/aa394582(VS.85).aspx

 

Espero que os guste.

Tip Rapido: Método Extensor

Bueno aquí va un mini-post.

Cuantas veces os habéis encontrado con:

if (a>=5 and a<=10)

Yo al menos recuerdo unas pocas.

Bueno aquí va el mini truco. Creamos una clase estática con un método extensor:

Code Snippet
  1. public static class ExtensionMethod
  2.  {
  3.    public  static bool Between(this int original, int menor, int mayor)
  4.      {
  5.          return (original >= menor && original <= mayor);
  6.      }
  7.  }

Ahora simplemente hacemos el using de la clase en donde queramos utilizarla y el IntelliSense de Visual Studio será capaz de asociar este método a nuestras variables de tipo int:

 

Code Snippet
  1. if (valorOriginal.Between(10, 20))
  2.             {
  3.  
  4.             }

Espero que os sea de utilidad.

 

Saludos.

[Channel9]Video Controles Personalizados

Bueno este post sirve para publicar el enlace de un pequeño video (mi primer video), en el que hablo acerca de la creación de Controles Personalizados dentro de Visual Studio, y el uso de algunos atributos en dichos controles.

 

Espero que os guste, y que me hagáis alguna crítica para futuros videos.

Se me olvidaba, lo mas importante dar las gracias a la gente de MSDN España por la publicación del video.

Un saludo