HierarchicalDataSourceControl Třída

Definice

public ref class HierarchicalDataSourceControl abstract : System::Web::UI::Control, System::Web::UI::IHierarchicalDataSource

[System.ComponentModel.Bindable(false)]
public abstract class HierarchicalDataSourceControl : System.Web.UI.Control, System.Web.UI.IHierarchicalDataSource

[<System.ComponentModel.Bindable(false)>]
type HierarchicalDataSourceControl = class
    inherit Control
    interface IHierarchicalDataSource

Public MustInherit Class HierarchicalDataSourceControl
Inherits Control
Implements IHierarchicalDataSource

Dědičnost

Object

Control

HierarchicalDataSourceControl

Odvozené

System.Web.UI.WebControls.SiteMapDataSource

System.Web.UI.WebControls.XmlDataSource

Atributy

BindableAttribute

Implementuje

IHierarchicalDataSource

Příklady

Následující příklad kódu ukazuje, jak rozšířit abstraktní HierarchicalDataSourceControl třídu a HierarchicalDataSourceView třídu a implementovat IHierarchicalEnumerable rozhraní a IHierarchyData k vytvoření hierarchického ovládacího prvku zdroje dat, který načítá informace systému souborů. Ovládací FileSystemDataSource prvek umožňuje ovládacím prvkům webového serveru vytvořit vazbu na FileSystemInfo objekty a zobrazit základní informace o systému souborů. Třída FileSystemDataSource v příkladu poskytuje implementaci GetHierarchicalView metody , která načte FileSystemDataSourceView objekt. Objekt FileSystemDataSourceView načte data z podkladového datového úložiště, v tomto případě informací o systému souborů na webovém serveru. Z bezpečnostních důvodů se informace o systému souborů zobrazují pouze v případě, že se ovládací prvek zdroje dat používá v ověřeném scénáři místního hostitele a začíná pouze virtuálním adresářem, ve kterém se nachází stránka Web Forms používající ovládací prvek zdroje dat. Nakonec dvě třídy, které implementují IHierarchicalEnumerable a IHierarchyData jsou k dispozici k zabalení FileSystemInfo objektů, které FileSystemDataSource používají.

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;

public class FileSystemDataSource :
    HierarchicalDataSourceControl, IHierarchicalDataSource
{
    private FileSystemDataSourceView view = null;

    public FileSystemDataSource() : base() { }

    protected override HierarchicalDataSourceView
        GetHierarchicalView(string viewPath)
    {
        view = new FileSystemDataSourceView(viewPath);
        return view;
    }
}
public class FileSystemDataSourceView : HierarchicalDataSourceView
{
    private string _viewPath;

