System.Collections.ListofTips

Hoy Jueves, le hice frente al 70-528… y pase con 929/1000! Le pifie algo sobre Roles de Usuarios.

En dias, estoy dando otro examen de MS…

Les recomiendo a todos los que no sepan para que es el…

<Identity Impersonate=”true”>

Este articulo bastante basico, pero simple…
http://209.200.119.101/Articulos/Articulo.aspx?ID=15
Este post solo fue, por que un conocido me pregunto para que servia, y como es algo simple, no vi la necesidad de escribir en este caso, Saludos.

Para manipulacion de Xml, entra en juego System.Xml

Pero partamos desde lo basico, que es XML? Es un metalenguaje extensible de etiquetas desarrollado por la W3C. Mas que nada fue una proposicion, a tomar un estandar para el intercambio de información entre diferentes plataformas.

En es una tecnologia muy simple, pero que hace posible interoperabilidades bastante importantes en distintos ambientes, ya que lo toman como un lenguaje para hablar por ejemplo un WebServices, tanto como una aplicación WinForm en C# como una aplicación de Consola de Lynx.

Los documentos XML debe seguir una estructura estrictamente jerárquica con lo que respecta a las etiquetas que delimitan sus elementos. Una etiqueta debe estar correctamente incluida en otra. Ademas que solo se permite un elemento raiz, osea solo puede tener un solo elemento inicial.

Hay detalles como, los valores de los atributos, deben estar encerrados entre comillas simples o dobles, no es un lenguaje flexible como es el html, es mucho mas estricto. Otro detalle, es que es Case-Sensitive.

El Web.Config, es un ejemplo claro de XML.
Nosotros tambien podria tener definida la estructura del XML, por DTD, XSD, XDR o XLS/XLST, vamos a ver puntualmente cada caso:

DTD (Document Type Definition):

Su función básica es la descripción del formato de datos, para usar un formato común y mantener la consistencia entre todos los documentos que utilicen la misma DTD. De esta forma, dichos documentos, pueden ser validados, conocen la estructura de los elementos y la descripción de los datos que trae consigo cada documento, y pueden además compartir la misma descripción y forma de validación dentro de un grupo de trabajo que usa el mismo tipo de información.

Una DTD describe:

• Elementos: indican qué etiquetas son permitidas y el contenido de dichas etiquetas.
  
• Estructura: indica el orden en que van las etiquetas en el documento.
  
• Anidamiento: indica qué etiquetas van dentro de otras.
  

Ejemplo de un DTD:

