Classe générique LinqToEntitiesDomainService

Fournit une classe de base pour les services de domaine fonctionnant sur des modèles de données LINQ to Entities.

Espace de noms: System.ServiceModel.DomainServices.EntityFramework
Assembly : System.ServiceModel.DomainServices.EntityFramework (dans system.servicemodel.domainservices.entityframework.dll)

Utilisation

'Utilisation
Dim instance As LinqToEntitiesDomainService(Of TContext)

Syntaxe

'Déclaration
<LinqToEntitiesDomainServiceDescriptionProviderAttribute> _
Public MustInherit Class LinqToEntitiesDomainService(Of TContext As ObjectContext)
    Inherits DomainService

[LinqToEntitiesDomainServiceDescriptionProviderAttribute] 
public abstract class LinqToEntitiesDomainService<TContext> : DomainService where TContext : ObjectContext

[LinqToEntitiesDomainServiceDescriptionProviderAttribute] 
generic<typename TContext> where TContext : ObjectContext
public ref class LinqToEntitiesDomainService abstract : public DomainService

GenericParameters

• TContext
  Type du ObjectContext LINQ to Entities.

Exemple

L'exemple suivant illustre un service de domaine qui dérive de LinqToEntitiesDomainService. Il contient des méthodes pour interroger, mettre à jour et supprimer des données.

<EnableClientAccess()>  _
Public Class OrderDomainService
    Inherits LinqToEntitiesDomainService(Of AdventureWorksLT_DataEntities)

    Public Function GetSalesOrders() As IQueryable(Of SalesOrderHeader)
        Return Me.ObjectContext.SalesOrderHeaders.Include("SalesOrderDetails")
    End Function
    
    Public Sub UpdateSalesOrder(ByVal currentSalesOrderHeader As SalesOrderHeader)
        Dim originalOrder As SalesOrderHeader = Me.ChangeSet.GetOriginal(currentSalesOrderHeader)

        If (currentSalesOrderHeader.EntityState = EntityState.Detached) Then
            If (IsNothing(originalOrder)) Then
                Me.ObjectContext.Attach(currentSalesOrderHeader)
            Else
                Me.ObjectContext.AttachAsModified(currentSalesOrderHeader, Me.ChangeSet.GetOriginal(currentSalesOrderHeader))
            End If
        End If

        For Each detail As SalesOrderDetail In Me.ChangeSet.GetAssociatedChanges(currentSalesOrderHeader, Function(o) o.SalesOrderDetails)
            Dim op As ChangeOperation = Me.ChangeSet.GetChangeOperation(detail)

            Select Case op
                Case ChangeOperation.Insert
                    If ((detail.EntityState = EntityState.Added) _
                    = False) Then
                        If ((detail.EntityState = EntityState.Detached) _
                                    = False) Then
                            Me.ObjectContext.ObjectStateManager.ChangeObjectState(detail, EntityState.Added)
                        Else
                            Me.ObjectContext.AddToSalesOrderDetails(detail)
                        End If
                    End If
                Case ChangeOperation.Update
                    Me.ObjectContext.AttachAsModified(detail, Me.ChangeSet.GetOriginal(detail))
                Case ChangeOperation.Delete
                    If (detail.EntityState = EntityState.Detached) Then
                        Me.ObjectContext.Attach(detail)
                    End If
                    Me.ObjectContext.DeleteObject(detail)
            End Select
        Next
    End Sub
    
    Public Sub DeleteSalesOrder(ByVal salesOrderHeader As SalesOrderHeader)
        If (salesOrderHeader.EntityState = EntityState.Detached) Then
            Me.ObjectContext.Attach(salesOrderHeader)
        End If

        Select Case salesOrderHeader.Status
            Case 1 ' in process
                Me.ObjectContext.DeleteObject(salesOrderHeader)
            Case 2, 3, 4 ' approved, backordered, rejected
                salesOrderHeader.Status = 6
            Case 5 ' shipped
                Throw New ValidationException("The order has been shipped and cannot be deleted.")
        End Select

    End Sub
End Class

