Compartilhar via

Criar e recuperar relacionamentos de entidades

  • Artigo

 

Publicado: novembro de 2016

Aplicável a: Dynamics CRM 2015

Este tópico mostra como criar e recuperar relacionamentos entre entidades.

Neste tópico

Criar um relacionamento 1:N entre entidades

Criar um relacionamento N:N entre entidades

Recuperar um relacionamento entre entidade

Criar um relacionamento 1:N entre entidades

O exemplo usa o método de EligibleCreateOneToManyRelationship para verificar se as entidades Account e Campaign podem participar de um relacionamento 1:N entre entidades e então cria o relacionamento entre entidades usando CreateOneToManyRequest.



bool eligibleCreateOneToManyRelationship =
    EligibleCreateOneToManyRelationship("account", "campaign");

if (eligibleCreateOneToManyRelationship)
{
    CreateOneToManyRequest createOneToManyRelationshipRequest =
        new CreateOneToManyRequest
    {
        OneToManyRelationship =
        new OneToManyRelationshipMetadata
        {
            ReferencedEntity = "account",
            ReferencingEntity = "campaign",
            SchemaName = "new_account_campaign",
            AssociatedMenuConfiguration = new AssociatedMenuConfiguration
            {
                Behavior = AssociatedMenuBehavior.UseLabel,
                Group = AssociatedMenuGroup.Details,
                Label = new Label("Account", 1033),
                Order = 10000
            },
            CascadeConfiguration = new CascadeConfiguration
            {
                Assign = CascadeType.NoCascade,
                Delete = CascadeType.RemoveLink,
                Merge = CascadeType.NoCascade,
                Reparent = CascadeType.NoCascade,
                Share = CascadeType.NoCascade,
                Unshare = CascadeType.NoCascade
            }
        },
        Lookup = new LookupAttributeMetadata
        {
            SchemaName = "new_parent_accountid",
            DisplayName = new Label("Account Lookup", 1033),
            RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
            Description = new Label("Sample Lookup", 1033)
        }
    };


    CreateOneToManyResponse createOneToManyRelationshipResponse =
        (CreateOneToManyResponse)_serviceProxy.Execute(
        createOneToManyRelationshipRequest);

    _oneToManyRelationshipId =
        createOneToManyRelationshipResponse.RelationshipId;
    _oneToManyRelationshipName = 
        createOneToManyRelationshipRequest.OneToManyRelationship.SchemaName;

    Console.WriteLine(
        "The one-to-many relationship has been created between {0} and {1}.",
        "account", "campaign");
}



Dim eligibleCreateOneToManyRelationship As Boolean =
 Me.EligibleCreateOneToManyRelationship("account", "campaign")

If eligibleCreateOneToManyRelationship Then
 Dim createOneToManyRelationshipRequest As CreateOneToManyRequest =
  New CreateOneToManyRequest With {
   .OneToManyRelationship = New OneToManyRelationshipMetadata With {
    .ReferencedEntity = "account",
    .ReferencingEntity = "campaign",
    .SchemaName = "new_account_campaign",
    .AssociatedMenuConfiguration =
    New AssociatedMenuConfiguration With {
     .Behavior = AssociatedMenuBehavior.UseLabel,
     .Group = AssociatedMenuGroup.Details,
     .Label = New Label("Account", 1033),
     .Order = 10000},
    .CascadeConfiguration =
    New CascadeConfiguration With {
     .Assign = CascadeType.Cascade,
     .Delete = CascadeType.Cascade,
     .Merge = CascadeType.Cascade,
     .Reparent = CascadeType.Cascade,
     .Share = CascadeType.Cascade,
     .Unshare = CascadeType.Cascade
    }
   },
   .Lookup = New LookupAttributeMetadata With {
    .SchemaName = "new_parent_accountid",
    .DisplayName = New Label("Account Lookup", 1033),
    .RequiredLevel = New AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
    .Description = New Label("Sample Lookup", 1033)
   }
  }


 Dim createOneToManyRelationshipResponse As CreateOneToManyResponse =
  CType(_serviceProxy.Execute(createOneToManyRelationshipRequest), CreateOneToManyResponse)

 _oneToManyRelationshipId = createOneToManyRelationshipResponse.RelationshipId
 _oneToManyRelationshipName = createOneToManyRelationshipRequest.OneToManyRelationship.SchemaName

 Console.WriteLine("The one-to-many relationship has been created between {0} and {1}.", "account", "campaign")
