Applies to Umbraco 9 and newer

Browse the API documentation for ConsentService.

• Namespace: Umbraco.Cms.Core.Services

• Assembly: Umbraco.Core.dll

A service for handling lawful data processing requirements.

What is a Consent

A consent is fully identified by a source (whoever is consenting), a context (for example, an application), and an action (whatever is consented). A consent state registers the state of the consent (granted, revoked...).

Register a new consent

Consent can be given or revoked or changed via the RegisterConsent method, which creates a new Consent entity to track the consent.

Get the current state

Getter methods of this service return the current state of a consent, that is the latest IConsent entity that was created.

Revoking a consent

Revoking a consent is performed by registering a revoked consent.

A consent cannot be deleted. It can only be revoked by registering a "revoked consent".

Examples

// store a new consent
var newConsent = _consentService.RegisterConsent("userId", "Our.Custom.Umbraco.Plugin", "AllowedToEmail", ConsentState.Granted, "some comments");

// lookup a consent
var consents = _consentService.LookupConsent("userId", "Our.Custom.Umbraco.Plugin", "AllowedToEmail", sourceStartsWith : true);
if (consents != null && consents.Any())
{
    var currentConsent = consents.First(c => c.Current == true);
    if(currentConsent.State  == ConsentState.Granted)
    {
        // Do what you need
    }
    else
    {
        // the state is None, Pending or Revoked
    }
}

In Razor views, you can access the consent service through the @inject directive:

@inject IConsentService ConsentService

The DataTypeService acts as a "gateway" to Umbraco data for operations which are related to DataTypes and DataTypeDefinitions.

Browse the API documentation for IDataTypeService.

• Namespace: Umbraco.Cms.Core.Services

• Assembly: Umbraco.Core.dll

All samples in this document will require references to the following dll:

• Umbraco.Core.dll

All samples in this document will require the following using statements:

using Umbraco.Cms.Core.Services;

For Razor views:

@using Umbraco.Cms.Core.Services

Getting the service

Dependency Injection

If you wish to use the Data Type service in a class, you need to specify the IDataTypeService interface in your constructor:

public class MyClass
{
    private IDataTypeService _dataTypeService;
    
    public MyClass(IDataTypeService dataTypeService)
    {
        _dataTypeService = dataTypeService;
    }
}

In Razor views, you can access the Data Type service through the @inject directive:

@inject IDataTypeService DataTypeService

The EntityService acts as a "gateway" to Umbraco data for operations which are related to entities.

Browse the API documentation for IEntityService interface.

• Namespace: Umbraco.Cms.Core.Services

• Assembly: Umbraco.Core.dll

All samples in this document will require references to the following dll:

• Umbraco.Core.dll

All samples in this document will require the following using statements:

using Umbraco.Cms.Core.Services;

For Razor views:

@using Umbraco.Cms.Core.Services

Getting the service

Dependency Injection

If you wish to use the entity service in a class, you need to specify the IEntityService interface in your constructor:

public class MyClass
{
	private IEntityService _entityService;

	public MyClass(IEntityService entityService)
	{
		_entityService = entityService;
	}
}

In Razor views, you can access the entity service through the @inject directive:

@inject IEntityService EntityService

The DomainService acts as a "gateway" to Umbraco data for operations which are related to domains.

Browse the API documentation for IDomainService.

• Namespace: Umbraco.Cms.Core.Services

• Assembly: Umbraco.Core.dll

All samples in this document will require references to the following dll:

• Umbraco.Core.dll

All samples in this document will require the following using statements:

using Umbraco.Cms.Core.Services;

For Razor views:

@using Umbraco.Cms.Core.Services

Getting the service

Dependency Injection

If you wish to use the domain service in a class, you need to specify the IDomainService interface in your constructor:

public class MyClass
{
    private IDomainService _domainService;
    
    public MyClass(IDomainService domainService)
    {
        _domainService = domainService;
    }
}

In Razor views, you can access the domain service through the @inject directive:

@inject IDomainService DomainService

The FileService acts as a "gateway" to Umbraco data for operations which are related to Scripts, Stylesheets and Templates.

Browse the API documentation for IFileService.

• Namespace: Umbraco.Cms.Core.Services

• Assembly: Umbraco.Core.dll

All samples in this document will require references to the following dll:

• Umbraco.Core.dll

All samples in this document will require the following using statements:

using Umbraco.Cms.Core.Services;

