(0) exportieren Drucken
Alle erweitern

HierarchicalDataSourceControl-Klasse

Stellt eine Basisklasse für Datenquellen-Steuerelemente bereit, die hierarchische Daten darstellen.

Namespace: System.Web.UI
Assembly: System.Web (in 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
Nicht zutreffend.

ASP.NET unterstützt eine Datenbindungsarchitektur für Steuerelemente, mit der Webserversteuerelemente Daten binden und einheitlich darstellen können. Webserversteuerelemente, die Daten binden, werden als datengebundene Steuerelemente bezeichnet. Die Klassen, die diese Bindung ermöglichen, werden Datenquellen-Steuerelemente genannt. Datenquellen-Steuerelemente können eine beliebige Datenquelle darstellen: eine Datei, einen Stream, eine relationale Datenbank, ein Geschäftsobjekt usw. Datenquellen-Steuerelemente stellen die Daten für datengebundene Steuerelemente unabhängig von der Quelle oder dem Format der zugrunde liegenden Daten einheitlich dar.

Datenquellen-Steuerelemente, die hierarchische Daten darstellen, werden aus der HierarchicalDataSourceControl-Klasse abgeleitet; Datenquellen-Steuerelemente, die Listen oder Tabellen darstellen, werden dagegen aus der DataSourceControl-Klasse abgeleitet. Die HierarchicalDataSourceControl-Klasse ist die Basisimplementierung der IHierarchicalDataSource-Schnittstelle, mit der eine einzelne Methode zum Abrufen hierarchischer Datenquellen-Ansichtsobjekte definiert wird, die dem Datenquellen-Steuerelement zugeordnet sind (GetHierarchicalView).

Sie können sich ein Datenquellen-Steuerelement als Kombination des HierarchicalDataSourceControl-Objekts und der zugehörigen Ansichten der zugrunde liegenden Daten vorstellen, die als Datenquellen-Ansichtsobjekte bezeichnet werden. Während Datenquellen-Steuerelemente, die tabellarische Daten darstellen, i. d. .R. nur einer benannten Ansicht zugeordnet sind, unterstützt die HierarchicalDataSourceControl-Klasse eine Datenquellenansicht für alle Ebenen der vom Datenquellen-Steuerelement dargestellten hierarchischen Daten. Die Ebene hierarchischer Daten wird von einem eindeutigen hierarchischen Pfad identifiziert, der im viewPath-Parameter an die GetHierarchicalView-Methode übergeben wird. Jedes HierarchicalDataSourceView-Objekt definiert die Funktionen eines Datenquellen-Steuerelements für die dargestellte hierarchische Ebene und führt Vorgänge wie Einfügen, Aktualisieren, Löschen und Sortieren aus.

Webserversteuerelemente, die von der HierarchicalDataBoundControl-Klasse abgeleitet sind (z. B. TreeView), verwenden hierarchische Datenquellen-Steuerelemente zur Bindung hierarchischer Daten.

Datenquellen-Steuerelemente werden als Steuerelemente implementiert, um die deklarative Beibehaltung zu aktivieren und optional die Integration in die Zustandsverwaltung zuzulassen. Datenquellen-Steuerelemente werden nicht visuell wiedergegeben und unterstützen deshalb keine Designs.

Im folgenden Codebeispiel wird die Erweiterung der abstrakten HierarchicalDataSourceControl-Klasse und der HierarchicalDataSourceView-Klasse dargestellt. Weiterhin wird die Implementierung der IHierarchicalEnumerable-Schnittstelle und der IHierarchyData-Schnittstelle zum Erstellen eines hierarchischen Datenquellen-Steuerelements veranschaulicht, das Dateisysteminformationen abruft. Mit dem FileSystemDataSource-Steuerelement können Webserversteuerelemente an FileSystemInfo-Objekte gebunden und grundlegende Dateisysteminformationen angezeigt werden. Im Beispiel wird von der FileSystemDataSource-Klasse die Implementierung der GetHierarchicalView-Methode bereitgestellt, die ein FileSystemDataSourceView-Objekt abruft. Mit dem FileSystemDataSourceView-Objekt werden die Daten aus dem zugrunde liegenden Datenspeicher abgerufen, in diesem Fall handelt es sich dabei um die Dateisysteminformationen auf dem Webserver. Aus Sicherheitsgründen werden die Dateisysteminformationen nur angezeigt, wenn das Datenquellen-Steuerelement in einem authentifizierten Localhost-Szenario verwendet wird; außerdem wird zunächst nur das virtuelle Verzeichnis angezeigt, in dem sich die Web Forms-Seite befindet, die das Datenquellen-Steuerelement verwendet. Abschließend werden zwei Klassen bereitgestellt, die IHierarchicalEnumerable und IHierarchyData implementieren, um die von FileSystemDataSource verwendeten FileSystemInfo-Objekte in einen Wrapper einzuschließen.

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;
    }
}

Im folgenden Codebeispiel wird anhand des FileSystemDataSource-Beispiels veranschaulicht, wie ein TreeView-Steuerelement deklarativ an die Dateisystemdaten gebunden wird.

<%@ 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>

Alle öffentlichen statischen (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Windows 98, Windows Server 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

Microsoft .NET Framework 3.0 wird unter Windows Vista, Microsoft Windows XP SP2 und Windows Server 2003 SP1 unterstützt.

.NET Framework

Unterstützt in: 3.0, 2.0
Anzeigen:
© 2014 Microsoft