HomeDev GuideAPI Reference
Dev GuideAPI ReferenceUser GuideGitHubNuGetDev CommunitySubmit a ticketLog In
GitHubNuGetDev CommunitySubmit a ticket

Restrict content types in properties

Describes how to control the addition of certain items to a property of type ContentArea, ContentReference or ContentReferenceList.

Restrict a ContentArea

The AllowedTypes attribute (placed in the EPiServer.DataAnnotations namespace, EPiServer assembly) can be applied to a property.

[AllowedTypes(new [] {
  typeof (PageData)
})]
public virtual ContentArea RelatedContentArea {
  get;
  set;
}

You can also set the same attribute as:

[AllowedTypes(AllowedTypes = new [] {
  typeof (PageData)
})]
public virtual ContentArea RelatedContentArea {
  get;
  set;
}

When an item that is part of the allowed types is dragged over this property, the property is highlighted, and the editor can add the item to the property. But if the editor tries to drag another item that is not part of the allowed types, the property is grayed out, and the item can't be added. The content selector dialog is also filtered out accordingly. Through the Create a new block link in the content area, editors can only add allowed item types.

550

You can specify several allowed types and inherited types:

[AllowedTypes(new [] {
  typeof (PageData), typeof (BlockData)
})]
public virtual ContentArea RelatedContentArea {
  get;
  set;
}

Restrict a certain set of types but allow others

The AllowedTypes attribute can also be used to restrict certain types from a larger pool of types. 
For example, if you supply two arrays of types as constructor arguments, the first array argument considers allowed items, while the second argument considers restricted items.

[AllowedTypes(new [] {
  typeof (BlockData)
}, new [] {
  typeof (EditorialBlock)
})]
public virtual ContentArea RelatedContentArea {
  get;
  set;
}

or

[AllowedTypes(AllowedTypes = new [] {
  typeof (BlockData)
}, RestrictedTypes = new [] {
  typeof (EditorialBlock)
})]
public virtual ContentArea RelatedContentArea {
  get;
  set;
}

In this case, you can add BlockData items the content area except the EditorialBlock, which is a BlockData but also part of restricted types. When an editor drags the EditorialBlock or its subtypes, the content area is grayed out. Similarly, when an editor clicks the Create a new block link, the content selector is filtered out accordingly.

Restriction based on base classes and interfaces

When you place the AllowTypes attribute on a ContentArea, ContentReference, or ContentReferenceList property, the user interface not only allows and restricts based on the given type but also on the given type's subtypes. For example:

[AllowedTypes(new [] {
  typeof (SiteBlockData)
})]
public virtual ContentArea RelatedContentArea {
  get;
  set;
}

In this case, the property not only lets you add SiteBlockData but other types inherited from the SiteBlockData also behave the same.

However, if you want to allow and restrict based on an interface, you must implement the UIDescriptor for the interface.

interface ISpecialInterface {}

public class SpecialBlock: BlockData, ISpecialInterface {}

To enable a content area to add blocks except the ones inherited from the ISpecialInterface, implement a UIDescriptor for the ISpecialInterface.

[UIDescriptorRegistration]
public class SpecialInterfaceDescriptor : UIDescriptor<ISpecialInterface> { }

Additionally, the interface has to inherit from IContentData interface.

public interface ISpecialInterface: IContentData {
  // properties and methods
}

After that, place the AllowedTypes on the content area property.

[AllowedTypes(AllowedTypes = new [] {
  typeof (BlockData)
}, RestrictedTypes = new [] {
  typeof (ISpecialInterface)
})]
public virtual ContentArea SomeArea {
  get;
  set;
}

This code lets you add blocks to SomeArea but restricts blocks that implement ISpecialInterface.

Restrict content reference properties

You can use the AllowedTypes attribute for ContentReference or ContentReferenceList properties, too:

[AllowedTypes(typeof (ProductPage))]
public virtual ContentReference SomeLink {
  get;
  set;
}

[AllowedTypes(typeof (ProductPage))]
public virtual IList < ContentReference > SomeLinks {
  get;
  set;
}

This code results in the same behavior as for content areas when dragging items to the property; that is, only items of the type ProductPage can be added to the property. Items not allowed (according to the AllowedTypes attribute) are not selectable in the content selector dialog.

Known limitations

  • AllowedTypes only works with ContentArea, ContentReference, and ContentReferenceList type properties.
  • RestrictedTypes always win. That means that if you give an item (a class or an interface) in RestrictedTypes, its instances and subitems are restricted whether the item or subitems exist in AllowedTypes.