private static async Task <System.Reflection.TypeInfo> RunSourceGeneratorAsync(
string typeName,
string testFile,
NullableContextOptions nullableContext = NullableContextOptions.Enable,
[CallerMemberName] string caller = null
)
{
var serializer = new SerializerGenerator();
var(producedCompilation, diagnostics) = await SourceGeneratorTestHelper.RunSourceGeneratorAsync(testFile, serializer, nullableContext, caller);
Assert.Empty(diagnostics);
var outputFile = Path.GetTempFileName();
var res = producedCompilation.Emit(outputFile);
Assert.Empty(res.Diagnostics);
Assert.True(res.Success);
var asm = Assembly.LoadFile(outputFile);
var ret = Assert.Single(asm.GetTypes().Where(t => t.FullName == typeName));
return(ret.GetTypeInfo());
}
/// <summary>
/// Creates a new Producer instance.
/// </summary>
/// <param name="config">
/// A collection of librdkafka configuration parameters
/// (refer to https://github.com/edenhill/librdkafka/blob/master/CONFIGURATION.md)
/// and parameters specific to this client (refer to:
/// <see cref="Confluent.Kafka.ConfigPropertyNames" />).
/// At a minimum, 'bootstrap.servers' must be specified.
/// </param>
/// <param name="keySerializerGenerator">
/// A delegate to use to create a delegate for serializing keys.
/// </param>
/// <param name="valueSerializerGenerator">
/// A delegate to use to create a delegate for serialize values.
/// </param>
public Producer(
IEnumerable <KeyValuePair <string, string> > config,
SerializerGenerator <TKey> keySerializerGenerator,
SerializerGenerator <TValue> valueSerializerGenerator)
{
this.ownedClient = new Producer(config);
this.handle = ownedClient.Handle;
this.producer = ownedClient;
setAndValidateSerializers(
keySerializerGenerator == null ? null: keySerializerGenerator(true),
valueSerializerGenerator == null ? null : valueSerializerGenerator(false));
}
/// <summary>
/// Generates the serializers using specified assembly file.
/// </summary>
/// <param name="sourceAssembly">The source assembly.</param>
/// <param name="includingPattern">The including regex pattern. Omitting indicates all public concrete types are included.</param>
/// <param name="excludingPattern">The excluding regex pattern. Omitting indicates all public concrete types are included.</param>
/// <returns>File pathes to the generated source codes.</returns>
/// <remarks>
/// Specifying both of <paramref name="includingPattern"/> and <paramref name="excludingPattern"/> indicates AND condition.
/// </remarks>
public IEnumerable <string> GenerateSerializers(
Assembly sourceAssembly,
string includingPattern,
string excludingPattern,
bool admitNonPublicTypes
)
{
if (sourceAssembly == null)
{
throw new ArgumentNullException("sourceAssembly");
}
if (!String.IsNullOrEmpty(includingPattern))
{
includingPattern = includingPattern.Trim();
}
if (!String.IsNullOrEmpty(excludingPattern))
{
excludingPattern = excludingPattern.Trim();
}
var includingRegex =
String.IsNullOrEmpty(includingPattern)
? null
: new Regex(includingPattern, RegexOptions.Compiled | RegexOptions.ExplicitCapture);
var excludingRegex =
String.IsNullOrEmpty(excludingPattern)
? null
: new Regex(excludingPattern, RegexOptions.Compiled | RegexOptions.ExplicitCapture);
return
(SerializerGenerator.GenerateCode(
this._configuration,
sourceAssembly.GetTypes()
.Where(
type =>
(admitNonPublicTypes || type.IsPublic) &&
!type.IsAbstract &&
!type.IsInterface &&
(includingRegex == null || includingRegex.IsMatch(type.FullName)) &&
(excludingRegex == null || !excludingRegex.IsMatch(type.FullName))
).ToArray()
));
}
/// <summary>
/// Creates a new Producer instance
/// </summary>
/// <param name="handle">
/// A librdkafka handle to use for Kafka cluster communication.
/// </param>
/// <param name="keySerializerGenerator">
/// A delegate to use to create a delegate for serializing keys.
/// </param>
/// <param name="valueSerializerGenerator">
/// A delegate to use to create a delegate for serialize values.
/// </param>
public Producer(
Handle handle,
SerializerGenerator <TKey> keySerializerGenerator,
SerializerGenerator <TValue> valueSerializerGenerator)
{
if (!(handle.Owner is Producer))
{
throw new ArgumentException("Handle must be owned by another Producer instance");
}
this.ownedClient = null;
this.handle = handle;
this.producer = (Producer)handle.Owner;
setAndValidateSerializers(
keySerializerGenerator == null ? null : keySerializerGenerator(true),
valueSerializerGenerator == null ? null : valueSerializerGenerator(false));
}
public async Task <ActionResult <PersonalTrainers> > PostPersonalTrainers(CreatePersonalTrainer input)
{
try
{
var converter = new SerializerGenerator();
var output = new PersonalTrainers();
var result = converter.SerializeObject(ref input, ref output);
_context.PersonalTrainers.Add(result);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetPersonalTrainers", new { id = result.Id }));
}
catch (Exception ex)
{
throw ex.InnerException;
}
}
static void GenerateMsgPackSerializers()
{
var settings = new SerializerCodeGenerationConfiguration
{
OutputDirectory = Path.GetTempPath(),
SerializationMethod = SerializationMethod.Array,
Namespace = "Sandbox.Shared.GeneratedSerializers",
IsRecursive = true,
PreferReflectionBasedSerializer = false,
WithNullableSerializers = true,
EnumSerializationMethod = EnumSerializationMethod.ByName
};
var result = SerializerGenerator.GenerateSerializerSourceCodes(settings, typeof(Person));
foreach (var item in result)
{
Console.WriteLine(item.FilePath);
}
}
public void Generate()
{
var applicationLibraryAssembly = typeof(ProtocolMessage).Assembly;
SerializerGenerator.GenerateCode(
new SerializerCodeGenerationConfiguration
{
Namespace = "IO.Ably.CustomSerialisers",
OutputDirectory = "../../../IO.Ably/CustomSerialisers/GeneratedSerializers",
EnumSerializationMethod = EnumSerializationMethod.ByName, // You can tweak it to use ByUnderlyingValue as you like.
IsRecursive = true, // Set depenendent serializers are also generated.
PreferReflectionBasedSerializer = false, // Set true if you want to use reflection based collection serializer, false if you want to get generated collection serializers.
SerializationMethod = SerializationMethod.Map // You tweak it to generate 'map' based serializers.
},
applicationLibraryAssembly.GetTypes().Where(type =>
type == typeof(TokenRequest)
//type == typeof(Message) || type == typeof(ProtocolMessage) || type == typeof(PresenceMessage) ||
//type == typeof(PaginatedResult<Stats>) || type == typeof(TokenDetails) || type == typeof(Stats)
///* ...you can filter types to be serialized by their namespace, custom attributes, etc... */
)
);
}
