Esta documentación está archivada y no tiene mantenimiento.

DataSourceControl (Clase)

Sirve de clase base para los controles que representan orígenes de datos para los controles enlazados a datos.

Espacio de nombres: System.Web.UI
Ensamblado: System.Web (en system.web.dll)

[BindableAttribute(false)] 
public abstract class DataSourceControl : Control, IDataSource, IListSource
/** @attribute BindableAttribute(false) */ 
public abstract class DataSourceControl extends Control implements IDataSource, IListSource
BindableAttribute(false) 
public abstract class DataSourceControl extends Control implements IDataSource, IListSource
No aplicable.

ASP.NET es compatible con una arquitectura de enlace a datos de control que permite que los controles de servidor Web se enlacen a los datos de forma coherente. Los controles de servidor Web que se enlazan a datos se denominan controles enlazados a datos y las clases que posibilitan este enlace se denominan controles de origen de datos. Los controles de origen de datos pueden representar cualquier origen de datos: una base de datos relacional, un archivo, una secuencia, un objeto comercial, etc. Los controles de origen de datos presentan los datos a los controles enlazados a datos de una forma coherente, sin tener en cuenta el origen o el formato de los datos subyacentes.

Los controles de origen de datos que se proporcionan con ASP.NET, como SqlDataSource, AccessDataSource y XmlDataSource, se utilizan para realizar la mayoría de las tareas de desarrollo Web. Utilice la clase base DataSourceControl cuando desee implementar su propio control de origen de datos personalizado.

Si bien cualquier clase que implemente la interfaz IDataSource es un control de origen de datos, la mayoría de los controles de origen de datos de ASP.NET amplían la clase abstracta DataSourceControl, que proporciona una implementación base de la interfaz IDataSource. La clase DataSourceControl proporciona también una implementación de la interfaz IListSource, que permite asignar mediante programación el control de origen de datos a la propiedad DataSource de un control enlazado a datos y devolver los datos al control como una lista básica.

Cualquier control ASP.NET que se derive de la clase DataBoundControl puede enlazarse a un control de origen de datos. Cuando un objeto DataBoundControl se enlaza a un control de origen de datos, el enlace de datos se realiza automáticamente en tiempo de ejecución. También puede utilizar los controles de origen de datos con controles ASP.NET que expongan una propiedad DataSource o DataSourceID y admitan el enlace básico de datos, pero no se deriven de DataBoundControl. Cuando utilice estos controles enlazados a datos, deberá llamar al método DataBind de forma explícita. Para obtener más información sobre el enlace de datos, vea Obtener acceso a datos con ASP.NET.

Un control de origen de datos se puede considerar como la combinación del objeto DataSourceControl y sus listas de datos asociadas, denominadas vistas de origen de datos. Cada una de las listas de datos está representada por un objeto DataSourceView. Como el almacenamiento de datos subyacente contiene una o varias listas de datos, un objeto DataSourceControl siempre estará asociado a uno o varios objetos DataSourceView con nombre. La interfaz IDataSource define los métodos que todos los controles de origen de datos utilizan para interactuar con las vistas de origen de datos: el método GetViewNames se utiliza para enumerar las vistas de origen de datos asociadas en la actualidad al control de origen de datos y el método GetView se utiliza para recuperar una instancia específica de la vista de origen de datos por su nombre.

El control de origen de datos puede considerarse también como dos interfaces distintas que los llamadores utilizan para obtener acceso a los datos. La clase DataSourceControl es la interfaz con la que los desarrolladores de páginas interactúan directamente al desarrollar páginas de formularios Web Forms, mientras que la clase DataSourceView es la interfaz con la que interactúan los controles enlazados a datos y los autores de controles enlazados a datos. Como el objeto DataSourceView sólo está disponible en tiempo de ejecución, el control de origen de datos debe exponer directamente todos los estados guardados para el control de origen de datos o la vista de origen de datos.

No existe ninguna representación gráfica de los controles de origen de datos ASP.NET; se implementan como controles para que puedan crearse de forma declarativa y, si se desea, para permitirles que participen en la administración de estado. Como consecuencia, los controles de origen de datos no admiten características gráficas como EnableTheming o SkinID.

En el siguiente código de ejemplo se muestra la forma en que una clase puede extender la clase DataSourceControl. El control CsvDataSource representa los datos de archivos delimitados por comas que se encuentran almacenados en un archivo .csv. La clase CsvDataSource proporciona sus propias implementaciones de los métodos GetView, GetViewNames y otros métodos, porque las implementaciones de la clase base no son funcionales.

using System;
using System.Collections;
using System.Data;
using System.IO;
using System.Security.Permissions;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

// The CsvDataSource is a data source control that retrieves its
// data from a comma-separated value file.
[AspNetHostingPermission(SecurityAction.Demand, Level=AspNetHostingPermissionLevel.Minimal)]
public class CsvDataSource : DataSourceControl
{
    public CsvDataSource() : base() {}

    // The comma-separated value file to retrieve data from.
    public string FileName {
        get {
            return ((CsvDataSourceView)this.GetView(String.Empty)).SourceFile;
        }
        set {
            // Only set if it is different.
            if ( ((CsvDataSourceView)this.GetView(String.Empty)).SourceFile != value) {
                ((CsvDataSourceView)this.GetView(String.Empty)).SourceFile = value;
                RaiseDataSourceChangedEvent(EventArgs.Empty);
            }
        }
    }

    // Do not add the column names as a data row. Infer columns if the CSV file does
    // not include column names.
    public bool IncludesColumnNames {
        get {
            return ((CsvDataSourceView)this.GetView(String.Empty)).IncludesColumnNames;
        }
        set {
            // Only set if it is different.
            if ( ((CsvDataSourceView)this.GetView(String.Empty)).IncludesColumnNames != value) {
                ((CsvDataSourceView)this.GetView(String.Empty)).IncludesColumnNames = value;
                RaiseDataSourceChangedEvent(EventArgs.Empty);
            }
        }
    }

    // Return a strongly typed view for the current data source control.
    private CsvDataSourceView view = null;
    protected override DataSourceView GetView(string viewName) {
        if (null == view) {
            view = new CsvDataSourceView(this, String.Empty);
        }
        return view;
    }
    // The ListSourceHelper class calls GetList, which
    // calls the DataSourceControl.GetViewNames method.
    // Override the original implementation to return
    // a collection of one element, the default view name.
    protected override ICollection GetViewNames() {
        ArrayList al = new ArrayList(1);
        al.Add(CsvDataSourceView.DefaultViewName);
        return al as ICollection;
    }
}

// The CsvDataSourceView class encapsulates the
// capabilities of the CsvDataSource data source control.
public class CsvDataSourceView : DataSourceView
{

    public CsvDataSourceView(IDataSource owner, string name) :base(owner, DefaultViewName) {

    }

    // The data source view is named. However, the CsvDataSource
    // only supports one view, so the name is ignored, and the
    // default name used instead.
    public static string DefaultViewName = "CommaSeparatedView";

    // The location of the .csv file.
    private string sourceFile = String.Empty;
    internal string SourceFile {
        get {
            return sourceFile;
        }
        set {
            // Use MapPath when the SourceFile is set, so that files local to the
            // current directory can be easily used.
            string mappedFileName = HttpContext.Current.Server.MapPath(value);
            sourceFile = mappedFileName;
        }
    }

    // Do not add the column names as a data row. Infer columns if the CSV file does
    // not include column names.
    private bool columns = false;
    internal bool IncludesColumnNames {
        get {
            return columns;
        }
        set {
            columns = value;
        }
    }

    // Get data from the underlying data source.
    // Build and return a DataView, regardless of mode.
    protected override IEnumerable ExecuteSelect(DataSourceSelectArguments selectArgs) {
        IEnumerable dataList = null;
        // Open the .csv file.
        if (File.Exists(this.SourceFile)) {
            DataTable data = new DataTable();

            // Open the file to read from.
            using (StreamReader sr = File.OpenText(this.SourceFile)) {
                // Parse the line
                string s = "";
                string[] dataValues;
                DataColumn col;

                // Do the following to add schema.
                dataValues = sr.ReadLine().Split(',');
                // For each token in the comma-delimited string, add a column
                // to the DataTable schema.
                foreach (string token in dataValues) {
                    col = new DataColumn(token,typeof(string));
                    data.Columns.Add(col);
                }

                // Do not add the first row as data if the CSV file includes column names.
                if (! IncludesColumnNames)
                    data.Rows.Add(CopyRowData(dataValues, data.NewRow()));

                // Do the following to add data.
                while ((s = sr.ReadLine()) != null) {
                    dataValues = s.Split(',');
                    data.Rows.Add(CopyRowData(dataValues, data.NewRow()));
                }
            }
            data.AcceptChanges();
            DataView dataView = new DataView(data);
            if (selectArgs.SortExpression != String.Empty) {
                dataView.Sort = selectArgs.SortExpression;
            }
            dataList = dataView;
        }
        else {
            throw new System.Configuration.ConfigurationErrorsException("File not found, " + this.SourceFile);
        }

        if (null == dataList) {
            throw new InvalidOperationException("No data loaded from data source.");
        }

        return dataList;
    }

    private DataRow CopyRowData(string[] source, DataRow target) {
        try {
            for (int i = 0;i < source.Length;i++) {
                target[i] = source[i];
            }
        }
        catch (System.IndexOutOfRangeException) {
            // There are more columns in this row than
            // the original schema allows.  Stop copying
            // and return the DataRow.
            return target;
        }
        return target;
    }
    // The CsvDataSourceView does not currently
    // permit deletion. You can modify or extend
    // this sample to do so.
    public override bool CanDelete {
        get {
            return false;
        }
    }
    protected override int ExecuteDelete(IDictionary keys, IDictionary values)
    {
        throw new NotSupportedException();
    }
    // The CsvDataSourceView does not currently
    // permit insertion of a new record. You can
    // modify or extend this sample to do so.
    public override bool CanInsert {
        get {
            return false;
        }
    }
    protected override int ExecuteInsert(IDictionary values)
    {
        throw new NotSupportedException();
    }
    // The CsvDataSourceView does not currently
    // permit update operations. You can modify or
    // extend this sample to do so.
    public override bool CanUpdate {
        get {
            return false;
        }
    }
    protected override int ExecuteUpdate(IDictionary keys, IDictionary values, IDictionary oldValues)
    {
        throw new NotSupportedException();
    }
}

En el siguiente ejemplo de código se muestra la forma de utilizar el control CsvDataSource en un formulario Web Forms.

<%@ Page Language="C#" %>
<%@ Register Tagprefix="aspSample"
             Namespace="Samples.AspNet.CS.Controls" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >
  <head runat="server">
    <title>ASP.NET Example</title>
</head>
<body>
    <form id="form1" runat="server">

      <asp:gridview
          id="GridView1"
          runat="server"
          allowsorting="True"
          datasourceid="CsvDataSource1" />

      <aspSample:CsvDataSource
          id = "CsvDataSource1"
          runat = "server"
          filename = "sample.csv"
          includescolumnnames="True" />

    </form>
  </body>
</html>

  • AspNetHostingPermission  para trabajar en un entorno alojado en host. Valor de la petición: LinkDemand; valor del permiso: Minimal.
  • AspNetHostingPermission  para trabajar en un entorno alojado en host. Valor de la petición: InheritanceDemand; valor del permiso: Minimal.

Los miembros estáticos públicos (Shared en Visual Basic) de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Windows 98, Windows 2000 Service Pack 4, Windows CE, Windows Millennium, Windows Mobile para Pocket PC, Windows Mobile para Smartphone, Windows Server 2003, Windows XP Media Center, Windows XP Professional x64, Windows XP SP2, Windows XP Starter

Microsoft .NET Framework 3.0 es compatible con Windows Vista, Microsoft Windows XP SP2 y Windows Server 2003 SP1.

.NET Framework

Compatible con: 3.0, 2.0
Mostrar: