ConsumerConnectionPoint Constructor

public:
 ConsumerConnectionPoint(System::Reflection::MethodInfo ^ callbackMethod, Type ^ interfaceType, Type ^ controlType, System::String ^ displayName, System::String ^ id, bool allowsMultipleConnections);

public ConsumerConnectionPoint(System.Reflection.MethodInfo callbackMethod, Type interfaceType, Type controlType, string displayName, string id, bool allowsMultipleConnections);

new System.Web.UI.WebControls.WebParts.ConsumerConnectionPoint : System.Reflection.MethodInfo * Type * Type * string * string * bool -> System.Web.UI.WebControls.WebParts.ConsumerConnectionPoint

Public Sub New (callbackMethod As MethodInfo, interfaceType As Type, controlType As Type, displayName As String, id As String, allowsMultipleConnections As Boolean)

Parameters

Uitzonderingen

Voorbeelden

In het volgende codevoorbeeld ziet u hoe u wordt afgeleid van de ConsumerConnectionPoint klasse om een aangepast providerverbindingspunt te maken.

Het codevoorbeeld heeft drie delen:

• Een bronbestand dat een providerbeheer WebPart , een consumentenbeheer WebPart en een aangepast ConsumerConnectionPoint object bevat.

• Een webpagina die als host fungeert voor de besturingselementen in een statische verbinding.

• Een uitleg van het uitvoeren van de voorbeeldcode.

Het eerste deel van het codevoorbeeld is de bron voor de provider en consumentenbesturingselementen WebPart en een aangepaste ConsumerConnectionPoint klasse met de naam TableConsumerConnectionPoint. Houd er rekening mee dat de constructor van de TableConsumerConnectionPoint klasse de basisconstructor aanroept, waarbij deze de vereiste parameters doorgeeft, zoals aangegeven in de sectie Parameters. Houd er ook rekening mee dat in de TableConsumer klasse de SetConnectionInterface methode wordt opgegeven als de callback-methode voor verbindingen en dat het ConnectionConsumer kenmerk de aangepaste TableConsumerConnectionPoint als parameter declareert. Dit laat zien hoe u een aangepast verbindingspunt voor consumenten maakt en vervolgens koppelt aan een consumentenbeheer. In dit voorbeeld wordt ervan uitgegaan dat de broncode dynamisch wordt gecompileerd, dus moet u het broncodebestand in een App_Code submap van uw webtoepassing plaatsen.

using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Reflection;
using System.Web;
using System.Web.UI;
using System.Security.Permissions;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;

//This sample code creates a Web Parts control that acts as a provider of table data.
namespace Samples.AspNet.CS.Controls
{
  [AspNetHostingPermission(SecurityAction.Demand,
    Level = AspNetHostingPermissionLevel.Minimal)]
  [AspNetHostingPermission(SecurityAction.InheritanceDemand,
    Level = AspNetHostingPermissionLevel.Minimal)]
    public sealed class TableProviderWebPart : WebPart, IWebPartTable
    {
        DataTable _table;

        public TableProviderWebPart()
        {
            _table = new DataTable();

            DataColumn col = new DataColumn();
            col.DataType = typeof(string);
            col.ColumnName = "Name";
            _table.Columns.Add(col);

            col = new DataColumn();
            col.DataType = typeof(string);
            col.ColumnName = "Address";
            _table.Columns.Add(col);

            col = new DataColumn();
            col.DataType = typeof(int);
            col.ColumnName = "ZIP Code";
            _table.Columns.Add(col);

            DataRow row = _table.NewRow();
            row["Name"] = "John Q. Public";
            row["Address"] = "123 Main Street";
            row["ZIP Code"] = 98000;
            _table.Rows.Add(row);
        }

        public PropertyDescriptorCollection Schema
        {
            get
            {
                return TypeDescriptor.GetProperties(_table.DefaultView[0]);
            }
        }
        public void GetTableData(TableCallback callback)
        {
                callback(_table.Rows);
        }

        public bool ConnectionPointEnabled
        {
            get
            {
                object o = ViewState["ConnectionPointEnabled"];
                return (o != null) ? (bool)o : true;
            }
            set
            {
                ViewState["ConnectionPointEnabled"] = value;
            }
        }

        [ConnectionProvider("Table", typeof(TableProviderConnectionPoint), AllowsMultipleConnections = true)]
        public IWebPartTable GetConnectionInterface()
        {
            return new TableProviderWebPart();
        }