<!ELEMENT lista_de_personas (persona*)>
<!ELEMENT persona (nombre, fechanacimiento?, sexo?, numeroseguridadsocial?)>
<!ELEMENT nombre(#PCDATA) >
<!ELEMENT fechanacimiento(#PCDATA) >
<!ELEMENT sexo(#PCDATA) >
<!ELEMENT numeroseguridadsocial(#PCDATA)>

Observándolo línea a línea nos dice:

• <lista_de_personas> es un nombre de elemento válido. El * indica que pueden haber 0 o más elementos de persona.
  
• <persona> es un nombre de elemento válido. Éste contiene obligatoriamente el elemento nombre mientras que el resto son opcionales. Y lo son porque nos lo indica el símbolo’?’
  
• <nombre> es un nombre de elemento válido. Contiene caracteres.
  
• <sexo> es un nombre de elemento válido. Contiene caracteres.
  
• <fechanacimiento> es un nombre de elemento válido.
  
• <numeroseguridadsocial> es un nombre de elemento válido.
  

Un ejemplo de un fichero XML que hace uso de esta DTD:

<?xml version=“1.0“ encoding=“iso-8859-1“?>
<!DOCTYPE lista_de_personas SYSTEM “ejemplo.dtd“>
<lista_de_personas>
<persona>
<nombre>José García</nombre>
<fechanacimiento>25/04/1984</fechanacimiento>
<sexo>Varón</sexo>
</persona>
</lista_de_personas>

Tienen mas información aca:
http://es.wikipedia.org/wiki/DTD

http://www.zvon.org/xxl/DTDTutorial/General_spa/book.html

http://www.xeml.net/ccdtdxml.html

http://gutfeldt.ch/matthias/articles/doctypeswitch/table.html

XSD (Xml Schema Definition): Basado en la gramática y pensado para proporcionar una mayor potencia expresiva que la DTD, más limitadas en la descripción de los documentos a nivel formal.

Los documentos esquema (usualmente con extensión .xsd de XML Schema Definition (XSD)) se concibieron como una alternativa a las DTD, más compleja, intentando superar sus puntos débiles y buscar nuevas capacidades a la hora de definir estructuras para documentos XML. La principal aportación de XML Schema es el gran número de los tipos de datos que incorpora. De esta manera, XML Schema aumenta las posibilidades y funcionalidades de aplicaciones de procesado de datos, incluyendo tipos de datos complejos como fechas, números y strings.

os esquemas se construyen a partir de diferentes tipos de componentes:

• Elemento (element)
  
• Atributo (attribute)
  
• Tipo simple (simple type)
  
• Tipo complejo (complex type)
  
• Notación (notation)
  
• Grupo modelo nombrado (named model group)
  
• Grupo de atributos (attribute group)
  
• Restricción identidad (identity constraint)
  

Estos componentes ofrecen la posibilidad de combinar características de alto o bajo nivel:

• Alto nivel: Se encargan de ofrecer un significado semántico del contenido del documento. Analizan el contenido y extraen de él un significado. Éste puede estar predefinido en la declaración del esquema o se puede extraer de la misma estructura.
  
• Bajo nivel: Son características más concretas del documento que están incluidos en los diferentes campos del esquema y se accede a ellas de manera directa. Son los que se comparan directamente con el criterio de búsqueda definido y halla palabras concretas en la definición de los esquemas.
  

XML Schema supera muchas de las limitaciones y debilidades de las DTDs. Fue diseñado completamente alrededor de namespaces y soporta tipos de datos típicos de los lenguajes de programación, como también tipos personalizados simples y complejos. Un esquema se define pensando en su uso final.

Un ejemplo de XSD seria:

<?xml version=“1.0“ encoding=“UTF-8“?>
<xsd:schema xmlns:xsd=“http://www.w3.org/2001/XMLSchema“>
<xsd:element name=“Libro“>
<xsd:complexType>
<xsd:sequence>
<xsd:element name=“Título“ type=“xsd:string“/>
<xsd:element name=“Autores“ type=“xsd:string“ maxOccurs=“10“/>
<xsd:element name=“Editorial“ type=“xsd:string“/>
</xsd:sequence>
<xsd:attribute name=“precio“ type=“xsd:double“/>
</xsd:complexType>
</xsd:element>
</xsd:schema>

Mas información:

http://es.wikipedia.org/wiki/XML_Schema

XDR (Xml Data Reduced): Es un formatode definición de esquemas tambien para XML.

Mas información:

http://www.ltg.ed.ac.uk/~ht/XMLData-Reduced.htm

XSL, XSLT:Es un estandar de la organización W3C que presenta una forma de transformar documentos XML en otros e incluso a formatos que no son XML. Las hojas de estilo (aunque el termino de hojas de estilo no se aplica sobre la función directa del XSLT) XSLT realizan la transformación del documento utilizando una o varias reglas de plantilla: unidas al documento fuente a transformar, esas reglas de plantilla alimentan a un procesador de XSLT, el cual realiza las transformaciones deseadas colocando el resultado en un archivo de salida o, como en el caso de una página web, directamente en un dispositivo de presentación, como el monitor de un usuario.

Actualmente, XSLT es muy usado en la edición web, generando páginas HTML o XHTML. La unión de XML y XSLT permite separar contenido y presentación, aumentando así la productividad.

Las clases mas importantes para el tratamiento de XML, son : XpathNavigator, XmlDocument, XmlDataDocument, XpathDocument, XslTransform, XmlTextReader, XmlTextWriter

Un dato importante que XmlDataDocument hereda de XmlDocument.

XPathDocument es una cache de sólo lectura que viene bien para usar con consultas XPath.

XmlConver es una clase con un montón de métodos estáticos que permiten realizar conversiones de datos acordes con estándares Xml.

XPathNavigator, permite recorrer un documento Xml de manera eficiente usando consultas XPath.

XmlNodeReader: Permite un acceso secuencial (forward-only) para recorrer un documento a partir de un nodo determinado.

XmlTextReader: Proporciona acceso secuencial (no chacheado) a un documento xml.

XmlTextWriter: Proporciona acceso secuencial, no chacheado para la escritura de documentos xml.

XmlReader: Permite leer y validar contenido conforme a un DTD, XDR o XSD.

XslTransform: Permite transformar un documento Xml a partir de lo especificado en otro XSL.

Veamos algunos ejemplos de XML, pero en codigo…

Si yo quisiera generar esta salida…

<?xml version=“1.0“ encoding=“utf-8“?>
<Customers>
<Customer CustomerId=“000“>
<Name>Name 0</Name>
</Customer>
</Customers>

Nuesto Codigo seria en una aplicación de consola:

1 using System;
2 using System.Collections.Generic;
3 using System.Text;
4 using System.Xml;
5
6 namespace ConsoleApplication1
7 {
8 class Program
9 {
10  static void Main(string[] args)
11 {
12 XmlDocument xmlDoc = new XmlDocument();
13 xmlDoc.AppendChild(xmlDoc.CreateXmlDeclaration(“1.0″, “utf-8″, null));
14 XmlElement rootNode = xmlDoc.CreateElement(“Customers”);
15 xmlDoc.AppendChild(rootNode);
16 for (int i = 0; i < 1; i++)
17 {
18 XmlElement customerElement = xmlDoc.CreateElement(“Customer”);
19 XmlAttribute idAttribute = xmlDoc.CreateAttribute(“CustomerId”);
20 idAttribute.Value = i.ToString(“000″);
21 customerElement.Attributes.Append(idAttribute);
22
23 XmlElement nameElement = xmlDoc.CreateElement(“Name”);
24 nameElement.InnerText = string.Format(“Name {0}”, i.ToString());
25 customerElement.AppendChild(nameElement);
26 rootNode.AppendChild(customerElement);
27  }
28 string fileName = “C:\\Customers.xml”;
29 xmlDoc.Save(fileName);
30 Console.WriteLine(“Archivo generado…”);
31 Console.ReadLine();
32 }
33 }
34 }

Si quisieramos leelo seria….

1 using System;
2 using System.Collections.Generic;
3 using System.Text;
4 using System.Xml;
5
6 namespace ConsoleApplication1
7 {
8  class Program
9 {
10 static void Main(string[] args)
11 {
12 XmlDocument xmlDoc = new XmlDocument();
13 string fileName = “C:\\Customers.xml”;
14 xmlDoc.Load(fileName);
15 foreach (XmlElement element in xmlDoc.DocumentElement.ChildNodes)
16 {
17 Console.WriteLine(“Atributo Id->” + element.Attributes[“CustomerId”].Value);
18 XmlNodeList childNodes = element.GetElementsByTagName(“Name”);
19 Console.WriteLine(“Nodo Hijo->” + childNodes[0].InnerText);
20 }
21 Console.WriteLine(“Se termino de recorrer el archivo”);
22 Console.ReadLine();
23
24 }
25 }
26 }

Y nuestra salida

Este metodo usa DOM, pero para un metodo de lectura, es mas optimo y consume menos recursos la clase XpathNavigator.

Para este caso seria:

1 using System;
2 using System.Collections.Generic;
3 using System.Text;
4 using System.Xml;
5 using System.Xml.XPath;
6
7 namespace ConsoleApplication1
8 {
9  class Program
10 {
11  static void Main(string[] args)
12 {
13 XmlDocument xmlDoc = new XmlDocument();
14 string fileName = “C:\\Customers.xml”;
15 xmlDoc.Load(fileName);
16 XPathNavigator xPathNav = xmlDoc.CreateNavigator();
17 xPathNav.MoveToFirstChild();
18 xPathNav.MoveToFirstChild();
19 do
20 {
21 xPathNav.MoveToFirstAttribute();
22 Console.WriteLine(“Atributo Id->” + xPathNav.Value);
23 //Podemos obtener el valor en Int si lo quisieramos
24 int _post=xPathNav.ValueAsInt;
25 xPathNav.MoveToParent();
26 xPathNav.MoveToFirstChild();
27 Console.WriteLine(“Nodo Hijo->”+xPathNav.Value);
28 xPathNav.MoveToParent();
29 }
30 while (xPathNav.MoveToNext());
31 Console.WriteLine(“Se termino de recorrer el archivo”);
32 Console.ReadLine();
33
34
35 }
36 }
37 }

Despues, publico algo mas interesante sobre XLST, etc… Saludos.

Esto es muy Básico, pero ya que estamos… lo posteamos…

Como pueden saber las capacidades del Browser del Cliente? Es muy simple… con la clase System.Web.HttpBrowserCapabilities

Aca tienen un ejemplo

1 using System;
2 using System.Data;
3 using System.Configuration;
4 using System.Web;
5 using System.Web.Security;
6 using System.Web.UI;
7 using System.Web.UI.WebControls;
8 using System.Web.UI.WebControls.WebParts;
9 using System.Web.UI.HtmlControls;
10
11 public partial class _Default : System.Web.UI.Page
12 {
13  protected void Page_Load(object sender, EventArgs e)
14 {
15 System.Web.HttpBrowserCapabilities browse = Request.Browser;
16 String s = “Browse Capabilities<br />”
17 + “Type =” + browse.Type + “;<br />”
18 + “Name = ” + browse.Browser + “;<br />”
19 + “Version = ” + browse.Version + “;<br />”
20 + “Major Version = ” + browse.MajorVersion + “;<br />”
21 + “Minor Version = ” + browse.MinorVersion + “;<br />”
22 + “Platform = ” + browse.Platform+ “;<br />”
23 + “Is Beta = ” + browse.Beta + “;<br />”
24 + “Is Crawler = ” + browse.Crawler + “;<br />”
25 + “Is AOL = ” + browse.AOL + “;<br />”
26 + “Is Win16 = ” + browse.Win16 + “;<br />”
27 + “Is Win32 = ” + browse.Win32 + “;<br />”
28 + “Supports Frames = ” + browse.Frames+ “;<br />”
29 + “Supports Tables = ” + browse.Tables+ “;<br />”
30 + “Supports Cookies = “ + browse.Cookies + “;<br />”
31 + “Supports VBScript = “ + browse.VBScript + “;<br />”
32 + “Supports JavaScript = “ + browse.EcmaScriptVersion.ToString() + “;<br />”
33 + “Supports Java Applets = “ + browse.JavaApplets + “;<br />”
34 + “Supports Activex Controls = “ + browse.ActiveXControls + “;<br />”;
35
36
37
38 Page.Response.Write(s);
39 }
40 }

Nuestra salida seria:

Saludos!

Hace un tiempo atrás, me paso.. al intentar hacer mi primer WebControl… no saber como usar un archivo embebido, en donde trabajo no les agrada mucho la idea de tocar el webconfig, asi que no podia leerlo desde afuera, entonces lo que se me ocurrio, como necesitaba un javascript con ciertas funciones, era imprimir el archivo embebido…

Y aunque no lo crean, no encontraba demasiada informacion sobre esto…

Asi que lo comparto, es muy simple.. esto es sobre asp.net 1.1

Tenia mi WebCustomControl… y cree una carpeta llamada Scripts, con mi js, del tipo Embebido, y genere una Clase llamada Get

1 using System;
2 using System.Collections;
3 using System.Text;
4 using System.IO;
5 namespace WebControlLibrary1.Scripts
6 {
7 public class Get
8 {
9 private string _fileName;
10 public Get(string _file)
11 {
12 _fileName = _file;
13 }
14 public string GetContent()
15 {
16 StringBuilder _js = new StringBuilder();
17 _js.Append(“<scripts>” + System.Environment.NewLine);
18 StreamReader reader =
19 new StreamReader(typeof (Get).Assembly.GetManifestResourceStream(typeof (Get), _fileName));
20 string line;
21 while( (line=reader.ReadLine()) != null)
22 _js.Append(line + System.Environment.NewLine);
23
24 _js.Append(“</scripts>”);
25 return _js.ToString();
26 }
27 }
28 }

Y en mi webControl en el OnPreRender solo hace Page.RegisterClientScriptBlock, con el contenido que me retorna .Get(”file.js”);

Como veran, la clase se podria pasar a static directamente, ya que no tiene mucho sentido.. pero en un entonces, tenia mas logica en el contrucctor, y asi quedo…

Espero que a alguien le sea util, saludos.