viernes, 22 de junio de 2018

Aplicaciones N-Capas en Visual NET


Aplicaciones N-Capas en Visual NET

1.   Contenido

o  Definición

La programación por capas es un estilo de programación en el que el objetivo primordial es la separación de la lógica de negocios de la lógica de diseño, el estilo arquitectural en n capas se basa en una distribución jerárquica de los roles y las responsabilidades para proporcionar una división efectiva de los problemas a resolver. Los roles indican el tipo y la forma de la interacción con otras capas y las responsabilidades la funcionalidad que implementan. Cuanto más se aumenta el proceso operativo de la empresa, las necesidades de proceso crecen hasta desbordar las máquinas. Es por ello que se separa la estructura de un programa en varias capas.
o   Capas
La división de aplicaciones en capas, normalmente está compuesta por tres capas:
·          Capa de presentación: Presenta el sistema al usuario, comunica la información y captura la información del usuario en un mínimo proceso. Esta capa se comunica únicamente con la capa de negocio.
·          Capa de negocio: Es donde residen los programas que se ejecutan, se reciben peticiones del usuario y se envían las respuestas tras el proceso, es aquí donde se establecen todas las reglas que deben cumplirse, se comunica con la capa de presentación, para recibir solicitudes y presentar los resultados, y con la capa de datos, para solicitar al gestor de base de datos almacenar o recuperar datos.
·         Capa de datos: Es donde residen los datos y es la encargada de acceder a los mismos. Está formada por uno o más gestores de bases de datos que realizan todo el almacenamiento de datos, reciben solicitudes de almacenamiento o recuperación de información desde la capa de negocio.


  
  
  






APLICACIONES DE 2 CAPAS

La arquitectura de dos capas en la actualidad es muy utilizada, aunque con muchas fallas, todavía no se ha podido dejar de usar. Estas arquitecturas fueron las primeras en aprovecharse de la estructura cliente-servidor.

Aplicación de dos capas
Las capas que esta arquitectura presenta son las siguientes:

nivel de aplicación
este nivel es en el que se encuentra toda la interfaz del sistema y es la que el usuario puede disponer para realizar su actividad con el sistema.

Nivel de la base de datos.
Este nivel de la base de datos también llamado el repositorio de datos, es la capa en donde se almacena toda la información ingresada en el sistema y que se deposita en forma permanente.
Existen herramientas para el desarrollo en dos capas por ejemplo visual basic, access y sql.





 APLICACIONES DE TRES CAPAS


La arquitectura de dos capas si bien ayudó en unos años atrás, se vio la necesidad de crear una nueva arquitectura ya que en dos capas se tenía algunos problemas en la capa de aplicación ya que la principal desventaja de esta era el peso que tenia para el cliente, como se mencionó anteriormente.






Aplicación de tres capas.

Por estas razones, existe una fuerte y bien avanzada tendencia a adoptar una arquitectura de tres capas.
Y es así que se creó la arquitectura de tres capas las cuales son:

• Nivel de aplicación
La diferencia de este nivel aplicado ahora en una arquitectura de tres capas es que solo tiene que trabajar con la semántica propia de aplicación, sin tener que preocuparse de cómo esta implementado este ni de su estructura física.

• Nivel de dominio de la aplicación.
En cambio este nivel se encarga de toda la estructura física y el dominio de aplicación.
algo muy importante y que es la mayor ventaja de esta arquitectura es que ahora únicamente se cambia la regla en el servidor de aplicación y esta actuará en todos los clientes, cosa que ni sucedía con la arquitectura en dos capas que si alguna regla se la cambia, se tenía que ir a cada cliente a realizar el cambio.

• Nivel de repositorio.
Sigue siendo la capa en donde se almacenan los datos y toda la información.
Las herramientas para el desarrollo de tres capas son:
• Visual Basic en lo que se refiere a la capa de aplicación
• SQL server en lo que se refiere al repositorio de datos.
• Mts en lo que se refiere al nivel del dominio de aplicación




  

APLICACIONES DE N CAPAS

En una aplicación distribuida en n-capas los diferentes procesos están distribuidos en diferentes capas no sólo lógicas, sino también físicas. Los procesos se ejecutan en diferentes equipos, que pueden incluso residir en plataformas o sistemas operativos completamente distintos. Cada equipo posee una configuración distinta y está optimizado para realizar el papel que le ha sido asignado dentro de la estructura de la aplicación, de modo que tanto los recursos como la eficiencia global del sistema se optimicen.





Aplicación n capas.

El surgimiento de la tecnología de componentes distribuidos es la clave de las arquitecturas de n-capas. Estos sistemas de computación utilizan un número variable de componentes individuales que se comunican entre ellos utilizando estándares predefinidos y frameworks de comunicación como:

