Styjun

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

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 

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

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.

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)."