C# Entity.Contains方法代码示例

        public void TestContains()
        {
            Entity entity = new Entity();
            entity.Add(new ComponentA());
            Assert.AreEqual(true, entity.Contains<ComponentA>());

            entity.Remove<ComponentA>();
            Assert.AreEqual(false, entity.Contains<ComponentA>());
        }

 public void SetAutonumbers(Entity entity)
 {
     var autonumbers = GetActiveAutonumbersForType(entity.LogicalName);
     foreach (var autonumber in autonumbers)
     {
         if (autonumber.OverwriteIfPopulated
             || !entity.Contains(autonumber.AutonumberField))
             SetAutonumber(entity, autonumber);
     }
 }

 public static Entity ReplicateWithFields(Entity entity, IEnumerable<string> fieldsToSubmit)
 {
     var submissionEntity = new Entity(entity.LogicalName) {Id = entity.Id};
     if (fieldsToSubmit != null)
     {
         foreach (var field in fieldsToSubmit)
         {
             if (entity.Contains(field))
                 XrmEntity.SetField(submissionEntity, field, XrmEntity.GetField(entity, field));
         }
     }
     return submissionEntity;
 }

 public void Create(Entity entity, IEnumerable<string> fieldsToSubmit)
 {
     if (fieldsToSubmit != null && fieldsToSubmit.Any())
     {
         var submissionEntity = new Entity(entity.LogicalName) {Id = entity.Id};
         foreach (var field in fieldsToSubmit)
         {
             if (entity.Contains(field))
                 XrmEntity.SetField(submissionEntity, field, XrmEntity.GetField(entity, field));
         }
         Create(submissionEntity);
     }
 }

        public static string ToJSON(Entity entity, Formatting format, int indent)
        {
            StringBuilder sb = new StringBuilder();
            var space = format == Formatting.Indented ? " " : "";
            sb.Append(
                Sep(format, indent + 0) + "{" + space +
                Sep(format, indent + 1) + "\"entity\":" + space + "\"" + entity.LogicalName + "\"," +
                Sep(format, indent + 1) + "\"id\":" + space + "\"{" + entity.Id.ToString() + "}\"," +
                Sep(format, indent + 1) + "\"attributes\":" + space + "[");

            bool first = true;
            foreach (KeyValuePair<string, object> attribute in entity.Attributes)
            {
                Object value = attribute.Value;
                if (attribute.Key == entity.LogicalName + "id")
                {
                    continue;
                }
                if (attribute.Key.EndsWith("_base") && entity.Contains(attribute.Key.Substring(0, attribute.Key.Length - 5)))
                {
                    continue;
                }

                if (first)
                {
                    sb.Append(Sep(format, indent + 2) + "{");
                    first = false;
                }
                else
                    sb.Append("," + Sep(format, indent + 2) + "{");

                if (value is AliasedValue)
                {
                    if (!string.IsNullOrEmpty(((AliasedValue)value).AttributeLogicalName))
                    {
                        sb.Append(Sep(format, indent + 3) + "\"attributelogicalname\":" + space + "\"" + (((AliasedValue)value).AttributeLogicalName) + "\",");
                    }
                    if (!string.IsNullOrEmpty(((AliasedValue)value).EntityLogicalName))
                    {
                        sb.Append(Sep(format, indent + 3) + "\"entitylogicalname\":" + space + "\"" + (((AliasedValue)value).EntityLogicalName) + "\",");
                    }
                    value = (((AliasedValue)value).Value);
                }

                sb.Append(Sep(format, indent + 3) + "\"name\":" + space + "\"" + attribute.Key + "\",");
                sb.Append(Sep(format, indent + 3) + "\"type\":" + space + "\"" + LastClassName(value) + "\",");

                if (value is EntityReference)
                {
                    sb.Append(Sep(format, indent + 3) + "\"entity\":" + space + "\"" + ((EntityReference)value).LogicalName + "\",");
                    if (!string.IsNullOrEmpty(((EntityReference)value).Name))
                    {
                        sb.Append(Sep(format, indent + 3) + "\"namevalue\":" + space + "\"" + ((EntityReference)value).Name + "\",");
                    }
                    value = ((EntityReference)value).Id;

                }

                if (value != null)
                {
                    sb.Append(string.Format(Sep(format, indent + 3) + "\"value\":" + space + "\"{0}\"", AttributeToBaseType(value)));
                }

                sb.Append(Sep(format, indent + 2) + "}");
            }
            sb.Append(Sep(format, indent + 1) + "]");
            sb.Append(Sep(format, indent + 0) + "}");
            return sb.ToString();
        }

        private string GetEntityName(Entity e)
        {
            try
            {
                var entityName = string.Empty;

                if (e.Contains("privilegeobjecttypecode.objecttypecode"))
                {
                    var alias = e.GetAttributeValue<AliasedValue>("privilegeobjecttypecode.objecttypecode");

                    entityName = alias != null ? alias.Value as string : string.Empty;
                }

                if (!string.IsNullOrEmpty(entityName))
                {
                    var entityMetadata = _entityMetadata
                        .Where(m => m.LogicalName == entityName)
                        .FirstOrDefault();

                    if (entityMetadata != null &&
                        entityMetadata.DisplayName != null &&
                        entityMetadata.DisplayName.UserLocalizedLabel != null)
                    {
                        entityName = entityMetadata.DisplayName.UserLocalizedLabel.Label;
                    }
                }

                return entityName;
            }
            catch
            {
                MessageBox.Show("Error encountered in GetEntityName");
                return "ERROR";
            }
        }

        private string ReplaceParameters(string text, Entity Target, IOrganizationService Service)
        {
            if (String.IsNullOrWhiteSpace(text))
            {
                return "";
            }

            foreach (RuntimeParameter param in RuntimeParameter.GetParametersFromString(text))
            {
                if (!param.IsParentParameter())
                {
                    text = text.Replace(param.ParameterText, param.GetParameterValue(Target));
                }
                else
                {
                    if (Target.Contains(param.ParentLookupName))
                    {
                        var parentRecord = Service.Retrieve(Target.GetAttributeValue<EntityReference>(param.ParentLookupName).LogicalName, Target.GetAttributeValue<EntityReference>(param.ParentLookupName).Id, new ColumnSet(param.AttributeName));
                        text = text.Replace(param.ParameterText, param.GetParameterValue(parentRecord));
                    }
                    else  // Target record has no parent, so use default value
                    {
                        text = text.Replace(param.ParameterText, param.DefaultValue);
                    }
                }
            }

            return text;
        }

        public string GetParameterValue(Entity Target)
        {
            if (Target.Contains(AttributeName))
            {
                if (Target[AttributeName] is EntityReference)
                {
                    // Lookup condition is based on GUID
                    return Conditional.HasCondition ? Conditional.GetResult(Target.GetAttributeValue<EntityReference>(AttributeName).Id) : Target.GetAttributeValue<EntityReference>(AttributeName).Name;
                }
                else if (Target[AttributeName] is OptionSetValue)
                {
                    // Conditional OptionSetValue is based on the integer value
                    return Conditional.HasCondition ? Conditional.GetResult(Target.GetAttributeValue<OptionSetValue>(AttributeName).Value.ToString()) : Target.FormattedValues[AttributeName];
                }
                else if (Target[AttributeName] is bool)
                {
                    // Note: Boolean values ignore the match value, they just use the attribute value itself as the condition
                    return Conditional.HasCondition ? Conditional.GetResult(Target.GetAttributeValue<bool>(AttributeName)) : Target.FormattedValues[AttributeName];
                }
                else if (Target[AttributeName] is DateTime)
                {
                    // If there is a format AND a condition, apply formatting first, then evaluate condition as a string
                    // If there is a condition without any format, evaluate condition as DateTime
                    return String.IsNullOrEmpty(StringFormatter) ? Conditional.GetResult(Target.GetAttributeValue<DateTime>(AttributeName)) : Conditional.GetResult(Target.GetAttributeValue<DateTime>(AttributeName).ToString(StringFormatter));
                }
                else if (Target[AttributeName] is Money)
                {
                    return Conditional.HasCondition ? Conditional.GetResult(Target.GetAttributeValue<Money>(AttributeName).Value) : Target.GetAttributeValue<Money>(AttributeName).Value.ToString(StringFormatter);
                }
                else if (Target[AttributeName] is int)
                {
                    return Conditional.HasCondition ? Conditional.GetResult(Target.GetAttributeValue<double>(AttributeName)) : Target.GetAttributeValue<double>(AttributeName).ToString(StringFormatter);
                }
                else if (Target[AttributeName] is decimal)
                {
                    return Conditional.HasCondition ? Conditional.GetResult(Target.GetAttributeValue<decimal>(AttributeName)) : Target.GetAttributeValue<decimal>(AttributeName).ToString(StringFormatter);
                }
                else if (Target[AttributeName] is double)
                {
                    return Conditional.HasCondition ? Conditional.GetResult(Target.GetAttributeValue<double>(AttributeName)) : Target.GetAttributeValue<double>(AttributeName).ToString(StringFormatter);
                }
                else if (Target[AttributeName] is string)
                {
                    return Conditional.GetResult(Target[AttributeName].ToString());
                }
            }
            else if (AttributeName.Equals("rand"))
            {
                string length = "";
                string stringStyle = "upper";
                int stringLength = 5;  // Seems like reasonable default

                if (StringFormatter.Contains('?'))
                {
                    length = StringFormatter.Split('?')[0];
                    stringStyle = StringFormatter.Split('?')[1].ToLower();
                }
                else
                {
                    length = StringFormatter;
                }

                if (!Int32.TryParse(length, out stringLength))
                {
                    stringLength = 5;
                }

                string stringValues = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
                if (stringStyle == "mix")
                {
                    stringValues = stringValues + stringValues.ToLower();
                }
                else if (stringStyle == "lower")
                {
                    stringValues = stringValues.ToLower();
                }

                Random rnd = new Random();
                return String.Join("", Enumerable.Range(0, stringLength).Select(n => stringValues[rnd.Next(stringValues.Length)]));
            }

            return DefaultValue;
        }

 private void OpenView()
 {
     EnableControls(false);
     if (views == null || views.Count == 0)
     {
         LoadViews(OpenView);
         return;
     }
     var viewselector = new SelectViewDialog(this);
     viewselector.StartPosition = FormStartPosition.CenterParent;
     if (viewselector.ShowDialog() == DialogResult.OK)
     {
         view = viewselector.View;
         var fetchDoc = new XmlDocument();
         if (view.Contains("fetchxml"))
         {
             fetchDoc.LoadXml(view["fetchxml"].ToString());
             FetchUpdated(fetchDoc.OuterXml);
         }
     }
     EnableControls(true);
 }

        private string GetAdministrator(Entity e)
        {
            try
            {
                if (e.Contains("administratorid.domainname"))
                {
                    var er = e.GetAttributeValue<AliasedValue>("administratorid.domainname");

                    if (er != null && er.Value != null)
                    {
                        return er.Value as string;
                    }
                }

                return null;
            }
            catch
            {
                throw new Exception("Error encountered in GetAdministrator");
            }
        }

        /// <summary>
        ///     Return the entity record which is configured as the logical parent of this records autonumber
        /// </summary>
        public Entity GetParentEntity(Entity entity, XrmAutonumber autonumber, IEnumerable<string> fields)
        {
            //Need to split the links to the parent and create a query which returns the parent record via the links
            if (!entity.Contains(autonumber.FirstLinkLookup))
                return null;

            //Create a query which traverses through the keys and entities we defined in our autonumber links
            var query = new QueryExpression();
            query.ColumnSet = XrmService.CreateColumnSet(fields);
            LinkEntity carry = null;
            //for each foreign key entity pairing work from last to first
            for (var i = autonumber.LinksToParent.LinkToParents.Count(); i > 0; i--)
            {
                var thisLink = autonumber.LinksToParent.LinkToParents.ElementAt(i - 1);
                //if this is the last item we need to create it as the type of entity we are returning
                if (i == autonumber.LinksToParent.LinkToParents.Count())
                    query.EntityName = thisLink.LinkTarget;
                //otherwise if this is not the last item we need to add a link from the previous type to this type
                else
                {
                    var previousPair = autonumber.LinksToParent.LinkToParents.ElementAt(i);
                    if (carry == null)
                        carry = query.AddLink(thisLink.LinkTarget, previousPair.LinkFieldTarget, previousPair.LinkFieldSource);
                    else
                        carry = carry.AddLink(thisLink.LinkTarget, previousPair.LinkFieldTarget, previousPair.LinkFieldSource);
                }
                //if this is the first item we need to add a filter on the first id with the value in the lookup from the record we are creating the autonumber for
                if (i == 1)
                {
                    var thisLookupId = entity.GetLookupGuid(thisLink.LinkFieldSource);
                    if (!thisLookupId.HasValue)
                        return null;
                    if (autonumber.LinksToParent.LinkToParents.Count() != 1)
                        carry.LinkCriteria.AddCondition(carry.LinkToEntityName + "id", ConditionOperator.Equal, thisLookupId.Value);
                    else
                        query.Criteria.AddCondition(query.EntityName + "id", ConditionOperator.Equal, thisLookupId.Value);
                }
            }
            //Run the query and if a result return it
            var parent = XrmService.RetrieveMultiple(query);
            if (parent.Entities.Count > 0)
                return parent.Entities[0];
            return null;
        }

        public void When_A_Plugin_Is_Executed_Configurations_Can_Be_Used()
        {
            var fakedContext = new XrmFakedContext();

            var guid1 = Guid.NewGuid();
            var target = new Entity("contact") { Id = guid1 };

            var inputParams = new ParameterCollection { new KeyValuePair<string, object>("Target", target) };

            var unsecureConfiguration = "Unsecure Configuration";
            var secureConfiguration = "Secure Configuration";

            //Execute our plugin against the selected target
            var plugCtx = fakedContext.GetDefaultPluginContext();
            plugCtx.InputParameters = inputParams;

            fakedContext.ExecutePluginWithConfigurations<ConfigurationPlugin>(plugCtx, unsecureConfiguration, secureConfiguration);

            Assert.True(target.Contains("unsecure"));
            Assert.True(target.Contains("secure"));
            Assert.Equal((string)target["unsecure"], unsecureConfiguration);
            Assert.Equal((string)target["secure"], secureConfiguration);
        }

 private static void CreateRecordWithStatusIfAny(Entity entity, IOrganizationService service)
 {
     //if trying to set the state, save it, remove from the entity and save it for changing the status after the creation
     var savedStatusCode = -1;
     var savedStateCode = -1;
     if (entity.Contains("statecode") && entity.Contains("statuscode"))
     {
         savedStateCode = entity.Attributes["statecode"] is OptionSetValue ?
             entity.GetAttributeValue<OptionSetValue>("statecode").Value : -1;
         savedStatusCode = entity.Attributes["statuscode"] is OptionSetValue ?
             entity.GetAttributeValue<OptionSetValue>("statuscode").Value : -1;
         entity.Attributes.Remove("statecode");
         entity.Attributes.Remove("statuscode");
     }
     var entityId = service.Create(entity);
     if (savedStatusCode != -1 && savedStateCode != -1)
     {
         var changeStateToNewRecordRequest = new SetStateRequest
         {
             State = new OptionSetValue(savedStateCode),
             Status = new OptionSetValue(savedStatusCode),
             EntityMoniker = new EntityReference(entity.LogicalName, entityId)
         };
         service.Execute(changeStateToNewRecordRequest);
     }
 }

 // This currently only supports ONE attribute being updated, can be expanded to set/touch several attributes in the future
 private void UpdateAttributes(bool onlychange, string entity, List<string> attributes, object value, Entity record, object currentvalue)
 {
     if (!onlychange || !ValuesEqual(value, currentvalue))
     {
         var updaterecord = new Entity(entity);
         updaterecord.Id = record.Id;
         foreach (var attribute in attributes)
         {
             updaterecord.Attributes.Add(attribute, value);
         }
         Service.Update(updaterecord);
         if (record.Contains(attributes[0]))
         {
             record[attributes[0]] = value;
         }
         else
         {
             record.Attributes.Add(attributes[0], value);
         }
     }
 }

        private bool GetIsUnderDefaultBusinessUnit(Entity e)
        {
            try
            {
                if (e.Contains("businessunitid.parentbusinessunitid"))
                {
                    var er = e.GetAttributeValue<AliasedValue>("businessunitid.parentbusinessunitid");

                    if (er != null && er.Value != null)
                    {
                        return false;
                    }
                }

                return true;
            }
            catch
            {
                throw new Exception("Error encountered in GetIsUnderDefaultBusinessUnit");
            }
        }