CODEWITHSUNDEEP
c#.netvisual-studiodynamics-crm-2011dynamics-crm
Alex Gordon
Alex Gordon

Reputation: 60871

How to identify the type of entity?

If I have a GUID for a record, but I do not know whether it is an Account or a Contact, how can I retrieve this record and identify its type?

For example, I can retrieve a specified type like so:

        var serviceAppointment = organizationService.Retrieve(
            "serviceappointment",
            serviceActivityGuid,
            new ColumnSet(true));

However, if I do not know what type of record it is, how can I retrieve it and identify its type?

Something like this:

        var myEntity = organizationService.Retrieve(
            "????",
            myEntityGuid,
            new ColumnSet(true));

Upvotes: 0

Views: 1297

Answers (4)

Zeliax
Zeliax

Reputation: 5386

I know this is an old question, but I thought I would add something in case someone stumples upon this in the future with a problem similar to mine. In this case it might not be particularly the same as OP has requested.

I had to identify whether an entity was one or the other type, so I could use one method instead of having to write standalone methods for each entity. Here goes:

var reference = new EntityReference
{
    Id = Guid.NewGuid(),
    LogicalName = "account" //Or some other logical name - "contact" or so.
}

And by passing it into the following method the type can be identified.

public void IdentifyType(EntityReference reference)
{
    switch(reference.LogicalName)
    {
        case Account.EntityLogicalName:
            //Do something if it's an account.
            Console.WriteLine($"The entity is of type {nameof(Account.EntityLogicalName)}."
        case Contact.EntityLogicalName:
            //Do something if it's a contact.
            Console.WriteLine($"The entity is of type {nameof(Contact.EntityLogicalName)}."
        default:
            //Do something if neither of above returns true.
            Console.WriteLine($"The entity is not of type {nameof(Account.EntityLogicalName)} or {nameof(Contact.EntityLogicalName)}."
    }
}

Upvotes: 1

Filburt
Filburt

Reputation: 18081

If you only need to distinguish between with Account and Contact and want to make sure the record really still exists, you could also use their CustomerAddress, LEFT OUTER JOINing both, Account and Contact:

var query = new QueryExpression
{
    EntityName = "customeraddress",
    ColumnSet = new ColumnSet("customeraddressid"),
    TopCount = 1,
    Criteria = new FilterExpression
    {
        Conditions =
        {
            // limit to Address 1
            new ConditionExpression("addressnumber", ConditionOperator.Equal, 1),
            // filter by "anonymous" GUID
            new ConditionExpression("parentid", ConditionOperator.Equal, myEntityGuid),
        },
    },
    LinkEntities =
    {
        new LinkEntity
        {
            EntityAlias = "acc",
            Columns = new ColumnSet("name"),
            LinkFromEntityName = "customeraddress",
            LinkFromAttributeName = "parentid",
            LinkToAttributeName = "accountid",
            LinkToEntityName = "account",
            JoinOperator = JoinOperator.LeftOuter
        },
        new LinkEntity
        {
            EntityAlias = "con",
            Columns = new ColumnSet("fullname"),
            LinkFromEntityName = "customeraddress",
            LinkFromAttributeName = "parentid",
            LinkToAttributeName = "contactid",
            LinkToEntityName = "contact",
            JoinOperator = JoinOperator.LeftOuter
        },
    },
};

... will allow you to retrieve whichever, Account or Contact in one go:

var customer = service.RetrieveMultiple(query).Entities.FirstOrDefault();

... but require to access their fields through AliasedValues:

string customername = (customer.GetAttributeValue<AliasedValue>("acc.name") ?? customer.GetAttributeValue<AliasedValue>("con.fullname") ?? new AliasedValue("whatever", "whatever", null)).Value as string;

... which can make reading a lot of attributes a little messy.

Upvotes: 1

Daryl
Daryl

Reputation: 18895

If you reference the DLaB.Xrm from Nuget, you could write this like this:

bool isAccount = service.GetEntitiesById<Account>(customerId).Count == 1;

If you wanted to actually get the actual values, you could do this.

var customerId = System.Guid.NewGuid();
var entity = service.GetEntitiesById<Account>(customerId).FirstOrDefault() ??
             service.GetEntitiesById<Contact>(customerId).FirstOrDefault() as Entity;

if (entity != null)
{
    var account = entity as Account; // will be null if the Guid was for a contact
    var contact = entity as Contact; // will be null if the Guid was for an account
}

Upvotes: 2

Stefan William-Worrall
Stefan William-Worrall

Reputation: 713

You cannot search by the GUID alone. You need both the GUID and the entity logical name.

Whenever you retrieve a entity reference using code, c# or javascript, the object will include the entity logical name

Update to try to find an account with a given ID: 

Guid Id = // Your GUID
IOrganizationService serviceProxy = // Create your serivce proxy 
var accountQuery = new QueryExpression
                   {
                       EntityName = "account",
                       TopCount = 1,
                       Criteria =
                       { 
                           Conditions = 
                           { 
                               new ConditionExpression("accountid", ConditionOperator.Equal, Id) 
                           }
                       }
                    } 
var response = serviceProxy.RerieveMultiple(accountQuery);
if(null == response.Entities.FirstOrDefault())
{
    //No Account Record Found 
}

Upvotes: 1

Related Questions