End If

EligibleCreateOneToManyRelationship

O exemplo a seguir cria um método de EligibleCreateOneToManyRelationship que usa CanBeReferencedRequest e CanBeReferencingRequest para verificar se duas entidades podem participar de um relacionamento 1:N entre entidades.


/// <summary>
/// Determines whether two entities are eligible to participate in a relationship
/// </summary>
/// <param name="referencedEntity">Primary Entity</param>
/// <param name="referencingEntity">Referencing Entity</param>
/// <returns></returns>
public bool EligibleCreateOneToManyRelationship(string referencedEntity, 
    string referencingEntity)
{
    //Checks whether the specified entity can be the primary entity in one-to-many
    //relationship.
    CanBeReferencedRequest canBeReferencedRequest = new CanBeReferencedRequest
    {
        EntityName = referencedEntity
    };

    CanBeReferencedResponse canBeReferencedResponse =
        (CanBeReferencedResponse)_serviceProxy.Execute(canBeReferencedRequest);

    if (!canBeReferencedResponse.CanBeReferenced)
    {
        Console.WriteLine(
            "Entity {0} can't be the primary entity in this one-to-many relationship", 
            referencedEntity);
    }

    //Checks whether the specified entity can be the referencing entity in one-to-many
    //relationship.
    CanBeReferencingRequest canBereferencingRequest = new CanBeReferencingRequest
    {
        EntityName = referencingEntity
    };

    CanBeReferencingResponse canBeReferencingResponse =
        (CanBeReferencingResponse)_serviceProxy.Execute(canBereferencingRequest);

    if (!canBeReferencingResponse.CanBeReferencing)
    {
        Console.WriteLine(
            "Entity {0} can't be the referencing entity in this one-to-many relationship", 
            referencingEntity);
    }


    if (canBeReferencedResponse.CanBeReferenced == true
        &amp;&amp; canBeReferencingResponse.CanBeReferencing == true)
    {
        return true;
    }
    else
    {
        return false;
    }
}


''' <summary>
''' Determines whether two entities are eligible to participate in a relationship
''' </summary>
''' <param name="referencedEntity">Primary Entity</param>
''' <param name="referencingEntity">Referencing Entity</param>
''' <returns></returns>
Public Function EligibleCreateOneToManyRelationship(ByVal referencedEntity As String, ByVal referencingEntity As String) As Boolean
 'Checks whether the specified entity can be the primary entity in one-to-many
 'relationship.
 Dim canBeReferencedRequest As CanBeReferencedRequest =
  New CanBeReferencedRequest With {.EntityName = referencedEntity}

 Dim canBeReferencedResponse As CanBeReferencedResponse =
  CType(_serviceProxy.Execute(canBeReferencedRequest), CanBeReferencedResponse)

 If Not canBeReferencedResponse.CanBeReferenced Then
  Console.WriteLine("Entity {0} can't be the primary entity in this one-to-many relationship", referencedEntity)
 End If

 'Checks whether the specified entity can be the referencing entity in one-to-many
 'relationship.
 Dim canBereferencingRequest As CanBeReferencingRequest =
  New CanBeReferencingRequest With {.EntityName = referencingEntity}

 Dim canBeReferencingResponse As CanBeReferencingResponse =
  CType(_serviceProxy.Execute(canBereferencingRequest), CanBeReferencingResponse)

 If Not canBeReferencingResponse.CanBeReferencing Then
  Console.WriteLine("Entity {0} can't be the referencing entity in this one-to-many relationship", referencingEntity)
 End If


 If canBeReferencedResponse.CanBeReferenced = True AndAlso canBeReferencingResponse.CanBeReferencing = True Then
  Return True
 Else
  Return False
 End If
End Function

Criar um relacionamento N:N entre entidades

O exemplo usa o método de EligibleCreateManyToManyRelationship para verificar se as entidades Account e Campaign podem participar de um relacionamento N:N entre entidades e então cria o relacionamento entre entidades usando CreateManyToManyRequest.



bool accountEligibleParticipate =
    EligibleCreateManyToManyRelationship("account");
bool campaignEligibleParticipate =
    EligibleCreateManyToManyRelationship("campaign");

if (accountEligibleParticipate &amp;&amp; campaignEligibleParticipate)
{

    CreateManyToManyRequest createManyToManyRelationshipRequest =
        new CreateManyToManyRequest
    {
        IntersectEntitySchemaName = "new_accounts_campaigns",
        ManyToManyRelationship = new ManyToManyRelationshipMetadata
        {
            SchemaName = "new_accounts_campaigns",
            Entity1LogicalName = "account",
            Entity1AssociatedMenuConfiguration =
            new AssociatedMenuConfiguration
            {
                Behavior = AssociatedMenuBehavior.UseLabel,
                Group = AssociatedMenuGroup.Details,
                Label = new Label("Account", 1033),
                Order = 10000
            },
            Entity2LogicalName = "campaign",
            Entity2AssociatedMenuConfiguration =
            new AssociatedMenuConfiguration
            {
                Behavior = AssociatedMenuBehavior.UseLabel,
                Group = AssociatedMenuGroup.Details,
                Label = new Label("Campaign", 1033),
                Order = 10000
            }
        }
    };

    CreateManyToManyResponse createManytoManyRelationshipResponse =
        (CreateManyToManyResponse)_serviceProxy.Execute(
        createManyToManyRelationshipRequest);


    _manyToManyRelationshipId =
        createManytoManyRelationshipResponse.ManyToManyRelationshipId;
    _manyToManyRelationshipName =
        createManyToManyRelationshipRequest.ManyToManyRelationship.SchemaName;

    Console.WriteLine(
        "The many-to-many relationship has been created between {0} and {1}.",
        "account", "campaign");
}



Dim accountEligibleParticipate As Boolean = EligibleCreateManyToManyRelationship("account")
Dim campaignEligibleParticipate As Boolean = EligibleCreateManyToManyRelationship("campaign")

If accountEligibleParticipate AndAlso campaignEligibleParticipate Then

 Dim createManyToManyRelationshipRequest As CreateManyToManyRequest =
  New CreateManyToManyRequest With {
   .IntersectEntitySchemaName = "new_accounts_campaigns",
   .ManyToManyRelationship = New ManyToManyRelationshipMetadata With {
    .SchemaName = "new_accounts_campaigns",
    .Entity1LogicalName = "account",
    .Entity1AssociatedMenuConfiguration =
    New AssociatedMenuConfiguration With {
     .Behavior = AssociatedMenuBehavior.UseLabel,
     .Group = AssociatedMenuGroup.Details,
     .Label = New Label("Account", 1033),
     .Order = 10000
    },
    .Entity2LogicalName = "campaign",
    .Entity2AssociatedMenuConfiguration =
    New AssociatedMenuConfiguration With {
     .Behavior = AssociatedMenuBehavior.UseLabel,
     .Group = AssociatedMenuGroup.Details,
     .Label = New Label("Campaign", 1033),
     .Order = 10000
    }
   }
  }

 Dim createManytoManyRelationshipResponse As CreateManyToManyResponse =
  CType(_serviceProxy.Execute(createManyToManyRelationshipRequest), CreateManyToManyResponse)


 _manyToManyRelationshipId = createManytoManyRelationshipResponse.ManyToManyRelationshipId
 _manyToManyRelationshipName = createManyToManyRelationshipRequest.ManyToManyRelationship.SchemaName

 Console.WriteLine("The many-to-many relationship has been created between {0} and {1}.", "account", "campaign")
End If

EligibleCreateManyToManyRelationship

O exemplo a seguir cria um método de EligibleCreateManyToManyRelationship que usa CanManyToManyRequest para verificar se duas entidades podem participar de um relacionamento N:N entre entidades.


