public string GetRead(string target, ITypeSymbol targetType, IValueSerializationGeneratorContext context)
{
if (_enums.IsResolvable(targetType))
{
var value = VariableHelper.GetName(targetType);
if (targetType.IsNullable())
{
return($@"
string {value};
{context.Read<string>(value)}
if (!string.IsNullOrEmpty({value}))
{{
{target} = {Enums.GetConverterName(targetType)}.FromString({value});
}}" );
}
else
{
return($@"
string {value};
{context.Read<string>(value)}
{target} = {Enums.GetConverterName(targetType)}.FromString({value});" );
}
}
return(null);
}
private string GetRead(string target, ITypeSymbol targetType, string formatValue, string stylesValue, IValueSerializationGeneratorContext context)
{
if (_supportedTypes.Contains(targetType.GetDeclarationGenericFullName()))
{
var value = VariableHelper.GetName <string>();
return($@"
string {value};
{context.Read<string>(value)}
{GetParseMethod(value, target, targetType, formatValue, stylesValue, context)}" );
}
else if (targetType.IsNullable(out targetType) &&
_supportedTypes.Contains(targetType.GetDeclarationGenericFullName()))
{
var value = VariableHelper.GetName <string>();
return($@"
string {value};
{context.Read<string>(value)}
if (!string.IsNullOrWhiteSpace({value}))
{{
{GetParseMethod(value, target, targetType, formatValue, stylesValue, context)}
}}" );
}
else
{
return(null);
}
}
public string GetWrite(string sourceName, string source, IPropertySymbol sourceProperty, IValueSerializationGeneratorContext context)
{
if (sourceProperty.FindAttributeByShortName("MicrosoftDateTimeFormatAttribute") != null)
{
var type = sourceProperty.Type;
if (_supportedTypes.Contains(type.GetDeclarationGenericFullName()))
{
return(context.Write <string>(sourceName, $"GeneratedSerializers.MicrosoftDateTimeHelper.ToString({source}.{sourceProperty.Name})"));
}
else if (type.IsNullable(out type) && _supportedTypes.Contains(type.GetDeclarationGenericFullName()))
{
var value = VariableHelper.GetName(sourceProperty.Type);
return($@"
var {value} = {source}.{sourceProperty.Name};
if ({value}.HasValue)
{{
{context.Write<string>(sourceName, $"GeneratedSerializers.MicrosoftDateTimeHelper.ToString({value}.Value)")}
}}" );
}
else
{
return($"\r\n #error {_nonSupportedTypeError}");
}
}
else
{
return(null);
}
}
private string GetWrite(string sourceName, string sourceCode, ITypeSymbol sourceType, string format, IValueSerializationGeneratorContext context)
{
var formatParameter = format.IsNullOrWhiteSpace()
? string.Empty
: $"\"{format}\", ";
var cultureParameter = sourceType.GetDeclarationGenericFullName().Contains("TimeSpan") && formatParameter.IsNullOrEmpty()
? string.Empty
: "System.Globalization.CultureInfo.InvariantCulture";
if (_supportedTypes.Contains(sourceType.GetDeclarationGenericFullName()))
{
return(context.Write <string>(sourceName, $"{sourceCode}.ToString({formatParameter} {cultureParameter})"));
}
else if (sourceType.IsNullable(out sourceType) && _supportedTypes.Contains(sourceType.GetDeclarationGenericFullName()))
{
var value = VariableHelper.GetName(sourceType);
return($@"
{sourceType.GetDeclarationGenericFullName()}? {value} = {sourceCode};
if ({value}.HasValue)
{{
{context.Write<string>(sourceName, $"{value}.Value.ToString({formatParameter} {cultureParameter})")}
}}" );
}
return(null);
}
public string GetRead(string target, IPropertySymbol targetProperty, IValueSerializationGeneratorContext context)
{
if (targetProperty.FindAttributeByShortName("MicrosoftDateTimeFormatAttribute") != null)
{
var value = VariableHelper.GetName("dateTime");
var targetName = $"{target}.{targetProperty.Name}";
var type = targetProperty.Type;
if (_supportedTypes.Contains(type.GetDeclarationGenericFullName()))
{
return($@"
string {value};
{context.Read<string>(value)}
{GetParseMethod(value, targetName, type)}" );
}
else if (type.IsNullable(out type) && _supportedTypes.Contains(type.GetDeclarationGenericFullName()))
{
return($@"
string {value};
{context.Read<string>(value)}
if (!string.IsNullOrWhiteSpace({value}))
{{
{GetParseMethod(value, targetName, type)}
}}" );
}
else
{
return($"\r\n #error {_nonSupportedTypeError}");
}
}
else
{
return(null);
}
}
public static string WriteDictionary(string sourceName, string sourceCode, ITypeSymbol itemType, IValueSerializationGeneratorContext context)
{
var itemTypeName = $"System.Collections.Generic.KeyValuePair<string, {itemType.GetDeclarationGenericFullName()}>";
var value = VariableHelper.GetName(itemType);
var enumerator = VariableHelper.GetName("enumerator");
if (sourceName.IsNullOrWhiteSpace())
{
return($@"
var {value} = {sourceCode};
if ({value} == null)
{{
{context.Write.Writer}.WriteNullValue();
}}
else
{{
{context.Write.Writer}.Write('{{');
var {enumerator} = {value}.GetEnumerator();
if ({enumerator}.MoveNext())
{{
{context.Write.Writer}.WritePropertyName((({itemTypeName}){enumerator}.Current).Key);
{context.GetWrite(null, $"(({itemTypeName}){enumerator}.Current).Value", itemType)};
}}
while ({enumerator}.MoveNext())
{{
{context.Write.Writer}.Write(',');
{context.Write.Writer}.WritePropertyName((({itemTypeName}){enumerator}.Current).Key);
{context.GetWrite(null, $"(({itemTypeName}){enumerator}.Current).Value", itemType)};
}}
{context.Write.Writer}.Write('}}');
}}" );
}
else
{
return($@"
var {value} = {sourceCode};
if ({value} != null)
{{
{context.Write.Object}.WritePropertyName(""{sourceName}"");
{context.Write.Writer}.Write('{{');
var {enumerator} = {value}.GetEnumerator();
if ({enumerator}.MoveNext())
{{
{context.Write.Writer}.WritePropertyName((({itemTypeName}){enumerator}.Current).Key);
{context.GetWrite(null, $"(({itemTypeName}){enumerator}.Current).Value", itemType)};
}}
while ({enumerator}.MoveNext())
{{
{context.Write.Writer}.Write(',');
{context.Write.Writer}.WritePropertyName((({itemTypeName}){enumerator}.Current).Key);
{context.GetWrite(null, $"(({itemTypeName}){enumerator}.Current).Value", itemType)};
}}
{context.Write.Writer}.Write('}}');
}}" );
}
}
public override string Read(string target, bool isNullable, IValueSerializationGeneratorContext context)
{
var guid = VariableHelper.GetName("guid");
return($@"
string {guid};
{context.Read<string>(guid)}
if (!string.IsNullOrWhiteSpace({guid}))
{{
{target} = Guid.Parse({guid});
}}" );
}
public override string Read(string target, bool isNullable, IValueSerializationGeneratorContext context)
{
var uri = VariableHelper.GetName("uri");
return($@"
string {uri};
{context.Read<string>(uri)}
if (!string.IsNullOrEmpty({uri}))
{{
{target} = new Uri({uri}, UriKind.RelativeOrAbsolute);
}}" );
}
private string GetParseMethod(string value, string target, ITypeSymbol targetType, string formatValue, string stylesValue, IValueSerializationGeneratorContext context)
{
var type = targetType.GetDeclarationGenericFullName();
string exact, format, styles;
if (formatValue.IsNullOrWhiteSpace())
{
exact = string.Empty;
format = string.Empty;
}
else
{
exact = "Exact";
format = $", \"{formatValue}\"";
}
if (type == _timeSpan)
{
// No DateTimeStyle for TimeSpan parsing
styles = string.Empty;
}
else if (stylesValue == null)
{
//https://github.com/dotnet/coreclr/blob/master/src/mscorlib/src/System/DateTime.cs
//as default value in .net Parse() method
styles = ", System.Globalization.DateTimeStyles.None";
}
else
{
styles = $", (System.Globalization.DateTimeStyles){stylesValue}";
}
if (_useTryParseOrDefault)
{
var result = VariableHelper.GetName(targetType);
return($@"
{type} {result};
{type}.TryParse{exact}({value} {format} {_invariantCulture} {styles}, out {result});
{target} = {result};" );
}
else
{
return($@"{target} = {type}.Parse{exact}({value} {format} {_invariantCulture} {styles});");
}
}
private string GetParseMethod(string value, string target, ITypeSymbol type)
{
if (_useTryParseOrDefault)
{
var result = VariableHelper.GetName(type);
return($@"
{type.GetDeclarationGenericFullName()} {result};
if (GeneratedSerializers.MicrosoftDateTimeHelper.TryParse{type.Name}({value}, out {result}))
{{
{target} = {result};
}}" );
}
else
{
return($"{target} = GeneratedSerializers.MicrosoftDateTimeHelper.Parse{type.Name}({value});");
}
}
public string GetWrite(string sourceName, string source, IPropertySymbol sourceProperty, IValueSerializationGeneratorContext context)
{
var serializerType = FindCustomSerializerType(sourceProperty);
if (serializerType != null)
{
var value = VariableHelper.GetName(sourceProperty.Type);
return($@"
var {value} = {source}.{sourceProperty.Name};
if ({value} != null)
{{
{context.Write.Object}.WritePropertyName(""{sourceName}"");
{StaticJsonCustomDeserializerGenerator.GetClassName(serializerType)}.Instance.Serialize({context.Write.Writer}, {value});
}}" );
}
return(null);
}
public string GetWrite(string sourceName, string sourceCode, ITypeSymbol sourceType, IValueSerializationGeneratorContext context)
{
if (_serializer.IsResolvable(sourceType))
{
var value = VariableHelper.GetName(sourceType);
string result;
if (sourceName.IsNullOrWhiteSpace())
{
// We are writing an item of a collection or something like that.
// We cannot ignore null values, instead we must write the "null" keyword.
result =
$@"var {value} = {sourceCode};
if ({value} == null)
{{
{context.Write.Writer}.WriteNullValue();
}}
else
{{
{_serializer.GetResolve(sourceType)}.Serialize({context.Write.Writer}, {value});
}}";
}
else
{
result =
$@"var {value} = {sourceCode};
if ({value} != null)
{{
{context.Write.Object}.WritePropertyName(""{sourceName}"");
{_serializer.GetResolve(sourceType)}.Serialize({context.Write.Writer}, {value});
}}";
}
return(result);
}
return(null);
}
public string ReadCollection(string target, ITypeSymbol collectionType, ITypeSymbol itemType, IValueSerializationGeneratorContext context)
{
var itemTypeName = itemType.GetDeclarationGenericFullName();
var implementation = _collectionResolver.FindImplementation(collectionType);
var collection = VariableHelper.GetName(implementation.Implementation);
var item = VariableHelper.GetName(itemType);
var collectionKind = VariableHelper.GetName("collectionType");
return($@"
var {collectionKind} = {context.Read.Reader}.OpenCollection({context.Read.FirstChar}, out {context.Read.OverChar});
if({collectionKind} == JsonReaderExtension.CollectionType.SingleValue)
{{
{implementation.CreateInstance(collection)}
var {item} = default({itemTypeName});
{context.UsingOverAsFirstChar(overHasValue: true).GetRead(item, itemType)}
{implementation.AddItemToInstance(collection, item)}
{implementation.InstanceToContract(collection, target)}
}}
else if({collectionKind} == JsonReaderExtension.CollectionType.Collection)
{{
// If collection type is Collection, then the overChar returned by OpenCollection is null.
{implementation.CreateInstance(collection)}
var {item} = default({itemTypeName});
while ({context.Read.Reader}.MoveToNextCollectionItem(ref {context.Read.OverChar}))
{{
{context.UsingOverAsFirstChar().GetRead(item, itemType)}
{implementation.AddItemToInstance(collection, item)}
}}
{implementation.InstanceToContract(collection, target)}
}}" );
}
public string ReadDictionary(string target, ITypeSymbol dictionaryType, ITypeSymbol itemType, IValueSerializationGeneratorContext context)
{
var implementation = _collectionResolver.FindImplementation(dictionaryType);
var dictionary = VariableHelper.GetName(implementation.Implementation);
var key = VariableHelper.GetName <string>();
// Note: the {context.Read.OverChar} is always null after the MoveToNextProperty so we don't need to propagate it as FirstChar
// This means that we don't need to specify the .UsingOverAsFirstChar() on the context for context.GetRead($"{dictionary}[{key}]", itemType).
return($@"
if ({context.Read.Reader}.OpenObject({context.Read.FirstChar}, out {context.Read.OverChar}))
{{
{implementation.CreateInstance(dictionary)}
var {key} = default(string);
while ({context.Read.Reader}.MoveToNextProperty(ref {context.Read.OverChar}, ref {key}, toUpper: false))
{{
{context.IgnoringCurrentFirstChar().GetRead($"{dictionary}[{key}]", itemType)}
}}
{implementation.InstanceToContract(dictionary, target)}
}}" );
}
public string GetWrite(string sourceName, string sourceCode, ITypeSymbol sourceType, IValueSerializationGeneratorContext context)
{
string mappedType;
if (sourceName.HasValueTrimmed())
{
// We are writing a property value, if the source is null, we can just ignore the whole property.
if (_stringType.Equals(sourceType.GetDeclarationGenericFullName(), StringComparison.OrdinalIgnoreCase))
{
var value = VariableHelper.GetName(sourceType);
return($@"
var {value} = {sourceCode};
if ({value} != null)
{{
{context.Write.Object}.WritePropertyName(""{sourceName}"");
{context.Write.Writer}.WriteStringValue({value});
}}" );
}
else if (_supportedTypes.TryGetValue(sourceType.GetDeclarationGenericFullName(), out mappedType))
{
return($@"
{context.Write.Object}.WritePropertyName(""{sourceName}"");
{context.Write.Writer}.Write(({mappedType}){sourceCode});" );
}
else if (sourceType.IsNullable(out sourceType) && _supportedTypes.TryGetValue(sourceType.GetDeclarationGenericFullName(), out mappedType))
{
var value = VariableHelper.GetName(sourceType);
return($@"
var {value} = {sourceCode};
if ({value}.HasValue)
{{
{context.Write.Object}.WritePropertyName(""{sourceName}"");
{context.Write.Writer}.Write(({mappedType}){value}.Value);
}}" );
}
}
else
{
// We are writing an item of a collection or something like that.
// We cannot ignore null values, instead we must write the "null" keyword.
if (_stringType.Equals(sourceType.GetDeclarationGenericFullName(), StringComparison.OrdinalIgnoreCase))
{
// WriteStringValue handles the "null" itself.
return($@"{context.Write.Writer}.WriteStringValue({sourceCode});");
}
else if (_supportedTypes.TryGetValue(sourceType.GetDeclarationGenericFullName(), out mappedType))
{
return($@"{context.Write.Writer}.Write(({mappedType}){sourceCode});");
}
else if (sourceType.IsNullable(out sourceType) && _supportedTypes.TryGetValue(sourceType.GetDeclarationGenericFullName(), out mappedType))
{
var value = VariableHelper.GetName(sourceType);
return($@"
var {value} = {sourceCode};
if ({value}.HasValue)
{{
{context.Write.Writer}.Write(({mappedType}){value}.Value);
}}
else
{{
{context.Write.Writer}.WriteNullValue();
}}" );
}
}
return(null);
}
