Composite A/S 
Nygårdsvej 16
DK-2100 Copenhagen 
Phone +45 3915 7600 
www.composite.net 
Composite C1 
IData Interface   
Composite 2015-12-14 
Pdf thumbnail fix - application software utility:C# PDF Thumbnail Create SDK: Draw thumbnail images for PDF in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Thumbnail Generation with Various Options for Quick PDF Navigation
www.rasteredge.com
Pdf thumbnail fix - application software utility:VB.NET PDF Thumbnail Create SDK: Draw thumbnail images for PDF in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Thumbnail Generation with Various Options for Quick PDF Navigation
www.rasteredge.com
Page 2 of 23 
Composite C1 
IData Interface  
Contents 
1
INTRODUCTION .................................................................................................... 4
2
SUPER INTERFACES............................................................................................ 6
2.1
IData 
6
2.2
IPublishControlled 
6
2.3
ILocalizedControlled 
6
3
INTERFACE ATTRIBUTES ................................................................................... 8
3.1
Required Attributes 
8
3.1.1
ImmutableTypeId Attribute 
8
3.1.2
KeyPropertyName Attribute 
8
3.1.3
DataScope Attribute 
8
3.2
Optional Attributes 
9
3.2.1
Title Attribute 
9
3.2.2
AutoUpdateble Attribute 
9
3.2.3
LabelPropertyName Attribute 
9
3.2.4
RelevantToUserType Attribute 
9
3.2.5
Caching Attribute 
10
3.2.6
PublishProcessControllerType Attribute 
10
3.3
Expert Attributes 
10
3.3.1
PublishControlledAuxiliary Attribute 
10
3.3.2
BuildNewHandler Attribute 
10
4
PROPERTY ATTRIBUTES .................................................................................. 12
4.1
Required Attributes 
12
4.1.1
ImmutableFieldId Attribute 
12
4.1.2
StoreFieldType Attribute 
12
4.2
Optional Attributes 
13
4.2.1
DefaultFieldValue Attribute 
13
4.2.2
ForeignKey Attribute 
13
4.2.3
FunctionBasedNewInstanceDefaultFieldValue Attribute 
14
4.3
Validation Attributes 
14
4.3.1
NotNullValidator 
14
4.3.2
RegexValidator 
14
4.3.3
DecimalPrecisionValidatorAttribute 
14
4.3.4
GuidNotEmptyAttribute 
14
4.3.5
IntegerRangeValidatorAttribute 
14
4.3.6
StringLengthValidatorAttribute 
15
4.3.7
NullStringLengthValidatorAttribute 
15
5
RESERVED ATTRIBUTES .................................................................................. 16
6
OBSOLETE ATTRIBUTES .................................................................................. 17
7
CREATING A PUBLISHABLE DATA TYPE ....................................................... 18
8
CREATING A PAGE FOLDER DATA TYPE ....................................................... 19
8.1
Minimal example 
19
9
CREATING A PAGE META DATA TYPE............................................................ 20
9.1
Minimal example 
20
10
MANUALLY ADDING A META TYPE TO A PAGE (BRANCH) ......................... 21
application software utility:VB.NET Image: Sharpen Images with DocImage SDK for .NET
or image files, you might want to sharpen your pictures before saving them, as image sharpening can help bring out the crispness of the pic or fix an image out
www.rasteredge.com
Page 3 of 23 
Composite C1 
IData Interface  
10.1
Minimal Example 
21
11
MANUALLY ADDING A NEW META DATA CATEGORY (TAB) ....................... 22
11.1
Minimal Example 
22
12
MANUALLY ADDING OR REMOVING A DATA TYPE IN C1 ............................ 23
12.1
Adding 
23
12.2
Removing 
23
Page 4 of 23 
Composite C1 
IData Interface  
Introduction 
A big part of C1 is the data services - C1 uses LINQ as the primary interface to query data, 
and all data is 100% based on CLR types. Thus .NET types (interfaces) play a big role when 
querying and working with data in C1.  
The data layer in C1 totally abstracts the underlying stores like SQL Server or XML files 
away from the developer without sacrificing developer control. Instead of writing SQL 
statements or XML queries to get data, you write LINQ statements. 
All data items have one common interface they all inherit from: Composite.Data.IData. In 
C1
’s
terminology an IData is what database developers would call a “table” or “schema” –
an interface that inherits from IData is a definition of a data object which holds properties 
(name, type) and meta data like primary keys, foreign keys etc.  
You can write a LINQ query without caring about the underlying store. If the underlying store 
is a SQL Server, then the LINQ query will be translated into a perfectly optimized SQL 
statement that gets the job done. And the same query, without any rewriting or even 
recompiling, can be used if the underlying store is XML 
or any other kind of store for that 
matter.  
Below is an example of a query that works for any data store (SQL, XML, …)
using (DataConnection connection = new DataConnection()) 
var q =  
from page in connection.Get<IPage>() 
where page.Title == "My Title" 
orderby page.UrlTitle 
select page; 
Here is another example that will result in an inner join statement in the SQL database and 
in-memory object join when XML is used. 
using (DataConnection connection = new DataConnection()) 
var q =  
from page in connection.Get<IPage>() 
from pagetype in connection.Get<IPageType>() 
where page.PageTypeId == pagetype.Id 
orderby page.Title 
select new { page.Title, pagetype.Name }; 
The last example shows a query that will result in a left outer join in the SQL database and 
in-memory object join when XML is used. 
using (DataConnection connection = new DataConnection()) 
var q =  
from pagetype in connection.Get<IPageType>() 
join page in connection.Get<IPage>() on pagetype.Id equals 
page.PageTypeId into sub 
from s in sub.DefaultIfEmpty() 
select s; 
In all these examples IPage and IPageType are data interfaces that inherit from the base 
data interface IData. Below is a minimal example of a data type in C1: 
Page 5 of 23 
Composite C1 
IData Interface  
[KeyPropertyName("Id")] 
[DataScope(DataScopeIdentifier.PublicName)] 
[ImmutableTypeId("{87122C34-E622-4e97-BD36-CBC398B862F9}")] 
public interface IPerson : IData 
[StoreFieldType(PhysicalStoreFieldType.Guid)] 
[ImmutableFieldId("{172DD44C-426B-4812-834B-6B45366E78CB}")] 
Guid Id { getset; } 
[StoreFieldType(PhysicalStoreFieldType.String, 249)] 
[ImmutableFieldId("{ADB24D3D-FA2A-496a-BBE9-91CFEB88336F}")] 
string Name { getset; } 
As seen in this example, the class and field attributes are heavily used. C1 uses these 
attributes as meta-information about the data type 
much like you have more information 
about SQL tables than just the table name and column name / type. This information is used 
throughout the system, from the low-level data store to the UI and is the basis of data types 
in C1. 
Please note that these custom data interfaces must be defined in a Class Library project, 
built as an assembly (DLL) and placed in /Bin. You cannot create them in /App_Code. 
If you were to create a new Data Type using the Data type wizards in the C1 console, 
restart the C1 site (Tools | Restart Server) and then examine “/bin/Composite.Generated.dll” 
using a program like .NET Reflector you would see that your data definition is actually a 
CLR type now, with properties and attributes like, the one shown above.  
So 
in short 
all data schemas are defined as CLR types (interfaces) whether they are 
defined by C1 (like pages, users, templates etc.), you as a C# developer or users that use 
the visual data creation tools. And they are all accessible via LINQ. 
When you are working with custom IData you typically only define an interface 
concrete 
classes are generated by C1 automatically.  
In this document we will go into the technical detail about the C1 IData concept. The 
intended audience is C# developers who need to create custom data types for use in C1. 
The document will describe how to prepare your custom IData for features like publishing 
workflow, page meta data, content localization and more. 
Page 6 of 23 
Composite C1 
IData Interface  
Super interfaces 
By making your data type inherit from one or more of the data interfaces in C1 you can 
“subscribe” to functional
ity and behavior to your type. The currently super data interfaces 
supplied by C1 are described below. 
2.1 
IData 
All data types in C1 have to derive from the IData interface.  
2.2 
IPublishControlled 
If your type should support publishing workflows, your type has to derive from the 
IPublishControlled interface. Types that support publishing can exist in two scopes:  
administrated 
public 
Published data is used when pages are rendered for the public site. See the Creating a 
publishable data type section for more information on types that support publishing 
workflows. Actually, IPublishControlled is an IData itself that has some special handling in 
C1. Here is how it’s defined:
[DataScope(DataScopeIdentifier.PublicName)] 
[DataScope(DataScopeIdentifier.AdministratedName)]     
public interface IPublishControlled : IProcessControlled 
[StoreFieldType(PhysicalStoreFieldType.String, 64, IsNullable = false)] 
[ImmutableFieldId("{FAB1CF0C-66B0-11DC-A47E-CF6356D89593}")] 
[DefaultFieldStringValue("")] 
[BeforeSet(typeof(PublishControlledSetPropertyHandler))] 
[FieldPosition(50)] 
string PublicationStatus { getset; } 
So, when your interface inherits the IPublishControlled interface, a property is added to your 
type. Also, two data scopes are added. 
2.3 
ILocalizedControlled 
If your type should support localization workflows, your type has to derive from the 
ILocalizedControlled interface. Types that support localization can have instances with the 
same ID in each active locale in a running system. In other words, if da-DK, en-US and it-IT 
locales have been added to a running C1 solution, then an instance of your type with the ID 
of 
‘X’ can exist in those three locales, but do not have to. If at one point a request to 
rendering a page in the en-US locale is made and data of your type is requested, only 
instances that have been added to the en-US scope will be returned. Like 
IPublishControlled, ILocalizedControlled is also just a specialized IData interface with some 
special handling in C1: 
Page 7 of 23 
Composite C1 
IData Interface  
public interface ILocalizedControlled : IProcessControlled 
[StoreFieldType(PhysicalStoreFieldType.String, 16)] 
[ImmutableFieldId("{E271D3EB-A8EB-49ea-9BB5-E5A54F88298F}")] 
[NotNullValidator()] 
[DefaultFieldStringValue("")] // Invariant 
string CultureName { getset; } 
[StoreFieldType(PhysicalStoreFieldType.String, 16)] 
[ImmutableFieldId("{0456EBB0-7FB1-46cd-9A23-4AE9AA3337FA}")] 
[NotNullValidator()] 
[DefaultFieldStringValue("")] // Invariant 
string SourceCultureName { getset; } 
Page 8 of 23 
Composite C1 
IData Interface  
Interface Attributes 
The following are interface attributes grouped as: 
Required attributes 
Optional attributes 
Expert attributes 
3.1 
Required Attributes 
These are required attributes: 
ImmutableTypeId Attribute 
KeyPropertyName Attribute 
DataScope Attribute 
Please consider using the LabelPropertyName attribute, too, to provide user-friendly labels 
for data items, for example, in function parameters of the DataReference<T> type. 
Otherwise, GUID-like labels will be used. 
3.1.1 
ImmutableTypeId Attribute 
This attribute specifies a unique ID for the type. The ID should be unique for the running C1 
solution. The value of the argument should be a string representation of a GUID. This 
unique ID is used by C1 to identify the type. This means that it is possible to rename the 
type and the type would still work. Though, when coding your own type and using the type 
name in code (your own or code that might use yours), the same compile rules apply as 
those with normal C# interfaces. Example: 
[ImmutableTypeId("{D261B424-3629-4e00-9D24-BDA763DE8DD8}")] 
3.1.2 
KeyPropertyName Attribute 
Use this attribute to specify one or more key property names. A key property is the property 
that will be used as a key for data type. No more than one instance of your data type may 
have the same key value (or keys values) in a given scope. The value of the argument 
should be a string with the name of one of the properties of your interface. Example: 
[KeyPropertyName("Id")] 
3.1.3 
DataScope Attribute 
This attribute specifies which data scopes items of the data types should exist in. Currently 
two scopes are supported: DataScopeIdentifier.Public and 
DataScopeIdentifier.Administrated. If your type should not support publishing workflows, 
then add this attribute once with the value DataScopeIdentifier.PublicName.  If your type 
should support publishing workflows, you should add this attribute twice with the argument 
values: DataScopeIdentifier.PublicName and DataScopeIdentifier.AdministratedName. See 
the Creating a publishable data type section for more information on types that support 
publishing workflows. 
Examples: 
[DataScope(DataScopeIdentifier.PublicName)] 
and 
Page 9 of 23 
Composite C1 
IData Interface  
[DataScope(DataScopeIdentifier.AdministratedName)] 
3.2 
Optional Attributes 
These are optional attributes: 
Title Attribute 
AutoUpdateble Attribute 
LabelPropertyName Attribute 
RelevantToUserType Attribute 
Caching Attribute 
PublishProcessControllerType Attribute 
3.2.1 
Title Attribute 
Use this attribute to assign a more user-friendly name for your type. The value of the 
argument should be a string. This will be used by C1 when the type
s name needs to be 
displayed in the UI. Example: 
[Title("Employee")] 
3.2.2 
AutoUpdateble Attribute 
This attribute will make C1 auto add and update your type. The type will be added to the 
default data provider when data is added for the first time. If reading data is done before the 
type has been added, zero items are returned.  If you change your type, adding a new 
property, then C1 will update the underlying data store automatically. If you omit this 
attribute, you have to manually add it to the data layer and future changes to the type also 
have to be made manually. It is recommended that your type has this attribute. See the 
Manually adding or removing a data type to or from C1 chapter for manually adding and 
removing a data type. Example: 
[AutoUpdateble
3.2.3 
LabelPropertyName Attribute 
Use this attribute to specify which property value should be used as label for items of the 
data type. The label is used when listing items in trees or other kinds of lists. 
If the property used as a label is nullable (optional) or is a string and the value of the 
property is 
null, then the title will be of the form: “(undefined [PROPERTY_NAME])”, where 
PROPERTY_NAME is the name of the property specified with this attribute. 
If the property is a reference property (See ForeignKey attribute) then the label of the 
referenced data will be displayed. The value of the argument should be a string with exactly 
the same name and casing as one of the properties of your interface. Example: 
[LabelPropertyName("Name")] 
Although this attribute is optional, we recommend using it to provide user-friendly labels for 
data items, for example, in function parameters of the DataReference<T> type. 
3.2.4 
RelevantToUserType Attribute 
If you add this attribute to your type then your type will be selectable in the UI. Examples: 
Data references, adding a Visual function for your type and being a part of the functions 
calls in XSLT functions. At the moment the only supported argument value for this attribute 
is: UserType.Developer. Example: 
Page 10 of 23 
Composite C1 
IData Interface  
[RelevantToUserType(UserType.Developer)] 
3.2.5 
Caching Attribute 
By specifying this attribute on your type, instances of your type will be cached by C1, thus 
making data access to your type faster. Caching is done in memory, so avoid caching a type 
where large data sets are expected. Example: 
[Caching(CachingType.Full)] 
3.2.6 
PublishProcessControllerType Attribute 
When your type supports publishing workflows this attribute should be specified. The value 
of the argument should be a type that implements the IPublishProcessController interface. 
For a default behavior you can use the type GenericPublishProcessController as an 
argument value for this attribute. See the Creating a publishable data type chapter for more 
information on types that supports publishing workflows. Example: 
[PublishProcessControllerType(typeof(GenericPublishProcessController))] 
3.3 
Expert Attributes 
These are expert attributes: 
PublishControlledAuxiliary Attribute 
BuildNewHandler Attribute 
3.3.1 
PublishControlledAuxiliary Attribute 
Use this attribute to get some custom code to run after the IPublishProcessController has 
done its work. The argument value of this attribute should be a type that implements the 
interface IPublishControlledAuxiliary. See the Creating a publishable data type chapter for 
more information on types that supports publish workflows. Example: 
public class MyPublishControlledAuxiliary : IPublishControlledAuxiliary 
// IPublishControlledAuxiliary Members 
[PublishControlledAuxiliary(typeof(MyPublishControlledAuxiliary))] 
public interface IMyData : IData 
// Properties 
3.3.2 
BuildNewHandler Attribute 
When the DataConnection.New<T>() is made, an object of a type that implements T is 
created. If you want to control which type is used to create a new object, then you should 
add this attribute to your type. The value of the argument should be a type value to a type 
that implements the interface IBuildNewHandler. Example: 
Documents you may be interested
Documents you may be interested