public LspContractResolver( ImmutableArray <CompletionItemKind> completionItemKinds, ImmutableArray <CompletionItemTag> completionItemTags, ImmutableArray <SymbolKind> documentSymbolKinds, ImmutableArray <SymbolKind> workspaceSymbolKinds, ImmutableArray <SymbolTag> documentSymbolTags, ImmutableArray <SymbolTag> workspaceSymbolTags, ImmutableArray <DiagnosticTag> diagnosticTags, ImmutableArray <CodeActionKind> codeActionKinds, ImmutableArray <SemanticTokenType> semanticTokenType, ImmutableArray <SemanticTokenModifier> semanticTokenModifier ) { _completionItemKinds = completionItemKinds; _completionItemTags = completionItemTags; _documentSymbolKinds = documentSymbolKinds; _workspaceSymbolKinds = workspaceSymbolKinds; _documentSymbolTags = documentSymbolTags; _workspaceSymbolTags = workspaceSymbolTags; _diagnosticTags = diagnosticTags; _codeActionKinds = codeActionKinds; _semanticTokenType = semanticTokenType; _semanticTokenModifier = semanticTokenModifier; NamingStrategy = new CamelCaseNamingStrategy(true, false, true); }
protected override JsonObjectContract CreateObjectContract(Type objectType) { var contract = base.CreateObjectContract(objectType); var objectTypeInfo = objectType.GetTypeInfo(); if (TypeData <ExtensibleObject> .TypeInfo.IsAssignableFrom(objectTypeInfo)) { contract.ExtensionDataGetter = o => ((DirtyDictionary <string, object>)((ExtensibleObject)o).ExtensionData).GetDirtyItems().Select(p => new KeyValuePair <object, object>(p.Key, p.Value)); contract.ExtensionDataSetter = (o, k, v) => ((ExtensibleObject)o).ExtensionData[k] = v; if (TypeData <DirtyExtensibleObject> .TypeInfo.IsAssignableFrom(objectTypeInfo)) { var idPropertyName = DirtyExtensibleObject.GetIdPropertyName(objectTypeInfo); var backingFieldTypeInfo = GetBackingFieldInfo(objectType, idPropertyName)?.FieldInfo.FieldType.GetTypeInfo(); idPropertyName = CamelCaseNamingStrategy.GetPropertyName(idPropertyName, false); var idProperty = contract.Properties.GetClosestMatchProperty(idPropertyName); if (idProperty != null && (backingFieldTypeInfo == null || !backingFieldTypeInfo.IsGenericType || backingFieldTypeInfo.IsGenericTypeDefinition || backingFieldTypeInfo.GetGenericTypeDefinition() != TypeData.OpenNeverSerializeValueType)) { idProperty.ShouldSerialize = o => ((IIdentifiable)o).Id != null; } ReadEntityAttributes(objectTypeInfo, contract); } } return(contract); }
public JsonDeserializer(NamingConvention namingConvention = NamingConvention.CamelHump) { _jsonSettings = new JsonSerializerSettings(); NamingStrategy selectedNamingStrategy; switch (namingConvention) { case NamingConvention.CamelHump: selectedNamingStrategy = new CamelCaseNamingStrategy(true, false); break; case NamingConvention.SnakeCase: selectedNamingStrategy = new SnakeCaseNamingStrategy(true, false); break; default: selectedNamingStrategy = new DefaultNamingStrategy(); break; } _jsonSettings.ContractResolver = new PrivateSetterContractResolver { NamingStrategy = selectedNamingStrategy }; }
public static NewtonsoftJsonSerializer Create(JsonNamingStrategy namingStrategy) { Newtonsoft.Json.Serialization.NamingStrategy chosenStrategy; switch (namingStrategy) { case JsonNamingStrategy.Default: chosenStrategy = new DefaultNamingStrategy(); break; case JsonNamingStrategy.CamelCase: chosenStrategy = new CamelCaseNamingStrategy(); break; case JsonNamingStrategy.SnakeCase: chosenStrategy = new SnakeCaseNamingStrategy(); break; default: throw new ArgumentOutOfRangeException( $"Unhandled JsonNamingStrategy: {namingStrategy}"); } return(new NewtonsoftJsonSerializer(new Newtonsoft.Json.JsonSerializer() { NullValueHandling = NullValueHandling.Ignore, Formatting = Formatting.None, ContractResolver = new DefaultContractResolver() { NamingStrategy = chosenStrategy } })); }
public NonCircularContractResolver(Type contractType) { _contractType = contractType; NamingStrategy = new CamelCaseNamingStrategy { OverrideSpecifiedNames = false }; }
public void Given_FakeModel_When_ToOpenApiSchemas_Invoked_Then_It_Should_Return_Result() { var type = typeof(FakeModel); var subType = typeof(FakeSubModel); var enumType = typeof(FakeEnum); var strategy = new CamelCaseNamingStrategy(); var schemas = OpenApiSchemaExtensions.ToOpenApiSchemas(type, strategy); schemas.Count.Should().Be(3); var schema = schemas[type.Name]; var subSchema = schemas[subType.Name]; var enumSchema = schemas[enumType.Name]; schema.Type.Should().Be("object"); schema.Properties["fakeProperty"].Type.Should().BeEquivalentTo("string"); schema.Properties["nullableInt"].Type.Should().BeEquivalentTo("integer"); schema.Properties["nullableInt"].Nullable.Should().BeTrue(); schema.Properties["subProperty"].Reference.Id.Should().BeEquivalentTo(subType.Name); schema.Properties["enumProperty"].Reference.Id.Should().BeEquivalentTo(enumType.Name); subSchema.Type.Should().Be("object"); subSchema.Properties["fakeSubModelProperty"].Type.Should().BeEquivalentTo("integer"); enumSchema.Type.Should().Be("string"); enumSchema.Enum.Count.Should().Be(2); }
protected override JsonObjectContract CreateObjectContract(Type objectType) { var contract = base.CreateObjectContract(objectType); var objectTypeInfo = objectType.GetTypeInfo(); if (TypeData <ExtensibleObject> .TypeInfo.IsAssignableFrom(objectTypeInfo)) { contract.ExtensionDataGetter = o => ((DirtyDictionary <string, object>)((ExtensibleObject)o).ExtensionData).GetDirtyItems().Select(p => new KeyValuePair <object, object>(p.Key, p.Value)); contract.ExtensionDataSetter = (o, k, v) => ((ExtensibleObject)o).ExtensionData[k] = v; if (TypeData <DirtyExtensibleObject> .TypeInfo.IsAssignableFrom(objectTypeInfo)) { var idPropertyName = DirtyExtensibleObject.GetIdPropertyName(objectTypeInfo); var backingFieldTypeInfo = GetBackingFieldInfo(objectType, idPropertyName)?.FieldInfo.FieldType.GetTypeInfo(); idPropertyName = CamelCaseNamingStrategy.GetPropertyName(idPropertyName, false); var property = contract.Properties.GetClosestMatchProperty(idPropertyName); if (property != null && (backingFieldTypeInfo == null || !backingFieldTypeInfo.IsGenericType || backingFieldTypeInfo.IsGenericTypeDefinition || backingFieldTypeInfo.GetGenericTypeDefinition() != TypeData.OpenNeverSerializeValueType)) { property.ShouldSerialize = o => ((IIdentifiable)o).Id != null; } var entityAttribute = objectTypeInfo.GetCustomAttribute <EntityAttribute>(false); if (entityAttribute != null && !string.IsNullOrEmpty(entityAttribute.PropertiesToAlwaysSerialize)) { var propertiesToAlwaysSerialize = entityAttribute.PropertiesToAlwaysSerialize.Split(','); foreach (var propertyToAlwaysSerialize in propertiesToAlwaysSerialize) { property = contract.Properties.GetClosestMatchProperty(propertyToAlwaysSerialize); var valueProvider = property.ValueProvider; property.ShouldSerialize = o => valueProvider.GetValue(o) != null; } } } } return(contract); }
public StringEnumConverter(bool camelCaseText) { if (camelCaseText) { NamingStrategy = new CamelCaseNamingStrategy(); } }
//P07 public static string GetCategoriesByProductsCount(ProductShopContext context) { var categories = context .Categories .OrderByDescending(c => c.CategoryProducts.Count) .Select(c => new { Category = c.Name, ProductsCount = c.CategoryProducts.Count, AveragePrice = $"{c.CategoryProducts.Average(cp => cp.Product.Price):f2}", TotalRevenue = $"{c.CategoryProducts.Sum(cp => cp.Product.Price):f2}" }); DefaultContractResolver contractResolver = new DefaultContractResolver(); { var namingStrategy = new CamelCaseNamingStrategy(); } var jsonResult = JsonConvert.SerializeObject(categories, new JsonSerializerSettings() { ContractResolver = contractResolver, Formatting = Formatting.Indented }); return(jsonResult); }
//P06 public static string GetSoldProducts(ProductShopContext context) { var usersWithSales = context .Users .Where(u => u.ProductsSold.Count > 0 && u.ProductsSold.Any(ps => ps.Buyer != null)) .OrderBy(u => u.LastName) .ThenBy(u => u.FirstName) .Include(u => u.ProductsSold) .ToList(); var jsonExport = Mapper.Map <IEnumerable <User>, IEnumerable <UserWithSalesDto> >(usersWithSales); DefaultContractResolver contractResolver = new DefaultContractResolver(); { var namingStrategy = new CamelCaseNamingStrategy(); } var jsonResult = JsonConvert.SerializeObject(jsonExport, new JsonSerializerSettings() { ContractResolver = contractResolver, Formatting = Formatting.Indented }); return(jsonResult); }
public IEnumerable <FieldResponse> GetAllForForm(string id) { var result = new List <FieldResponse>(); foreach (var field in FieldProvider.GetAllFor(id)) { if (!field.AutoGenerate) { continue; } var control = ControlMatcher.GetFor(field.Type, field.UIHints); var embeddedFormId = FormProvider.GetAll().FirstOrDefault(f => f.Type == field.Type); if (control == null && embeddedFormId == null) { continue; } result.Add(new FieldResponse { Id = field.Id, Label = field.Label ?? Humanizer.Humanize(field.Id), CamelCaseId = CamelCaseNamingStrategy.GetPropertyName(field.Id, false), Control = control, EmbeddedFormId = embeddedFormId?.Id, IsSortable = field.IsSortable, Group = field.Group, }); } return(result); }
/// <summary> /// Create an instance of CosmosSerializationOptions /// with the default values for the Cosmos SDK /// </summary> public CosmosSerializationOptions() { this.IgnoreNullValues = false; this.Indented = false; this.PropertyNamingPolicy = CosmosPropertyNamingPolicy.Default; this.camelCaseNamingStrategy = new CamelCaseNamingStrategy(); }
public void Given_OpenApiResponseWithBodyAttribute_When_ToOpenApiMediaType_Invoked_Then_It_Should_Return_Result(Type bodyType, string expected, bool items, bool additionalProperties, string underlyingType) { var statusCode = HttpStatusCode.OK; var contentType = "application/json"; var attribute = new OpenApiResponseWithBodyAttribute(statusCode, contentType, bodyType); var namingStrategy = new CamelCaseNamingStrategy(); var result = OpenApiPayloadAttributeExtensions.ToOpenApiMediaType(attribute, namingStrategy); result.Schema.Type.Should().Be(expected); result.Schema.Deprecated.Should().BeFalse(); if (items) { result.Schema.Items.Should().NotBeNull(); result.Schema.Items.Type.Should().Be(underlyingType); } else { result.Schema.Items.Should().BeNull(); } if (additionalProperties) { result.Schema.AdditionalProperties.Should().NotBeNull(); result.Schema.AdditionalProperties.Type.Should().Be(underlyingType); } else { result.Schema.AdditionalProperties.Should().BeNull(); } }
public SwaggerContractResolver(JsonSerializerSettings applicationSerializerSettings) { NamingStrategy = new CamelCaseNamingStrategy { ProcessDictionaryKeys = false }; _applicationTypeConverter = new ApplicationTypeConverter(applicationSerializerSettings); }
public NoteMeContractResolver() { NamingStrategy = new CamelCaseNamingStrategy(); IgnoreSerializableAttribute = true; IgnoreSerializableInterface = true; SerializeCompilerGeneratedMembers = true; }
public ElasticApmContractResolver(IConfigurationReader configurationReader) { NamingStrategy = new CamelCaseNamingStrategy { ProcessDictionaryKeys = true, OverrideSpecifiedNames = true }; _headerDictionarySanitizerConverter = new HeaderDictionarySanitizerConverter(configurationReader); }
public void Resolve(string source, string excepted) { var strategy = new CamelCaseNamingStrategy(); var result = strategy.Resolve(source); Assert.Equal(excepted, result); }
public void Test() { CamelCaseNamingStrategy namingStrategy = new CamelCaseNamingStrategy( processDictionaryKeys: true, overrideSpecifiedNames: false ); TestClass c = new TestClass { Value = TestEnum.UpperCaseName }; string json = JsonConvert.SerializeObject( c, new JsonSerializerSettings { ContractResolver = new DefaultContractResolver { NamingStrategy = namingStrategy }, Converters = new[] { new StringEnumConverter { NamingStrategy = namingStrategy } } } ); Assert.AreEqual(@"{""value"":""UPPER_CASE_NAME""}", json); }
protected override IList <JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization) { var properties = base.CreateProperties(type, memberSerialization); if (UseCamelCase) { NamingStrategy = new CamelCaseNamingStrategy(true, true); } if (!IncludeUnderscoreProperties) { properties = properties.Where(each => !each.PropertyName.StartsWith("_")).ToList(); } if (IdPropertyAlwaysFirst && SortAlphabetically) { properties = properties.OrderByDescending(p => p.PropertyName.ToLower() == "id").ThenBy(each => each.PropertyName).ToList(); } else if (IdPropertyAlwaysFirst) { properties = properties.OrderByDescending(p => p.PropertyName.ToLower() == "id").ToList(); } else if (SortAlphabetically) { properties = properties.OrderByDescending(each => each.PropertyName).ToList(); } return(properties); }
public CustomContractWrapper() { if (_customJsonContract.UseCamelCaseNamingStrategy) { NamingStrategy = new CamelCaseNamingStrategy(); } }
public OneRosterContractResolver(Type type) { Type = type; NamingStrategy = new CamelCaseNamingStrategy { ProcessDictionaryKeys = true, OverrideSpecifiedNames = true }; }
public void Given_OpenApiResponseWithBodyAttribute_With_Example_When_ToOpenApiMediaType_Invoked_Then_It_Should_Return_Result(Type example, int count) { var statusCode = HttpStatusCode.OK; var contentType = "application/json"; var bodyType = typeof(object); var attribute = new OpenApiResponseWithBodyAttribute(statusCode, contentType, bodyType) { Example = example, }; var namingStrategy = new CamelCaseNamingStrategy(); var result = OpenApiPayloadAttributeExtensions.ToOpenApiMediaType(attribute, namingStrategy); result.Examples.Should().NotBeNull(); result.Examples.Should().HaveCount(count); if (count == 0) { return; } var instance = (dynamic)Activator.CreateInstance(example); var examples = (IDictionary <string, OpenApiExample>)instance.Build(namingStrategy).Examples; var first = examples.First().Value; (result.Example as OpenApiString).Value.Should().Be((first.Value as OpenApiString).Value); }
public void CamelNamingStrategyTest(string original, string expected) { CamelCaseNamingStrategy strategy = new CamelCaseNamingStrategy(); string modified = strategy.GetName(original); Assert.AreEqual(expected, modified); }
public InteractiveJsonContractResolver() { NamingStrategy = new CamelCaseNamingStrategy { ProcessDictionaryKeys = true, OverrideSpecifiedNames = true }; }
static JsonMessageSerializer() { ByteArrayConverter = new ByteArrayConverter(); ListJsonConverter = new ListJsonConverter(); CaseInsensitiveDictionaryJsonConverter = new CaseInsensitiveDictionaryJsonConverter(); InterfaceProxyConverter = new InterfaceProxyConverter(); MessageDataJsonConverter = new MessageDataJsonConverter(); StringDecimalConverter = new StringDecimalConverter(); var namingStrategy = new CamelCaseNamingStrategy(); DefaultContractResolver deserializerContractResolver = new JsonContractResolver( ByteArrayConverter, ListJsonConverter, CaseInsensitiveDictionaryJsonConverter, InterfaceProxyConverter, MessageDataJsonConverter, StringDecimalConverter) { NamingStrategy = namingStrategy }; DefaultContractResolver serializerContractResolver = new JsonContractResolver(ByteArrayConverter, MessageDataJsonConverter, StringDecimalConverter) { NamingStrategy = namingStrategy }; _encoding = new Lazy <Encoding>(() => new UTF8Encoding(false, true), LazyThreadSafetyMode.PublicationOnly); DeserializerSettings = new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore, DefaultValueHandling = DefaultValueHandling.Ignore, MissingMemberHandling = MissingMemberHandling.Ignore, ObjectCreationHandling = ObjectCreationHandling.Auto, ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor, ContractResolver = deserializerContractResolver, TypeNameHandling = TypeNameHandling.None, DateParseHandling = DateParseHandling.None, DateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind }; SerializerSettings = new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore, DefaultValueHandling = DefaultValueHandling.Ignore, MissingMemberHandling = MissingMemberHandling.Ignore, ObjectCreationHandling = ObjectCreationHandling.Auto, ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor, ContractResolver = serializerContractResolver, TypeNameHandling = TypeNameHandling.None, DateParseHandling = DateParseHandling.None, DateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind }; _deserializer = new Lazy <JsonSerializer>(() => JsonSerializer.Create(DeserializerSettings)); _serializer = new Lazy <JsonSerializer>(() => JsonSerializer.Create(SerializerSettings)); }
public NullToEmptyStringResolver() : base() { NamingStrategy = new CamelCaseNamingStrategy { ProcessDictionaryKeys = true, OverrideSpecifiedNames = true }; }
public ConiziDefaultResolver() : base() { NamingStrategy = new CamelCaseNamingStrategy { ProcessDictionaryKeys = true, OverrideSpecifiedNames = true }; }
public JsonFormatContractResolver(IDurableTypeSet durableTypes) { _durableTypes = durableTypes; NamingStrategy = new CamelCaseNamingStrategy { ProcessDictionaryKeys = false }; }
public ObjectPropertyResolver() : base() { NamingStrategy = new CamelCaseNamingStrategy { ProcessDictionaryKeys = true, OverrideSpecifiedNames = true }; }
public void CamelCaseNamingStrategyEquality() { var s1 = new CamelCaseNamingStrategy(); var s2 = new CamelCaseNamingStrategy(); Assert.IsTrue(s1.Equals(s2)); Assert.IsTrue(s1.GetHashCode() == s2.GetHashCode()); }