    public FileSystemDataSourceView(string viewPath)
    {
        HttpRequest currentRequest = HttpContext.Current.Request;
        if (viewPath == "")
        {
            _viewPath = currentRequest.MapPath(currentRequest.ApplicationPath);
        }
        else
        {
            _viewPath = Path.Combine(
                currentRequest.MapPath(currentRequest.ApplicationPath),
                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"))
        {
            DirectoryInfo rootDirectory = new DirectoryInfo(_viewPath);
            if (!rootDirectory.Exists)
            {
                return null;
            }

            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
{
    private FileSystemInfo fileSystemObject = null;

    public FileSystemHierarchyData(FileSystemInfo obj)
    {
        fileSystemObject = obj;
    }

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

Imports System.Collections
Imports System.IO
Imports System.Runtime.InteropServices
Imports System.Security.Permissions
Imports System.Web
Imports System.Web.UI
Imports System.Web.UI.WebControls

Namespace Samples.AspNet

    Public Class FileSystemDataSource
        Inherits HierarchicalDataSourceControl

        Public Sub New()
        End Sub

        Private view As FileSystemDataSourceView = Nothing

        Protected Overrides Function GetHierarchicalView( _
            ByVal viewPath As String) As HierarchicalDataSourceView

            view = New FileSystemDataSourceView(viewPath)
            Return view
        End Function

    End Class
    Public Class FileSystemDataSourceView
        Inherits HierarchicalDataSourceView

        Private _viewPath As String

        Public Sub New(ByVal viewPath As String)
            Dim currentRequest As HttpRequest = HttpContext.Current.Request
            If viewPath = "" Then
                _viewPath = currentRequest.MapPath(currentRequest.ApplicationPath)
            Else
                _viewPath = Path.Combine(currentRequest.MapPath(currentRequest.ApplicationPath), viewPath)
            End If
        End Sub


        ' 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 Overrides Function [Select]() As IHierarchicalEnumerable
            Dim currentRequest As HttpRequest = 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 AndAlso _
                (currentRequest.UserHostAddress = "127.0.0.1" OrElse _
                 currentRequest.UserHostAddress = "::1") Then

                Dim rootDirectory As New DirectoryInfo(_viewPath)

                Dim fshe As New FileSystemHierarchicalEnumerable()

                Dim fsi As FileSystemInfo
                For Each fsi In rootDirectory.GetFileSystemInfos()
                    fshe.Add(New FileSystemHierarchyData(fsi))
                Next fsi
                Return fshe
            Else
                Throw New NotSupportedException( _
                    "The FileSystemDataSource only " + _
                    "presents data in an authenticated, localhost context.")
            End If
        End Function 'Select
    End Class

    Public Class FileSystemHierarchicalEnumerable
        Inherits ArrayList
        Implements IHierarchicalEnumerable

        Public Sub New()
        End Sub


        Public Overridable Function GetHierarchyData( _
            ByVal enumeratedItem As Object) As IHierarchyData _
            Implements IHierarchicalEnumerable.GetHierarchyData

            Return CType(enumeratedItem, IHierarchyData)
        End Function

    End Class


    Public Class FileSystemHierarchyData
        Implements IHierarchyData

        Public Sub New(ByVal obj As FileSystemInfo)
            fileSystemObject = obj
        End Sub

        Private fileSystemObject As FileSystemInfo = Nothing

        Public Overrides Function ToString() As String
            Return fileSystemObject.Name
        End Function

        ' IHierarchyData implementation.
        Public Overridable ReadOnly Property HasChildren() As Boolean _
         Implements IHierarchyData.HasChildren
            Get
                If GetType(DirectoryInfo) Is fileSystemObject.GetType() Then
                    Dim temp As DirectoryInfo = _
                        CType(fileSystemObject, DirectoryInfo)
                    Return temp.GetFileSystemInfos().Length > 0
                Else
                    Return False
                End If
            End Get
        End Property
        ' DirectoryInfo returns the OriginalPath, while FileInfo returns
        ' a fully qualified path.

        Public Overridable ReadOnly Property Path() As String _
         Implements IHierarchyData.Path
            Get
                Return fileSystemObject.ToString()
            End Get
        End Property

        Public Overridable ReadOnly Property Item() As Object _
         Implements IHierarchyData.Item
            Get
                Return fileSystemObject
            End Get
        End Property

        Public Overridable ReadOnly Property Type() As String _
         Implements IHierarchyData.Type
            Get
                Return "FileSystemData"
            End Get
        End Property

        Public Overridable Function GetChildren() _
            As IHierarchicalEnumerable _
            Implements IHierarchyData.GetChildren

            Dim children As New FileSystemHierarchicalEnumerable()

            If GetType(DirectoryInfo) Is fileSystemObject.GetType() Then
                Dim temp As DirectoryInfo = _
                    CType(fileSystemObject, DirectoryInfo)
                Dim fsi As FileSystemInfo
                For Each fsi In temp.GetFileSystemInfos()
                    children.Add(New FileSystemHierarchyData(fsi))
                Next fsi
            End If
            Return children
        End Function 'GetChildren


        Public Overridable Function GetParent() As IHierarchyData _
         Implements IHierarchyData.GetParent
            Dim parentContainer As New FileSystemHierarchicalEnumerable()

            If GetType(DirectoryInfo) Is fileSystemObject.GetType() Then
                Dim temp As DirectoryInfo = _
                    CType(fileSystemObject, DirectoryInfo)
                Return New FileSystemHierarchyData(temp.Parent)
            ElseIf GetType(FileInfo) Is fileSystemObject.GetType() Then
                Dim temp As FileInfo = CType(fileSystemObject, FileInfo)
                Return New FileSystemHierarchyData(temp.Directory)
            End If
            ' If FileSystemObj is any other kind of FileSystemInfo, ignore it.
            Return Nothing
        End Function 'GetParent
    End Class
End Namespace

Následující příklad kódu ukazuje, jak deklarativně svázat TreeView ovládací prvek s daty systému souborů pomocí příkladu FileSystemDataSource .

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

<!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>

<%@ Page Language="VB" %>
<%@ Register Tagprefix="aspSample" Namespace="Samples.AspNet" %>

<!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>

Poznámky

ASP.NET podporuje architekturu ovládacích prvků datových vazeb, která umožňuje ovládacím prvkům webového serveru vytvořit vazbu na data a prezentovat je konzistentním způsobem. Ovládací prvky webového serveru, které se váže na data, se nazývají ovládací prvky vázané na data a třídy, které usnadňují vazbu, se nazývají ovládací prvky zdroje dat. Ovládací prvky zdroje dat můžou představovat libovolný zdroj dat: soubor, datový proud, relační databázi, obchodní objekt atd. Ovládací prvky zdroje dat prezentují data konzistentním způsobem v ovládacích prvcích vázaných na data bez ohledu na zdroj nebo formát podkladových dat.

Ovládací prvky zdroje dat, které představují hierarchická data, jsou odvozeny z HierarchicalDataSourceControl třídy , zatímco ovládací prvky zdroje dat, které představují seznamy nebo tabulky dat, jsou odvozeny z DataSourceControl třídy . Třída HierarchicalDataSourceControl je základní implementací IHierarchicalDataSource rozhraní, které definuje jednu metodu pro načtení hierarchických objektů zobrazení zdroje dat přidružených k ovládacímu prvku GetHierarchicalViewzdroje dat .

Ovládací prvek zdroje dat si můžete představit jako kombinaci objektu HierarchicalDataSourceControl a jeho přidružených zobrazení na podkladových datech, označovanou jako objekty zobrazení zdroje dat. Zatímco ovládací prvky zdroje dat, které představují tabulková data, jsou obvykle přidruženy pouze k jednomu pojmenovaným zobrazení, HierarchicalDataSourceControl třída podporuje zobrazení zdroje dat pro každou úroveň hierarchických dat, které představuje ovládací prvek zdroje dat. Úroveň hierarchických dat je určena jedinečnou hierarchickou cestou předanou GetHierarchicalView metodě v parametru viewPath . Každý HierarchicalDataSourceView objekt definuje možnosti ovládacího prvku zdroje dat pro reprezentovanou hierarchickou úroveň a provádí operace, jako je vložení, aktualizace, odstranění a řazení.

Ovládací prvky webového HierarchicalDataBoundControl serveru, které jsou odvozeny z třídy , například TreeView, používají hierarchické ovládací prvky zdroje dat k vytvoření vazby na hierarchická data.

Ovládací prvky zdroje dat se implementují jako ovládací prvky, které umožňují deklarativní trvalost a volitelně umožňují účast na správě stavu. Ovládací prvky zdroje dat nemají žádné vizuální vykreslování, a proto nepodporují motivy.

Konstruktory

Vlastnosti

Metody

Událost

Explicitní implementace rozhraní

Metody rozšíření

Platí pro

Viz také

• IHierarchicalDataSource
• DataSourceControl