• corba: (common object request broker architecture) del object management group (omg).
• dna : (distributed network applications) de microsoft (incluye com/dcom y com+ además de mts, msmq, etc.
• ejb : (enterprise java beans) de sun microsystems.
• xml : (extensible markup language) del world wide web consortium (w3
• net: de microsoft que incluye nuevos lenguajes como visual basic.net, c#.




   
2.   Resumen

Es un lenguaje de programación orientado a objetos que se puede considerar una evolución de Visual Basic implementada sobre el framework .NET. Su introducción resultó muy controvertida, ya que debido a cambios significativos en el lenguaje VB.NET no es retro compatible con Visual Basic, pero el manejo de las instrucciones es similar a versiones anteriores de Visual Basic, facilitando así el desarrollo de aplicaciones más avanzadas con herramientas modernas. Para mantener eficacia en el desarrollo de las aplicaciones. La gran mayoría de programadores de VB.NET utilizan el entorno de desarrollo integrado Microsoft Visual Studio en alguna de sus versiones (desde el primer Visual Studio.NET hasta Visual Studio ,NET 2015, que es la última versión de Visual Studio para la plataforma .NET), aunque existen otras alternativas, como SharpDevelop (que además es libre).
Los paradigmas en el desarrollo de programas han venido evolucionando a través de los años y actualmente contamos con una de las técnicas que brinda mayor facilidad a los programadores, nos referimos a la Programación Orientada a Objetos en N capas, ya que permite dividir el trabajo en varias capas modulares. Actualmente, la más utilizada en cuanto a este estilo es la programación en tres capas que se divide en:
1) Capa de presentación, la cual interactúa con el usuario.
2) La capa de negocios, donde se establecen las reglas del negocio que deben cumplirse.
3) La capa de datos en la cual se define la conexión con el servidor y la base de datos, es en esta capa en donde se invoca a los procedimientos almacenados o comandos SQL, a fin de que se realicen las operaciones correspondientes en la base de datos.

3.   Summary
It is an object-oriented programming language that can be considered an evolution of Visual Basic implemented over the .NET framework. Its introduction was very controversial, because due to significant changes in the VB.NET language it is not retro compatible with Visual Basic, but the handling of the instructions is similar to previous versions of Visual Basic, thus facilitating the development of more advanced applications with modern tools to maintain efficiency in the development of applications. The vast majority of VB.NET programmers use the Microsoft Visual Studio integrated development environment in some of their versions (from the first Visual Studio.NET to Visual Studio, NET 2015, which is the latest version of Visual Studio for the platform. NET), although there are other alternatives, such as SharpDevelop (which is also free).

The paradigms in the development of programs have been evolving through the years and now we have one of the techniques that provides the programmers with greater ease, we refer to Object-Oriented Programming in N layers, since it allows to divide the work into several modular layers. Currently, the most used in terms of this style is the programming in three layers that is divided into:
1) Presentation layer, which interacts with the user.
2) The business layer, where the business rules that must be met are established.
3) The layer of data in which the connection with the server and the database is defined, is in this layer where the stored procedures or SQL commands are invoked, so that the corresponding operations in the base are carried out of data.

4.   Recomendaciones

   C# no permite crear módulos, en su lugar están las clases, pero podemos definir clases estáticas por si necesitamos usar una en particular que sólo declare miembros que necesitemos acceder de forma pública desde todo el proyecto y no requerimos crear una instancia de dicho objeto.
 La programación con 3 capaz sería lo más recomendable debido a que es convencional y la programación es ordenada y segura.
No exceder en el número de creación de capas, es posible que exista perdida de eficiencia.

5.   Conclusiones
 Ayuda mucho al programador de aplicaciones para dar mantenimiento al sistema, dado que el problema que pudiera suscitarse en visto a la capa respectiva.
 El estilo de programación en N capaz se basa en segmentar un proyecto en varias partes para realizar una programación independiente en cada una de ellas.
 La programación en N capaz es una herramienta didáctica que facilitara la reducción del tiempo por parte del usuario.

6.   Apreciación del Equipo
Ø Las “aplicaciones  n-capas  en  visual net” son muy importantes porque nos permiten almacenar y recuperar información en   grandes volúmenes y así, las personas encargadas de la organización puedan tomar decisiones más claras.
Ø Reduce la complejidad o facilidad para distribuir el desarrollo del software.
Ø La programación N capas es importante ya que nos ayuda a organizar los códigos de programación y eso nos da muchas ventajas al momento de programar.
Ø Tener la facilidad para desarrollar en múltiples plataformas (Web, escritorio, móvil).


7.   Glosario de Términos

Zócalo: nivel del suelo; en general hace referencia al pavimento.

Jerarquía: En una clase anterior hablábamos sobre las abstracciones y como estas definían el comportamiento general de un “objeto”, en programación orientada a objetos, estas abstracciones pueden ordenarse y clasificarse.

Complejidad: En programación el rendimiento o la complejidad de un algoritmo se suele medir utilizando una notación denominada Big-O, y también conocida como Notación Asintótica o Notación Landau.

Plataformas: Está definido por un estándar alrededor del cual se determina una arquitectura de hardware y una plataforma de software

Herramienta didáctica: Permite distribuir, ampliar, generar conocimientos, debatir, investigar y elaborar la información.


8.   Bibliografía o Linkografía


sábado, 9 de junio de 2018

OBJETO DATA TABLE Y DATASET








OBJETO DATA TABLE Y DATASET

1.     Contenido


o   Definición

Objetos DataTable

Un objeto DataSet está formado por una colección de tablas, relaciones y restricciones. En ADO.NET, DataTable objetos se utilizan para representar las tablas en un conjunto de datos.A DataTable representa una tabla de datos relacionales en memoria; los datos están locales para el. Aplicación de red en el que reside, pero se pueden llenar desde un origen de datos como Microsoft SQL Server mediante un DataAdapter para obtener más información, consulte llenar un DataSet desde un DataAdapter .

Objetos DataSet


El DataSet de ADO.NET es una representación de datos residente en memoria que proporciona un modelo de programación relacional coherente independientemente del origen de datos que contiene. Un DataSet representa un conjunto completo de datos, incluyendo las tablas que contienen, ordenan y restringen los datos, así como las relaciones entre las tablas.

o   Propiedades

DataSet

Ø  CaseSensitive: Obtiene o establece un valor que indica si comparaciones dentro de cadenas DataTable objetos distinguen mayúsculas de minúsculas.
Ø  Container: Obtiene el contenedor del componente.(Heredado de MarshalByValueComponent).
Ø  DataSetName: Obtiene o establece el nombre del actual DataSet.
Ø  DefaultViewManager: Obtiene una vista personalizada de los datos contenidos en el DataSet para permitir filtrar, buscar y desplazarse mediante un personalizado DataViewManager.
Ø  DesignMode: Obtiene un valor que indica si el componente está actualmente en modo de diseño.(Heredado de MarshalByValueComponent).
Ø  EnforceConstraints: Obtiene o establece un valor que indica si se siguen las reglas de restricción al intentar cualquier operación de actualización.
Ø  Events: Obtiene la lista de controladores de eventos que están asociados a este componente.(Heredado de MarshalByValueComponent).
Ø  ExtendedProperties: Obtiene la colección de información personalizada del usuario asociada a la DataSet.
Ø  HasErrors: Obtiene un valor que indica si hay errores en cualquiera de los DataTable objetos dentro de esteDataSet.
Ø  IsInitialized: Obtiene un valor que indica si el DataSet se inicializa.
Ø  Locale: Obtiene o establece la información de configuración regional utilizada para comparar las cadenas de la tabla.
Ø  Namespace: Obtiene o establece el espacio de nombres de la DataSet.
Ø  Prefix: Obtiene o establece un prefijo XML que crea alias del espacio de nombres de la DataSet.
Ø  Relations: Obtiene la colección de relaciones que vincula las tablas y permitir la navegación de primario tablas a las tablas secundarias.
Ø  RemotingFormat: Obtiene o establece un SerializationFormat para el DataSet utilizado durante la comunicación remota.
Ø  SchemaSerializationMode: Obtiene o establece un SchemaSerializationMode para un DataSet.
Ø  Site: Obtiene o establece una interfaz System.ComponentModel.ISite para el objeto DataSet.(Invalida MarshalByValueComponent.Site).
Ø  Tables: Obtiene la colección de tablas contenidas en el DataSet.


DataTable


ü  CaseSensitive: Indica si las comparaciones de cadenas dentro de la tabla distinguen mayúsculas de minúsculas.
ü  ChildRelations: Obtiene la colección de relaciones secundarias para este DataTable.
ü  Columns: Obtiene la colección de columnas que pertenecen a esta tabla.
ü  Constraints: Obtiene la colección de restricciones mantenidas por esta tabla.
ü  Container: Obtiene el contenedor del componente.(Heredado de MarshalByValueComponent).
ü  DataSet: Obtiene el DataSet al que pertenece esta tabla.
ü  DefaultView: Obtiene una vista personalizada de la tabla que puede incluir una vista filtrada o una posición del cursor.
ü  DesignMode: Obtiene un valor que indica si el componente está actualmente en modo de diseño.(Heredado de MarshalByValueComponent).
ü  DisplayExpression: Obtiene o establece la expresión que devuelve un valor utilizado para representar esta tabla en la interfaz de usuario. El DisplayExpression propiedad le permite mostrar el nombre de esta tabla en una interfaz de usuario.
ü  Events: Obtiene la lista de controladores de eventos que están asociados a este componente.(Heredado de MarshalByValueComponent).
ü  ExtendedProperties: Obtiene la colección de información personalizada del usuario.
ü  HasErrors: Obtiene un valor que indica si hay errores en cualquiera de las filas en cualquiera de las tablas de la DataSet al que pertenece la tabla.
ü  IsInitialized: Obtiene un valor que indica si el DataTable se inicializa.
ü  Locale: Obtiene o establece la información de configuración regional utilizada para comparar las cadenas de la tabla.
ü  MinimumCapacity: Obtiene o establece el tamaño inicial para esta tabla.
ü  Namespace: Obtiene o establece el espacio de nombres para la representación XML de los datos almacenados en el DataTable.
ü  ParentRelations: Obtiene la colección de relaciones primarias para este DataTable.
ü  Prefix: Obtiene o establece el espacio de nombres para la representación XML de los datos almacenados en el DataTable.
ü  PrimaryKey: Obtiene o establece una matriz de columnas que funcionan como claves principales para la tabla de datos.
ü  RemotingFormat: Obtiene o establece el formato de serialización.
ü  Rows: Obtiene la colección de filas que pertenecen a esta tabla.
ü  Site: Obtiene o establece una interfaz System.ComponentModel.ISite para el objetoDataTable.(Invalida MarshalByValueComponent.Site).
ü  TableName: Obtiene o establece el nombre de DataTable.






DataSet

Métodos

