1 out of 2 rated this helpful - Rate this topic

TemplateContainerAttribute Class

.NET Framework 2.0

Declares the base type of the container control of a property that returns an ITemplate interface and is marked with the TemplateContainerAttribute attribute. The control with the ITemplate property must implement the INamingContainer interface. This class cannot be inherited.

Namespace: System.Web.UI
Assembly: System.Web (in system.web.dll)

Syntax

C++

Copy

[AttributeUsageAttribute(AttributeTargets.Property)] 
public sealed class TemplateContainerAttribute : Attribute

Copy

/** @attribute AttributeUsageAttribute(AttributeTargets.Property) */ 
public final class TemplateContainerAttribute extends Attribute

JScript

Copy

AttributeUsageAttribute(AttributeTargets.Property) 
public final class TemplateContainerAttribute extends Attribute

Remarks

The Type object that is passed in as a parameter of the TemplateContainerAttribute object is used by the parser as the type of Container object that is used in data-binding expressions. The control whose property returns an ITemplate interface and is marked with the TemplateContainerAttribute, must implement the INamingContainer interface.

For more information about using attributes, see Extending Metadata Using Attributes.

Example

The following code example demonstrates how to create a templated control named TemplatedFirstControl and associate it with a container named FirstTemplateContainer. This allows the creation of custom controls that display the server time when the template is not specified and the template's content when the template is specified.

Copy

using System;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Collections;

namespace Samples.AspNet.CS.Controls
{
	[ParseChildren(true)]
	public class TemplatedFirstControl : Control, INamingContainer
	{
		private ITemplate firstTemplate;
		private String text = null;
		private Control myTemplateContainer;

		[System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name = "FullTrust")]
		protected override void OnDataBinding(EventArgs e)
		{
			EnsureChildControls();
			base.OnDataBinding(e);
		}


		[TemplateContainer(typeof(FirstTemplateContainer))]
		public ITemplate FirstTemplate
		{
			get
			{
				return firstTemplate;
			}
			set
			{
				firstTemplate = value;
			}
		}

		public String Text
		{
			get
			{
				return text;
			}
			set
			{
				text = value;
			}
		}

		public String DateTime
		{
			get
			{
				return System.DateTime.Now.ToLongTimeString();
			}

		}

		public Control MyTemplateContainer
		{
			get
			{
				return myTemplateContainer;
			}
		}

		[System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name = "FullTrust")]
		protected override void CreateChildControls()
		{
			if (FirstTemplate != null)
			{
				myTemplateContainer = new FirstTemplateContainer(this);
				FirstTemplate.InstantiateIn(myTemplateContainer);
				Controls.Add(myTemplateContainer);
			}
			else
			{
				Controls.Add(new LiteralControl(Text + " " + DateTime));
			}
		}

	}


    public class FirstTemplateContainer : Control, INamingContainer
    {
      private TemplatedFirstControl parent;
      public FirstTemplateContainer(TemplatedFirstControl parent)
      {
        this.parent = parent;
      }
            
      public String Text
      {
        get
        {
          return parent.Text;
        }
      }
     
      public String DateTime
      {
        get 
        {
          return parent.DateTime;
        }
                  
      }
    }
    
  }

Copy

package Samples.AspNet.CS.Controls;
/* File name:templatecontainerattribute.jsl. */

import System.*;
import System.Web.*;
import System.Web.UI.*;
import System.Web.UI.WebControls.*;
import System.Collections.*;

/** @attribute ParseChildren(true)
 */
public class TemplatedFirstControl extends Control implements INamingContainer
{
    private ITemplate firstTemplate;
    private String text = null;
    private Control myTemplateContainer;

    protected void OnDataBinding(EventArgs e)
    {
        EnsureChildControls();
        super.OnDataBinding(e);
    } //OnDataBinding

    /** @attribute TemplateContainer(FirstTemplateContainer.class)
     */
    /** @property 
     */
    public ITemplate get_FirstTemplate()
    {
        return firstTemplate;
    } //get_FirstTemplate