[EnableClientAccess()]
public class OrderDomainService : LinqToEntitiesDomainService<AdventureWorksLT_DataEntities>
{
    public IQueryable<SalesOrderHeader> GetSalesOrders()
    {
        return this.ObjectContext.SalesOrderHeaders.Include("SalesOrderDetails");
    }

    public void UpdateSalesOrder(SalesOrderHeader currentSalesOrderHeader)
    {
        SalesOrderHeader originalOrder = this.ChangeSet.GetOriginal(currentSalesOrderHeader);

        if ((currentSalesOrderHeader.EntityState == EntityState.Detached))
        {
            if (originalOrder != null)
            {
                this.ObjectContext.AttachAsModified(currentSalesOrderHeader, this.ChangeSet.GetOriginal(currentSalesOrderHeader));
            }
            else
            {
                this.ObjectContext.Attach(currentSalesOrderHeader);
            }
        }

        foreach (SalesOrderDetail detail in this.ChangeSet.GetAssociatedChanges(currentSalesOrderHeader, o => o.SalesOrderDetails))
        {
            ChangeOperation op = this.ChangeSet.GetChangeOperation(detail);
            switch (op)
            {
                case ChangeOperation.Insert:
                    if ((detail.EntityState != EntityState.Added))
                    {
                        if ((detail.EntityState != EntityState.Detached))
                        {
                            this.ObjectContext.ObjectStateManager.ChangeObjectState(detail, EntityState.Added);
                        }
                        else
                        {
                            this.ObjectContext.AddToSalesOrderDetails(detail);
                        }
                    }
                    break;
                case ChangeOperation.Update:
                    this.ObjectContext.AttachAsModified(detail, this.ChangeSet.GetOriginal(detail));
                    break;
                case ChangeOperation.Delete:
                    if (detail.EntityState == EntityState.Detached)
                    {
                        this.ObjectContext.Attach(detail);
                    }
                    this.ObjectContext.DeleteObject(detail);
                    break;
                case ChangeOperation.None:
                    break;
                default:
                    break;
            }
        }
    }

    public void DeleteSalesOrder(SalesOrderHeader salesOrderHeader)
    {
        if ((salesOrderHeader.EntityState == EntityState.Detached))
        {
            this.ObjectContext.Attach(salesOrderHeader);
        }
        
        switch (salesOrderHeader.Status)
        {
            case 1: // in process
                this.ObjectContext.DeleteObject(salesOrderHeader);
                break;
            case 2: // approved
            case 3: // backordered
            case 4: // rejected
                salesOrderHeader.Status = 6;
                break;
            case 5: // shipped
                throw new ValidationException("The order has been shipped and cannot be deleted.");
            default:
                break;
        }
       
    }
}

Notes

Vous créez des classes de service de domaine qui dérivent de la classe LinqToEntitiesDomainService lorsque vous exposez des types LINQ to Entities. Lorsque vous utilisez la boîte de dialogue Ajouter une nouvelle classe DomainService pour créer un service de domaine qui expose des types LINQ to Entities, cette boîte de dialogue crée automatiquement une classe qui dérive de LinqToEntitiesDomainService. La classe créée fournit des méthodes qui proposent un point de départ pour l'implémentation de la logique métier dans votre application. La classe comprend une méthode de requête. Si vous activez la case à cocher Activer Modifier, des méthodes d'insertion, de mise à jour et de suppression sont incluses. Vous devez ajouter des méthodes ou personnaliser les méthodes existantes pour répondre aux besoins de votre application.

Vous utilisez la propriété ObjectContext pour accéder à l'objet qui facilite l'interaction avec les objets de données d'entité.

Hiérarchie d'héritage

System.Object
   System.ServiceModel.DomainServices.Server.DomainService
    System.ServiceModel.DomainServices.EntityFramework.LinqToEntitiesDomainService

Sécurité des threads

Tous les membres publics statiques (Partagés dans Visual Basic) de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Plateformes

Plateformes de développement

Windows XP Édition familiale, Windows XP Professionnel, Windows Server 2003 , Windows Server 2008 et Windows 2000

Plateformes cibles

Change History

Voir aussi

Référence

Membres LinqToEntitiesDomainService
Espace de noms System.ServiceModel.DomainServices.EntityFramework