For Razor views:

@using Umbraco.Cms.Core.Services

Getting the service

Dependency Injection

If you wish to use the file service in a class, you need to specify the IFileService interface in your constructor:

public class MyClass
{
    private IFileService _fileService;
    
    public MyClass(IFileService fileService)
    {
        _fileService = fileService;
    }
}

In Razor views, you can access the file service through the @inject directive:

@inject IFileService FileService

The ExternalLoginService is used to store the external login info and can be replaced with your own implementation.

Browse the API documentation for IEntityService interface.

• Namespace: Umbraco.Cms.Core.Services

• Assembly: Umbraco.Core.dll

All samples in this document will require references to the following dll:

• Umbraco.Core.dll

All samples in this document will require the following using statements:

using Umbraco.Cms.Core.Services;

Getting the service

Dependency Injection

If you wish to use the entity service in a class, you need to specify the IExternalLoginService interface in your constructor:

public class MyClass
{
	private IExternalLoginService _externalLoginService;

	public MyClass(IExternalLoginService externalLoginService)
	{
		_externalLoginService = externalLoginService;
	}
}

In Razor views, you can access the entity service through the @inject directive:

@inject IExternalLoginService ExternalLoginService

The MemberService acts as a "gateway" to Umbraco data for operations which are related to Members.

.

• Namespace: Umbraco.Cms.Core.Services

• Assembly: Umbraco.Core.dll

All samples in this document will require references to the following dll:

• Umbraco.Core.dll

All samples in this document will require the following using statements:

For Razor views:

Getting the service

Dependency Injection

If you wish to use the member service in a class, you need to specify the IMemberService interface in your constructor:

In Razor views, you can access the member service through the @inject directive:

The NotificationServices is used to perform operations related to backoffice notifications.

.

• Namespace: Umbraco.Cms.Core.Services

• Assembly: Umbraco.Core.dll

All samples in this document will require references to the following dll:

• Umbraco.Core.dll

All samples in this document will require the following using statements:

Getting the service

Dependency Injection

In other cases, you may be able to use Dependency Injection. For instance if you have registered your own class in Umbraco's dependency injection, you can specify the INotificationService interface in your constructor:

In Razor views, you can access the member type service through the @inject directive:

The PackagingService provides import/export functionality for the Core models of the API.

.

• Namespace: Umbraco.Cms.Core.Services

• Assembly: Umbraco.Core.dll

All samples in this document will require references to the following dll:

• Umbraco.Core.dll

All samples in this document will require the following using statements:

Getting the service

Dependency Injection

In other cases, you may be able to use Dependency Injection. For instance if you have registered your own class in Umbraco's dependency injection, you can specify the IPackagingService interface in your constructor:

In Razor views, you can access the member service through the @inject directive:

Defines the MacroService, which is an access to operations involving IMacro.

.

• Namespace: Umbraco.Cms.Core.Services

• Assembly: Umbraco.Core.dll

All samples in this document will require references to the following dll:

• Umbraco.Core.dll

For Razor views:

Getting the service

Dependency Injection

If you wish to use the macro service in a class, you need to specify the IMacroService interface in your constructor:

In Razor views, you can access the macro service through the @inject directive:

The RedirectUrlService is used for CRUD operations related to Redirects.

Browse the API documentation for IRedirectUrlService interface.

• Namespace: Umbraco.Cms.Core.Services

• Assembly: Umbraco.Core.dll

All samples in this document will require references to the following dll:

• Umbraco.Core.dll

All samples in this document will require the following using statements:

using Umbraco.Cms.Core.Services;

Getting the service

Dependency Injection

In other cases, you may be able to use Dependency Injection. For instance if you have registered your own class in Umbraco's dependency injection, you can specify the IRedirectUrlService interface in your constructor:

public class MyClass
{
    private IRedirectUrlService _redirectUrlService;

	public MyClass(IRedirectUrlService redirectUrlService)
	{
		_redirectUrlService = redirectUrlService;
	}
}

In Razor views, you can access the member service through the @inject directive:

@inject IRedirectUrlService RedirectUrlService

The AuditService acts as a "gateway" to Umbraco data for operations which are related to the audit trail.

Browse the API documentation for IAuditService interface.

• Namespace: Umbraco.Cms.Core.Services

• Assembly: Umbraco.Core.dll

All samples in this document will require references to the following dll:

