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

HierarchicalDataSourceControl (Clase)

Proporciona una clase base para controles de origen de datos que representan datos jerárquicos.

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

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

ASP.NET admite una arquitectura de enlace de datos de controles que permite enlazar los controles de servidor Web a los datos y presentarlos de una manera coherente. Los controles de servidor Web que se enlazan a los datos se denominan controles enlazados a datos y las clases que facilitan ese enlace se denominan controles de origen de datos. Los controles de origen de datos pueden representar cualquier origen de datos: un archivo, una secuencia, una base de datos relacional, un objeto comercial, etc. Los controles de origen de datos presentan los datos de una manera coherente a los controles enlazados a datos, sin tener en cuenta el origen o formato de los datos subyacentes.

Los controles de origen de datos que representan datos jerárquicos derivan de la clase HierarchicalDataSourceControl, mientras los controles de origen de datos que representan listas o tablas de datos derivan de la clase DataSourceControl. La clase HierarchicalDataSourceControl es la implementación base de la interfaz IHierarchicalDataSource, que define un método único para recuperar los objetos de vista de origen de datos jerárquicos asociados al control de origen de datos, GetHierarchicalView.

Un control de origen de datos se puede considerar como la combinación del objeto HierarchicalDataSourceControl y sus vistas asociadas en los datos subyacentes, denominadas objetos de vista de origen de datos. Aunque los controles de origen de datos que representan datos tabulares están asociados por lo general con una única vista con nombre, la clase HierarchicalDataSourceControl admite una vista de origen de datos para cada nivel de datos jerárquicos que representa el control de origen de datos. Una ruta de acceso jerárquica única, pasada al método GetHierarchicalView en el parámetro viewPath, identifica el nivel de datos jerárquicos. Cada objeto HierarchicalDataSourceView define las funciones de un control de origen de datos para el nivel jerárquico representado y realiza operaciones de inserción, actualización, eliminación y ordenación.

Los controles de servidor Web que derivan de la clase HierarchicalDataBoundControl, como TreeView, utilizan controles de origen de datos jerárquicos para enlazarse a los datos jerárquicos.

Los controles de origen de datos se implementan como controles para habilitar la persistencia declarativa y opcionalmente para permitir la participación en administración de los estados. Los controles de origen de datos no tienen ninguna interpretación gráfica y por consiguiente no admiten temas.

En el ejemplo de código siguiente se muestra la forma de extender la clase HierarchicalDataSourceControl abstracta y la clase HierarchicalDataSourceView y se implementan las interfaces IHierarchicalEnumerable y IHierarchyData para crear un control de origen de datos jerárquico que recupera información del sistema de archivos. El control FileSystemDataSource permite a los controles de servidor Web enlazarse a los objetos FileSystemInfo y mostrar información básica del sistema de archivos. La clase FileSystemDataSource del ejemplo proporciona la implementación del método GetHierarchicalView, que recupera un objeto FileSystemDataSourceView. El objeto FileSystemDataSourceView recupera los datos del almacenamiento de datos subyacente, en este caso la información del sistema de archivos sobre el servidor Web. A efectos de seguridad, sólo se muestra información del sistema de archivos si el control de origen de datos se utiliza en un escenario autenticado y de host local, y sólo se inicia con el directorio virtual de la página de formularios Web Forms utilizando el control de origen de datos en el que reside. Finalmente, se incluyen dos clases que implementan los objetos IHierarchicalEnumerable y IHierarchyData para ajustar el objeto FileSystemInfo que utiliza FileSystemDataSource.

using System;
using System.Collections;
using System.IO;
using System.Runtime.InteropServices;
using System.Security.Permissions;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

[AspNetHostingPermission(SecurityAction.Demand, Level=AspNetHostingPermissionLevel.Minimal)]
public class FileSystemDataSource : HierarchicalDataSourceControl, IHierarchicalDataSource
{
    public FileSystemDataSource() : base() {}

    // Return a strongly typed view for the current data source control.
    private FileSystemDataSourceView view = null;
    protected override HierarchicalDataSourceView GetHierarchicalView(string viewPath) {
        if (null == view) {
            view = new FileSystemDataSourceView(viewPath);
        }
        return view;
    }

    // The FileSystemDataSource can be used declaratively. To enable
    // declarative use, override the default implementation of
    // CreateControlCollection to return a ControlCollection that
    // you can add to.
    protected override ControlCollection CreateControlCollection() {
        return new ControlCollection(this);
    }
}
// The FileSystemDataSourceView class encapsulates the
// capabilities of the FileSystemDataSource data source control.
public class FileSystemDataSourceView : HierarchicalDataSourceView
{
private string _viewPath;

