public void TypeDiscoveryWithRenamedAttribute()
{
// Compile the referenced assembly first.
Compilation referencedCompilation = CompilationHelper.CreateReferencedLocationCompilation();
// Emit the image of the referenced assembly.
byte[] referencedImage = CompilationHelper.CreateAssemblyImage(referencedCompilation);
MetadataReference[] additionalReferences = { MetadataReference.CreateFromImage(referencedImage) };
string source = @"
using System.Text.Json.Serialization;
using ReferencedAssembly;
using @JsonSerializable = System.Runtime.Serialization.CollectionDataContractAttribute ;
using AliasedAttribute = System.Text.Json.Serialization.JsonSerializableAttribute;
namespace HelloWorld
{
[AliasedAttribute(typeof(HelloWorld.MyType))]
[AliasedAttribute(typeof(ReferencedAssembly.Location))]
[@JsonSerializable]
internal partial class JsonContext : JsonSerializerContext
{
}
public class MyType
{
public int PublicPropertyInt { get; set; }
public string PublicPropertyString { get; set; }
private int PrivatePropertyInt { get; set; }
private string PrivatePropertyString { get; set; }
public double PublicDouble;
public char PublicChar;
private double PrivateDouble;
private char PrivateChar;
public void MyMethod() { }
public void MySecondMethod() { }
public void UsePrivates()
{
PrivateDouble = 0;
PrivateChar = ' ';
double d = PrivateDouble;
char c = PrivateChar;
}
}
}";
Compilation compilation = CompilationHelper.CreateCompilation(source, additionalReferences);
JsonSourceGenerator generator = new JsonSourceGenerator();
Compilation newCompilation = CompilationHelper.RunGenerators(compilation, out var generatorDiags, generator);
// Make sure compilation was successful.
CheckCompilationDiagnosticsErrors(generatorDiags);
CheckCompilationDiagnosticsErrors(newCompilation.GetDiagnostics());
Dictionary <string, Type> types = generator.GetSerializableTypes();
// Check base functionality of found types.
Assert.Equal(2, types.Count);
// Check for MyType.
Type myType = types["HelloWorld.MyType"];
Assert.Equal("HelloWorld.MyType", myType.FullName);
// Check for received fields, properties and methods for MyType.
string[] expectedFieldNamesMyType = { "PublicChar", "PublicDouble" };
string[] expectedPropertyNamesMyType = { "PublicPropertyInt", "PublicPropertyString" };
string[] expectedMethodNamesMyType = { "get_PrivatePropertyInt", "get_PrivatePropertyString", "get_PublicPropertyInt", "get_PublicPropertyString", "MyMethod", "MySecondMethod", "set_PrivatePropertyInt", "set_PrivatePropertyString", "set_PublicPropertyInt", "set_PublicPropertyString", "UsePrivates" };
CheckFieldsPropertiesMethods(myType, expectedFieldNamesMyType, expectedPropertyNamesMyType, expectedMethodNamesMyType);
// Check for NotMyType.
Type notMyType = types["ReferencedAssembly.Location"];
Assert.Equal("ReferencedAssembly.Location", notMyType.FullName);
// Check for received fields, properties and methods for NotMyType.
string[] expectedFieldNamesNotMyType = { };
string[] expectedPropertyNamesNotMyType = { "Address1", "Address2", "City", "Country", "Id", "Name", "PhoneNumber", "PostalCode", "State" };
string[] expectedMethodNamesNotMyType = { "get_Address1", "get_Address2", "get_City", "get_Country", "get_Id", "get_Name", "get_PhoneNumber", "get_PostalCode", "get_State",
"set_Address1", "set_Address2", "set_City", "set_Country", "set_Id", "set_Name", "set_PhoneNumber", "set_PostalCode", "set_State" };
CheckFieldsPropertiesMethods(notMyType, expectedFieldNamesNotMyType, expectedPropertyNamesNotMyType, expectedMethodNamesNotMyType);
}
public void CanGetAttributes()
{
string source = @"
using System;
using System.Text.Json.Serialization;
namespace HelloWorld
{
[JsonSerializable(typeof(HelloWorld.MyType))]
internal partial class JsonContext : JsonSerializerContext
{
}
public class MyType
{
[JsonInclude]
public double PublicDouble;
[JsonPropertyName(""PPublicDouble"")]
public char PublicChar;
[JsonIgnore]
private double PrivateDouble;
private char PrivateChar;
public MyType() {{ }}
[JsonConstructor]
public MyType(double d) {{ PrivateDouble = d; }}
[JsonPropertyName(""TestName"")]
public int PublicPropertyInt { get; set; }
[JsonExtensionData]
public string PublicPropertyString { get; set; }
[JsonIgnore]
private int PrivatePropertyInt { get; set; }
private string PrivatePropertyString { get; set; }
[Obsolete(""Testing"", true)]
public void MyMethod() { }
public void MySecondMethod() { }
}
}";
Compilation compilation = CompilationHelper.CreateCompilation(source);
JsonSourceGenerator generator = new JsonSourceGenerator();
Compilation outCompilation = CompilationHelper.RunGenerators(compilation, out ImmutableArray <Diagnostic> generatorDiags, generator);
// Check base functionality of found types.
Dictionary <string, Type> types = generator.GetSerializableTypes();
Assert.Equal(1, types.Count);
Type foundType = types.First().Value;
Assert.Equal("HelloWorld.MyType", foundType.FullName);
// Check for ConstructorInfoWrapper attribute usage.
(string, string[])[] receivedCtorsWithAttributeNames = foundType.GetConstructors().Select(ctor => (ctor.DeclaringType.FullName, ctor.GetCustomAttributesData().Cast <CustomAttributeData>().Select(attributeData => attributeData.AttributeType.Name).ToArray())).ToArray();
public void TypeDiscoveryPrimitivePOCO()
{
string source = @"
using System.Text.Json.Serialization;
namespace HelloWorld
{
[JsonSerializable(typeof(HelloWorld.MyType))]
internal partial class JsonContext : JsonSerializerContext
{
}
public class MyType
{
public int PublicPropertyInt { get; set; }
public string PublicPropertyString { get; set; }
private int PrivatePropertyInt { get; set; }
private string PrivatePropertyString { get; set; }
public double PublicDouble;
public char PublicChar;
private double PrivateDouble;
private char PrivateChar;
public void MyMethod() { }
public void MySecondMethod() { }
public void UsePrivates()
{
PrivateDouble = 0;
PrivateChar = ' ';
double d = PrivateDouble;
char c = PrivateChar;
}
}
}";
Compilation compilation = CompilationHelper.CreateCompilation(source);
JsonSourceGenerator generator = new JsonSourceGenerator();
Compilation newCompilation = CompilationHelper.RunGenerators(compilation, out ImmutableArray <Diagnostic> generatorDiags, generator);
// Make sure compilation was successful.
CheckCompilationDiagnosticsErrors(generatorDiags);
CheckCompilationDiagnosticsErrors(newCompilation.GetDiagnostics());
Dictionary <string, Type> types = generator.GetSerializableTypes();
// Check base functionality of found types.
Assert.Equal(1, types.Count);
Type myType = types["HelloWorld.MyType"];
Assert.Equal("HelloWorld.MyType", myType.FullName);
// Check for received fields, properties and methods in created type.
string[] expectedPropertyNames = { "PublicPropertyInt", "PublicPropertyString", };
string[] expectedFieldNames = { "PublicChar", "PublicDouble" };
string[] expectedMethodNames = { "get_PrivatePropertyInt", "get_PrivatePropertyString", "get_PublicPropertyInt", "get_PublicPropertyString", "MyMethod", "MySecondMethod", "set_PrivatePropertyInt", "set_PrivatePropertyString", "set_PublicPropertyInt", "set_PublicPropertyString", "UsePrivates" };
CheckFieldsPropertiesMethods(myType, expectedFieldNames, expectedPropertyNames, expectedMethodNames);
}
public void MetadataLoadFilePathHandle()
{
// Create a MetadataReference from new code.
string referencedSource = @"
namespace ReferencedAssembly
{
public class ReferencedType
{
public int ReferencedPublicInt;
public double ReferencedPublicDouble;
}
}";
// Compile the referenced assembly first.
Compilation referencedCompilation = CompilationHelper.CreateCompilation(referencedSource);
// Emit the image of the referenced assembly.
byte[] referencedImage;
using (MemoryStream ms = new MemoryStream())
{
var emitResult = referencedCompilation.Emit(ms);
if (!emitResult.Success)
{
throw new InvalidOperationException();
}
referencedImage = ms.ToArray();
}
string source = @"
using System.Text.Json.Serialization;
using ReferencedAssembly;
namespace HelloWorld
{
[JsonSerializable(typeof(HelloWorld.MyType))]
[JsonSerializable(typeof(ReferencedAssembly.ReferencedType))]
internal partial class JsonContext : JsonSerializerContext
{
}
public class MyType
{
public void MyMethod() { }
public void MySecondMethod() { }
}
}";
MetadataReference[] additionalReferences = { MetadataReference.CreateFromImage(referencedImage) };
// Compilation using the referenced image should fail if out MetadataLoadContext does not handle.
Compilation compilation = CompilationHelper.CreateCompilation(source, additionalReferences);
JsonSourceGenerator generator = new JsonSourceGenerator();
Compilation newCompilation = CompilationHelper.RunGenerators(compilation, out ImmutableArray <Diagnostic> generatorDiags, generator);
// Make sure compilation was successful.
Assert.Empty(generatorDiags.Where(diag => diag.Severity.Equals(DiagnosticSeverity.Error)));
Assert.Empty(newCompilation.GetDiagnostics().Where(diag => diag.Severity.Equals(DiagnosticSeverity.Error)));
// Should find both types since compilation above was successful.
Assert.Equal(2, generator.GetSerializableTypes().Count);
}