• Umbraco.Core.dll

All samples in this document will require the following using statements:

using Umbraco.Cms.Core.Services;

For Razor views:

@using Umbraco.Cms.Core.Services

Getting the service

Dependency Injection

If you wish to use the audit service in a class, you need to use Dependency Injection (DI). For instance if you have registered your own class in Umbraco's DI container, you can specify the IAuditService interface in your constructor:

public class MyClass
{
    private IAuditService _auditService;
    
    public MyClass(IAuditService auditService)
    {
        _auditService = auditService;
    }
}

In Razor views, you can access the audit service through the @inject directive:

@inject IAuditService AuditService

Service to handle public access.

Browse the API documentation for IPublicAccessService interface.

• Namespace: Umbraco.Cms.Core.Services

• Assembly: Umbraco.Core.dll

All samples in this document will require references to the following dll:

• Umbraco.Core.dll

All samples in this document will require the following using statements:

using Umbraco.Cms.Core.Services;

Getting the service

Dependency Injection

In other cases, you may be able to use Dependency Injection. For instance if you have registered your own class in Umbraco's dependency injection, you can specify the IPublicAccessService interface in your constructor:

public class MyClass
{
    private IPublicAccessService _publicAccessService;

	public MyClass(IPublicAccessService publicAccessService)
	{
		_publicAccessService = publicAccessService;
	}
}

In Razor views, you can access the member service through the @inject directive:

@inject IPublicAccessService PublicAccessService

The MediaService acts as a "gateway" to Umbraco data for operations which are related to media.

Browse the API documentation for IMediaService interface.

• Namespace: Umbraco.Cms.Core.Services

• Assembly: Umbraco.Core.dll

All samples in this document will require reference to the following packages:

• Umbraco.Cms.Core

Samples in this document will require the following using statements:

using Umbraco.Cms.Core;
using Umbraco.Cms.Core.IO;
using Umbraco.Cms.Core.Models;
using Umbraco.Cms.Core.PropertyEditors;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Core.Strings;
using Umbraco.Extensions;

Getting the service

Dependency Injection

If you wish to use the media service in a class, you need to specify the IMediaService interface in your constructor:

public class MyClass
{
    private IMediaService _mediaService;
    
    public MyClass(IMediaService mediaService)
    {
        _mediaService = mediaService;
    }
}

In Razor views, you can access the media service through the @inject directive:

@inject IMediaService MediaService

Samples

Creating a new folder

To create a new folder at the root of the media archive, your code could look like the following:

// Initialize a new media at the root of the media archive
IMedia folder = _mediaService.CreateMedia("Samples Media Item Folder", Constants.System.Root, Constants.Conventions.MediaTypes.Folder);

// Save the folder
var result = _mediaService.Save(folder);

Alternatively, you can replace the Constants in the above sample with hardcoded values.

// Initialize a new media at the root of the media archive
IMedia folder = _mediaService.CreateMedia("Samples Media Item Folder", -1, "Folder");

// Save the folder
var result = _mediaService.Save(folder);

For the CreateMedia method, the first parameter is the name of the folder to be created.

The second parameter is the ID of the parent media item. Constants.System.Root is a constant defined in Umbraco with the value of -1, which is used for indicating the root of the media archive. Instead of specifying the numeric ID of the parent, you may instead specify either a Guid ID or an IMedia instance representing the parent media.

The third parameter is the alias of the Media Type. As Umbraco comes with a Folder Type by default, we can use the Constants.Conventions.MediaTypes.Folder constant to specify that the alias of the Media Type is Folder.

Besides the three mandatory parameters, you can specify a user's numeric ID for media creation attribution. Unspecified cases default to the "Administrator" user with ID -1.

Creating a new media item from a stream

You can specify a Stream for the contents of the file that should be created.

As an example, if you have an image on disk named unicorn.jpg in the images folder of wwwroot. You can open a new stream for a file on the disk, and then create a new media item for that file in Umbraco:

Please be aware that you will need to inject the following services:

• MediaFileManager _mediaFileManager

• IShortStringHelper _shortStringHelper

• IContentTypeBaseServiceProvider _contentTypeBaseServiceProvider

• MediaUrlGeneratorCollection _mediaUrlGeneratorCollection

• IMediaService _mediaService

• IWebHostEnvironment _webHostEnvironment

string webRootPath = _webHostEnvironment.WebRootPath;
var path = Path.Combine(webRootPath, "images", "unicorn.jpg");

// Open a new stream to the file
using (Stream stream = System.IO.File.OpenRead(path))
{
    // Initialize a new image at the root of the media archive
    IMedia media = _mediaService.CreateMedia("Unicorn", Constants.System.Root, Constants.Conventions.MediaTypes.Image);
    // Set the property value (Umbraco will handle the underlying magic)
    media.SetValue(_mediaFileManager, _mediaUrlGeneratorCollection, _shortStringHelper, _contentTypeBaseServiceProvider, Constants.Conventions.Media.File, "unicorn.jpg", stream);

    // Save the media
    var result = _mediaService.Save(media);
}
}

Again Umbraco will make sure the necessary properties are updated.

The MemberTypeService acts as a "gateway" to Umbraco data for operations which are related to MemberTypes.

.

• Namespace: Umbraco.Cms.Core.Services

• Assembly: Umbraco.Core.dll

All samples in this document will require references to the following dll:

• Umbraco.Core.dll

All samples in this document will require the following using statements:

For Razor views:

Getting the service

Dependency Injection

If you wish to use the member type service in a class, you need to specify the IMemberTypeService interface in your constructor:

In Razor views, you can access the member type service through the @inject directive:

The MemberGroupService acts as a "gateway" to Umbraco data for operations which are related to Member groups, which are also known as Member Roles.

.

• Namespace: Umbraco.Cms.Core.Services

• Assembly: Umbraco.Core.dll

All samples in this document will require references to the following dll:

• Umbraco.Core.dll

All samples in this document will require the following using statements:

For Razor views:

Getting the service

Dependency Injection

If you wish to use the member group service in a class, you need to specify the IMemberGroupService interface in your constructor:

In Razor views, you can access the member group service through the @inject directive:

In the example below, a new page is programmatically created using the content service. It is assumed that there are two document types, namely people and person. In this case, a new person is added underneath the people page.

Getting a single content type container