AcceptChanges():Confirma todos los cambios realizados en esta DataSet desde que se cargó o desde la última vez AcceptChanges se llamó.
BeginInit():Activa la inicialización de un objeto DataSet que se emplea en un formulario o que utiliza otro componente. La inicialización se produce en tiempo de ejecución.
Clear():Borra la DataSet de los datos mediante la eliminación de todas las filas de todas las tablas.
Clone():Copia la estructura de la DataSet, todas las incluidas DataTable esquemas, relaciones y restricciones. No copia los datos.
Copy(): Copia la estructura y los datos para este DataSet.
CreateDataReader():Devuelve un DataTableReader con un conjunto de resultados por DataTable, en la misma secuencia que las tablas aparecen en la Tables colección.
CreateDataReader(DataTable[]):Devuelve un DataTableReader con un conjunto de resultados por DataTable.
Dispose():Libera todos los recursos que usa MarshalByValueComponent.(Heredado de MarshalByValueComponent).
Dispose(Boolean): Libera los recursos no administrados que usa MarshalByValueComponent y libera los recursos administrados de forma opcional.(Heredado de MarshalByValueComponent).
EndInit():Finaliza la inicialización de un objeto DataSet que se emplea en un formulario o que utiliza otro componente. La inicialización se produce en tiempo de ejecución.
Equals(Object): Determina si el objeto especificado es igual al objeto actual.(Heredado de Object).
Finalize():Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de que sea reclamado por la recolección de elementos no utilizados.(Heredado de MarshalByValueComponent).
GetChanges():Obtiene una copia de la DataSet que contiene todos los cambios realizados desde que se cargó o desde AcceptChanges por última vez.
GetChanges(DataRowState):  Obtiene una copia de la DataSet que contiene todos los cambios realizados desde que se cargó o desde AcceptChanges se llama, filtrados por DataRowState.
GetDataSetSchema(XmlSchemaSet): Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Obtiene una copia de XmlSchemaSet del conjunto de datos.
GetHashCode():Sirve como la función hash predeterminada.(Heredado de Object).
GetObjectData(SerializationInfo, StreamingContext): Rellena un objeto de información de serialización con los datos necesarios para serializar el DataSet.
GetSchemaSerializable():Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Devuelve un serializable T:System.Xml.Schema.XMLSchema instancia.
GetSerializationData(SerializationInfo, StreamingContext): Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Deserializa los datos de la tabla de la secuencia binaria o XML.
GetService(Type): Obtiene el implementador de la IServiceProvider.(Heredado de MarshalByValueComponent).
GetType():Obtiene el Type de la instancia actual.(Heredado de Object).
GetXml():Devuelve la representación XML de los datos almacenados en el DataSet.
GetXmlSchema():Devuelve el esquema XML para la representación XML de los datos almacenados en elDataSet.
HasChanges():Obtiene un valor que indica si la DataSet presenta cambios, incluidas filas nuevas, eliminadas o modificadas.
HasChanges(DataRowState): Obtiene un valor que indica si la DataSet presenta cambios, incluidas filas nuevas, eliminadas o modificadas, filtrados por DataRowState.
InferXmlSchema(Stream, String[]):Aplica el esquema XML especificado Stream a la DataSet.
InferXmlSchema(String, String[]):Aplica el esquema XML del archivo especificado a la DataSet.
InferXmlSchema(TextReader, String[]):Aplica el esquema XML especificado TextReader a la DataSet.
InferXmlSchema(XmlReader, String[]):Aplica el esquema XML especificado XmlReader a la DataSet.
InitializeDerivedDataSet():Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. La deserialización de todos los datos de tablas del conjunto de datos de la secuencia binaria o XML.
IsBinarySerialized(SerializationInfo, StreamingContext): Inspecciona el formato de la representación serializada de la DataSet.
Load(IDataReader, LoadOption, DataTable[]):Rellena un DataSet con los valores de un origen de datos con el IDataReader, utilizando una matriz de DataTable instancias para proporcionar la información de esquema y espacio de nombres.
Load(IDataReader, LoadOption, String[]):Rellena un DataSet con los valores de un origen de datos con el IDataReader, utilizando una matriz de cadenas para suministrar los nombres de las tablas dentro de la DataSet.
MemberwiseClone():Crea una copia superficial del Object actual.(Heredado de Object).
Merge(DataRow[]):Combina una matriz de DataRow objetos en actual DataSet.
Merge(DataRow[], Boolean, MissingSchemaAction): Combina una matriz de DataRow objetos en actual DataSet, conservando o descartando los cambios efectuados en el DataSet y controlando un esquema incompatible de acuerdo con los argumentos especificados.
Merge(DataSet): Combina un especificado DataSet y su esquema en el actual DataSet.
Merge(DataSet, Boolean): Combina un especificado DataSet y su esquema en el actual DataSet, conservando o descartando los cambios en esta DataSet según el argumento especificado.
Merge(DataSet, Boolean, MissingSchemaAction): Combina un especificado DataSet y su esquema con el actual DataSet, conservando o descartando los cambios efectuados en este DataSet y controlando un esquema incompatible de acuerdo con los argumentos especificados.
Merge(DataTable): Combina un especificado DataTable y su esquema en el actual DataSet.
Merge(DataTable, Boolean, MissingSchemaAction): Combina un especificado DataTable y su esquema en el actual DataSet, conservando o descartando los cambios efectuados en el DataSet y controlando un esquema incompatible de acuerdo con los argumentos especificados.
OnRemoveRelation(DataRelation): Se produce cuando un DataRelation objeto se quita de un DataTable.
OnRemoveTable(DataTable): Se produce cuando un DataTable se quita de un DataSet.
RaisePropertyChanging(String): Envía una notificación de que el especificado DataSet propiedad que se va a cambiar.
ReadXml(Stream): Lee el esquema XML y los datos del DataSet usando el objeto System.IO.Stream.
ReadXml(Stream, XmlReadMode): Lee el esquema XML y datos en la DataSet con System.IO.Stream y XmlReadMode.
ReadXml(String): Lee el esquema XML y los datos del DataSet utilizando el archivo especificado.
ReadXml(String, XmlReadMode): Lee el esquema XML y los datos del DataSet utilizando el archivo especificado y XmlReadMode.
ReadXml(TextReader): Lee el esquema XML y los datos del DataSet usando el objeto System.IO.TextReader.
ReadXml(TextReader, XmlReadMode): Lee el esquema XML y datos en la DataSet con System.IO.TextReader y XmlReadMode.
ReadXml(XmlReader): Lee el esquema XML y los datos del DataSet usando el objeto System.Xml.XmlReader
ReadXml(XmlReader, XmlReadMode): Lee el esquema XML y datos en la DataSet con System.Xml.XmlReader y XmlReadMode.
ReadXmlSchema(Stream): Lee el esquema XML especificado Stream en la DataSet.
ReadXmlSchema(String): Lee el esquema XML del archivo especificado en el DataSet.
ReadXmlSchema(TextReader): Lee el esquema XML especificado TextReader en la DataSet.
ReadXmlSchema(XmlReader): Lee el esquema XML especificado XmlReader en la DataSet.
ReadXmlSerializable(XmlReader): Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Omite los atributos y devuelve un conjunto de datos vacío.
RejectChanges(): Deshace todos los cambios realizados en el DataSet desde que se creó o desde la última vez DataSet.AcceptChanges se llamó.
Reset(): Borra todas las tablas y quita todas las relaciones, restricciones externas y tablas de la DataSet. Las subclases deben reemplazar Reset para restaurar un DataSet a su estado original.
ShouldSerializeRelations(): Obtiene un valor que indica si Relations propiedad debe persistir.
ShouldSerializeTables(): Obtiene un valor que indica si Tables propiedad debe persistir.
ToString():Devuelve un String que contiene el nombre de la Component, si existe. Este método no se debe invalidar.(Heredado de MarshalByValueComponent).
WriteXml(Stream): Escribe los datos actuales para el DataSet usando el objeto System.IO.Stream.
WriteXml(Stream, XmlWriteMode):  Escribe los datos actuales y, opcionalmente, el esquema para el DataSet usando el objeto System.IO.Stream y XmlWriteMode. Para escribir el esquema, establezca el valor de la mode parámetro WriteSchema.
WriteXml(String): Escribe los datos actuales para el DataSet en el archivo especificado.
WriteXml(String, XmlWriteMode): Escribe los datos actuales y, opcionalmente, el esquema para el DataSet en el archivo especificado utilizando el parámetro XmlWriteMode. Para escribir el esquema, establezca el valor de la mode parámetro WriteSchema.
WriteXml(TextWriter): Escribe los datos actuales para el DataSet usando el objeto TextWriter.
WriteXml(TextWriter, XmlWriteMode): Escribe los datos actuales y, opcionalmente, el esquema para el DataSet usando el objeto TextWriter y XmlWriteMode. Para escribir el esquema, establezca el valor de la mode parámetro WriteSchema

WriteXml(XmlWriter): Escribe los datos actuales para el DataSet especificado XmlWriter.
WriteXml(XmlWriter, XmlWriteMode) : Escribe los datos actuales y, opcionalmente, el esquema para el DataSet usando el objeto XmlWriter y XmlWriteMode. Para escribir el esquema, establezca el valor de la mode parámetro WriteSchema.
WriteXmlSchema(Stream): Escribe el DataSet estructura como un esquema XML especificado System.IO.Streamobjeto.
WriteXmlSchema(Stream, Converter<Type, String>): Escribe el DataSet estructura como un esquema XML especificado System.IO.Streamobjeto.
WriteXmlSchema(String): Escribe el DataSet estructura como un esquema XML a un archivo.
WriteXmlSchema(String, Converter<Type, String>): Escribe el DataSet estructura como un esquema XML a un archivo.
WriteXmlSchema(TextWriter): Escribe la estructura DataSet como un esquema XML al objeto TextWriter especificado.
WriteXmlSchema(TextWriter, Converter<Type, String>): Escribe el DataSet estructura como un esquema XML especificado TextWriter.
WriteXmlSchema(XmlWriter): Escribe el DataSet estructura como un esquema XML a un XmlWriter objeto.
WriteXmlSchema(XmlWriter, Converter<Type, String>): Escribe el DataSet estructura como un esquema XML especificado XmlWriter.

o   Ejemplos

DataTable

se crean dos objetos DataTable, un objeto DataRelation y se agregan los nuevos objetos a DataSet. A continuación, las tablas se muestran en un control DataGridView.

// Put the next line into the Declarations section.
private System.Data.DataSet dataSet;
 
private void MakeDataTables()
{
    // Run all of the functions. 
    MakeParentTable();
    MakeChildTable();
    MakeDataRelation();
    BindToDataGrid();
}
 
private void MakeParentTable()
{
    // Create a new DataTable.
    System.Data.DataTable table = new DataTable("ParentTable");
    // Declare variables for DataColumn and DataRow objects.
    DataColumn column;
    DataRow row;
 
    // Create new DataColumn, set DataType, 
    // ColumnName and add to DataTable.    
    column = new DataColumn();
    column.DataType = System.Type.GetType("System.Int32");
    column.ColumnName = "id";
    column.ReadOnly = true;
    column.Unique = true;
    // Add the Column to the DataColumnCollection.
    table.Columns.Add(column);
 
    // Create second column.
    column = new DataColumn();
    column.DataType = System.Type.GetType("System.String");
    column.ColumnName = "ParentItem";
    column.AutoIncrement = false;
    column.Caption = "ParentItem";
    column.ReadOnly = false;
    column.Unique = false;
    // Add the column to the table.
    table.Columns.Add(column);
 
    // Make the ID column the primary key column.
    DataColumn[] PrimaryKeyColumns = new DataColumn[1];
    PrimaryKeyColumns[0] = table.Columns["id"];
    table.PrimaryKey = PrimaryKeyColumns;
 
    // Instantiate the DataSet variable.
    dataSet = new DataSet();
    // Add the new DataTable to the DataSet.
    dataSet.Tables.Add(table);
 
    // Create three new DataRow objects and add 
    // them to the DataTable
    for (int i = 0; i<= 2; i++)
    {
        row = table.NewRow();
        row["id"] = i;
        row["ParentItem"] = "ParentItem " + i;
        table.Rows.Add(row);
    }
}
 
private void MakeChildTable()
{
    // Create a new DataTable.
    DataTable table = new DataTable("childTable");
    DataColumn column;
    DataRow row;
 
    // Create first column and add to the DataTable.
    column = new DataColumn();
    column.DataType= System.Type.GetType("System.Int32");
    column.ColumnName = "ChildID";
    column.AutoIncrement = true;
    column.Caption = "ID";
    column.ReadOnly = true;
    column.Unique = true;
 
    // Add the column to the DataColumnCollection.
    table.Columns.Add(column);
 
    // Create second column.
    column = new DataColumn();
    column.DataType= System.Type.GetType("System.String");
    column.ColumnName = "ChildItem";
    column.AutoIncrement = false;
    column.Caption = "ChildItem";
    column.ReadOnly = false;
    column.Unique = false;
    table.Columns.Add(column);
 
    // Create third column.
    column = new DataColumn();
    column.DataType= System.Type.GetType("System.Int32");
    column.ColumnName = "ParentID";
    column.AutoIncrement = false;
    column.Caption = "ParentID";
    column.ReadOnly = false;
    column.Unique = false;
    table.Columns.Add(column);
 
    dataSet.Tables.Add(table);
 
    // Create three sets of DataRow objects, 
    // five rows each, and add to DataTable.
    for(int i = 0; i <= 4; i ++)
    {
        row = table.NewRow();
        row["childID"] = i;
        row["ChildItem"] = "Item " + i;
        row["ParentID"] = 0 ;
        table.Rows.Add(row);
    }
    for(int i = 0; i <= 4; i ++)
    {
        row = table.NewRow();
        row["childID"] = i + 5;
        row["ChildItem"] = "Item " + i;
        row["ParentID"] = 1 ;
        table.Rows.Add(row);
    }
    for(int i = 0; i <= 4; i ++)
    {
        row = table.NewRow();
        row["childID"] = i + 10;
        row["ChildItem"] = "Item " + i;
        row["ParentID"] = 2 ;
        table.Rows.Add(row);
    }
}
 
private void MakeDataRelation()
{
    // DataRelation requires two DataColumn 
    // (parent and child) and a name.
    DataColumn parentColumn = 
        dataSet.Tables["ParentTable"].Columns["id"];
    DataColumn childColumn = 
        dataSet.Tables["ChildTable"].Columns["ParentID"];
    DataRelation relation = new 
        DataRelation("parent2Child", parentColumn, childColumn);
    dataSet.Tables["ChildTable"].ParentRelations.Add(relation);
}
 
private void BindToDataGrid()
{
    // Instruct the DataGrid to bind to the DataSet, with the 
    // ParentTable as the topmost DataTable.
    dataGrid1.SetDataBinding(dataSet,"ParentTable");
}

DATA SET

The following example consists of several methods that, combined, create and fill a T:System.Data.DataSet from the Northwind database.
using System;
using System.Data;
using System.Data.SqlClient;
 
namespace Microsoft.AdoNet.DataSetDemo
{
    class NorthwindDataSet
    {
        static void Main()
        {
            string connectionString = GetConnectionString();
            ConnectToData(connectionString);
        }
 
        private static void ConnectToData(string connectionString)
        {
            //Create a SqlConnection to the Northwind database.
            using (SqlConnection connection =
                       new SqlConnection(connectionString))
            {
                //Create a SqlDataAdapter for the Suppliers table.
                SqlDataAdapter adapter = new SqlDataAdapter();
 
                // A table mapping names the DataTable.
                adapter.TableMappings.Add("Table", "Suppliers");
 
                // Open the connection.
                connection.Open();
                Console.WriteLine("The SqlConnection is open.");
 
                // Create a SqlCommand to retrieve Suppliers data.
                SqlCommand command = new SqlCommand(
                    "SELECT SupplierID, CompanyName FROM dbo.Suppliers;",
                    connection);
                command.CommandType = CommandType.Text;
 
                // Set the SqlDataAdapter's SelectCommand.
                adapter.SelectCommand = command;
 
                // Fill the DataSet.
                DataSet dataSet = new DataSet("Suppliers");
                adapter.Fill(dataSet);
 
                // Create a second Adapter and Command to get
                // the Products table, a child table of Suppliers. 
                SqlDataAdapter productsAdapter = new SqlDataAdapter();
                productsAdapter.TableMappings.Add("Table", "Products");
 
                SqlCommand productsCommand = new SqlCommand(
                    "SELECT ProductID, SupplierID FROM dbo.Products;",
                    connection);
                productsAdapter.SelectCommand = productsCommand;
 
                // Fill the DataSet.
                productsAdapter.Fill(dataSet);
 
                // Close the connection.
                connection.Close();
                Console.WriteLine("The SqlConnection is closed.");
 
                // Create a DataRelation to link the two tables
                // based on the SupplierID.
                DataColumn parentColumn =
                    dataSet.Tables["Suppliers"].Columns["SupplierID"];
                DataColumn childColumn =
                    dataSet.Tables["Products"].Columns["SupplierID"];
                DataRelation relation =
                    new System.Data.DataRelation("SuppliersProducts",
                    parentColumn, childColumn);
                dataSet.Relations.Add(relation);
                Console.WriteLine(
                    "The {0} DataRelation has been created.",
                    relation.RelationName);
            }
        }
 
        static private string GetConnectionString()
        {
            // To avoid storing the connection string in your code, 
            // you can retrieve it from a configuration file.
            return "Data Source=(local);Initial Catalog=Northwind;"
                + "Integrated Security=SSPI";
        }
   }
}




2.     Resumen

El DataTable clase es un miembro de la System.Data espacio de nombres dentro de la biblioteca de clases de .NET Framework. Puede crear y utilizar un DataTable por separado o como un miembro de un conjunto de datos, y DataTable objetos también pueden utilizarse junto con otros objetos de .NET Framework incluidas la DataView. Obtener acceso a la colección de tablas en un conjunto de datos a través de la tablas propiedad de la conjunto de datos objeto.
El esquema, o estructura, de una tabla se representa con columnas y restricciones. Las columnas de una tabla se pueden asignar a columnas de un origen de datos, pueden contener valores calculados de expresiones, aumentar sus valores automáticamente o contener valores de clave principal.
Además del esquema, un DataTable debe tener también filas para albergar y ordenar los datos.
El DataSet de ADO.NET es una representación de datos residente en memoria que proporciona un modelo de programación relacional coherente independientemente del origen de datos que contiene. Un DataSet representa un conjunto completo de datos, incluyendo las tablas que contienen, ordenan y restringen los datos, así como las relaciones entre las tablas.

3.     Summary

The DataTable class is a member of the System.Data namespace within the .NET Framework class library. You can create and use a DataTable separately or as a member of a data set, and DataTable objects can also be used in conjunction with other .NET Framework objects including the DataView. Access the collection of tables in a data set through the tables owned by the object data set.
The schema, or structure, of a table is represented by columns and constraints. Columns in a table can be assigned to columns in a data source, can contain calculated values ​​of expressions, increase their values ​​automatically, or contain primary key values.
In addition to the schema, a DataTable must also have rows to host and sort the data.
The ADO.NET DataSet is a memory resident data representation that provides a consistent relational programming model regardless of the data source it contains. A DataSet represents a complete set of data, including the tables that contain, order and restrict the data, as well as the relationships between the tables.

4.     Conclusiones

o   En un DataSet, se pueden realizar las mismas actividades que al utilizar una tabla de una base de datos. Se puede agregar, ver, modificar y eliminar datos en la tabla, supervisar los errores y eventos y consultar los datos de la tabla.
o   Es una representación residente en memoria de datos que proporciona un modelo de programación relacional coherente e independiente del origen de datos.
o   El objeto DataTable proporciona una serie de eventos que una aplicación puede procesar

5.     Apreciación del equipo

o   El DataSet es una copia en memoria de los datos
o   El Datatable es igual que el Dataset, solo que con una sola tabla.
o   Un DataSet contiene varias tablas de datos, cada una de las cuales corresponde típicamente a una tabla o vista de la base de datos.

6.     Glosario de Términos

DATASET
En general, se denomina así, a cualquier conjunto de datos, aunque también se le llama así al dispositivo convertidor de señal o modulador-demodulador (módem).
Dispose():Libera todos los recursos que usa MarshalByValueComponent.(Heredado de MarshalByValueComponent).
Dispose(Boolean): Libera los recursos no administrados que usa MarshalByValueComponent y libera los recursos administrados de forma opcional.(Heredado de MarshalByValueComponent).
EndInit():Finaliza la inicialización de un objeto DataSet que se emplea en un formulario o que utiliza otro componente. La inicialización se produce en tiempo de ejecución.
Equals(Object): Determina si el objeto especificado es igual al objeto actual.(Heredado de Object).
Container: Obtiene el contenedor del componente.(Heredado de MarshalByValueComponent).
DataSetName: Obtiene o establece el nombre del actual DataSet.
DefaultViewManager: Obtiene una vista personalizada de los datos contenidos en el DataSet para permitir filtrar, buscar y desplazarse mediante un personalizado DataViewManager.
DesignMode: Obtiene un valor que indica si el componente está actualmente en modo de diseño.(Heredado de MarshalByValueComponent).
EnforceConstraints: Obtiene o establece un valor que indica si se siguen las reglas de restricción al intentar cualquier operación de actualización.




7.     Linkografia

§