C# JsonPropertyCollection类代码示例

        /// <summary>
        /// Initializes a new instance of the <see cref="JsonDynamicContract"/> class.
        /// </summary>
        /// <param name="underlyingType">The underlying type for the contract.</param>
        public JsonDynamicContract(Type underlyingType)
            : base(underlyingType)
        {
            ContractType = JsonContractType.Dynamic;

            Properties = new JsonPropertyCollection(UnderlyingType);
        }

    /// <summary>
    /// Initializes a new instance of the <see cref="JsonObjectContract"/> class.
    /// </summary>
    /// <param name="underlyingType">The underlying type for the contract.</param>
    public JsonObjectContract(Type underlyingType)
      : base(underlyingType)
    {
      ContractType = JsonContractType.Object;

      Properties = new JsonPropertyCollection(UnderlyingType);
      ConstructorParameters = new JsonPropertyCollection(UnderlyingType);
    }

        protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
        {
            List<MemberInfo> members = this.GetSerializableMembers(type);
            if (members == null)
            {
                throw new JsonSerializationException("Null collection of seralizable members returned.");
            }

            JsonPropertyCollection properties = new JsonPropertyCollection(type);

            foreach (MemberInfo member in members)
            {
                JsonProperty property = this.CreateProperty(member, memberSerialization);

                if (property != null)
                {
                    properties.AddProperty(property);
                }
            }

            // IList<JsonProperty> orderedProperties = properties.OrderBy(p => p.Order ?? -1).ToList();
            return properties;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="JsonObjectContract"/> class.
 /// </summary>
 /// <param name="underlyingType">The underlying type for the contract.</param>
 public JsonObjectContract(Type underlyingType)
   : base(underlyingType)
 {
   Properties = new JsonPropertyCollection(UnderlyingType);
 }

        /// <summary>
        /// Creates properties for the given <see cref="JsonObjectContract"/>.
        /// </summary>
        /// <param name="contract">The contract to create properties for.</param>
        /// <returns>Properties for the given <see cref="JsonObjectContract"/>.</returns>
        protected virtual IList<JsonProperty> CreateProperties(JsonObjectContract contract)
        {
            List<MemberInfo> members = GetSerializableMembers(contract.UnderlyingType);
              if (members == null)
            throw new JsonSerializationException("Null collection of seralizable members returned.");

              JsonPropertyCollection properties = new JsonPropertyCollection(contract);

              foreach (MemberInfo member in members)
              {
            JsonProperty property = CreateProperty(contract, member);

            if (property != null)
              properties.AddProperty(property);
              }

              return properties;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="JsonObjectContract"/> class.
 /// </summary>
 /// <param name="underlyingType">The underlying type for the contract.</param>
 public JsonObjectContract(Type underlyingType)
     : base(underlyingType)
 {
     Properties = new JsonPropertyCollection();
       CreatedType = underlyingType;
 }

        protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
        {
            var objectType = type.GetBaseObjectType() ?? type;

            if (!_propertyies.ContainsKey(objectType))
            {
                var props = base.CreateProperties(objectType, memberSerialization);

                if (!objectType.IsBaseObject())
                {
                    _propertyies.Add(objectType, props);

                    return _propertyies[objectType];
                }

                if (_config.TypeEntity == objectType)
                {
                    var resProps = new List<JsonProperty>();

                    foreach (var prop in props)
                    {
                        if (prop.PropertyType.IsBaseObject() || prop.PropertyType.IsBaseCollection())
                        {
                            if (_editors.All(x => x.PropertyName != prop.PropertyName)) continue;
                        }

                        resProps.Add(prop);
                    }

                    _propertyies.Add(objectType, resProps);
                }
                else
                {
                    var config = _uiFasade.GetViewModelConfig(objectType);

                    if (config == null) return props;

                    if (objectType.IsDefined(typeof(ComplexTypeAttribute), false)) return props;

                    var editor = _editors.FirstOrDefault(x => x.EditorType == objectType);

                    if (editor == null) return props;

                    if (editor.EditorTemplate == "EasyCollection")
                    {
                        var typeEasyCollection = editor.ViewModelConfig.TypeEntity;

                        if (!_propertyies.ContainsKey(typeEasyCollection))
                        {
                            var properties = new JsonPropertyCollection(typeEasyCollection);

                            properties.AddProperty(CreateProperty(typeEasyCollection.GetProperty("ID"),
                                memberSerialization));

                            if (editor.ViewModelConfig.LookupProperty != "ID")
                                properties.AddProperty(CreateProperty(
                                    typeEasyCollection.GetProperty(editor.ViewModelConfig.LookupProperty), memberSerialization));

                            _propertyies.Add(typeEasyCollection, properties);
                        }
                    }

                    if (editor.Relationship == Relationship.OneToMany) return props;

                    var sysColumns = _uiFasade.GetEditors(objectType)
                        .Where(
                            c =>
                                c.IsSystemPropery &&
                                (c.PropertyName != "RowVersion" && c.PropertyName != "Hidden" &&
                                 c.PropertyName != "SortOrder")).ToList();

                    props =
                        props.Where(
                            p =>
                                p.PropertyName == config.LookupProperty ||
                                sysColumns.Any(x => x.PropertyName == p.PropertyName && x.IsSystemPropery)).ToList();

                    _propertyies.Add(objectType, props);
                }
            }

            return _propertyies[objectType];
        }

 protected virtual IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
 {
   List<MemberInfo> serializableMembers = this.GetSerializableMembers(type);
   if (serializableMembers == null)
     throw new JsonSerializationException("Null collection of seralizable members returned.");
   JsonPropertyCollection propertyCollection = new JsonPropertyCollection(type);
   foreach (MemberInfo member in serializableMembers)
   {
     JsonProperty property = this.CreateProperty(member, memberSerialization);
     if (property != null)
       propertyCollection.AddProperty(property);
   }
   return (IList<JsonProperty>) Enumerable.ToList<JsonProperty>((IEnumerable<JsonProperty>) Enumerable.OrderBy<JsonProperty, int>((IEnumerable<JsonProperty>) propertyCollection, (Func<JsonProperty, int>) (p => p.Order ?? -1)));
 }

 protected virtual IList<JsonProperty> CreateConstructorParameters(ConstructorInfo constructor, JsonPropertyCollection memberProperties)
 {
   ParameterInfo[] parameters = constructor.GetParameters();
   JsonPropertyCollection propertyCollection = new JsonPropertyCollection(constructor.DeclaringType);
   foreach (ParameterInfo parameterInfo in parameters)
   {
     JsonProperty matchingMemberProperty = parameterInfo.Name != null ? memberProperties.GetClosestMatchProperty(parameterInfo.Name) : (JsonProperty) null;
     if (matchingMemberProperty != null && matchingMemberProperty.PropertyType != parameterInfo.ParameterType)
       matchingMemberProperty = (JsonProperty) null;
     JsonProperty constructorParameter = this.CreatePropertyFromConstructorParameter(matchingMemberProperty, parameterInfo);
     if (constructorParameter != null)
       propertyCollection.AddProperty(constructorParameter);
   }
   return (IList<JsonProperty>) propertyCollection;
 }

 protected override IList<JsonProperty> CreateProperties (Type type, MemberSerialization serialization)
 {
     var properties = new JsonPropertyCollection(type);
     foreach (JsonProperty property in GetSerializableMembers(type).Select(m => CreateProperty(m, serialization)).WhereNotNull())
         properties.AddProperty(property);
     return properties
         .OrderBy(p => p.Order ?? -1)
         .ThenBy(IsPropertyCollection)
         .ThenBy(GetPropertyTypeDepth)
         .ThenBy(p => p.PropertyName)
         .ToList();
 }

        protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
        {
            var serializableMembers = GetSerializableMembers(type).Cast<PropertyInfo>();
            if (serializableMembers == null)
                throw new JsonSerializationException("Null collection of seralizable members returned.");

            var typeDefinition = _ServerConfiguration.GetScimTypeDefinition(type);
            var propertyCollection = new JsonPropertyCollection(type);
            foreach (var member in serializableMembers)
            {
                var property = CreateProperty(member, memberSerialization);
                if (property != null)
                {
                    var state = _InstanceState;
                    var propertyNameTable = state.NameTable;
                    bool lockTaken = false;
                    try
                    {
                        Monitor.Enter(propertyNameTable, ref lockTaken);
                        property.PropertyName = state.NameTable.Add(property.PropertyName);

                        IScimTypeAttributeDefinition attributeDefinition;
                        if (typeDefinition != null && typeDefinition.AttributeDefinitions.TryGetValue(member, out attributeDefinition))
                        {
                            // Internal json.net deserialization logic will hit the ShouldDeserialize delegate before checking property.Writable
                            // Still, we'll set Writable to accurately reflect this
                            property.Writable = attributeDefinition.Mutability != Mutability.ReadOnly;  // deserializable?

                            // setting property.Readable will shortcut the ShouldSerialize delegate
                            // INTERNAL JSON.NET LOGIC
                            // if (!property.Ignored && property.Readable && ShouldSerialize(writer, property, value) && IsSpecified(writer, property, value))
                            property.Readable = attributeDefinition.Mutability != Mutability.WriteOnly; // serializable?

                            // Only attach a conditional deserialization delegate if the attribute is not ReadWrite.
                            if (attributeDefinition.Mutability != Mutability.ReadWrite)
                            {
                                property.ShouldDeserialize = o =>
                                {
                                    if (attributeDefinition.Mutability == Mutability.ReadOnly)
                                        return false;

                                    return true;
                                };
                            }

                            // Only attach a conditional serialization delegate if the attribute is not Always returned.
                            if (attributeDefinition.Returned != Returned.Always)
                            {
                                var existingShouldSerializeFunc = property.ShouldSerialize;
                                property.ShouldSerialize = o =>
                                {
                                    if (attributeDefinition.Mutability == Mutability.WriteOnly || attributeDefinition.Returned == Returned.Never)
                                        return false;

                                    var httpMethod = AmbientRequestService.HttpMethod;
                                    if (attributeDefinition.Returned == Returned.Default ||
                                        (attributeDefinition.Returned == Returned.Request && (httpMethod == HttpMethod.Post || httpMethod == _Patch || httpMethod == HttpMethod.Put)))
                                    {
                                        var queryOptions = AmbientRequestService.QueryOptions;
                                        if (queryOptions.Attributes.Any() && !queryOptions.Attributes.Contains(property.PropertyName))
                                            return false;

                                        if (queryOptions.ExcludedAttributes.Any() && queryOptions.ExcludedAttributes.Contains(property.PropertyName))
                                            return false;
                                    }

                                    if (existingShouldSerializeFunc != null)
                                        return existingShouldSerializeFunc(o);

                                    return true;
                                };
                            }
                        }
                    }
                    finally
                    {
                        if (lockTaken)
                            Monitor.Exit(propertyNameTable);
                    }

                    propertyCollection.AddProperty(property);
                }
            }

            return propertyCollection.OrderBy(p => p.Order ?? -1).ToList();
        }