Partager via


ConsumerConnectionPoint Constructeur

Définition

Initialise une nouvelle instance de la classe ConsumerConnectionPoint.

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)

Paramètres

callbackMethod
MethodInfo

Méthode dans le contrôle consommateur qui retourne une instance d'interface aux consommateurs pour établir une connexion.

interfaceType
Type

Type de l'interface que le consommateur reçoit d'un fournisseur.

controlType
Type

Type du contrôle consommateur auquel le point de connexion du consommateur est associé.

displayName
String

Nom complet convivial pour le point de connexion du consommateur qui apparaît aux utilisateurs dans l'interface utilisateur de connexion.

id
String

Identificateur unique pour le point de connexion du consommateur.

allowsMultipleConnections
Boolean

Valeur Boolean qui indique si le point de connexion du consommateur peut avoir plusieurs connexions simultanées avec des fournisseurs.

Exceptions

callbackMethod a la valeur null.

-ou-

interfaceType a la valeur null.

-ou-

controlType a la valeur null.

- ou -

displayName ou null est une chaîne vide ("").

controlType n'est pas du même type que le contrôle consommateur (ou une classe valide dérivée de celui-ci).

Exemples

L’exemple de code suivant montre comment dériver de la ConsumerConnectionPoint classe pour créer un point de connexion de fournisseur personnalisé.

L’exemple de code comporte trois parties :

  • Fichier source qui contient un contrôle fournisseur WebPart , un contrôle consommateur WebPart et un objet personnalisé ConsumerConnectionPoint .

  • Page Web qui héberge les contrôles dans une connexion statique.

  • Explication de l’exécution de l’exemple de code.

La première partie de l’exemple de code est la source pour les contrôles fournisseur et consommateur WebPart , et une classe personnalisée ConsumerConnectionPoint , nommée TableConsumerConnectionPoint. Notez que le constructeur de la TableConsumerConnectionPoint classe appelle le constructeur de base, en lui passant les paramètres requis comme indiqué dans la section Paramètres. Notez également que dans la TableConsumer classe , la SetConnectionInterface méthode est spécifiée comme méthode de rappel pour les connexions et que l’attribut ConnectionConsumer déclare le personnalisé TableConsumerConnectionPoint en tant que paramètre. Cela montre comment créer un point de connexion consommateur personnalisé, puis l’associer à un contrôle consommateur. Cet exemple suppose que le code source est compilé dynamiquement. Vous devez donc placer le fichier de code source dans un App_Code sous-dossier de votre application web.

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)
      {
      }
    }
  }
}

La deuxième partie de l’exemple de code est la page Web qui héberge les contrôles personnalisés dans une connexion de composants WebPart statique. En haut de la page se trouve une Register directive pour déclarer un préfixe et l’espace de noms pour les contrôles personnalisés. La connexion est déclarée à l’aide d’un <asp:webpartconnection> élément, et les contrôles fournisseur et consommateur sont déclarés dans un <asp:webpartzone> élément.

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

Chargez la page dans un navigateur. La connexion entre les contrôles existe déjà et le consommateur affiche les données du fournisseur, car la connexion a été déclarée en tant que connexion statique dans la page.

Remarques

Le ConsumerConnectionPoint constructeur de la ConsumerConnectionPoint classe appelle simplement le constructeur de base, en lui passant les différents paramètres et en initialisant la classe de base.

Le constructeur de classe de base vérifie un certain nombre de paramètres pour un point de connexion et peut lever plusieurs exceptions. Pour obtenir la liste des exceptions possibles, consultez la section Exceptions.

Vous pouvez appeler le ConsumerConnectionPoint constructeur pour créer votre propre instance de la ConsumerConnectionPoint classe . Toutefois, dans les cas où vous établissez simplement une connexion sans étendre la classe, vous devez appeler la GetConsumerConnectionPoints méthode pour retourner un objet de point de connexion à partir d’un fournisseur.

S’applique à

Voir aussi