• A single public CLR class (C1) within an explicitly defined namespace is used to define all the top-level entity sets in the model. Top-level resources are accessible using the first path segment in a URI.

• The namespace in which the class C1 exists is the namespace that identifies C1 as the entity container. This is constant even if C1 is a derived type.

• The name of the class C1 represents the entity container. A single entity container can be defined for the namespace. This is constant even if C1 is a derived type.

• Each entity set must be represented as a public property (P1) of the class C1 with a return type of IQueryable<T>. Zero or more such properties may exist on the class C1 or, if the class is a derived type, on one of its parent classes.

  • T represents the entity type within the entity set.

  • T must have a property suitable to be an entity key in order for property C1 to be considered an entity set. If no such suitable key property exists, property P1 is skipped and C1 is not considered to represent an entity set by the ADO.NET Data Services data service.

  • The same type T cannot be returned by more than one property on class C1 or a parent class of C1. This model definition based on the CLR does not support including the same entity type, in this case represented by class T, in multiple entity sets. Multiple entity sets per type can be implemented in the Entity Framework but not as classes deployed by ADO.NET Data Services.

• A public CLR class (C1) represents an entity type.

• To be recognized as an entity type, a class must have a property or properties that represent the key of the type. Such a property or group of properties becomes the key(s) for the entity type. The rules for properties that represent a key are:

  • Public property named ID.

  • Public property named <className>ID.

  • Public properties marked with the attribute DataWebKeyAttribute attribute.

  • If a class contains a property or group of properties that are marked with the DataWebKeyAttribute, those properties are used as the key, and the first two rules are ignored. If no properties contain the attribute then those properties matching the first two rules determine the key property of the entity type. If more than one property matches the rules, the enity type has, by definition, a composite key.

• If the class C1 is part of a hierarchy, the class hierarchy is translated to an entity type hierarchy by applying the following rules:

  • The CLR class nearest to the root of the class hierarchy that includes a valid key property becomes the root of the entity type hierarchy. If class C1 is not the root of the CLR class hierarchy in which it participates, then the properties declared by classes above C1 in the hierarchy are assumed to be declared by C1.

• Each property (P) declared by the class C1 is translated to a property on the entity type if the CLR property conforms to all of the following conventions:

  • The CLR property must have public scope.

  • The CLR property must implement a get method for the property.

  • The CLR property must not be an indexer.

  • If the return type of property P is a primitive type, and the type corresponds to an EDM type, the property must be represented as a property. See ADO.NET Data Services Content Types for a mapping of EDM types to CLR types.

  • If the return type of property P is a reference type, and the type or one of its parent objects, if it is a derived type, represents an entity type, then P represents a (1-1) navigation link.

  • If the return type of property P is IEnumerable<T> and T represents an entity type, then P represents a one-to-many navigation link.

  • If the return type of property P is a value type, then P represents a complex type.

• A public CLR value type (V1) represents a complex type.

• Each property of the value type V1 is translated to a property of a complex type. Complex types follow rules similar to entity types to determine if a CLR property will be mapped to a property.

  • The CLR property must have public scope.

  • The CLR property must implement a Get method for the property.

  • The CLR property must not be an indexer.

  • If the return type of property P is a reference type, and the type or one of its parent objects, if it is a derived type, represents an entity type, P represents a one-to-one navigation link.

The following example shows CLR classes that include inheritance used to implement ADO.NET Data Services resources types.

namespace Accounting
{
    public class DataModel
    {
        public IQueryable<Customer> Customers
        {
            get
            {
                return new Customer[] { new Customer(1, "name1"),
                    new Customer(2, "name2") }.AsQueryable<Customer>();
            }
        }

        public IQueryable<Order> Orders
        {
            get
            {
                return new Order[] { new Order(1, "order1"),
                   new Order(2, "order2") }.AsQueryable<Order>();
            }
        }
    }


    public class DerivedDataModel : DataModel
    {
        public IQueryable<HumanResources.Employee> Employees
        {
            get { return new HumanResources.Employee[] { new 
                        HumanResources.Employee(1, "EmpName1"), new 
                        HumanResources.Employee(2, "EmpName2") 
                         }.AsQueryable<HumanResources.Employee>(); 
               } 
        }
    }

    public class Person
    {
        protected int _ID;
        public Person() { }
        public Person(int i)
        {
            _ID = i;
        }

        [DataWebKeyAttribute]
        public int ID
        {
            get { return _ID; }
        }
    }

    public class Customer : Person
    {
        private string _name;
        private Address _address;
        List<Order> _orders;

        public Customer(int i, string name)
        {
            _ID = i;
            _name = name;
            _orders = new List<Order>();
            if (i == 1) { _orders.Add(new Order(1, "order1")); }
            if (i == 2) { _orders.Add(new Order(2, "order2")); }
            _address.Line1 = "Line" + i;
            _address.Line2 = "Line" + i;
        }

        public string CustName
        {
            get { return _name; }
        }

        public Address Address
        {
            get { return _address; }
        }

        public IList<Order> Orders
        {
            get { return _orders; }
        }
    }

    public class Order
    {
        private int _ID;
        private string _name;

        public Order(int i, string name)
        {
            _ID = i;
            _name = name;
        }

        [DataWebKeyAttribute]
        public int OrderKey
        {
            get { return _ID; }
        }

        public string OrderName
        {
            get { return _name; }
        }
    }

    public struct Address
    {
        private string line1;
        private string line2;

        public string Line1
        {
            get { return this.line1; }
            set { this.line1 = value; }
        }

        public string Line2
        {
            get { return this.line2; }
            set { this.line2 = value; }
        }
    }
}

namespace HumanResources
{
    public class Employee
    {
        private int _ID;
        private string _name;

        public Employee(int i, string name)
        {
            _ID = i;
            _name = name;
        }

        public int ID
        {
            get { return _ID; }
        }

        public string EmpName
        {
            get { return _name; }
        }
    }
}

To enable create, update, and delete support on a CLR data model, the class that models the top-level entity sets must implement the IUpdatable interface. In reference to Example 2, CLR Objects to ADO.NET Data Services Framework resources above, the Accounting.DataModel class would be required to implement the IUpdatable interface.