    /** @property 
     */
    public void set_FirstTemplate(ITemplate value)
    {
        firstTemplate = value;
    } //set_FirstTemplate

    /** @property 
     */
    public String get_Text()
    {
        return text;
    } //get_Text

    /** @property 
     */
    public void set_Text(String value)
    {
        text = value;
    } //set_Text

    /** @property 
     */
    public String get_DateTime()
    {
        return System.DateTime.get_Now().ToLongTimeString();
    } //get_DateTime

    /** @property 
     */
    public Control get_MyTemplateContainer()
    {
        return myTemplateContainer;
    } //get_MyTemplateContainer

    protected void CreateChildControls()
    {
         if (get_FirstTemplate() != null) {
            myTemplateContainer = new FirstTemplateContainer(this);
            get_FirstTemplate().InstantiateIn(myTemplateContainer);
            get_Controls().Add(myTemplateContainer);
        }
        else {
            get_Controls().Add(new LiteralControl(get_Text() + " "
                + DateTime.class));
        }
    } //CreateChildControls
} //TemplatedFirstControl

public class FirstTemplateContainer extends Control implements INamingContainer
{
    private TemplatedFirstControl parent;

    public FirstTemplateContainer(TemplatedFirstControl parent)
    {
        this.parent = parent;
    } //FirstTemplateContainer

    /** @property 
     */
    public String get_Text()
    {
        return parent.get_Text();
    } //get_Text

    /** @property 
     */
    public String get_DateTime()
    {
        return parent.get_DateTime();
    } //get_DateTime
} //FirstTemplateContainer

The following Web form demonstrates how to use the custom control created in the preceding code example. Two instances of the TemplatedFirstControl are placed on the page:

The first instance includes the template <FirstTemplate>.
The second instance does not include <FirstTemplate>; therefore, it shows just the time.

Copy

<%@ Page Language="C#" %>
<%@ Import Namespace="System.Reflection" %>
<%@ Register TagPrefix="aspSample" Namespace="Samples.AspNet.CS.Controls" Assembly="Samples.AspNet.CS.Controls" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<script runat="server">

  protected void Page_Load(object sender, EventArgs e)
  {

    // Get the class type for which to access metadata.
    Type clsType = typeof(TemplatedFirstControl);
    // Get the PropertyInfo object for FirstTemplate.
    PropertyInfo pInfo = clsType.GetProperty("FirstTemplate");
    // See if the TemplateContainer attribute is defined for this property.
    bool isDef = Attribute.IsDefined(pInfo, typeof(TemplateContainerAttribute));
    // Display the result if the attribute exists.
    if (isDef)
    {
      TemplateContainerAttribute tca =
        (TemplateContainerAttribute)Attribute.GetCustomAttribute(pInfo, typeof(TemplateContainerAttribute));
      Response.Write("The binding direction is: " + tca.BindingDirection.ToString());
    }

  }
</script>

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title>TemplateContainerAttribute Example</title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
      <aspSample:TemplatedFirstControl id="TemplatedFirstControl1" runat="server">
         <FirstTemplate>This is the first template.</FirstTemplate>
      </aspSample:TemplatedFirstControl>
      <br />
      <aspSample:TemplatedFirstControl id="TemplatedFirstControl2" runat="server">
      </aspSample:TemplatedFirstControl>    
    </div>
    </form>
</body>
</html>

.NET Framework Security

AspNetHostingPermission for operating in a hosted environment. Demand value: LinkDemand; Permission value: Minimal.

Inheritance Hierarchy

System.Object
System.Attribute
System.Web.UI.TemplateContainerAttribute

Thread Safety

Any public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.

Platforms

Windows 98, Windows 2000 SP4, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

The .NET Framework does not support all versions of every platform. For a list of the supported versions, see System Requirements.

Version Information

.NET Framework

Supported in: 2.0, 1.1, 1.0

Reference

TemplateContainerAttribute Members
System.Web.UI Namespace
Attribute

Other Resources

Extending Metadata Using Attributes

Did you find this helpful? Yes No

Not accurate

Not enough depth

Need more code examples

(1500 characters remaining)

Community Content Add

FAQ