Clase genérica LinqToEntitiesDomainService

Proporciona una clase base para los servicios de dominio que operan en modelos de datos de LINQ to Entities.

Espacio de nombres: System.ServiceModel.DomainServices.EntityFramework
Ensamblado: System.ServiceModel.DomainServices.EntityFramework (en system.servicemodel.domainservices.entityframework.dll)

Uso

'Uso
Dim instance As LinqToEntitiesDomainService(Of TContext)

Sintaxis

'Declaración
<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
  Tipo de ObjectContext de LINQ to Entities.

Ejemplo

En el ejemplo siguiente se muestra un servicio de dominio que se deriva de LinqToEntitiesDomainService. Contiene métodos para consultar, actualizar y eliminar datos.

<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;
        }
       
    }
}

Notas

Las clases de servicio de dominio derivadas de la clase LinqToEntitiesDomainService se crean cuando se exponen tipos de LINQ to Entities. Cuando se usa el cuadro de diálogo Agregar nueva clase DomainService para crear un servicio de dominio que expone tipos de LINQ to Entities, el cuadro de diálogo crea automáticamente una clase derivada de LinqToEntitiesDomainService. La clase se crea con métodos que proporcionan un punto de partida para implementar lógica de negocios en la aplicación. En la clase se incluye un método de consulta. Si se activa la casilla, Habilitar edición, se incluyen métodos de inserción, actualización y eliminación. Deben agregarse métodos nuevos o personalizar los existentes para satisfacer los requisitos de la aplicación.

La propiedad ObjectContext se utiliza para tener acceso al objeto que facilita la interacción con los objetos de datos de entidad.

Jerarquía de herencia

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

Seguridad para subprocesos

Cualquier miembro estático público (Compartidos en Visual Basic) de este tipo es seguro para subprocesos. No se garantiza que los miembros de instancia sean seguros para subprocesos.

Plataformas

Plataformas de desarrollo

Microsoft Windows XP Home Edition, Windows XP Professional, Windows Server 2003 , Windows Server 2008 y Windows 2000

Plataformas de destino

Change History

Vea también

Referencia

Miembros LinqToEntitiesDomainService
Espacio de nombres System.ServiceModel.DomainServices.EntityFramework