Chiebot-Mirror
/
protobuf
mirror of https://github.com/protocolbuffers/protobuf.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

[C#] Fix trimming warning in JSON formatter enum handling (#14789)

Browse Source 
There is a new trimming/AOT warning in JSON formatter enum handling. I have fixed it by suppressing the value.
I also tested the solution with the .NET 8 SDK and suppressed some other warnings that came up (they're already handled).

It would be great to include this fix in a 25.x release.

Closes #14789

COPYBARA_INTEGRATE_REVIEW=https://github.com/protocolbuffers/protobuf/pull/14789 from JamesNK:jamesnk/enum-trimming-warning d64dda15f0
PiperOrigin-RevId: 592306588
pull/15106/head
James Newton-King 1 year ago committed by Copybara-Service
parent 1427a855b1
commit ec1fd2700e
3 changed files with 1162 additions and 1256 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 5
      csharp/src/Google.Protobuf/Google.Protobuf.csproj
  2. 1742
      csharp/src/Google.Protobuf/JsonFormatter.cs
  3. 671
      csharp/src/Google.Protobuf/Reflection/ReflectionUtil.cs

5
csharp/src/Google.Protobuf/Google.Protobuf.csproj
Unescape View File

@ -1,4 +1,4 @@
<Project Sdk="Microsoft.NET.Sdk"> <Project Sdk="Microsoft.NET.Sdk">
<!-- If you update this, update the .csproj in the Docker file as well --> <!-- If you update this, update the .csproj in the Docker file as well -->
<PropertyGroup> <PropertyGroup>
@ -23,6 +23,9 @@
<!-- Include PDB in the built .nupkg --> <!-- Include PDB in the built .nupkg -->
<AllowedOutputExtensionsInPackageBuildOutputFolder>$(AllowedOutputExtensionsInPackageBuildOutputFolder);.pdb</AllowedOutputExtensionsInPackageBuildOutputFolder> <AllowedOutputExtensionsInPackageBuildOutputFolder>$(AllowedOutputExtensionsInPackageBuildOutputFolder);.pdb</AllowedOutputExtensionsInPackageBuildOutputFolder>
<IsTrimmable>true</IsTrimmable> <IsTrimmable>true</IsTrimmable>
<!-- Disable warnings about AOT and trimming features on older targets, e.g. netstandard2.0.
For now, continue to apply these features to these targets because some packages don't have a target that supports them -->
<NoWarn>$(NoWarn);NETSDK1195;NETSDK1210</NoWarn>
</PropertyGroup> </PropertyGroup>
<PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' "> <PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' ">

1742
csharp/src/Google.Protobuf/JsonFormatter.cs
View File

File diff suppressed because it is too large Load Diff

671
csharp/src/Google.Protobuf/Reflection/ReflectionUtil.cs
Unescape View File

@ -13,378 +13,363 @@ using System.Reflection;
using System.Runtime.CompilerServices; using System.Runtime.CompilerServices;
using Google.Protobuf.Compatibility; using Google.Protobuf.Compatibility;
namespace Google.Protobuf.Reflection namespace Google.Protobuf.Reflection {
{ /// <summary>
/// The methods in this class are somewhat evil, and should not be tampered with lightly.
/// Basically they allow the creation of relatively weakly typed delegates from MethodInfos
/// which are more strongly typed. They do this by creating an appropriate strongly typed
/// delegate from the MethodInfo, and then calling that within an anonymous method.
/// Mind-bending stuff (at least to your humble narrator) but the resulting delegates are
/// very fast compared with calling Invoke later on.
/// </summary>
internal static class ReflectionUtil {
static ReflectionUtil() {
ForceInitialize<string>(); // Handles all reference types
ForceInitialize<int>();
ForceInitialize<long>();
ForceInitialize<uint>();
ForceInitialize<ulong>();
ForceInitialize<float>();
ForceInitialize<double>();
ForceInitialize<bool>();
ForceInitialize < int ? > ();
ForceInitialize < long ? > ();
ForceInitialize < uint ? > ();
ForceInitialize < ulong ? > ();
ForceInitialize < float ? > ();
ForceInitialize < double ? > ();
ForceInitialize < bool ? > ();
ForceInitialize<SampleEnum>();
SampleEnumMethod();
}
internal static void ForceInitialize<T>() => new ReflectionHelper<IMessage, T>();
/// <summary> /// <summary>
/// The methods in this class are somewhat evil, and should not be tampered with lightly. /// Empty Type[] used when calling GetProperty to force property instead of indexer fetching.
/// Basically they allow the creation of relatively weakly typed delegates from MethodInfos
/// which are more strongly typed. They do this by creating an appropriate strongly typed
/// delegate from the MethodInfo, and then calling that within an anonymous method.
/// Mind-bending stuff (at least to your humble narrator) but the resulting delegates are
/// very fast compared with calling Invoke later on.
/// </summary> /// </summary>
internal static class ReflectionUtil internal static readonly Type[] EmptyTypes = new Type[0];
{
static ReflectionUtil() /// <summary>
{ /// Creates a delegate which will cast the argument to the type that declares the method,
ForceInitialize<string>(); // Handles all reference types /// call the method on it, then convert the result to object.
ForceInitialize<int>(); /// </summary>
ForceInitialize<long>(); /// <param name="method">The method to create a delegate for, which must be declared in an
ForceInitialize<uint>(); /// IMessage implementation.</param>
ForceInitialize<ulong>(); internal static Func<IMessage, object> CreateFuncIMessageObject(MethodInfo method) =>
ForceInitialize<float>(); GetReflectionHelper(method.DeclaringType, method.ReturnType)
ForceInitialize<double>(); .CreateFuncIMessageObject(method);
ForceInitialize<bool>();
ForceInitialize<int?>(); /// <summary>
ForceInitialize<long?>(); /// Creates a delegate which will cast the argument to the type that declares the method,
ForceInitialize<uint?>(); /// call the method on it, then convert the result to the specified type. The method is expected
ForceInitialize<ulong?>(); /// to actually return an enum (because of where we're calling it - for oneof cases). Sometimes
ForceInitialize<float?>(); /// that means we need some extra work to perform conversions.
ForceInitialize<double?>(); /// </summary>
ForceInitialize<bool?>(); /// <param name="method">The method to create a delegate for, which must be declared in an
ForceInitialize<SampleEnum>(); /// IMessage implementation.</param>
SampleEnumMethod(); internal static Func<IMessage, int> CreateFuncIMessageInt32(MethodInfo method) =>
} GetReflectionHelper(method.DeclaringType, method.ReturnType)
.CreateFuncIMessageInt32(method);
/// <summary>
/// Creates a delegate which will execute the given method after casting the first argument to
/// the type that declares the method, and the second argument to the first parameter type of
/// the method.
/// </summary>
/// <param name="method">The method to create a delegate for, which must be declared in an
/// IMessage implementation.</param>
internal static Action<IMessage, object> CreateActionIMessageObject(MethodInfo method) =>
GetReflectionHelper(method.DeclaringType, method.GetParameters()[0].ParameterType)
.CreateActionIMessageObject(method);
internal static void ForceInitialize<T>() => new ReflectionHelper<IMessage, T>(); /// <summary>
/// Creates a delegate which will execute the given method after casting the first argument to
/// <summary> /// type that declares the method.
/// Empty Type[] used when calling GetProperty to force property instead of indexer fetching. /// </summary>
/// </summary> /// <param name="method">The method to create a delegate for, which must be declared in an
internal static readonly Type[] EmptyTypes = new Type[0]; /// IMessage implementation.</param>
internal static Action<IMessage> CreateActionIMessage(MethodInfo method) =>
/// <summary> GetReflectionHelper(method.DeclaringType, typeof(object)).CreateActionIMessage(method);
/// Creates a delegate which will cast the argument to the type that declares the method,
/// call the method on it, then convert the result to object. internal static Func<IMessage, bool> CreateFuncIMessageBool(MethodInfo method) =>
/// </summary> GetReflectionHelper(method.DeclaringType, method.ReturnType).CreateFuncIMessageBool(method);
/// <param name="method">The method to create a delegate for, which must be declared in an IMessage
/// implementation.</param> [UnconditionalSuppressMessage(
internal static Func<IMessage, object> CreateFuncIMessageObject(MethodInfo method) => "Trimming", "IL2026",
GetReflectionHelper(method.DeclaringType, method.ReturnType).CreateFuncIMessageObject(method); Justification =
"Type parameter members are preserved with DynamicallyAccessedMembers on GeneratedClrTypeInfo.ctor clrType parameter.")]
/// <summary> [UnconditionalSuppressMessage(
/// Creates a delegate which will cast the argument to the type that declares the method, "AotAnalysis", "IL3050:RequiresDynamicCode",
/// call the method on it, then convert the result to the specified type. The method is expected Justification =
/// to actually return an enum (because of where we're calling it - for oneof cases). Sometimes that "Type definition is explicitly specified and type argument is always a message type.")]
/// means we need some extra work to perform conversions. internal static Func<IMessage, bool> CreateIsInitializedCaller([
/// </summary> DynamicallyAccessedMembers(GeneratedClrTypeInfo.MessageAccessibility)
/// <param name="method">The method to create a delegate for, which must be declared in an IMessage ] Type msg) => ((IExtensionSetReflector)Activator
/// implementation.</param> .CreateInstance(typeof(ExtensionSetReflector<>).MakeGenericType(msg)))
internal static Func<IMessage, int> CreateFuncIMessageInt32(MethodInfo method) => .CreateIsInitializedCaller();
GetReflectionHelper(method.DeclaringType, method.ReturnType).CreateFuncIMessageInt32(method);
/// <summary>
/// <summary> /// Creates a delegate which will execute the given method after casting the first argument to
/// Creates a delegate which will execute the given method after casting the first argument to /// the type that declares the method, and the second argument to the first parameter type of
/// the type that declares the method, and the second argument to the first parameter type of the method. /// the method.
/// </summary> /// </summary>
/// <param name="method">The method to create a delegate for, which must be declared in an IMessage [UnconditionalSuppressMessage(
/// implementation.</param> "Trimming", "IL2026",
internal static Action<IMessage, object> CreateActionIMessageObject(MethodInfo method) => Justification =
GetReflectionHelper(method.DeclaringType, method.GetParameters()[0].ParameterType).CreateActionIMessageObject(method); "Type parameter members are preserved with DynamicallyAccessedMembers on GeneratedClrTypeInfo.ctor clrType parameter.")]
[UnconditionalSuppressMessage("AOT", "IL3050",
/// <summary> Justification = "Dynamic code won't call Type.MakeGenericType.")]
/// Creates a delegate which will execute the given method after casting the first argument to internal static IExtensionReflectionHelper CreateExtensionHelper(Extension extension) {
/// type that declares the method.
/// </summary>
/// <param name="method">The method to create a delegate for, which must be declared in an IMessage
/// implementation.</param>
internal static Action<IMessage> CreateActionIMessage(MethodInfo method) =>
GetReflectionHelper(method.DeclaringType, typeof(object)).CreateActionIMessage(method);
internal static Func<IMessage, bool> CreateFuncIMessageBool(MethodInfo method) =>
GetReflectionHelper(method.DeclaringType, method.ReturnType).CreateFuncIMessageBool(method);
[UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Type parameter members are preserved with DynamicallyAccessedMembers on GeneratedClrTypeInfo.ctor clrType parameter.")]
[UnconditionalSuppressMessage("AotAnalysis", "IL3050:RequiresDynamicCode", Justification = "Type definition is explicitly specified and type argument is always a message type.")]
internal static Func<IMessage, bool> CreateIsInitializedCaller([DynamicallyAccessedMembers(GeneratedClrTypeInfo.MessageAccessibility)]Type msg) =>
((IExtensionSetReflector)Activator.CreateInstance(typeof(ExtensionSetReflector<>).MakeGenericType(msg))).CreateIsInitializedCaller();
/// <summary>
/// Creates a delegate which will execute the given method after casting the first argument to
/// the type that declares the method, and the second argument to the first parameter type of the method.
/// </summary>
[UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Type parameter members are preserved with DynamicallyAccessedMembers on GeneratedClrTypeInfo.ctor clrType parameter.")]
internal static IExtensionReflectionHelper CreateExtensionHelper(Extension extension)
{
#if NET5_0_OR_GREATER #if NET5_0_OR_GREATER
if (!RuntimeFeature.IsDynamicCodeSupported) if (!RuntimeFeature.IsDynamicCodeSupported) {
{ // Using extensions with reflection is not supported with AOT.
// Using extensions with reflection is not supported with AOT. // This helper is created when descriptors are populated. Delay throwing error until an app
// This helper is created when descriptors are populated. Delay throwing error until an app // uses IFieldAccessor with an extension field.
// uses IFieldAccessor with an extension field. return new AotExtensionReflectionHelper();
return new AotExtensionReflectionHelper(); }
}
#endif #endif
var t1 = extension.TargetType; var t1 = extension.TargetType;
var t3 = extension.GetType().GenericTypeArguments[1]; var t3 = extension.GetType().GenericTypeArguments[1];
return (IExtensionReflectionHelper) Activator.CreateInstance(typeof(ExtensionReflectionHelper<,>).MakeGenericType(t1, t3), extension); return (IExtensionReflectionHelper)Activator.CreateInstance(
} typeof(ExtensionReflectionHelper<, >).MakeGenericType(t1, t3), extension);
}
/// <summary> /// <summary>
/// Creates a reflection helper for the given type arguments. Currently these are created on demand /// Creates a reflection helper for the given type arguments. Currently these are created on
/// rather than cached; this will be "busy" when initially loading a message's descriptor, but after that /// demand rather than cached; this will be "busy" when initially loading a message's
/// they can be garbage collected. We could cache them by type if that proves to be important, but creating /// descriptor, but after that they can be garbage collected. We could cache them by type if
/// an object is pretty cheap. /// that proves to be important, but creating an object is pretty cheap.
/// </summary> /// </summary>
[UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Type parameter members are preserved with DynamicallyAccessedMembers on GeneratedClrTypeInfo.ctor clrType parameter.")] [UnconditionalSuppressMessage(
private static IReflectionHelper GetReflectionHelper(Type t1, Type t2) "Trimming", "IL2026",
{ Justification =
"Type parameter members are preserved with DynamicallyAccessedMembers on GeneratedClrTypeInfo.ctor clrType parameter.")]
[UnconditionalSuppressMessage("AOT", "IL3050",
Justification = "Dynamic code won't call Type.MakeGenericType.")]
private static IReflectionHelper GetReflectionHelper(Type t1, Type t2) {
#if NET5_0_OR_GREATER #if NET5_0_OR_GREATER
if (!RuntimeFeature.IsDynamicCodeSupported) if (!RuntimeFeature.IsDynamicCodeSupported) {
{ return new AotReflectionHelper();
return new AotReflectionHelper(); }
}
#endif #endif
return (IReflectionHelper) Activator.CreateInstance(typeof(ReflectionHelper<,>).MakeGenericType(t1, t2)); return (IReflectionHelper)Activator.CreateInstance(
} typeof(ReflectionHelper<, >).MakeGenericType(t1, t2));
}
// Non-generic interface allowing us to use an instance of ReflectionHelper<T1, T2> without statically // Non-generic interface allowing us to use an instance of ReflectionHelper<T1, T2> without
// knowing the types involved. // statically knowing the types involved.
private interface IReflectionHelper private interface IReflectionHelper {
{ Func<IMessage, int> CreateFuncIMessageInt32(MethodInfo method);
Func<IMessage, int> CreateFuncIMessageInt32(MethodInfo method); Action<IMessage> CreateActionIMessage(MethodInfo method);
Action<IMessage> CreateActionIMessage(MethodInfo method); Func<IMessage, object> CreateFuncIMessageObject(MethodInfo method);
Func<IMessage, object> CreateFuncIMessageObject(MethodInfo method); Action<IMessage, object> CreateActionIMessageObject(MethodInfo method);
Action<IMessage, object> CreateActionIMessageObject(MethodInfo method); Func<IMessage, bool> CreateFuncIMessageBool(MethodInfo method);
Func<IMessage, bool> CreateFuncIMessageBool(MethodInfo method); }
}
internal interface IExtensionReflectionHelper {
object GetExtension(IMessage message);
void SetExtension(IMessage message, object value);
bool HasExtension(IMessage message);
void ClearExtension(IMessage message);
}
internal interface IExtensionReflectionHelper private interface IExtensionSetReflector {
{ Func<IMessage, bool> CreateIsInitializedCaller();
object GetExtension(IMessage message); }
void SetExtension(IMessage message, object value);
bool HasExtension(IMessage message); private sealed class ReflectionHelper<T1, T2> : IReflectionHelper {
void ClearExtension(IMessage message); public Func<IMessage, int> CreateFuncIMessageInt32(MethodInfo method) {
// On pleasant runtimes, we can create a Func<int> from a method returning
// an enum based on an int. That's the fast path.
if (CanConvertEnumFuncToInt32Func) {
var del = (Func<T1, int>)method.CreateDelegate(typeof(Func<T1, int>));
return message => del((T1)message);
} else {
// On some runtimes (e.g. old Mono) the return type has to be exactly correct,
// so we go via boxing. Reflection is already fairly inefficient, and this is
// only used for one-of case checking, fortunately.
var del = (Func<T1, T2>)method.CreateDelegate(typeof(Func<T1, T2>));
return message => (int)(object)del((T1)message);
} }
}
public Action<IMessage> CreateActionIMessage(MethodInfo method) {
var del = (Action<T1>)method.CreateDelegate(typeof(Action<T1>));
return message => del((T1)message);
}
public Func<IMessage, object> CreateFuncIMessageObject(MethodInfo method) {
var del = (Func<T1, T2>)method.CreateDelegate(typeof(Func<T1, T2>));
return message => del((T1)message);
}
public Action<IMessage, object> CreateActionIMessageObject(MethodInfo method) {
var del = (Action<T1, T2>)method.CreateDelegate(typeof(Action<T1, T2>));
return (message, arg) => del((T1)message, (T2)arg);
}
public Func<IMessage, bool> CreateFuncIMessageBool(MethodInfo method) {
var del = (Func<T1, bool>)method.CreateDelegate(typeof(Func<T1, bool>));
return message => del((T1)message);
}
}
private sealed class ExtensionReflectionHelper<T1, T3> : IExtensionReflectionHelper
where T1 : IExtendableMessage<T1> {
private readonly Extension extension;
private interface IExtensionSetReflector public ExtensionReflectionHelper(Extension extension) {
{ this.extension = extension;
Func<IMessage, bool> CreateIsInitializedCaller(); }
public object GetExtension(IMessage message) {
if (message is not T1 extensionMessage) {
throw new InvalidCastException(
"Cannot access extension on message that isn't IExtensionMessage");
} }
private sealed class ReflectionHelper<T1, T2> : IReflectionHelper if (extension is Extension<T1, T3> ext13) {
{ return extensionMessage.GetExtension(ext13);
public Func<IMessage, int> CreateFuncIMessageInt32(MethodInfo method) } else if (extension is RepeatedExtension<T1, T3> repeatedExt13) {
{ return extensionMessage.GetOrInitializeExtension(repeatedExt13);
// On pleasant runtimes, we can create a Func<int> from a method returning } else {
// an enum based on an int. That's the fast path. throw new InvalidCastException(
if (CanConvertEnumFuncToInt32Func) "The provided extension is not a valid extension identifier type");
{
var del = (Func<T1, int>) method.CreateDelegate(typeof(Func<T1, int>));
return message => del((T1) message);
}
else
{
// On some runtimes (e.g. old Mono) the return type has to be exactly correct,
// so we go via boxing. Reflection is already fairly inefficient, and this is
// only used for one-of case checking, fortunately.
var del = (Func<T1, T2>) method.CreateDelegate(typeof(Func<T1, T2>));
return message => (int) (object) del((T1) message);
}
}
public Action<IMessage> CreateActionIMessage(MethodInfo method)
{
var del = (Action<T1>) method.CreateDelegate(typeof(Action<T1>));
return message => del((T1) message);
}
public Func<IMessage, object> CreateFuncIMessageObject(MethodInfo method)
{
var del = (Func<T1, T2>) method.CreateDelegate(typeof(Func<T1, T2>));
return message => del((T1) message);
}
public Action<IMessage, object> CreateActionIMessageObject(MethodInfo method)
{
var del = (Action<T1, T2>) method.CreateDelegate(typeof(Action<T1, T2>));
return (message, arg) => del((T1) message, (T2) arg);
}
public Func<IMessage, bool> CreateFuncIMessageBool(MethodInfo method)
{
var del = (Func<T1, bool>)method.CreateDelegate(typeof(Func<T1, bool>));
return message => del((T1)message);
}
} }
}
private sealed class ExtensionReflectionHelper<T1, T3> : IExtensionReflectionHelper public bool HasExtension(IMessage message) {
where T1 : IExtendableMessage<T1> if (message is not T1 extensionMessage) {
{ throw new InvalidCastException(
private readonly Extension extension; "Cannot access extension on message that isn't IExtensionMessage");
public ExtensionReflectionHelper(Extension extension)
{
this.extension = extension;
}
public object GetExtension(IMessage message)
{
if (message is not T1 extensionMessage)
{
throw new InvalidCastException("Cannot access extension on message that isn't IExtensionMessage");
}
if (extension is Extension<T1, T3> ext13)
{
return extensionMessage.GetExtension(ext13);
}
else if (extension is RepeatedExtension<T1, T3> repeatedExt13)
{
return extensionMessage.GetOrInitializeExtension(repeatedExt13);
}
else
{
throw new InvalidCastException("The provided extension is not a valid extension identifier type");
}
}
public bool HasExtension(IMessage message)
{
if (message is not T1 extensionMessage)
{
throw new InvalidCastException("Cannot access extension on message that isn't IExtensionMessage");
}
if (extension is Extension<T1, T3> ext13)
{
return extensionMessage.HasExtension(ext13);
}
else if (extension is RepeatedExtension<T1, T3>)
{
throw new InvalidOperationException("HasValue is not implemented for repeated extensions");
}
else
{
throw new InvalidCastException("The provided extension is not a valid extension identifier type");
}
}
public void SetExtension(IMessage message, object value)
{
if (message is not T1 extensionMessage)
{
throw new InvalidCastException("Cannot access extension on message that isn't IExtensionMessage");
}
if (extension is Extension<T1, T3> ext13)
{
extensionMessage.SetExtension(ext13, (T3)value);
}
else if (extension is RepeatedExtension<T1, T3>)
{
throw new InvalidOperationException("SetValue is not implemented for repeated extensions");
}
else
{
throw new InvalidCastException("The provided extension is not a valid extension identifier type");
}
}
public void ClearExtension(IMessage message)
{
if (message is not T1 extensionMessage)
{
throw new InvalidCastException("Cannot access extension on message that isn't IExtensionMessage");
}
if (extension is Extension<T1, T3> ext13)
{
extensionMessage.ClearExtension(ext13);
}
else if (extension is RepeatedExtension<T1, T3> repeatedExt13)
{
extensionMessage.GetExtension(repeatedExt13).Clear();
}
else
{
throw new InvalidCastException("The provided extension is not a valid extension identifier type");
}
}
} }
#if NET5_0_OR_GREATER if (extension is Extension<T1, T3> ext13) {
/// <summary> return extensionMessage.HasExtension(ext13);
/// This helper is compatible with .NET Native AOT. } else if (extension is RepeatedExtension<T1, T3>) {
/// MakeGenericType doesn't work when a type argument is a value type in AOT. throw new InvalidOperationException(
/// MethodInfo.Invoke is used instead of compiled expressions because it's faster in AOT. "HasValue is not implemented for repeated extensions");
/// </summary> } else {
private sealed class AotReflectionHelper : IReflectionHelper throw new InvalidCastException(
{ "The provided extension is not a valid extension identifier type");
private static readonly object[] EmptyObjectArray = new object[0];
public Action<IMessage> CreateActionIMessage(MethodInfo method) => message => method.Invoke(message, EmptyObjectArray);
public Action<IMessage, object> CreateActionIMessageObject(MethodInfo method) => (message, arg) => method.Invoke(message, new object[] { arg });
public Func<IMessage, bool> CreateFuncIMessageBool(MethodInfo method) => message => (bool) method.Invoke(message, EmptyObjectArray);
public Func<IMessage, int> CreateFuncIMessageInt32(MethodInfo method) => message => (int) method.Invoke(message, EmptyObjectArray);
public Func<IMessage, object> CreateFuncIMessageObject(MethodInfo method) => message => method.Invoke(message, EmptyObjectArray);
} }
}
/// <summary> public void SetExtension(IMessage message, object value) {
/// Reflection with extensions isn't supported because IExtendableMessage members are used to get values. if (message is not T1 extensionMessage) {
/// Can't use reflection to invoke those methods because they have a generic argument. throw new InvalidCastException(
/// MakeGenericMethod can't be used because it will break whenever the extension type is a value type. "Cannot access extension on message that isn't IExtensionMessage");
/// This could be made to work if there were non-generic methods available for getting and setting extension values.
/// </summary>
private sealed class AotExtensionReflectionHelper : IExtensionReflectionHelper
{
private const string Message = "Extensions reflection is not supported with AOT.";
public object GetExtension(IMessage message) => throw new NotSupportedException(Message);
public bool HasExtension(IMessage message) => throw new NotSupportedException(Message);
public void SetExtension(IMessage message, object value) => throw new NotSupportedException(Message);
public void ClearExtension(IMessage message) => throw new NotSupportedException(Message);
} }
#endif
private sealed class ExtensionSetReflector< if (extension is Extension<T1, T3> ext13) {
[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] extensionMessage.SetExtension(ext13, (T3)value);
T1> : IExtensionSetReflector where T1 : IExtendableMessage<T1> } else if (extension is RepeatedExtension<T1, T3>) {
{ throw new InvalidOperationException(
public Func<IMessage, bool> CreateIsInitializedCaller() "SetValue is not implemented for repeated extensions");
{ } else {
var prop = typeof(T1).GetTypeInfo().GetDeclaredProperty("_Extensions"); throw new InvalidCastException(
var getFunc = (Func<T1, ExtensionSet<T1>>)prop.GetMethod.CreateDelegate(typeof(Func<T1, ExtensionSet<T1>>)); "The provided extension is not a valid extension identifier type");
var initializedFunc = (Func<ExtensionSet<T1>, bool>)
typeof(ExtensionSet<T1>)
.GetTypeInfo()
.GetDeclaredMethod("IsInitialized")
.CreateDelegate(typeof(Func<ExtensionSet<T1>, bool>));
return (m) => {
var set = getFunc((T1)m);
return set == null || initializedFunc(set);
};
}
} }
}
// Runtime compatibility checking code - see ReflectionHelper<T1, T2>.CreateFuncIMessageInt32 for public void ClearExtension(IMessage message) {
// details about why we're doing this. if (message is not T1 extensionMessage) {
throw new InvalidCastException(
// Deliberately not inside the generic type. We only want to check this once. "Cannot access extension on message that isn't IExtensionMessage");
private static bool CanConvertEnumFuncToInt32Func { get; } = CheckCanConvertEnumFuncToInt32Func();
private static bool CheckCanConvertEnumFuncToInt32Func()
{
try
{
// Try to do the conversion using reflection, so we can see whether it's supported.
MethodInfo method = typeof(ReflectionUtil).GetMethod(nameof(SampleEnumMethod));
// If this passes, we're in a reasonable runtime.
method.CreateDelegate(typeof(Func<int>));
return true;
}
catch (ArgumentException)
{
return false;
}
} }
public enum SampleEnum if (extension is Extension<T1, T3> ext13) {
{ extensionMessage.ClearExtension(ext13);
X } else if (extension is RepeatedExtension<T1, T3> repeatedExt13) {
extensionMessage.GetExtension(repeatedExt13).Clear();
} else {
throw new InvalidCastException(
"The provided extension is not a valid extension identifier type");
} }
}
}
// Public to make the reflection simpler. #if NET5_0_OR_GREATER
public static SampleEnum SampleEnumMethod() => SampleEnum.X; /// <summary>
/// This helper is compatible with .NET Native AOT.
/// MakeGenericType doesn't work when a type argument is a value type in AOT.
/// MethodInfo.Invoke is used instead of compiled expressions because it's faster in AOT.
/// </summary>
private sealed class AotReflectionHelper : IReflectionHelper {
private static readonly object[] EmptyObjectArray = new object[0];
public Action<IMessage> CreateActionIMessage(MethodInfo method) => message =>
method.Invoke(message, EmptyObjectArray);
public Action<IMessage, object> CreateActionIMessageObject(MethodInfo method) =>
(message, arg) => method.Invoke(message, new object[] { arg });
public Func<IMessage, bool> CreateFuncIMessageBool(MethodInfo method) => message =>
(bool)method.Invoke(message, EmptyObjectArray);
public Func<IMessage, int> CreateFuncIMessageInt32(MethodInfo method) => message =>
(int)method.Invoke(message, EmptyObjectArray);
public Func<IMessage, object> CreateFuncIMessageObject(MethodInfo method) => message =>
method.Invoke(message, EmptyObjectArray);
}
/// <summary>
/// Reflection with extensions isn't supported because IExtendableMessage members are used to
/// get values. Can't use reflection to invoke those methods because they have a generic
/// argument. MakeGenericMethod can't be used because it will break whenever the extension type
/// is a value type. This could be made to work if there were non-generic methods available for
/// getting and setting extension values.
/// </summary>
private sealed class AotExtensionReflectionHelper : IExtensionReflectionHelper {
private const string Message = "Extensions reflection is not supported with AOT.";
public object GetExtension(IMessage message) => throw new NotSupportedException(Message);
public bool HasExtension(IMessage message) => throw new NotSupportedException(Message);
public void SetExtension(IMessage message,
object value) => throw new NotSupportedException(Message);
public void ClearExtension(IMessage message) => throw new NotSupportedException(Message);
}
#endif
private sealed class ExtensionSetReflector<[DynamicallyAccessedMembers(
DynamicallyAccessedMemberTypes.PublicProperties |
DynamicallyAccessedMemberTypes.NonPublicProperties)] T1> : IExtensionSetReflector
where T1 : IExtendableMessage<T1> {
public Func<IMessage, bool> CreateIsInitializedCaller() {
var prop = typeof(T1).GetTypeInfo().GetDeclaredProperty("_Extensions");
var getFunc = (Func<T1, ExtensionSet<T1>>)prop.GetMethod.CreateDelegate(
typeof(Func<T1, ExtensionSet<T1>>));
var initializedFunc = (Func<ExtensionSet<T1>, bool>)typeof(ExtensionSet<T1>)
.GetTypeInfo()
.GetDeclaredMethod("IsInitialized")
.CreateDelegate(typeof(Func<ExtensionSet<T1>, bool>));
return (m) => {
var set = getFunc((T1)m);
return set == null || initializedFunc(set);
};
}
}
// Runtime compatibility checking code - see ReflectionHelper<T1, T2>.CreateFuncIMessageInt32
// for details about why we're doing this.
// Deliberately not inside the generic type. We only want to check this once.
private static bool CanConvertEnumFuncToInt32Func { get; } =
CheckCanConvertEnumFuncToInt32Func();
private static bool CheckCanConvertEnumFuncToInt32Func() {
try {
// Try to do the conversion using reflection, so we can see whether it's supported.
MethodInfo method = typeof(ReflectionUtil).GetMethod(nameof(SampleEnumMethod));
// If this passes, we're in a reasonable runtime.
method.CreateDelegate(typeof(Func<int>));
return true;
} catch (ArgumentException) {
return false;
}
} }
public enum SampleEnum { X }
// Public to make the reflection simpler.
public static SampleEnum SampleEnumMethod() => SampleEnum.X;
}
} }

Write Preview
Loading…
Cancel
Save