        public class TableProviderConnectionPoint : ProviderConnectionPoint
        {
            public TableProviderConnectionPoint(MethodInfo callbackMethod, Type interfaceType, Type controlType,
            string name, string id, bool allowsMultipleConnections) : base(
                callbackMethod, interfaceType, controlType,
                name, id, allowsMultipleConnections)
            {
            }
            public override bool GetEnabled(Control control)
            {
                return ((TableProviderWebPart)control).ConnectionPointEnabled;
            }
        }
    }
    
    // This code sample demonstrates a custom WebPart controls that acts as 
    // a consumer in a Web Parts connection.
  [AspNetHostingPermission(SecurityAction.Demand,
    Level = AspNetHostingPermissionLevel.Minimal)]
  [AspNetHostingPermission(SecurityAction.InheritanceDemand,
    Level = AspNetHostingPermissionLevel.Minimal)]
  public class TableConsumer : WebPart
  {
    private IWebPartTable _provider;
    private ICollection _tableData;

    private void GetTableData(object tableData)
    {
      _tableData = (ICollection)tableData;
    }

    protected override void OnPreRender(EventArgs e)
    {
      if (_provider != null)
      {
        _provider.GetTableData(new TableCallback(GetTableData));
      }
    }

    protected override void RenderContents(HtmlTextWriter writer)
    {
      if (_provider != null)
      {
        PropertyDescriptorCollection props = _provider.Schema;
        int count = 0;
        if (props != null && props.Count > 0 && _tableData != null)
        {
          foreach (PropertyDescriptor prop in props)
          {
            foreach (DataRow o in _tableData)
            {
              writer.Write(prop.DisplayName + ": " + o[count]);
            }
            writer.WriteBreak();
            writer.WriteLine();
            count = count + 1;
          }
        }
        else
        {
          writer.Write("No data");
        }
      }
      else
      {
        writer.Write("Not connected");
      }
    }
    [ConnectionConsumer("Table")]
    public void SetConnectionInterface(IWebPartTable provider)
    {
      _provider = provider;
    }

    public class TableConsumerConnectionPoint : ConsumerConnectionPoint
    {
      public TableConsumerConnectionPoint(MethodInfo callbackMethod, Type interfaceType, Type controlType,
      string name, string id, bool allowsMultipleConnections)
        : base(
        callbackMethod, interfaceType, controlType,
        name, id, allowsMultipleConnections)
      {
      }
    }
  }
}

Het tweede deel van het codevoorbeeld is de webpagina die als host fungeert voor de aangepaste besturingselementen in een verbinding met statische webonderdelen. Boven aan de pagina staat een Register instructie voor het declareren van een voorvoegsel en de naamruimte voor de aangepaste besturingselementen. De verbinding wordt gedeclareerd met behulp van een <asp:webpartconnection> element en de provider- en consumentenbesturingselementen worden binnen een <asp:webpartzone> element gedeclareerd.

<%@ 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>IField Test Page</title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <asp:webpartmanager id="WebPartManager1" runat="server">
            <StaticConnections>
                <asp:WebPartConnection id="wp1" ProviderID="provider1" ConsumerID="consumer1">
                </asp:WebPartConnection>
            </StaticConnections>
        </asp:webpartmanager>
        <asp:webpartzone id="WebPartZone1" runat="server">
          <zoneTemplate>
            <aspSample:TableProviderWebPart ID="provider1" runat="server" 
              ToolTip="Web Parts Table Provider Control" />
            <aspSample:TableConsumer ID="consumer1" runat="server" 
              ToolTip="Web Parts Table Consumer Control"/>
          </zoneTemplate>
        </asp:webpartzone>
    </div>
    </form>
</body>
</html>

Laad de pagina in een browser. De verbinding tussen de besturingselementen bestaat al en de consument geeft de gegevens van de provider weer, omdat de verbinding is gedeclareerd als een statische verbinding op de pagina.

Opmerkingen

De ConsumerConnectionPoint constructor voor de ConsumerConnectionPoint klasse roept gewoon de basisconstructor aan, waarbij de verschillende parameters worden doorgegeven en de basisklasse wordt geïnitialiseerd.

De constructor van de basisklasse controleert een aantal parameters voor een verbindingspunt en kan verschillende uitzonderingen veroorzaken. Zie de sectie Uitzonderingen voor een lijst met mogelijke uitzonderingen.

U kunt de ConsumerConnectionPoint constructor aanroepen om uw eigen exemplaar van de ConsumerConnectionPoint klasse te maken. Als u echter gewoon een verbinding tot stand brengt en de klasse niet uitbreidt, moet u de GetConsumerConnectionPoints methode aanroepen om een verbindingspuntobject van een provider te retourneren.

Zie ook

• GetConsumerConnectionPoints(WebPart)
• ASP.NET besturingselementen voor webonderdelen