    public FileSystemDataSourceView(string viewPath)
    {
        // This implementation of HierarchicalDataSourceView does not
        // use the viewPath parameter but other implementations
        // could make use of it for retrieving values.
        _viewPath = viewPath;
    }

    // Starting with the rootNode, recursively build a list of
    // FileSystemInfo nodes, create FileSystemHierarchyData
    // objects, add them all to the FileSystemHierarchicalEnumerable,
    // and return the list.
    public override IHierarchicalEnumerable Select() {
        HttpRequest currentRequest = HttpContext.Current.Request;

        // SECURITY: There are many security issues that can be raised
        // SECURITY: by exposing the file system structure of a Web server
        // SECURITY: to an anonymous user in a limited trust scenario such as
        // SECURITY: a Web page served on an intranet or the Internet.
        // SECURITY: For this reason, the FileSystemDataSource only
        // SECURITY: shows data when the HttpRequest is received
        // SECURITY: from a local Web server. In addition, the data source
        // SECURITY: does not display data to anonymous users.
        if ( currentRequest.IsAuthenticated &&
            (currentRequest.UserHostAddress == "127.0.0.1" ||
             currentRequest.UserHostAddress == "::1"))
        {
            string rootPath = currentRequest.MapPath (currentRequest.ApplicationPath);

            DirectoryInfo rootDirectory = new DirectoryInfo(rootPath);

            FileSystemHierarchicalEnumerable fshe = new FileSystemHierarchicalEnumerable();

            foreach (FileSystemInfo fsi in rootDirectory.GetFileSystemInfos()) {
                fshe.Add(new FileSystemHierarchyData(fsi));
            }
            return fshe;
        }
        else {
            throw new NotSupportedException("The FileSystemDataSource only " + "presents data in an authenticated, localhost context.");
        }
    }
}
// A collection of FileSystemHierarchyData objects
public class FileSystemHierarchicalEnumerable : ArrayList, IHierarchicalEnumerable
{
    public FileSystemHierarchicalEnumerable () : base (){
    }

    public IHierarchyData GetHierarchyData(object enumeratedItem) {
        return enumeratedItem as IHierarchyData;
    }
}

public class FileSystemHierarchyData : IHierarchyData
{
    public FileSystemHierarchyData (FileSystemInfo obj) {
        fileSystemObject = obj;
    }

    private FileSystemInfo fileSystemObject = null;

    public override string ToString() {
        return fileSystemObject.Name;
    }
    // IHierarchyData implementation.
    public bool HasChildren {
        get {
            if (typeof(DirectoryInfo) ==  fileSystemObject.GetType()   ) {
                DirectoryInfo temp = (DirectoryInfo) fileSystemObject;
                return (temp.GetFileSystemInfos().Length > 0);
            }
            else return false;
        }
    }
    // DirectoryInfo returns the OriginalPath, while FileInfo returns
    // a fully qualified path.
    public string Path {
        get {
            return fileSystemObject.ToString();
        }
    }
    public object Item {
        get {
            return fileSystemObject;
        }
    }
    public string Type {
        get {
            return "FileSystemData";
        }
    }
    public IHierarchicalEnumerable GetChildren() {
        FileSystemHierarchicalEnumerable children =
            new FileSystemHierarchicalEnumerable();

        if (typeof(DirectoryInfo) == fileSystemObject.GetType()) {
            DirectoryInfo temp = (DirectoryInfo)fileSystemObject;
            foreach (FileSystemInfo fsi in temp.GetFileSystemInfos()) {
                children.Add(new FileSystemHierarchyData(fsi));
            }
        }
        return children;
    }

    public IHierarchyData GetParent()
    {
        FileSystemHierarchicalEnumerable parentContainer =
            new FileSystemHierarchicalEnumerable();

        if (typeof(DirectoryInfo) == fileSystemObject.GetType())
        {
            DirectoryInfo temp = (DirectoryInfo)fileSystemObject;
            return new FileSystemHierarchyData(temp.Parent);
        }
        else if (typeof(FileInfo) == fileSystemObject.GetType())
        {
            FileInfo temp = (FileInfo)fileSystemObject;
            return new FileSystemHierarchyData(temp.Directory);
        }
        // If FileSystemObj is any other kind of FileSystemInfo, ignore it.
        return null;
    }
}

En el ejemplo de código siguiente se muestra la forma de enlazar mediante declaración un control TreeView a los datos del sistema de archivos utilizando el ejemplo FileSystemDataSource.

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

<!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:treeview
                id="TreeView1"
                runat="server"
                datasourceid="FileSystemDataSource1" />            

            <aspSample:filesystemdatasource
                id = "FileSystemDataSource1"
                runat = "server" />            

        </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: