Lire en anglais

Partager via

IDataSource Interface

  • Référence

Définition

Espace de noms:
System.Web.UI
Assembly:
System.Web.dll

Représente une source de données abstraite à laquelle associer les contrôles liés aux données.

C# 
public interface IDataSource
Dérivé

Exemples

L’exemple de code suivant montre comment une classe peut implémenter les méthodes définies par l’interface IDataSource pour fournir des données aux contrôles liés aux données. Le contrôle de source de données dans cet exemple agit en tant que source de données sur un fichier de valeurs séparées par des virgules et peut être utilisé par n’importe quel contrôle lié aux données pour afficher des données de fichier séparées par des virgules. Cet exemple de code fait partie d’un exemple plus grand fourni pour la DataSourceControl classe .

C# 
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 (!string.IsNullOrEmpty(selectArgs.SortExpression)) {
                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();
    }
}

Remarques

ASP.NET prend en charge une architecture de liaison de données de contrôle qui permet aux contrôles serveur web de lier des données de manière cohérente. Les contrôles de serveur web qui lient des données sont appelés contrôles liés aux données, et les classes qui facilitent cette liaison sont appelées contrôles de source de données. Les contrôles de source de données peuvent représenter n’importe quelle source de données : une base de données relationnelle, un fichier, un flux, un objet métier, etc. Les contrôles de source de données présentent les données de manière cohérente avec les contrôles liés aux données, quel que soit la source ou le format des données sous-jacentes.

Vous implémentez l’interface IDataSource lorsque vous souhaitez implémenter votre propre contrôle de source de données ASP.NET personnalisé.

Toute classe qui implémente l’interface IDataSource est un contrôle de source de données. L’interface IDataSource sert de base à tous les contrôles de source de données ASP.NET et définit l’un des concepts fondamentaux de l’architecture de liaison de données avec ses deux méthodes : la GetView méthode et la GetViewNames méthode. Ce concept est que tous les contrôles de source de données prennent en charge une ou plusieurs vues nommées sur leurs données. L’objet de vue de source de données est similaire à l’abstraction DataView dans l’espace System.Data de noms : une vue de données personnalisée et pouvant être liée à des données pour le tri, le filtrage et d’autres opérations de données que la vue définit. À la base, un contrôle de source de données ne fait rien d’autre que récupérer des vues sur des données.

Un contrôle de source de données peut avoir un ou plusieurs objets de vue de source de données associés. Certains contrôles de source de données, y compris ceux qui représentent des bases de données relationnelles telles que SqlDataSource et AccessDataSource, ne prennent en charge qu’une seule vue. D’autres contrôles de source de données, notamment les contrôles de source de données hiérarchiques tels que SiteMapDataSource, prennent en charge de nombreux affichages. La vue de source de données définit les fonctionnalités d’une source de données et les opérations qu’elle prend en charge.

En résumé, les contrôles de source de données implémentent l’interface IDataSource , prennent en charge une ou plusieurs vues nommées sur les données qu’ils représentent et prennent toujours en charge la récupération des données à partir de la source de données qu’ils représentent. Les contrôles de source de données récupèrent toujours des données à la demande, par exemple quand DataBind est appelé sur un contrôle lié aux données.

Méthodes

GetView(String)

Obtient l'affichage de source de données associé au contrôle de source de données.
GetViewNames()

Obtient une collection des noms qui représentent la liste d'objets d'affichage associée à l'interface IDataSource.

Événements

DataSourceChanged

Se produit lorsque la modification d'un contrôle de source de données affecte les contrôles liés aux données.

Méthodes d’extension

GetDefaultValues(IDataSource)

Obtient la collection des valeurs par défaut pour la source de données spécifiée.
GetMetaTable(IDataSource)

Obtient les métadonnées pour une table dans l'objet source de données spécifié.
TryGetMetaTable(IDataSource, MetaTable)

Détermine si des métadonnées de table sont disponibles.

S’applique à

Produit Versions
.NET Framework 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1

Voir aussi