Content types can be added either at the root level, under another content type or under a content type container (or folders as they're called in the Umbraco backoffice). The approach for getting a single container is similar to getting a single content type, meaning that you can look up a container - either by its GUID:

// Declare the GUID ID
Guid guid = new Guid("d3b9cc9a-d471-4465-a89a-112c6bc1e5b4");

// Get a container by its GUID ID
EntityContainer container = _contentTypeService.GetContainer(guid);

or its numeric counterpart:

// Get a container by its numeric ID
EntityContainer container = _contentTypeService.GetContainer(1090);

Getting a list of content type containers

In the same way as you can get the content types of a container, you can get the child containers of another container. This is done by calling the GetContainers method with an array of numeric IDs:

// Declare the array of IDs to lookup
int[] ids = new[] {1090};

// Get the child containers via the content type service
IEnumerable<EntityContainer> containers = _contentTypeService.GetContainers(ids);

Also, if the array is empty, all containers will be returned:

// Declare the array of IDs to lookup
int[] ids = new int[0];

// Get all content type containers
IEnumerable<EntityContainer> containers = _contentTypeService.GetContainers(ids);

The ServerRegistrationService manages server registrations in the database.

Browse the API documentation for IServerRegistrationService interface.

• Namespace: Umbraco.Cms.Core.Services

• Assembly: Umbraco.Core.dll

All samples in this document will require references to the following dll:

• Umbraco.Core.dll

The Umbraco.Core.dll allows you to reference the Constants classes used in the below examples.

All samples in this document will require the following using statements:

using Umbraco.Cms.Core.Services;

For Razor views:

@using Umbraco.Cms.Core.Services

Getting the service

Dependency Injection

If you wish to use the server registration service in a class, you need to specify the IServerRegistrationService interface in your constructor:

public class MyClass
{
    private IServerRegistrationService _serverRegistrationService;

	public MyClass(IServerRegistrationService serverRegistrationService)
	{
		_serverRegistrationService = serverRegistrationService;
	}
}

In Razor views, you can access the server registration service through the @inject directive:

@inject IServerRegistrationService ServerRegistrationService

The LocalizationService acts as a "gateway" to Umbraco data for operations which are related to Dictionary items and Languages.

.

• Namespace: Umbraco.Cms.Core.Services

• Assembly: Umbraco.Core.dll

All samples in this document will require references to the following dll:

• Umbraco.Core.dll

All samples in this document will require the following using statements:

For Razor views:

Getting the service

Dependency Injection

If you wish to use the localization service in a class, you need to specify the ILocalizationService interface in your constructor:

In Razor views, you can access the localization service through the @inject directive:

Samples

If you want to create a new user, you'd use ASP.NET identity APIs like it is used in core.

Assigning the user to a user group

Permissions aren't administered for the specific user, but rather for the user group(s) that the user is a part of. So to add our new user to a user group, we first need to get a reference to the user via the GetUserGroupByAlias method, and then use the AddGroup method for adding the group to our user:

To make sure that these changed are saved to the database, we must also make sure to call the Save method. The GetUserGroupByAlias method takes the alias of a user group - eg. admin for the default Administrators user group.

Tag service to query for tags in the tags db table.

Browse the API documentation for ITagService interface.

• Namespace: Umbraco.Cms.Core.Services

• Assembly: Umbraco.Core.dll

All samples in this document will require references to the following dll:

• Umbraco.Core.dll

All samples in this document will require the following using statements:

using Umbraco.Cms.Core.Services;

Getting the service

Dependency Injection

In other cases, you may be able to use Dependency Injection. For instance if you have registered your own class in Umbraco's dependency injection, you can specify the ITagService interface in your constructor:

public class MyClass
{
    private ITagService _tagService;

	public MyClass(ITagService tagService)
	{
		_tagService = tagService;
	}
}

In Razor views, you can access the member service through the @inject directive:

@inject ITagService TagService

The ContentService acts as a "gateway" to Umbraco data for operations which are related to Content.

Browse the v9 API documentation for ContentService.

• Namespace: Umbraco.Cms.Core.Services

• Assembly: Umbraco.Core.dll

All samples in this document will require references to the following dll:

• Umbraco.Core.dll

All samples in this document will require the following using statements:

using Umbraco.Cms.Core.Services;

For Razor views:

@using Umbraco.Cms.Core.Services

Getting the service

If you wish to use the content service in a class, you need to use Dependency Injection (DI) in your constructor:

public class MyClass
{
    private IContentService _contentService;
    
    public MyClass(IContentService contentService)
    {
        _contentService = contentService;
    }
}

In Razor views, you can access the content service through the @inject directive:

@inject IContentService ContentService

The content type service acts as a "gateway" to Umbraco data for operations which are related to both content types and media types.

Browse the API documentation for IContentTypeService.

• Namespace: Umbraco.Cms.Core.Services

• Assembly: Umbraco.Core.dll

All samples in this document will require references to the following dll:

• Umbraco.Core.dll

All samples in this document will require the following using statements:

using Umbraco.Cms.Core.Services;

For Razor views:

@using Umbraco.Cms.Core.Services

Getting the service

Dependency Injection

If you wish to use the content type service in a class, you need to specify the IContentTypeService interface in your constructor:

public class MyClass
{
    private IContentTypeService _contentTypeService;
    
    public MyClass(IContentTypeService contentTypeService)
    {
        _contentTypeService = contentTypeService;
    }
}

In Razor views, you can access the content type service through the @inject directive:

@inject IContentTypeService ContentTypeService

Samples

• Retrieving content types See examples on how to retrieve content types via the service - either individually or as a collection.

• Retrieving content type containers See examples on how to retrieve content type containers (folders) via the service - either individually or as a collection.

The RelationService is pretty awesome as it allows you to create relations between objects that would otherwise have no obvious connection.

.

• Namespace: Umbraco.Core.Services

• Assembly: Umbraco.Core.dll

Getting the service

When you are using an Umbraco controller class (Such as SurfaceController or RenderMvcController) you have access to the RelationService through the ServiceContext:

You can also use the RelationService in any other class by injecting its interface:

Methods

AreRelated(int parentId, int childId, string relationTypeAlias)

Checks if two items are related.

Returns bool.

AreRelated(IUmbracoEntity parent, IUmbracoEntity child, string relationTypeAlias)

Checks if two items are related.

Returns bool.

AreRelated(int parentId, int childId)

Checks if two items are related.

Returns bool.

Delete(IRelation relation)

Deletes a relation.

Returns void.

Delete(IRelationType relationType)

Deletes a relation type.

Returns void.

DeleteRelationsOfType(IRelationType relationType)

Deletes relation of the specified relation type.

Returns void.

GetAllRelations(params int[] ids)

Gets a collection of Umbraco.Core.Models.Relation objects. Optional array of integer ids to return relations for.

Returns IEnumerable<IRelation>.

GetAllRelationsByRelationType(RelationType relationType)

Gets a collection of Umbraco.Core.Models.Relation objects by their relation type.

Returns IEnumerable<IRelation>.

GetAllRelationsByRelationType(int relationTypeId)

Gets a collection of Umbraco.Core.Models.Relation objects by their relation type id.

Returns IEnumerable<IRelation>.

GetAllRelationTypes(params int[] ids)

Gets a collection of Umbraco.Core.Models.Relation objects. Optional array of integer ids to return relationtypes for.

Returns IEnumerable<IRelationType>.

GetByChild(IUmbracoEntity child)

Gets a collection of Umbraco.Core.Models.Relation objects by their child entity.

Returns IEnumerable<IRelation>.

GetByChild(IUmbracoEntity child, string relationTypeAlias)

Gets a collection of Umbraco.Core.Models.Relation objects their child entity and relation type alias.

Returns IEnumerable<IRelation>.

GetByChildId(int id)

Gets a collection of Umbraco.Core.Models.Relation objects by their child id.

Returns IEnumerable<IRelation>.

GetById(int id)

Gets a Umbraco.Core.Models.Relation object by its id.

Returns IRelation.

GetByParent(IUmbracoEntity parent, string relationTypeAlias)

Gets a collection of Umbraco.Core.Models.Relation objects by their parent entity and relation type alias.

Returns IEnumerable<IRelation>.

GetByParent(IUmbracoEntity parent)

Gets a collection of Umbraco.Core.Models.Relation objects by their parent entity.

Returns IEnumerable<IRelation>.

GetByParentId(int id)

Gets a collection of Umbraco.Core.Models.Relation objects by their parent id.

Returns IEnumerable<IRelation>.

GetByParentOrChildId(int id, string relationTypeAlias)

Gets a collection of Umbraco.Core.Models.Relation objects by their parent or child id and relation type alias.

Returns IEnumerable<IRelation>.

GetByParentOrChildId(int id)

Gets a collection of Umbraco.Core.Models.Relation objects by their parent or child id.

Returns IEnumerable<IRelation>.

GetByRelationTypeAlias(string relationTypeAlias)

Gets a collection of Umbraco.Core.Models.Relation objects by their relation type alias.

Returns IEnumerable<IRelation>.

GetByRelationTypeId(int relationTypeId)

Gets a collection of Umbraco.Core.Models.Relation objects by the id of their relation type.

Returns IEnumerable<IRelation>.

GetByRelationTypeName(string relationTypeName)

Gets a collection of Umbraco.Core.Models.Relation objects by the name of their relation type.

Returns IEnumerable<IRelation>.

GetChildEntitiesFromRelations(IEnumerable relations)

Gets the child objects from a collection of IRelation as a collection of Umbraco.Core.Models.Entities.IUmbracoEntity.

Returns IEnumerable<IUmbracoEntity>.

GetChildEntityFromRelation(IRelation relation)

Gets the child object from a relation as an Umbraco.Core.Models.Entities.IUmbracoEntity object.

Returns IUmbracoEntity.

GetEntitiesFromRelation(IRelation relation)

Gets the parent and child objects from a relation as a System.Tuple with Umbraco.Core.Models.Entities.IUmbracoEntity.

Returns Tuple<IUmbracoEntity, IUmbracoEntity>.

GetEntitiesFromRelations(IEnumerable relations)

Gets the parent and child objects from a collection of relations as a list of Umbraco.Core.Models.Entities.IUmbracoEntity objects.

Returns IEnumerable<Tuple<IUmbracoEntity, IUmbracoEntity>>.

GetParentEntitiesFromRelations(IEnumerable relations)

Gets the parent objects from a collection of relations as a collection of Umbraco.Core.Models.Entities.IUmbracoEntity.

Returns IEnumerable<IUmbracoEntity>.

GetParentEntityFromRelation(IRelation relation)

Gets the parent object from a relation as an Umbraco.Core.Models.Entities.IUmbracoEntity object.

GetRelationTypeByAlias(string alias)

Gets an relation by its alias.

Returns IRelationType.

GetRelationTypeById(Guid id)

Gets a relation type by its Id

Returns IRelationType.

GetRelationTypeById(int id)

Gets a relation type by its id.

Returns IRelationType.

HasRelations(IRelationType relationType)

Checks if any relations exist for the specified relation type.

Returns bool.

IsRelated(int id)

Checks if any relations exist for the specified id.

Returns void.

Relate(int parentId, int childId, IRelationType relationType)

Relates two objects by their ids using the specified relation type.

Returns IRelation.

Relate(IUmbracoEntity parent, IUmbracoEntity child, IRelationType relationType)

Relates two IUmbracoEntity objects using the specified relation type.

Returns IRelation.

Relate(IUmbracoEntity parent, IUmbracoEntity child, string relationTypeAlias)

Relates two IUmbracoEntity objects using the specified relation type alias.

Returns IRelation.

Relate(int parentId, int childId, string relationTypeAlias)

Relates two IUmbracoEntity objects using the specified relation type alias.

Returns IRelation.

Save(IRelation relation)

Saves a relation.

Returns Void.

Save(IRelationType relationType)

Saves a relation type.

Returns Void.

Examples

Below you will examples using the RelationService.

Automatically relate to root node

Odd example, I know.. but why not?

To perform the said task we need a component in which we can register to the ContentService.Published event:

To have Umbraco recognize our component we need to register it in a composer:

If I know Save and Publish my Products node I get the following result:

Cool! Now let us try and fetch the data from an API.

Notice the x => new Relation()? We need to make sure what we are returning can be serialized. Therefore the Relation class is:

Browsing /umbraco/api/relations/getbyrelationtypealias?alias=homesick now returns the following:

The TextService is the entry point to localize any key in the text storage source for a given culture.

.

• Namespace: Umbraco.Cms.Core.Services

• Assembly: Umbraco.Core.dll

All samples in this document will require references to the following dll:

• Umbraco.Core.dll

All samples in this document will require the following using statements:

Getting the service

Dependency Injection

In other cases, you may be able to use Dependency Injection. For instance if you have registered your own class in Umbraco's dependency injection, you can specify the ILocalizedTextService interface in your constructor:

In Razor views, you can access the member service through the @inject directive:

Getting a single content type

A given content type has a few different unique identifier that we can use to look it up via the content type service. For instance, if we know the GUID of the content type, we can look it up like this:

// Declare the GUID ID
Guid guid = new Guid("796a8d5c-b7bb-46d9-bc57-ab834d0d1248");

// Get a reference to the content type by its GUID ID
IContentType contentType = _contentTypeService.Get(guid);

Although the use of a GUID is preferable, you can also use it's numeric ID:

// Get a reference to the content type by its numeric ID
IContentType contentType = _contentTypeService.Get(1234); 

Finally, you can also look up a content type by its alias:

// Get a reference to the content type by its alias
IContentType contentType = _contentTypeService.Get("home");

Getting a list of content types

As content types are stored in a hierarchical list with folders (containers), there is also multiple ways to can get content types. If you are looking for a flat list of all content types, you can use the GetAll method:

// Get a collection of all content types
IEnumerable<IContentType> contentTypes = _contentTypeService.GetAll();

In the example above, the method was called without any parameters. The method also has two overloads, which lets you look up a collection fo content types by either specifying their GUID or numeric IDs:

// Get a collection of two specific content types by their GUIDs IDs
IEnumerable<IContentType> contentTypes = _contentTypeService.GetAll(new[] {
    new Guid("2b54088e-d355-4b9e-aa4b-5aec4b3f87eb"),
    new Guid("859c5916-19d8-4a72-9bd0-5641ad503aa9")
});

// Get a collection of two specific content types by their numeric IDs
IEnumerable<IContentType> contentTypes = _contentTypeService.GetAll(1234, 1235);

To get a list of all content types of another content type, you can instead use the GetChildren method - either by specifying the numeric ID or the GUID:

// Get a collection of content types of a specific content type
IEnumerable<IContentType> contentTypes = _contentTypeService.GetChildren(1232);

IEnumerable<IContentType> contentTypes = _contentTypeService.GetChildren(Guid.Parse("4f89dd28-d038-4209-aaa1-06109b7946a7"));

Check whether a content type has children

In some cases it can be useful to check if a content type has children. The HasChildren method can be used to check whether a content type has children.

// Check if there are children
bool hasChildren = _contentTypeService.HasChildren(Guid.Parse("2b54088e-d355-4b9e-aa4b-5aec4b3f87eb"));

Although the use of a GUID is preferable, you can also use it's numeric ID:

// Check if there are children
bool hasChildren = _contentTypeService.HasChildren(1234);

Getting a single language

The localization service contains a number of methods for looking up languages. If you already know the ID of a specific language (eg. the default language has ID 1), you can use the GetLanguageById method to get the reference to that language:

// Get a reference to the language by its ID
ILanguage language1 = _localizationService.GetLanguageById(1);

Alternative, you can look up a language by its iso code via the GetLanguageByIsoCode method:

// Get a reference to the language by its ISO code
ILanguage language2 = _localizationService.GetLanguageByIsoCode("en-US");

The ISO code is a combination of the two-letter ISO 639-1 language code (lowercase) and two-letter ISO-3166 country code (uppercase). Eg. en-US for English in the United States, en-GB for English in the United Kingdom and da-DK for Danish in Denmark.

Both methods will return an instance of the ILanguage interface, which has traditional properties like Id and Key, but also properties specific to the language like CultureName, CultureInfo and IsoCode. You can see the API reference for further information on the properties of the interface.

Getting all languages

If you need instead need a list of all installed languages, you can use the GetAllLanguages method. It takes no parameters, and as such a returns a collection of all languages (with no pagination like some of the other services):

// Get a collection of all languages
IEnumerable<ILanguage> languages = _localizationService.GetAllLanguages();

// Iterate over the collection
foreach (ILanguage language in languages)
{
    // Get the .NET culture info
    CultureInfo cultureInfo = language.CultureInfo;

    <pre>ID: @language.Id</pre>
    <pre>Key: @language.Key</pre>
    <pre>Name: @language.CultureName</pre>
    <pre>ISO: @language.IsoCode</pre>
    <pre>Culture info: @cultureInfo</pre>
    <hr />
}

As shown in the example above, you can get the System.Globalization.CultureInfo instance of each language, which determines how numbers, dates and similar should be either parsed or formatted in .NET.

Full example

Below you can see a full example of the examples shown above - including the necessary imports:

@using System.Globalization
@using Umbraco.Cms.Core.Models
@using Umbraco.Cms.Core.Services
@inherits Umbraco.Cms.Web.Common.Views.UmbracoViewPage
@inject ILocalizationService LocalizationService

@{
    // Get a collection of all languages
    IEnumerable<ILanguage> languages = LocalizationService.GetAllLanguages();

    // Iterate over the collection
    foreach (ILanguage language in languages)
    {

        // Get the .NET culture info
        CultureInfo cultureInfo = language.CultureInfo;

        <pre>ID: @language.Id</pre>
        <pre>Key: @language.Key</pre>
        <pre>Name: @language.CultureName</pre>
        <pre>ISO: @language.IsoCode</pre>
        <pre>Culture info: @cultureInfo</pre>
        <hr />

    }

    // Get a reference to the language by its ID
    ILanguage language1 = LocalizationService.GetLanguageById(1);

    // Get a reference to the language by its ISO code
    ILanguage language2 = LocalizationService.GetLanguageByIsoCode("en-US");

    <pre>@language1</pre>
    <pre>@language2</pre>
}

The UserService acts as a "gateway" to Umbraco data for operations which are related to Users.

• Namespace: Umbraco.Core.Services

• Assembly: Umbraco.Core.dll

All samples listed in this document will require references to the following dll:

• Umbraco.Core.dll

All samples in this document will require the following using statements:

using Umbraco.Core;
using Umbraco.Core.Models;
using Umbraco.Core.Services;

Getting the service

Services property

If you wish to use the UserService in a class that inherits from one of the Umbraco base classes (eg. SurfaceController, UmbracoApiController or UmbracoAuthorizedApiController), you can access the service through a local Services property:

IUserService userService = Services.UserService;

Dependency Injection

In other cases, you may be able to use Dependency Injection. For instance if you have registered your own class in Umbraco's dependency injection, you can specify the IUserService interface in your constructor:

public class MyClass
{

    private IUserService _userService;
    
    public MyClass(IUserService userService)
    {
        _userService = userService;
    }

}

Static accessor

If neither a Services property or Dependency Injection is available, you can also reference the static Current class directly:

IUserService userService = Umbraco.Core.Composing.Current.Services.UserService;

Samples

• Create a new user Quick sample showing how to create a new backoffice user; including setting a password, assigning the user to a user group, and setting the name of the user.