/// <summary>
/// Determines whether the entity can participate in a many-to-many relationship.
/// </summary>
/// <param name="entity">Entity</param>
/// <returns></returns>
public bool EligibleCreateManyToManyRelationship(string entity)
{
    CanManyToManyRequest canManyToManyRequest = new CanManyToManyRequest
    {
        EntityName = entity
    };

    CanManyToManyResponse canManyToManyResponse =
        (CanManyToManyResponse)_serviceProxy.Execute(canManyToManyRequest);

    if (!canManyToManyResponse.CanManyToMany)
    {
        Console.WriteLine(
            "Entity {0} can't participate in a many-to-many relationship.", 
            entity);
    }

    return canManyToManyResponse.CanManyToMany;
}


''' <summary>
''' Determines whether the entity can participate in a many-to-many relationship.
''' </summary>
''' <param name="entity">Entity</param>
''' <returns></returns>
Public Function EligibleCreateManyToManyRelationship(ByVal entity As String) As Boolean
 Dim canManyToManyRequest As CanManyToManyRequest =
  New CanManyToManyRequest With {.EntityName = entity}

 Dim canManyToManyResponse As CanManyToManyResponse =
  CType(_serviceProxy.Execute(canManyToManyRequest), CanManyToManyResponse)

 If Not canManyToManyResponse.CanManyToMany Then
  Console.WriteLine("Entity {0} can't participate in a many-to-many relationship.", entity)
 End If

 Return canManyToManyResponse.CanManyToMany
End Function

Recuperar um relacionamento entre entidade

O exemplo a seguir recupera os relacionamentos entre duas entidades criados anteriormente com RetrieveRelationshipRequest. O primeiro exemplo usa o MetadataId e o segundo usa o Name.



//You can use either the Name or the MetadataId of the relationship.

//Retrieve the One-to-many relationship using the MetadataId.
RetrieveRelationshipRequest retrieveOneToManyRequest =
    new RetrieveRelationshipRequest { MetadataId = _oneToManyRelationshipId };
RetrieveRelationshipResponse retrieveOneToManyResponse =
    (RetrieveRelationshipResponse)_serviceProxy.Execute(retrieveOneToManyRequest);

Console.WriteLine("Retrieved {0} One-to-many relationship by id", retrieveOneToManyResponse.RelationshipMetadata.SchemaName);

//Retrieve the Many-to-many relationship using the Name.
RetrieveRelationshipRequest retrieveManyToManyRequest =
    new RetrieveRelationshipRequest { Name = _manyToManyRelationshipName};
RetrieveRelationshipResponse retrieveManyToManyResponse =
    (RetrieveRelationshipResponse)_serviceProxy.Execute(retrieveManyToManyRequest);

Console.WriteLine("Retrieved {0} Many-to-Many relationship by Name", retrieveManyToManyResponse.RelationshipMetadata.MetadataId);



'You can use either the Name or the MetadataId of the relationship.

'Retrieve the One-to-many relationship using the MetadataId.
Dim retrieveOneToManyRequest As RetrieveRelationshipRequest =
 New RetrieveRelationshipRequest With {.MetadataId = _oneToManyRelationshipId}
Dim retrieveOneToManyResponse As RetrieveRelationshipResponse =
 CType(_serviceProxy.Execute(retrieveOneToManyRequest), RetrieveRelationshipResponse)

Console.WriteLine("Retrieved {0} One-to-many relationship by id",
                  retrieveOneToManyResponse.RelationshipMetadata.SchemaName)

'Retrieve the Many-to-many relationship using the Name.
Dim retrieveManyToManyRequest As RetrieveRelationshipRequest =
 New RetrieveRelationshipRequest With {
  .Name = _manyToManyRelationshipName
 }
Dim retrieveManyToManyResponse As RetrieveRelationshipResponse =
 CType(_serviceProxy.Execute(retrieveManyToManyRequest), RetrieveRelationshipResponse)

Console.WriteLine("Retrieved {0} Many-to-Many relationship by Name",
                  retrieveManyToManyResponse.RelationshipMetadata.MetadataId)

Confira Também

Personalizar metadados do relacionamento entre entidades
Mensagens de metadados do relacionamento da entidade
Exemplo: Criar e recuperar relacionamentos entre entidades

© 2017 Microsoft. Todos os direitos reservados. Direitos autorais