Here are the examples of the csharp api System.Reflection.MethodBase.GetParameters() taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
4180 Examples
19
Source : DataContext.cs
with MIT License
from 0x0ade
with MIT License
from 0x0ade
public void RegisterHandlersIn(object owner) {
if (RegisteredHandlers.ContainsKey(owner))
return;
List<Tuple<Type, DataHandler>> handlers = RegisteredHandlers[owner] = new();
List<Tuple<Type, DataFilter>> filters = RegisteredFilters[owner] = new();
foreach (MethodInfo method in owner.GetType().GetMethods()) {
if (method.Name == "Handle" || method.Name == "Filter") {
ParameterInfo[] args = method.GetParameters();
if (args.Length != 2 || !args[0].ParameterType.IsCompatible(typeof(CelesteNetConnection)))
continue;
Type argType = args[1].ParameterType;
if (!argType.IsCompatible(typeof(DataType)))
continue;
if (method.Name == "Filter") {
Logger.Log(LogLevel.VVV, "data", $"Autoregistering filter for {argType}: {method.GetID()}");
DataFilter filter = (con, data) => method.Invoke(owner, new object[] { con, data }) as bool? ?? false;
filters.Add(Tuple.Create(argType, filter));
RegisterFilter(argType, filter);
} else {
Logger.Log(LogLevel.VVV, "data", $"Autoregistering handler for {argType}: {method.GetID()}");
DataHandler handler = (con, data) => method.Invoke(owner, new object[] { con, data });
handlers.Add(Tuple.Create(argType, handler));
RegisterHandler(argType, handler);
}
}
}
}
19
Source : MethodInvoker.cs
with MIT License
from 1100100
with MIT License
from 1100100
private Func<object, object[], dynamic> BuildInvoker(MethodInfo methodInfo)
{
if (methodInfo == null)
throw new ArgumentNullException(nameof(methodInfo), "MethodInfo cannot be null.");
var instanceParameter = Expression.Parameter(typeof(object));
var argsParameter = Expression.Parameter(typeof(object[]));
var argsExpressions = methodInfo.GetParameters().Select((item, index) => Expression.Convert(Expression.ArrayIndex(argsParameter, Expression.Constant(index)), item.ParameterType));
var instanceObj = methodInfo.IsStatic ? null : Expression.Convert(instanceParameter, methodInfo.DeclaringType ?? throw new InvalidOperationException());
var methodCaller = Expression.Call(instanceObj, methodInfo, argsExpressions);
if (methodCaller.Type == typeof(Task))
{
var action = Expression.Lambda<Action<object, object[]>>(methodCaller, instanceParameter, argsParameter).Compile();
return (instance, args) => { action(instance, args); return Task.CompletedTask; };
}
var instanceMethodCaller = Expression.Convert(methodCaller, methodInfo.ReturnType);
return Expression.Lambda<Func<object, object[], object>>(instanceMethodCaller, instanceParameter, argsParameter).Compile();
}
19
Source : ProxyGenerator.cs
with MIT License
from 1100100
with MIT License
from 1100100
private static List<string> FindAllNamespace(Type @interface)
{
var namespaces = new List<string>{
"System.Threading.Tasks","System.Collections.Generic",typeof(DynamicProxyAbstract).Namespace,typeof(IRemotingInvoke).Namespace,@interface.Namespace
};
foreach (var method in @interface.GetMethods())
{
var returnType = method.ReturnType;
FindNamespace(returnType, namespaces);
foreach (var arg in method.GetParameters())
{
FindNamespace(arg.ParameterType, namespaces);
}
}
return namespaces;
}
19
Source : ProxyGenerator.cs
with MIT License
from 1100100
with MIT License
from 1100100
private static MemberDeclarationSyntax GenerateMethod(string routePrefix, MethodInfo methodInfo, string serviceName)
{
if (methodInfo.ReturnType.Namespace != typeof(Task).Namespace)
throw new NotSupportedException($"Only support proxy asynchronous methods.[{methodInfo.DeclaringType?.Namespace}.{methodInfo.DeclaringType?.Name}.{methodInfo.Name}]");
var methodAttr = methodInfo.GetCustomAttribute<ServiceRouteAttribute>();
var serviceRoute = $"{routePrefix}/{(methodAttr == null ? methodInfo.Name : methodAttr.Route)}";
var returnDeclaration = GenerateType(methodInfo.ReturnType);
var argDeclarations = new List<SyntaxNodeOrToken>();
foreach (var arg in methodInfo.GetParameters())
{
argDeclarations.Add(arg.ParameterType.IsGenericType
? SyntaxFactory.Parameter(SyntaxFactory.Identifier(arg.Name))
.WithType(GenerateType(arg.ParameterType))
: SyntaxFactory.Parameter(SyntaxFactory.Identifier(arg.Name))
.WithType(GenerateQualifiedNameSyntax(arg.ParameterType)));
argDeclarations.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
}
if (argDeclarations.Any())
{
argDeclarations.RemoveAt(argDeclarations.Count - 1);
}
//Generate return type.
var methodDeclaration = SyntaxFactory.MethodDeclaration(methodInfo.ReturnType == typeof(void) ? SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword)) : returnDeclaration, SyntaxFactory.Identifier(methodInfo.Name));
if (methodInfo.ReturnType.Namespace == typeof(Task).Namespace)
{
methodDeclaration = methodDeclaration.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword),
SyntaxFactory.Token(SyntaxKind.AsyncKeyword)));
}
else
{
methodDeclaration = methodDeclaration.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)));
}
methodDeclaration = methodDeclaration.WithParameterList(
SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList<ParameterSyntax>(argDeclarations)));
ExpressionSyntax expressionSyntax;
if (methodInfo.ReturnType == typeof(Task))
{
expressionSyntax = SyntaxFactory.IdentifierName("InvokeAsync");
}
else
{
expressionSyntax = SyntaxFactory.GenericName(SyntaxFactory.Identifier("InvokeAsync"))
.WithTypeArgumentList(((GenericNameSyntax)returnDeclaration).TypeArgumentList);
}
var argNames = methodInfo.GetParameters().Select(p => SyntaxFactory.IdentifierName(SyntaxFactory.Identifier(p.Name))).ToList();
var token = new SyntaxNodeOrToken[]
{
SyntaxFactory.Argument(SyntaxFactory
.ArrayCreationExpression(SyntaxFactory
.ArrayType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ObjectKeyword)))
.WithRankSpecifiers(SyntaxFactory.SingletonList(
SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SingletonSeparatedList<ExpressionSyntax>(
SyntaxFactory.OmittedArraySizeExpression())))))
.WithInitializer(SyntaxFactory.InitializerExpression(SyntaxKind.CollectionInitializerExpression,
SyntaxFactory.SeparatedList<ExpressionSyntax>(argNames)))),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.LiteralExpression(
SyntaxKind.StringLiteralExpression,
SyntaxFactory.Literal(serviceRoute))),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.LiteralExpression(
SyntaxKind.StringLiteralExpression,
SyntaxFactory.Literal(serviceName)))
};
expressionSyntax = SyntaxFactory.AwaitExpression(SyntaxFactory.InvocationExpression(expressionSyntax)
.WithArgumentList(
SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList<ArgumentSyntax>(token))
));
StatementSyntax statementSyntax;
if (methodInfo.ReturnType != typeof(Task) && methodInfo.ReturnType != typeof(void))
{
statementSyntax = SyntaxFactory.ReturnStatement(expressionSyntax);
}
else
{
statementSyntax = SyntaxFactory.ExpressionStatement(expressionSyntax);
}
return methodDeclaration.WithBody(SyntaxFactory.Block(SyntaxFactory.SingletonList(statementSyntax)));
}
19
Source : ICachingKeyGenerator.Default.cs
with MIT License
from 1100100
with MIT License
from 1100100
public string GenerateKeyPlaceholder(string keyPrefix, int globalExpire, string route, MethodInfo methodInfo, CachingAttribute cachingAttribute = default)
{
var sb = new StringBuilder();
if (!string.IsNullOrWhiteSpace(keyPrefix))
sb.AppendFormat("{0}{1}", keyPrefix, LinkString);
if (cachingAttribute == null || string.IsNullOrWhiteSpace(cachingAttribute.Key))
{
sb.AppendFormat("{0}", route);
if (methodInfo.GetParameters().Length > 0)
sb.Append(LinkString + "{0}");
}
else
sb.Append(cachingAttribute.Key);
return sb.ToString();
}
19
Source : ServiceBuilder.cs
with MIT License
from 1100100
with MIT License
from 1100100
private static bool IsImplementationMethod(MethodInfo serviceMethod, MethodInfo implementationMethod)
{
return serviceMethod.Name == implementationMethod.Name &&
serviceMethod.ReturnType == implementationMethod.ReturnType &&
serviceMethod.ContainsGenericParameters == implementationMethod.ContainsGenericParameters &&
SameParameters(serviceMethod.GetParameters(), implementationMethod.GetParameters());
}
19
Source : EntityMapperProvider.cs
with Apache License 2.0
from 1448376744
with Apache License 2.0
from 1448376744
public ConstructorInfo FindConstructor(Type csharpType)
{
var constructor = csharpType.GetConstructor(Type.EmptyTypes);
if (constructor == null)
{
var constructors = csharpType.GetConstructors();
constructor = constructors.Where(a => a.GetParameters().Length == constructors.Max(s => s.GetParameters().Length)).FirstOrDefault();
}
return constructor;
}
19
Source : EntityMapperProvider.cs
with Apache License 2.0
from 1448376744
with Apache License 2.0
from 1448376744
private Func<IDataRecord, T> CreateTypeSerializerHandler<T>(MemberMapper mapper, IDataRecord record)
{
var type = typeof(T);
var methodName = $"Serializer{Guid.NewGuid():N}";
var dynamicMethod = new DynamicMethod(methodName, type, new Type[] { typeof(IDataRecord) }, type, true);
var generator = dynamicMethod.GetILGenerator();
LocalBuilder local = generator.DeclareLocal(type);
var dataInfos = new DataReaderCellInfo[record.FieldCount];
for (int i = 0; i < record.FieldCount; i++)
{
var dataname = record.GetName(i);
var datatype = record.GetFieldType(i);
var typename = record.GetDataTypeName(i);
dataInfos[i] = new DataReaderCellInfo(i, typename, datatype, dataname);
}
if (dataInfos.Length == 1 && (type.IsValueType || type == typeof(string) || type == typeof(object)))
{
var dataInfo = dataInfos.First();
var convertMethod = mapper.FindConvertMethod(type, dataInfo.DataType);
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldc_I4, 0);
if (convertMethod.IsVirtual)
generator.Emit(OpCodes.Callvirt, convertMethod);
else
generator.Emit(OpCodes.Call, convertMethod);
if (type == typeof(object) && convertMethod.ReturnType.IsValueType)
{
generator.Emit(OpCodes.Box, convertMethod.ReturnType);
}
generator.Emit(OpCodes.Stloc, local);
generator.Emit(OpCodes.Ldloc, local);
generator.Emit(OpCodes.Ret);
return dynamicMethod.CreateDelegate(typeof(Func<IDataRecord, T>)) as Func<IDataRecord, T>;
}
var constructor = mapper.FindConstructor(type);
if (constructor.GetParameters().Length > 0)
{
var parameters = constructor.GetParameters();
var locals = new LocalBuilder[parameters.Length];
for (int i = 0; i < locals.Length; i++)
{
locals[i] = generator.DeclareLocal(parameters[i].ParameterType);
}
for (int i = 0; i < locals.Length; i++)
{
var item = mapper.FindConstructorParameter(dataInfos, parameters[i]);
if (item == null)
{
continue;
}
var convertMethod = mapper.FindConvertMethod(parameters[i].ParameterType, item.DataType);
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldc_I4, item.Ordinal);
if (convertMethod.IsVirtual)
generator.Emit(OpCodes.Callvirt, convertMethod);
else
generator.Emit(OpCodes.Call, convertMethod);
generator.Emit(OpCodes.Stloc, locals[i]);
}
for (int i = 0; i < locals.Length; i++)
{
generator.Emit(OpCodes.Ldloc, locals[i]);
}
generator.Emit(OpCodes.Newobj, constructor);
generator.Emit(OpCodes.Stloc, local);
generator.Emit(OpCodes.Ldloc, local);
generator.Emit(OpCodes.Ret);
return dynamicMethod.CreateDelegate(typeof(Func<IDataRecord, T>)) as Func<IDataRecord, T>;
}
else
{
var properties = type.GetProperties();
generator.Emit(OpCodes.Newobj, constructor);
generator.Emit(OpCodes.Stloc, local);
foreach (var item in dataInfos)
{
var property = mapper.FindMember(properties, item) as PropertyInfo;
if (property == null)
{
continue;
}
var convertMethod = mapper.FindConvertMethod(property.PropertyType, item.DataType);
if (convertMethod == null)
{
continue;
}
int i = record.GetOrdinal(item.DataName);
generator.Emit(OpCodes.Ldloc, local);
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldc_I4, i);
if (convertMethod.IsVirtual)
generator.Emit(OpCodes.Callvirt, convertMethod);
else
generator.Emit(OpCodes.Call, convertMethod);
generator.Emit(OpCodes.Callvirt, property.GetSetMethod());
}
generator.Emit(OpCodes.Ldloc, local);
generator.Emit(OpCodes.Ret);
return dynamicMethod.CreateDelegate(typeof(Func<IDataRecord, T>)) as Func<IDataRecord, T>;
}
}
19
Source : InterfaceImplementation.cs
with MIT License
from 1996v
with MIT License
from 1996v
public static Type CreateType(Type interfaceType)
{
try
{
TypeBuilder typeBuilder = Impreplacedembly.DefineInterfaceImpType(interfaceType);
List<MemberInfo> allMembers = interfaceType.GetAllInterfaceMembers();
List<MethodInfo> propertyInfos = new List<MethodInfo>();
foreach (PropertyInfo prop in allMembers.OfType<PropertyInfo>())
{
Type propType = prop.PropertyType;
PropertyBuilder propBuilder = typeBuilder.DefineProperty(prop.Name, prop.Attributes, propType, Type.EmptyTypes);
MethodInfo iGetter = prop.GetMethod;
MethodInfo iSetter = prop.SetMethod;
if (iGetter != null)
{
propertyInfos.Add(iGetter);
}
if (iSetter != null)
{
propertyInfos.Add(iSetter);
}
if (prop.Name == "Item")
{
if (iGetter != null)
{
MethodAttributes accessor = iGetter.Attributes;
accessor &= ~MethodAttributes.Abstract;
MethodBuilder methBuilder = typeBuilder.DefineMethod(iGetter.Name, accessor, iGetter.ReturnType, iGetter.GetParameters().Select(e => e.ParameterType).ToArray());
ILGenerator il = methBuilder.GetILGenerator();
il.Emit(OpCodes.Newobj, typeof(NotImplementedException).GetConstructors()[0]);
il.Emit(OpCodes.Throw);
propBuilder.SetGetMethod(methBuilder);
}
if (iSetter != null)
{
MethodAttributes accessor = iSetter.Attributes;
accessor &= ~MethodAttributes.Abstract;
MethodBuilder methBuilder = typeBuilder.DefineMethod(iSetter.Name, accessor, iSetter.ReturnType, iSetter.GetParameters().Select(e => e.ParameterType).ToArray());
ILGenerator il = methBuilder.GetILGenerator();
il.Emit(OpCodes.Newobj, typeof(NotImplementedException).GetConstructors()[0]);
il.Emit(OpCodes.Throw);
propBuilder.SetSetMethod(methBuilder);
}
continue;
}
Func<FieldInfo> getBackingField;
{
FieldInfo backingField = null;
getBackingField =
() =>
{
if (backingField == null)
{
backingField = typeBuilder.DefineField("_" + prop.Name + "_" + Guid.NewGuid(), propType, FieldAttributes.Private);
}
return backingField;
};
}
if (iGetter != null)
{
MethodAttributes accessor = iGetter.Attributes;
accessor &= ~MethodAttributes.Abstract;
MethodBuilder methBuilder = typeBuilder.DefineMethod(iGetter.Name, accessor, propType, Type.EmptyTypes);
ILGenerator il = methBuilder.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, getBackingField());
il.Emit(OpCodes.Ret);
propBuilder.SetGetMethod(methBuilder);
}
if (iGetter != null || iSetter != null)
{
MethodAttributes accessor = iSetter != null ? iSetter.Attributes : MethodAttributes.Private;
string name = iSetter != null ? iSetter.Name : "set_" + prop.Name;
accessor &= ~MethodAttributes.Abstract;
MethodBuilder methBuilder = typeBuilder.DefineMethod(name, accessor, typeof(void), new[] { propType });
ILGenerator il = methBuilder.GetILGenerator();
if (iGetter != null)
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Stfld, getBackingField());
il.Emit(OpCodes.Ret);
}
else
{
il.Emit(OpCodes.Ret);
}
propBuilder.SetSetMethod(methBuilder);
}
}
foreach (MethodInfo method in allMembers.OfType<MethodInfo>().Except(propertyInfos))
{
MethodBuilder methBuilder = typeBuilder.DefineMethod(method.Name, MethodAttributes.Private | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual | MethodAttributes.Final, method.ReturnType, method.GetParameters().Select(e => e.ParameterType).ToArray());
if (method.IsGenericMethod)
{
methBuilder.DefineGenericParameters(method.GetGenericArguments().Select(e => e.Name).ToArray());
}
ILGenerator il = methBuilder.GetILGenerator();
il.Emit(OpCodes.Newobj, typeof(NotImplementedException).GetConstructors()[0]);
il.Emit(OpCodes.Throw);
typeBuilder.DefineMethodOverride(methBuilder, method);
}
return typeBuilder.CreateTypeInfo();
}
catch
{
throw BssomSerializationTypeFormatterException.UnsupportedType(interfaceType);
}
}
19
Source : TypeUtils.cs
with MIT License
from 1996v
with MIT License
from 1996v
public static ConstructorInfo GetDefaultNoArgCtorOrAppointTypeCtor(this Type type, Type ctorParaTypes = null)
{
foreach (ConstructorInfo ctor in type.GetConstructors())
{
ParameterInfo[] ctorParas = ctor.GetParameters();
if (ctorParas.Length == 0)
{
return ctor;//no args
}
if (ctorParaTypes != null && ctorParas.Length == 1)
{
if (ctorParas[0].ParameterType == ctorParaTypes)
{
return ctor;
}
}
}
return null;
}
19
Source : TypeUtils.cs
with MIT License
from 1996v
with MIT License
from 1996v
public static ConstructorInfo GetAppointTypeCtor(this Type type, Type ctorParaType)
{
foreach (ConstructorInfo ctor in type.GetConstructors())
{
ParameterInfo[] ctorParas = ctor.GetParameters();
if (ctorParas.Length == 1)
{
if (ctorParas[0].ParameterType == ctorParaType)
{
return ctor;
}
}
}
return null;
}
19
Source : ICollectionResolver.cs
with MIT License
from 1996v
with MIT License
from 1996v
public static TypeInfo BuildICollectionImplementationType(DynamicFormatterreplacedembly replacedembly, Type type, ConstructorInfo constructor,
Type itemType,
bool isImplGenerIList, bool IsImplIList, bool isImplGenerICollec, bool isImplIReadOnlyList)
{
TypeBuilder typeBuilder = replacedembly.DefineFormatterType(type);
MethodBuilder sizeMethod = TypeBuildHelper.DefineSizeMethod(typeBuilder, type);
MethodBuilder serializeMethod = TypeBuildHelper.DefineSerializeMethod(typeBuilder, type);
if (itemType == typeof(object))
{
//itemType is Object, Array2
if (IsImplIList)
{
TypeBuildHelper.CallOneMethodInSerialize(serializeMethod, typeof(Array2FormatterHelper).GetMethod(nameof(Array2FormatterHelper.SerializeIList), BindingFlags.Public | BindingFlags.Static));
}
else
{
TypeBuildHelper.CallOneMethodInSerialize(serializeMethod, typeof(Array2FormatterHelper).GetMethod(nameof(Array2FormatterHelper.SerializeIEnumerable), BindingFlags.Public | BindingFlags.Static));
}
TypeBuildHelper.CallOneMethodInSize(sizeMethod, typeof(Array2FormatterHelper).GetMethod(nameof(Array2FormatterHelper.SizeIEnumerable), BindingFlags.Public | BindingFlags.Static));
}
else
{
if (Array1FormatterHelper.IsArray1Type(itemType))
{
//Array1
TypeBuildHelper.CallOneMethodInSerialize(serializeMethod, typeof(Array1FormatterHelper).GetMethod(nameof(Array1FormatterHelper.SerializeIEnumerable), new Type[] { typeof(BssomWriter).MakeByRefType(), typeof(BssomSerializeContext).MakeByRefType(), typeof(IEnumerable<>).MakeGenericType(itemType) }));
TypeBuildHelper.CallOneMethodInSize(sizeMethod, typeof(Array1FormatterHelper).GetMethod(nameof(Array1FormatterHelper.SizeIEnumerable), new Type[] { typeof(BssomSizeContext).MakeByRefType(), typeof(IEnumerable<>).MakeGenericType(itemType) }));
}
else
{
if (isImplGenerIList || isImplIReadOnlyList)
{
TypeBuildHelper.CallOneMethodInSerialize(serializeMethod, typeof(Array2FormatterHelper).GetMethod(nameof(Array2FormatterHelper.SerializeGenerIList), BindingFlags.Public | BindingFlags.Static).MakeGenericMethod(itemType));
}
else
{
TypeBuildHelper.CallOneMethodInSerialize(serializeMethod, typeof(Array2FormatterHelper).GetMethod(nameof(Array2FormatterHelper.SerializeGenericIEnumerable), BindingFlags.Public | BindingFlags.Static).MakeGenericMethod(itemType));
}
TypeBuildHelper.CallOneMethodInSize(sizeMethod, typeof(Array2FormatterHelper).GetMethod(nameof(Array2FormatterHelper.SizeGenericIEnumerable), BindingFlags.Public | BindingFlags.Static).MakeGenericMethod(itemType));
}
}
MethodBuilder deserializeMethod = TypeBuildHelper.DefineDeserializeMethod(typeBuilder, type);
ParameterInfo[] args = constructor.GetParameters();
if (args.Length == 1 && args[0].ParameterType != typeof(int))
{
//new T(IEnumerable t)
Type dynamicCacheType = typeof(CollectionDynamicDelegateCache<>).MakeGenericType(type);
MethodInfo methodinfo = dynamicCacheType.GetMethod(nameof(CollectionDynamicDelegateCache<int>.GenerateInjectCtor));
methodinfo.Invoke(null, new object[] { constructor, args[0].ParameterType });
TypeBuildHelper.CallDeserializeDelegate(deserializeMethod, type, dynamicCacheType.GetField(nameof(CollectionDynamicDelegateCache<int>.Deserialize), BindingFlags.Public | BindingFlags.Static));
}
else
{
if (itemType == typeof(DateTime))//DateTime需要特殊处理,因为要处理Standrand和Native
{
Type dtCollBuilder = typeof(DateTimeCollectionDeserializeBuilder<>).MakeGenericType(type);
MethodInfo methodinfo = dtCollBuilder.GetMethod(nameof(DateTimeCollectionDeserializeBuilder<ICollection<DateTime>>.ConstructorInit));
methodinfo.Invoke(null, new object[] { constructor });
TypeBuildHelper.CallOneMethodInDeserialize(deserializeMethod, dtCollBuilder.GetMethod(nameof(DateTimeCollectionDeserializeBuilder<ICollection<DateTime>>.Deserialize)));
}
else
{
Type dynamicCacheType = typeof(CollectionDynamicDelegateCache<>).MakeGenericType(type);
if (args.Length == 0)
{
MethodInfo methodinfo = dynamicCacheType.GetMethod(nameof(CollectionDynamicDelegateCache<int>.GenerateDeserializeWithEmptyCtor));
methodinfo.Invoke(null, new object[] { constructor, isImplGenerICollec, itemType });
}
else
{
DEBUG.replacedert(args.Length == 1 && args[0].ParameterType == typeof(int));
MethodInfo methodinfo = dynamicCacheType.GetMethod(nameof(CollectionDynamicDelegateCache<int>.GenerateDeserializeWithCapacityCtor));
methodinfo.Invoke(null, new object[] { constructor, isImplGenerICollec, itemType });
}
TypeBuildHelper.CallDeserializeDelegate(deserializeMethod, type, dynamicCacheType.GetField(nameof(CollectionDynamicDelegateCache<int>.Deserialize), BindingFlags.Public | BindingFlags.Static));
}
}
return typeBuilder.CreateTypeInfo();
}
19
Source : ICollectionResolver.cs
with MIT License
from 1996v
with MIT License
from 1996v
public static void ConstructorInit(ConstructorInfo ctor)
{
ParameterInfo[] paras = ctor.GetParameters();
ParameterExpression count = Expression.Parameter(typeof(int));
Expression body;
if (paras.Length == 0)
{
body = Expression.New(ctor);
}
else
{
body = Expression.New(ctor, count);
}
constructor = Expression.Lambda<Ctor>(body, CommonExpressionMeta.Par_Reader, count).Compile();
}
19
Source : ICollectionResolver.cs
with MIT License
from 1996v
with MIT License
from 1996v
private static bool TryGetConstructorInfo(Type targetType, Type itemType, bool isFindEmptyCtor, out ConstructorInfo constructor)
{
constructor = null;
foreach (ConstructorInfo item in targetType.GetConstructors())
{
ParameterInfo[] paras = item.GetParameters();
if (isFindEmptyCtor)
{
if (paras.Length == 0)
{
constructor = item;
return true;
}
}
if (constructor != null)
{
continue;
}
if (paras.Length == 1)
{
Type ctorArgType = paras[0].ParameterType;
if (targetType == ctorArgType)
{
continue;
}
if (
(TypeIsArray(ctorArgType, out int rank, out Type eleType) &&
rank == 1 && eleType == itemType
) ||
(TypeIsCollection(ctorArgType, out ConstructorInfo a, out eleType, out bool c, out bool d, out bool e, out bool f) &&
eleType == itemType)
)
{
constructor = item;
if (!isFindEmptyCtor)
{
return true;
}
}
}
}
return constructor != null;
}
19
Source : IDictionaryResolver.cs
with MIT License
from 1996v
with MIT License
from 1996v
private static bool TryGetConstructorInfo(Type targetType, Type genericKeyType, Type genericValueType, bool isFindEmptyCtor, out ConstructorInfo constructor)
{
constructor = null;
foreach (ConstructorInfo item in targetType.GetConstructors())
{
ParameterInfo[] paras = item.GetParameters();
if (isFindEmptyCtor)
{
if (paras.Length == 0)
{
constructor = item;
return true;
}
}
if (constructor != null)
{
continue;
}
if (paras.Length == 1)
{
Type ctorArgType = paras[0].ParameterType;
if (targetType == ctorArgType)
{
continue;
}
if (TypeIsDictionary(ctorArgType, out ConstructorInfo cons, out bool tIsGener, out Type generTypeDefine, out Type generKeyType, out Type generValueType))
{
if (tIsGener == false ||
(generKeyType == genericKeyType && generValueType == genericValueType))
{
constructor = item;
if (!isFindEmptyCtor)
{
return true;
}
}
}
}
}
return constructor != null;
}
19
Source : IDictionaryResolver.cs
with MIT License
from 1996v
with MIT License
from 1996v
public static TypeInfo BuildGenericIDictionaryImplementationType(DynamicFormatterreplacedembly replacedembly, ConstructorInfo constructor, Type type, Type genericKeyType, Type genericValueType)
{
TypeBuilder typeBuilder = replacedembly.DefineFormatterType(type);
MethodBuilder serializeMethod = TypeBuildHelper.DefineSerializeMethod(typeBuilder, type);
TypeBuildHelper.CallOneMethodInSerialize(serializeMethod, typeof(MapFormatterHelper).GetMethod(nameof(MapFormatterHelper.SerializeGenericDictionary), BindingFlags.Public | BindingFlags.Static).MakeGenericMethod(new Type[] { genericKeyType, genericValueType }));
MethodBuilder deserializeMethod = TypeBuildHelper.DefineDeserializeMethod(typeBuilder, type);
ParameterInfo[] args = constructor.GetParameters();
Type dynamicCacheType = typeof(IDictionaryDynamicDelegateCache<>).MakeGenericType(type);
if (args.Length == 0)
{
MethodInfo methodinfo = dynamicCacheType.GetMethod(nameof(IDictionaryDynamicDelegateCache<int>.GenerateDeserializeWithGenericDictEmptyCtor));
methodinfo.Invoke(null, new object[] { constructor, genericKeyType, genericValueType });
}
else
{
DEBUG.replacedert(args.Length == 1);
if (args[0].ParameterType == typeof(int))
{
MethodInfo methodinfo = dynamicCacheType.GetMethod(nameof(IDictionaryDynamicDelegateCache<int>.GenerateDeserializeWithGenericDictCapacityCtor));
methodinfo.Invoke(null, new object[] { constructor, genericKeyType, genericValueType });
}
else
{
MethodInfo methodinfo = dynamicCacheType.GetMethod(nameof(IDictionaryDynamicDelegateCache<int>.GenerateInjectCtor));
methodinfo.Invoke(null, new object[] { constructor, args[0].ParameterType });
}
}
TypeBuildHelper.CallDeserializeDelegate(deserializeMethod, type, dynamicCacheType.GetField(nameof(IDictionaryDynamicDelegateCache<int>.Deserialize), BindingFlags.Public | BindingFlags.Static));
MethodBuilder sizeMethod = TypeBuildHelper.DefineSizeMethod(typeBuilder, type);
TypeBuildHelper.CallOneMethodInSize(sizeMethod, typeof(MapFormatterHelper).GetMethod(nameof(MapFormatterHelper.SizeGenericDictionary), BindingFlags.Public | BindingFlags.Static).MakeGenericMethod(genericKeyType, genericValueType));
return typeBuilder.CreateTypeInfo();
}
19
Source : IDictionaryResolver.cs
with MIT License
from 1996v
with MIT License
from 1996v
public static TypeInfo BuildIDictionaryImplementationType(DynamicFormatterreplacedembly replacedembly, ConstructorInfo constructor, Type type)
{
TypeBuilder typeBuilder = replacedembly.DefineFormatterType(type);
MethodBuilder serializeMethod = TypeBuildHelper.DefineSerializeMethod(typeBuilder, type);
TypeBuildHelper.CallOneMethodInSerialize(serializeMethod, typeof(MapFormatterHelper).GetMethod(nameof(MapFormatterHelper.SerializeIDictionary), BindingFlags.Public | BindingFlags.Static));
MethodBuilder deserializeMethod = TypeBuildHelper.DefineDeserializeMethod(typeBuilder, type);
ParameterInfo[] args = constructor.GetParameters();
Type dynamicCacheType = typeof(IDictionaryDynamicDelegateCache<>).MakeGenericType(type);
if (args.Length == 1)
{
DEBUG.replacedert(args[0].ParameterType == typeof(IDictionary));
//return new T(IDictionaryFormatter.Deserialize)
MethodInfo methodinfo = dynamicCacheType.GetMethod(nameof(IDictionaryDynamicDelegateCache<int>.GenerateInjectCtor));
methodinfo.Invoke(null, new object[] { constructor, args[0].ParameterType });
}
else
{
MethodInfo methodinfo = dynamicCacheType.GetMethod(nameof(IDictionaryDynamicDelegateCache<int>.GenerateDeserializeWithIDictionaryEmptyCtor));
methodinfo.Invoke(null, new object[] { });
}
TypeBuildHelper.CallDeserializeDelegate(deserializeMethod, type, dynamicCacheType.GetField(nameof(IDictionaryDynamicDelegateCache<int>.Deserialize), BindingFlags.Public | BindingFlags.Static));
MethodBuilder sizeMethod = TypeBuildHelper.DefineSizeMethod(typeBuilder, type);
TypeBuildHelper.CallOneMethodInSize(sizeMethod, typeof(MapFormatterHelper).GetMethod(nameof(MapFormatterHelper.SizeIDictionary), BindingFlags.Public | BindingFlags.Static));
return typeBuilder.CreateTypeInfo();
}
19
Source : IDictionaryResolverTest_TypeIsIDictionary.cs
with MIT License
from 1996v
with MIT License
from 1996v
[Fact]
public void GenerDictionary_EmptyParasCtor_IsDictionary()
{
IDictionaryResolver.TypeIsDictionary(typeof(_GenerDictionary_EmptyParasCtor),
out ConstructorInfo constructor, out bool typeIsGeneric, out Type genericTypeDefinition, out Type genericKeyType, out Type genericValueType)
.IsTrue();
genericKeyType.Is(typeof(int));
genericValueType.Is(typeof(int));
constructor.GetParameters().Length.Is(0);
}
19
Source : ICollectionResolverTest_TypeIsCollection.cs
with MIT License
from 1996v
with MIT License
from 1996v
[Fact]
public void GenerICollectionImpl_EmptyParasCtor_IsCollection()
{
ICollectionResolver.TypeIsCollection(typeof(_GenerICollection_Int_EmptyParasCtor),
out ConstructorInfo constructor,
out Type itemType,
out bool isImplGenerIList, out bool IsImplIList, out bool isImplGenerICollec, out bool isImplIReadOnlyList).IsTrue();
itemType.Is(typeof(int));
constructor.GetParameters().Length.Is(0);
isImplGenerICollec.IsTrue();
}
19
Source : InvokeMethodAction.cs
with MIT License
from 1iveowl
with MIT License
from 1iveowl
private void UpdateMethodDescriptors()
{
_methodDescriptors.Clear();
_cachedMethodDescriptor = null;
if (string.IsNullOrWhiteSpace(MethodName) || _targetObjectType is null)
{
return;
}
foreach (var method in _targetObjectType.GetRuntimeMethods())
{
if (string.Equals(method.Name, MethodName, StringComparison.Ordinal)
&& method.ReturnType == typeof(void)
&& method.IsPublic)
{
var parameters = method.GetParameters();
if (parameters.Length == 0)
{
_cachedMethodDescriptor = new MethodDescriptor(method, parameters);
}
else if (parameters.Length == 2 && parameters[0].ParameterType == typeof(object))
{
_methodDescriptors.Add(new MethodDescriptor(method, parameters));
}
}
}
}
19
Source : ICollectionResolverTest_TypeIsCollection.cs
with MIT License
from 1996v
with MIT License
from 1996v
[Fact]
public void IListImpl_EmptyParasCtor_IsCollection()
{
ICollectionResolver.TypeIsCollection(typeof(_IList_EmptyParasCtor),
out ConstructorInfo constructor,
out Type itemType,
out bool isImplGenerIList, out bool IsImplIList, out bool isImplGenerICollec, out bool isImplIReadOnlyList).IsTrue();
itemType.Is(typeof(object));
constructor.GetParameters().Length.Is(0);
}
19
Source : ICollectionResolverTest_TypeIsCollection.cs
with MIT License
from 1996v
with MIT License
from 1996v
[Fact]
public void GenerIListImpl_EmptyParasCtor_IsCollection()
{
ICollectionResolver.TypeIsCollection(typeof(_GenerIList_Int_EmptyParasCtor),
out ConstructorInfo constructor,
out Type itemType,
out bool isImplGenerIList, out bool IsImplIList, out bool isImplGenerICollec, out bool isImplIReadOnlyList).IsTrue();
itemType.Is(typeof(int));
constructor.GetParameters().Length.Is(0);
isImplGenerIList.IsTrue();
}
19
Source : TypeHelper.cs
with MIT License
from 279328316
with MIT License
from 279328316
internal static string GetMethodModuleMark(MethodInfo method)
{
string moduleMark = null;
string controllerName = method.DeclaringType.FullName;
string methodName = method.Name;
string parametersName = "";
List<ParameterInfo> parameters = method.GetParameters().ToList();
if (parameters.Count > 0)
{
parametersName = "(";
for (int i = 0; i < parameters.Count; i++)
{
if (i > 0)
{
parametersName += ",";
}
parametersName += GetParameterTypeName(parameters[i].ParameterType);
}
parametersName += ")";
}
moduleMark = $"M:{controllerName}.{methodName}{parametersName}";
return moduleMark;
}
19
Source : TypeExtension.cs
with MIT License
from 2881099
with MIT License
from 2881099
public static string ToInterface(this MethodInfo method, bool isAlign = true)
{
if (method == null) return null;
var sb = new StringBuilder();
//if (method.IsPublic) sb.Append("public ");
//if (method.Isreplacedembly) sb.Append("internal ");
//if (method.IsFamily) sb.Append("protected ");
//if (method.IsPrivate) sb.Append("private ");
//if (method.IsPrivate) sb.Append("private ");
//if (method.IsStatic) sb.Append("static ");
//if (method.IsAbstract && method.DeclaringType.IsInterface == false) sb.Append("abstract ");
//if (method.IsVirtual && method.DeclaringType.IsInterface == false) sb.Append(isOverride ? "override " : "virtual ");
if (isAlign)
sb.Append(" ");
sb.Append(method.ReturnType.DisplayCsharp()).Append(" ").Append(method.Name);
var genericParameters = method.GetGenericArguments();
if (method.DeclaringType.IsNested && method.DeclaringType.DeclaringType.IsGenericType)
{
var dic = genericParameters.ToDictionary(a => a.Name);
foreach (var nestedGenericParameter in method.DeclaringType.DeclaringType.GetGenericArguments())
if (dic.ContainsKey(nestedGenericParameter.Name))
dic.Remove(nestedGenericParameter.Name);
genericParameters = dic.Values.ToArray();
}
if (genericParameters.Any())
sb.Append("<")
.Append(string.Join(", ", genericParameters.Select(a => a.DisplayCsharp())))
.Append(">");
sb.Append("(").Append(string.Join(", ", method.GetParameters().Select(a => $"{a.ParameterType.DisplayCsharp()} {a.Name}"))).Append(")");
if (isAlign)
sb.Append(";\r\n\r\n");
return sb.ToString();
}
19
Source : TccMaster.cs
with MIT License
from 2881099
with MIT License
from 2881099
TccMaster<TDBKey> Then(Type tccUnitType, object state)
{
if (tccUnitType == null) throw new ArgumentNullException(nameof(tccUnitType));
var unitTypeBase = typeof(TccUnit<>);
if (state == null && tccUnitType.BaseType.GetGenericTypeDefinition() == typeof(TccUnit<>)) unitTypeBase = unitTypeBase.MakeGenericType(tccUnitType.BaseType.GetGenericArguments()[0]);
else unitTypeBase = unitTypeBase.MakeGenericType(state.GetType());
if (unitTypeBase.IsreplacedignableFrom(tccUnitType) == false) throw new ArgumentException($"{tccUnitType.DisplayCsharp(false)} 必须继承 {unitTypeBase.DisplayCsharp(false)}");
var unitCtors = tccUnitType.GetConstructors();
if (unitCtors.Length != 1 && unitCtors[0].GetParameters().Length > 0) throw new ArgumentException($"{tccUnitType.FullName} 不能使用构造函数");
var unitTypeConved = Type.GetType(tccUnitType.replacedemblyQualifiedName);
if (unitTypeConved == null) throw new ArgumentException($"{tccUnitType.FullName} 无效");
var unit = unitTypeConved.CreateInstanceGetDefaultValue() as ITccUnit;
(unit as ITccUnitSetter)?.SetState(state);
_thenUnits.Add(unit);
_thenUnitInfos.Add(new TccUnitInfo
{
Description = unitTypeConved.GetDescription(),
Index = _thenUnitInfos.Count + 1,
Stage = TccUnitStage.Try,
State = state == null ? null : Newtonsoft.Json.JsonConvert.SerializeObject(state),
StateTypeName = state?.GetType().replacedemblyQualifiedName,
Tid = _tid,
TypeName = tccUnitType.replacedemblyQualifiedName,
});
return this;
}
19
Source : DynamicProxyExtensions.cs
with MIT License
from 2881099
with MIT License
from 2881099
internal static string DisplayCsharp(this MethodInfo method, bool isOverride)
{
if (method == null) return null;
var sb = new StringBuilder();
if (method.IsPublic) sb.Append("public ");
if (method.Isreplacedembly) sb.Append("internal ");
if (method.IsFamily) sb.Append("protected ");
if (method.IsPrivate) sb.Append("private ");
if (method.IsPrivate) sb.Append("private ");
if (method.IsStatic) sb.Append("static ");
if (method.IsAbstract && method.DeclaringType.IsInterface == false) sb.Append("abstract ");
if (method.IsVirtual && method.DeclaringType.IsInterface == false) sb.Append(isOverride ? "override " : "virtual ");
sb.Append(method.ReturnType.DisplayCsharp()).Append(" ").Append(method.Name);
var genericParameters = method.GetGenericArguments();
if (method.DeclaringType.IsNested && method.DeclaringType.DeclaringType.IsGenericType)
{
var dic = genericParameters.ToDictionary(a => a.Name);
foreach (var nestedGenericParameter in method.DeclaringType.DeclaringType.GetGenericArguments())
if (dic.ContainsKey(nestedGenericParameter.Name))
dic.Remove(nestedGenericParameter.Name);
genericParameters = dic.Values.ToArray();
}
if (genericParameters.Any())
sb.Append("<")
.Append(string.Join(", ", genericParameters.Select(a => a.DisplayCsharp())))
.Append(">");
sb.Append("(").Append(string.Join(", ", method.GetParameters().Select(a => $"{a.ParameterType.DisplayCsharp()} {a.Name}"))).Append(")");
return sb.ToString();
}
19
Source : SagaMaster.cs
with MIT License
from 2881099
with MIT License
from 2881099
SagaMaster<TDBKey> Then(Type sagaUnitType, object state)
{
if (sagaUnitType == null) throw new ArgumentNullException(nameof(sagaUnitType));
var unitTypeBase = typeof(SagaUnit<>);
if (state == null && sagaUnitType.BaseType.GetGenericTypeDefinition() == typeof(SagaUnit<>)) unitTypeBase = unitTypeBase.MakeGenericType(sagaUnitType.BaseType.GetGenericArguments()[0]);
else unitTypeBase = unitTypeBase.MakeGenericType(state.GetType());
if (unitTypeBase.IsreplacedignableFrom(sagaUnitType) == false) throw new ArgumentException($"{sagaUnitType.DisplayCsharp(false)} 必须继承 {unitTypeBase.DisplayCsharp(false)}");
var unitCtors = sagaUnitType.GetConstructors();
if (unitCtors.Length != 1 && unitCtors[0].GetParameters().Length > 0) throw new ArgumentException($"{sagaUnitType.FullName} 不能使用构造函数");
var unitTypeConved = Type.GetType(sagaUnitType.replacedemblyQualifiedName);
if (unitTypeConved == null) throw new ArgumentException($"{sagaUnitType.FullName} 无效");
var unit = unitTypeConved.CreateInstanceGetDefaultValue() as ISagaUnit;
(unit as ISagaUnitSetter)?.SetState(state);
_thenUnits.Add(unit);
_thenUnitInfos.Add(new SagaUnitInfo
{
Description = unitTypeConved.GetDescription(),
Index = _thenUnitInfos.Count + 1,
Stage = SagaUnitStage.Commit,
State = state == null ? null : Newtonsoft.Json.JsonConvert.SerializeObject(state),
StateTypeName = state?.GetType().replacedemblyQualifiedName,
Tid = _tid,
TypeName = sagaUnitType.replacedemblyQualifiedName,
});
return this;
}
19
Source : DynamicProxy.cs
with MIT License
from 2881099
with MIT License
from 2881099
public static DynamicProxyMeta CreateDynamicProxyMeta(Type type, bool isCompile, bool isThrow)
{
if (type == null) return null;
var typeCSharpName = type.DisplayCsharp();
if (type.IsNotPublic)
{
if (isThrow) throw new ArgumentException($"FreeSql.DynamicProxy 失败提示:{typeCSharpName} 需要使用 public 标记");
return null;
}
var matchedMemberInfos = new List<MemberInfo>();
var matchedAttributes = new List<DynamicProxyAttribute>();
var matchedAttributesFromServices = new List<FieldInfo[]>();
var clreplacedName = $"AopProxyClreplaced___{Guid.NewGuid().ToString("N")}";
var methodOverrideSb = new StringBuilder();
var sb = methodOverrideSb;
#region Common Code
Func<Type, DynamicProxyInjectorType, bool, int, string, string> getMatchedAttributesCode = (returnType, injectorType, isAsync, attrsIndex, proxyMethodName) =>
{
var sbt = new StringBuilder();
for (var a = attrsIndex; a < matchedAttributes.Count; a++)
{
sbt.Append($@"{(proxyMethodName == "Before" ? $@"
var __DP_ARG___attribute{a} = __DP_Meta.{nameof(DynamicProxyMeta.CreateDynamicProxyAttribute)}({a});
__DP_ARG___attribute{a}_FromServicesCopyTo(__DP_ARG___attribute{a});" : "")}
var __DP_ARG___{proxyMethodName}{a} = new {(proxyMethodName == "Before" ? _beforeAgumentsName : _afterAgumentsName)}(this, {_injectorTypeName}.{injectorType.ToString()}, __DP_Meta.MatchedMemberInfos[{a}], __DP_ARG___parameters, {(proxyMethodName == "Before" ? "null" : "__DP_ARG___return_value, __DP_ARG___exception")});
{(isAsync ? "await " : "")}__DP_ARG___attribute{a}.{proxyMethodName}(__DP_ARG___{proxyMethodName}{a});
{(proxyMethodName == "Before" ?
$@"if (__DP_ARG___is_return == false)
{{
__DP_ARG___is_return = __DP_ARG___{proxyMethodName}{a}.Returned;{(returnType != typeof(void) ? $@"
if (__DP_ARG___is_return) __DP_ARG___return_value = __DP_ARG___{proxyMethodName}{a}.ReturnValue;" : "")}
}}" :
$"if (__DP_ARG___{proxyMethodName}{a}.Exception != null && __DP_ARG___{proxyMethodName}{a}.ExceptionHandled == false) throw __DP_ARG___{proxyMethodName}{a}.Exception;")}");
}
return sbt.ToString();
};
Func<Type, DynamicProxyInjectorType, bool, string, string> getMatchedAttributesCodeReturn = (returnType, injectorType, isAsync, basePropertyValueTpl) =>
{
var sbt = new StringBuilder();
var taskType = returnType.ReturnTypeWithoutTask();
sbt.Append($@"
{(returnType == typeof(void) ? "return;" : (isAsync == false && returnType.IsTask() ?
(taskType.IsValueType || taskType.IsGenericParameter ?
$"return __DP_ARG___return_value == null ? null : (__DP_ARG___return_value.GetType() == typeof({taskType.DisplayCsharp()}) ? System.Threading.Tasks.Task.FromResult(({taskType.DisplayCsharp()})__DP_ARG___return_value) : ({returnType.DisplayCsharp()})__DP_ARG___return_value);" :
$"return __DP_ARG___return_value == null ? null : (__DP_ARG___return_value.GetType() == typeof({taskType.DisplayCsharp()}) ? System.Threading.Tasks.Task.FromResult(__DP_ARG___return_value as {taskType.DisplayCsharp()}) : ({returnType.DisplayCsharp()})__DP_ARG___return_value);"
) :
(returnType.IsValueType || returnType.IsGenericParameter ? $"return ({returnType.DisplayCsharp()})__DP_ARG___return_value;" : $"return __DP_ARG___return_value as {returnType.DisplayCsharp()};")))}");
return sbt.ToString();
};
Func<string, Type, string> getMatchedAttributesCodeAuditParameter = (methodParameterName, methodParameterType) =>
{
return $@"
if (!object.ReferenceEquals({methodParameterName}, __DP_ARG___parameters[""{methodParameterName}""])) {methodParameterName} = {(methodParameterType.IsValueType ? $@"({methodParameterType.DisplayCsharp()})__DP_ARG___parameters[""{methodParameterName}""]" : $@"__DP_ARG___parameters[""{methodParameterName}""] as {methodParameterType.DisplayCsharp()}")};";
};
#endregion
#region Methods
var ctors = type.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Where(a => a.IsStatic == false).ToArray();
var methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
foreach (var method in methods)
{
if (method.Name.StartsWith("get_") || method.Name.StartsWith("set_"))
if (type.GetProperty(method.Name.Substring(4), BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly) != null) continue;
var attrs = method.GetCustomAttributes(false).Select(a => a as DynamicProxyAttribute).Where(a => a != null).ToArray();
if (attrs.Any() == false) continue;
var attrsIndex = matchedAttributes.Count;
matchedMemberInfos.AddRange(attrs.Select(a => method));
matchedAttributes.AddRange(attrs);
#if net50 || ns21 || ns20
matchedAttributesFromServices.AddRange(attrs.Select(af => af.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly)
.Where(gf => gf.GetCustomAttribute(typeof(DynamicProxyFromServicesAttribute)) != null).ToArray()));
#else
matchedAttributesFromServices.AddRange(attrs.Select(af => new FieldInfo[0]));
#endif
if (method.IsVirtual == false || method.IsFinal)
{
if (isThrow) throw new ArgumentException($"FreeSql.DynamicProxy 失败提示:{typeCSharpName} 方法 {method.Name} 需要使用 virtual 标记");
continue;
}
#if net40
var returnType = method.ReturnType;
var methodIsAsync = false;
#else
var returnType = method.ReturnType.ReturnTypeWithoutTask();
var methodIsAsync = method.ReturnType.IsTask();
//if (attrs.Where(a => a.GetType().GetMethod("BeforeAsync", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly) != null).Any() ||
// attrs.Where(a => a.GetType().GetMethod("AfterAsync", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly) != null).Any())
//{
//}
#endif
var baseInvoke = type.IsInterface == false ? $@"
try
{{
if (__DP_ARG___is_return == false)
{{{string.Join("", method.GetParameters().Select(a => getMatchedAttributesCodeAuditParameter(a.Name, a.ParameterType)))}
{(returnType != typeof(void) ? "__DP_ARG___return_value = " : "")}{(methodIsAsync ? "await " : "")}base.{method.Name}({(string.Join(", ", method.GetParameters().Select(a => a.Name)))});
}}
}}
catch (Exception __DP_ARG___ex)
{{
__DP_ARG___exception = __DP_ARG___ex;
}}" : "";
sb.Append($@"
{(methodIsAsync ? "async " : "")}{method.DisplayCsharp(true)}
{{
Exception __DP_ARG___exception = null;
var __DP_ARG___is_return = false;
object __DP_ARG___return_value = null;
var __DP_ARG___parameters = new Dictionary<string, object>();{string.Join("\r\n ", method.GetParameters().Select(a => $"__DP_ARG___parameters.Add(\"{a.Name}\", {a.Name});"))}
{getMatchedAttributesCode(returnType, DynamicProxyInjectorType.Method, methodIsAsync, attrsIndex, "Before")}{baseInvoke}
{getMatchedAttributesCode(returnType, DynamicProxyInjectorType.Method, methodIsAsync, attrsIndex, "After")}
{getMatchedAttributesCodeReturn(returnType, DynamicProxyInjectorType.Method, methodIsAsync, null)}
}}");
}
#endregion
var propertyOverrideSb = new StringBuilder();
sb = propertyOverrideSb;
#region Property
var props = type.IsInterface == false ? type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly) : new PropertyInfo[0];
foreach (var prop2 in props)
{
var getMethod = prop2.GetGetMethod(false);
var setMethod = prop2.GetSetMethod(false);
if (getMethod?.IsFinal == true || setMethod?.IsFinal == true || (getMethod?.IsVirtual == false && setMethod?.IsVirtual == false))
{
if (getMethod?.GetCustomAttributes(false).Select(a => a as DynamicProxyAttribute).Where(a => a != null).Any() == true ||
setMethod?.GetCustomAttributes(false).Select(a => a as DynamicProxyAttribute).Where(a => a != null).Any() == true)
{
if (isThrow) throw new ArgumentException($"FreeSql.DynamicProxy 失败提示:{typeCSharpName} 属性 {prop2.Name} 需要使用 virtual 标记");
continue;
}
}
var attrs = prop2.GetCustomAttributes(false).Select(a => a as DynamicProxyAttribute).Where(a => a != null).ToArray();
var prop2AttributeAny = attrs.Any();
var getMethodAttributeAny = prop2AttributeAny;
var setMethodAttributeAny = prop2AttributeAny;
if (attrs.Any() == false && getMethod?.IsVirtual == true)
{
attrs = getMethod.GetCustomAttributes(false).Select(a => a as DynamicProxyAttribute).Where(a => a != null).ToArray();
getMethodAttributeAny = attrs.Any();
}
if (attrs.Any() == false && setMethod?.IsVirtual == true)
{
attrs = setMethod.GetCustomAttributes(false).Select(a => a as DynamicProxyAttribute).Where(a => a != null).ToArray();
setMethodAttributeAny = attrs.Any();
}
if (attrs.Any() == false) continue;
var attrsIndex = matchedAttributes.Count;
matchedMemberInfos.AddRange(attrs.Select(a => prop2));
matchedAttributes.AddRange(attrs);
#if net50 || ns21 || ns20
matchedAttributesFromServices.AddRange(attrs.Select(af => af.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly)
.Where(gf => gf.GetCustomAttribute(typeof(DynamicProxyFromServicesAttribute)) != null).ToArray()));
#else
matchedAttributesFromServices.AddRange(attrs.Select(af => new FieldInfo[0]));
#endif
var returnTypeCSharpName = prop2.PropertyType.DisplayCsharp();
var propModification = (getMethod?.IsPublic == true || setMethod?.IsPublic == true ? "public " : (getMethod?.Isreplacedembly == true || setMethod?.Isreplacedembly == true ? "internal " : (getMethod?.IsFamily == true || setMethod?.IsFamily == true ? "protected " : (getMethod?.IsPrivate == true || setMethod?.IsPrivate == true ? "private " : ""))));
var propSetModification = (setMethod?.IsPublic == true ? "public " : (setMethod?.Isreplacedembly == true ? "internal " : (setMethod?.IsFamily == true ? "protected " : (setMethod?.IsPrivate == true ? "private " : ""))));
var propGetModification = (getMethod?.IsPublic == true ? "public " : (getMethod?.Isreplacedembly == true ? "internal " : (getMethod?.IsFamily == true ? "protected " : (getMethod?.IsPrivate == true ? "private " : ""))));
if (propSetModification == propModification) propSetModification = "";
if (propGetModification == propModification) propGetModification = "";
//if (getMethod.IsAbstract) sb.Append("abstract ");
sb.Append($@"
{propModification}{(getMethod?.IsStatic == true ? "static " : "")}{(getMethod?.IsVirtual == true ? "override " : "")}{returnTypeCSharpName} {prop2.Name}
{{");
if (getMethod != null)
{
if (getMethodAttributeAny == false) sb.Append($@"
{propGetModification} get
{{
return base.{prop2.Name}
}}");
else sb.Append($@"
{propGetModification} get
{{
Exception __DP_ARG___exception = null;
var __DP_ARG___is_return = false;
object __DP_ARG___return_value = null;
var __DP_ARG___parameters = new Dictionary<string, object>();
{getMatchedAttributesCode(prop2.PropertyType, DynamicProxyInjectorType.PropertyGet, false, attrsIndex, "Before")}
try
{{
if (__DP_ARG___is_return == false) __DP_ARG___return_value = base.{prop2.Name};
}}
catch (Exception __DP_ARG___ex)
{{
__DP_ARG___exception = __DP_ARG___ex;
}}
{getMatchedAttributesCode(prop2.PropertyType, DynamicProxyInjectorType.PropertyGet, false, attrsIndex, "After")}
{getMatchedAttributesCodeReturn(prop2.PropertyType, DynamicProxyInjectorType.Method, false, null)}
}}");
}
if (setMethod != null)
{
if (setMethodAttributeAny == false) sb.Append($@"
{propSetModification} set
{{
base.{prop2.Name} = value;
}}");
else sb.Append($@"
{propSetModification} set
{{
Exception __DP_ARG___exception = null;
var __DP_ARG___is_return = false;
object __DP_ARG___return_value = null;
var __DP_ARG___parameters = new Dictionary<string, object>();
__DP_ARG___parameters.Add(""value"", value);
{getMatchedAttributesCode(prop2.PropertyType, DynamicProxyInjectorType.PropertySet, false, attrsIndex, "Before")}
try
{{
if (__DP_ARG___is_return == false)
{{{getMatchedAttributesCodeAuditParameter("value", prop2.PropertyType)}
base.{prop2.Name} = value;
}}
}}
catch (Exception __DP_ARG___ex)
{{
__DP_ARG___exception = __DP_ARG___ex;
}}
{getMatchedAttributesCode(prop2.PropertyType, DynamicProxyInjectorType.PropertySet, false, attrsIndex, "After")}
}}");
}
sb.Append($@"
}}");
}
#endregion
string proxyCscode = "";
replacedembly proxyreplacedembly = null;
Type proxyType = null;
if (matchedMemberInfos.Any())
{
#region Constructors
sb = new StringBuilder();
var fromServicesTypes = matchedAttributesFromServices.SelectMany(fs => fs).GroupBy(a => a.FieldType).Select((a, b) => new KeyValuePair<Type, string>(a.Key, $"__DP_ARG___FromServices_{b}")).ToDictionary(a => a.Key, a => a.Value);
sb.Append(string.Join("", fromServicesTypes.Select(serviceType => $@"
private {serviceType.Key.DisplayCsharp()} {serviceType.Value};")));
foreach (var ctor in ctors)
{
var ctorParams = ctor.GetParameters();
sb.Append($@"
{(ctor.IsPrivate ? "private " : "")}{(ctor.IsFamily ? "protected " : "")}{(ctor.Isreplacedembly ? "internal " : "")}{(ctor.IsPublic ? "public " : "")}{clreplacedName}({string.Join(", ", ctorParams.Select(a => $"{a.ParameterType.DisplayCsharp()} {a.Name}"))}{
(ctorParams.Any() && fromServicesTypes.Any() ? ", " : "")}{
string.Join(", ", fromServicesTypes.Select(serviceType => $@"{serviceType.Key.DisplayCsharp()} parameter{serviceType.Value}"))})
: base({(string.Join(", ", ctorParams.Select(a => a.Name)))})
{{{string.Join("", fromServicesTypes.Select(serviceType => $@"
{serviceType.Value} = parameter{serviceType.Value};"))}
}}");
}
for (var a = 0; a < matchedAttributesFromServices.Count; a++)
{
sb.Append($@"
private void __DP_ARG___attribute{a}_FromServicesCopyTo({_idynamicProxyName} attr)
{{{string.Join("", matchedAttributesFromServices[a].Select(fs => $@"
__DP_Meta.{nameof(DynamicProxyMeta.SetDynamicProxyAttributePropertyValue)}({a}, attr, ""{fs.Name}"", {fromServicesTypes[fs.FieldType]});"))}
}}");
}
#endregion
proxyCscode = $@"using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text;
public clreplaced {clreplacedName} : {typeCSharpName}
{{
private {_metaName} __DP_Meta = {typeof(DynamicProxy).DisplayCsharp()}.{nameof(GetAvailableMeta)}(typeof({typeCSharpName}));
//这里要注释掉,如果重写的基类没有无参构造函数,会报错
//public {clreplacedName}({_metaName} meta)
//{{
// __DP_Meta = meta;
//}}
{sb.ToString()}
{methodOverrideSb.ToString()}
{propertyOverrideSb.ToString()}
}}";
proxyreplacedembly = isCompile == false ? null : CompileCode(proxyCscode);
proxyType = isCompile == false ? null : proxyreplacedembly.GetExportedTypes()/*.DefinedTypes*/.Where(a => a.FullName.EndsWith(clreplacedName)).FirstOrDefault();
}
methodOverrideSb.Clear();
propertyOverrideSb.Clear();
sb.Clear();
return new DynamicProxyMeta(
type, ctors,
matchedMemberInfos.ToArray(), matchedAttributes.ToArray(),
isCompile == false ? proxyCscode : null, clreplacedName, proxyreplacedembly, proxyType);
}
19
Source : DynamicProxyMeta.cs
with MIT License
from 2881099
with MIT License
from 2881099
public static object CreateInstanceDefault(Type type)
{
if (type == null) return null;
if (type == typeof(string)) return default(string);
if (type.IsArray) return Array.CreateInstance(type, 0);
var ctorParms = InternalGetTypeConstructor0OrFirst(type, true)?.GetParameters();
if (ctorParms == null || ctorParms.Any() == false) return Activator.CreateInstance(type, null);
return Activator.CreateInstance(type, ctorParms.Select(a => a.ParameterType.IsInterface || a.ParameterType.IsAbstract || a.ParameterType == typeof(string) ? null : Activator.CreateInstance(a.ParameterType, null)).ToArray());
}
19
Source : DynamicProxyMeta.cs
with MIT License
from 2881099
with MIT License
from 2881099
internal static NewExpression InternalNewExpression(Type that)
{
var ctor = InternalGetTypeConstructor0OrFirst(that);
return Expression.New(ctor, ctor.GetParameters().Select(a => Expression.Constant(CreateInstanceDefault(a.ParameterType), a.ParameterType)));
}
19
Source : Admin.cs
with MIT License
from 2881099
with MIT License
from 2881099
async public static Task<bool> Use(HttpContext context, IFreeSql fsql, string requestPathBase, Dictionary<string, Type> dicEnreplacedyTypes) {
HttpRequest req = context.Request;
HttpResponse res = context.Response;
var remUrl = req.Path.ToString().Substring(requestPathBase.Length).Trim(' ', '/').Split('/');
var enreplacedyName = remUrl.FirstOrDefault();
if (!string.IsNullOrEmpty(enreplacedyName)) {
if (dicEnreplacedyTypes.TryGetValue(enreplacedyName, out var enreplacedyType) == false) throw new Exception($"UseFreeAdminLtePreview 错误,找不到实体类型:{enreplacedyName}");
var tb = fsql.CodeFirst.GetTableByEnreplacedy(enreplacedyType);
if (tb == null) throw new Exception($"UseFreeAdminLtePreview 错误,实体类型无法映射:{enreplacedyType.FullName}");
var tpl = _tpl.Value;
switch (remUrl.ElementAtOrDefault(1)?.ToLower()) {
case null:
//首页
if (true) {
MakeTemplateFile($"{enreplacedyName}-list.html", Views.List);
//ManyToOne/OneToOne
var getlistFilter = new List<(TableRef, string, string, Dictionary<string, object>, List<Dictionary<string, object>>)>();
foreach (var prop in tb.Properties) {
if (tb.ColumnsByCs.ContainsKey(prop.Key)) continue;
var tbref = tb.GetTableRef(prop.Key, false);
if (tbref == null) continue;
switch (tbref.RefType) {
case TableRefType.OneToMany: continue;
case TableRefType.ManyToOne:
getlistFilter.Add(await Utils.GetTableRefData(fsql, tbref));
continue;
case TableRefType.OneToOne:
continue;
case TableRefType.ManyToMany:
getlistFilter.Add(await Utils.GetTableRefData(fsql, tbref));
continue;
}
}
int.TryParse(req.Query["page"].FirstOrDefault(), out var getpage);
int.TryParse(req.Query["limit"].FirstOrDefault(), out var getlimit);
if (getpage <= 0) getpage = 1;
if (getlimit <= 0) getlimit = 20;
var getselect = fsql.Select<object>().AsType(enreplacedyType);
foreach (var getlistF in getlistFilter) {
var qv = req.Query[getlistF.Item3].ToArray();
if (qv.Any()) {
switch (getlistF.Item1.RefType) {
case TableRefType.OneToMany: continue;
case TableRefType.ManyToOne:
getselect.Where(Utils.GetObjectWhereExpressionContains(tb, enreplacedyType, getlistF.Item1.Columns[0].CsName, qv));
continue;
case TableRefType.OneToOne:
continue;
case TableRefType.ManyToMany:
if (true) {
var midType = getlistF.Item1.RefMiddleEnreplacedyType;
var midTb = fsql.CodeFirst.GetTableByEnreplacedy(midType);
var midISelect = typeof(ISelect<>).MakeGenericType(midType);
var funcType = typeof(Func<,>).MakeGenericType(typeof(object), typeof(bool));
var expParam = Expression.Parameter(typeof(object), "a");
var midParam = Expression.Parameter(midType, "mdtp");
var anyMethod = midISelect.GetMethod("Any");
var selectExp = qv.Select(c => Expression.Convert(Expression.Constant(FreeSql.Internal.Utils.GetDataReaderValue(getlistF.Item1.MiddleColumns[1].CsType, c)), getlistF.Item1.MiddleColumns[1].CsType)).ToArray();
var expLambad = Expression.Lambda<Func<object, bool>>(
Expression.Call(
Expression.Call(
Expression.Call(
Expression.Constant(fsql),
typeof(IFreeSql).GetMethod("Select", new Type[0]).MakeGenericMethod(midType)
),
midISelect.GetMethod("Where", new[] { typeof(Expression<>).MakeGenericType(typeof(Func<,>).MakeGenericType(midType, typeof(bool))) }),
Expression.Lambda(
typeof(Func<,>).MakeGenericType(midType, typeof(bool)),
Expression.AndAlso(
Expression.Equal(
Expression.MakeMemberAccess(Expression.TypeAs(expParam, enreplacedyType), tb.Properties[getlistF.Item1.Columns[0].CsName]),
Expression.MakeMemberAccess(midParam, midTb.Properties[getlistF.Item1.MiddleColumns[0].CsName])
),
Expression.Call(
Utils.GetLinqContains(getlistF.Item1.MiddleColumns[1].CsType),
Expression.NewArrayInit(
getlistF.Item1.MiddleColumns[1].CsType,
selectExp
),
Expression.MakeMemberAccess(midParam, midTb.Properties[getlistF.Item1.MiddleColumns[1].CsName])
)
),
midParam
)
),
anyMethod,
Expression.Default(anyMethod.GetParameters().FirstOrDefault().ParameterType)
),
expParam);
getselect.Where(expLambad);
}
continue;
}
}
}
var getlistTotal = await getselect.CountAsync();
var getlist = await getselect.Page(getpage, getlimit).ToListAsync();
var gethashlists = new Dictionary<string, object>[getlist.Count];
var gethashlistsIndex = 0;
foreach (var getlisreplacedem in getlist) {
var gethashlist = new Dictionary<string, object>();
foreach (var getcol in tb.ColumnsByCs) {
gethashlist.Add(getcol.Key, tb.Properties[getcol.Key].GetValue(getlisreplacedem));
}
gethashlists[gethashlistsIndex++] = gethashlist;
}
var options = new Dictionary<string, object>();
options["tb"] = tb;
options["getlist"] = gethashlists;
options["getlistTotal"] = getlistTotal;
options["getlistFilter"] = getlistFilter;
var str = _tpl.Value.RenderFile($"{enreplacedyName}-list.html", options);
await res.WriteAsync(str);
}
return true;
case "add":
case "edit":
//编辑页
object gereplacedem = null;
Dictionary<string, object> gethash = null;
if (req.Query.Any()) {
gereplacedem = Activator.CreateInstance(enreplacedyType);
foreach (var getpk in tb.Primarys) {
var reqv = req.Query[getpk.CsName].ToArray();
if (reqv.Any())
fsql.SetEnreplacedyValueWithPropertyName(enreplacedyType, gereplacedem, getpk.CsName, reqv.Length == 1 ? (object)reqv.FirstOrDefault() : reqv);
}
gereplacedem = await fsql.Select<object>().AsType(enreplacedyType).WhereDynamic(gereplacedem).FirstAsync();
if (gereplacedem != null) {
gethash = new Dictionary<string, object>();
foreach (var getcol in tb.ColumnsByCs) {
gethash.Add(getcol.Key, tb.Properties[getcol.Key].GetValue(gereplacedem));
}
}
}
if (req.Method.ToLower() == "get") {
MakeTemplateFile($"{enreplacedyName}-edit.html", Views.Edit);
//ManyToOne/OneToOne
var getlistFilter = new Dictionary<string, (TableRef, string, string, Dictionary<string, object>, List<Dictionary<string, object>>)>();
var getlistManyed = new Dictionary<string, IEnumerable<string>>();
foreach (var prop in tb.Properties) {
if (tb.ColumnsByCs.ContainsKey(prop.Key)) continue;
var tbref = tb.GetTableRef(prop.Key, false);
if (tbref == null) continue;
switch (tbref.RefType) {
case TableRefType.OneToMany: continue;
case TableRefType.ManyToOne:
getlistFilter.Add(prop.Key, await Utils.GetTableRefData(fsql, tbref));
continue;
case TableRefType.OneToOne:
continue;
case TableRefType.ManyToMany:
getlistFilter.Add(prop.Key, await Utils.GetTableRefData(fsql, tbref));
if (gereplacedem != null) {
var midType = tbref.RefMiddleEnreplacedyType;
var midTb = fsql.CodeFirst.GetTableByEnreplacedy(midType);
var manyed = await fsql.Select<object>().AsType(midType)
.Where(Utils.GetObjectWhereExpression(midTb, midType, tbref.MiddleColumns[0].CsName, fsql.GetEnreplacedyKeyValues(enreplacedyType, gereplacedem)[0]))
.ToListAsync();
getlistManyed.Add(prop.Key, manyed.Select(a => fsql.GetEnreplacedyValueWithPropertyName(midType, a, tbref.MiddleColumns[1].CsName).ToString()));
}
continue;
}
}
var options = new Dictionary<string, object>();
options["tb"] = tb;
options["gethash"] = gethash;
options["getlistFilter"] = getlistFilter;
options["getlistManyed"] = getlistManyed;
options["postaction"] = $"{requestPathBase}restful-api/{enreplacedyName}";
var str = _tpl.Value.RenderFile($"{enreplacedyName}-edit.html", options);
await res.WriteAsync(str);
} else {
if (gereplacedem == null) {
gereplacedem = Activator.CreateInstance(enreplacedyType);
foreach(var getcol in tb.Columns.Values) {
if (new[] { typeof(DateTime), typeof(DateTime?) }.Contains(getcol.CsType) && new[] { "create_time", "createtime" }.Contains(getcol.CsName.ToLower()))
fsql.SetEnreplacedyValueWithPropertyName(enreplacedyType, gereplacedem, getcol.CsName, DateTime.Now);
}
}
var manySave = new List<(TableRef, object[], List<object>)>();
if (req.Form.Any()) {
foreach(var getcol in tb.Columns.Values) {
if (new[] { typeof(DateTime), typeof(DateTime?) }.Contains(getcol.CsType) && new[] { "update_time", "updatetime" }.Contains(getcol.CsName.ToLower()))
fsql.SetEnreplacedyValueWithPropertyName(enreplacedyType, gereplacedem, getcol.CsName, DateTime.Now);
var reqv = req.Form[getcol.CsName].ToArray();
if (reqv.Any())
fsql.SetEnreplacedyValueWithPropertyName(enreplacedyType, gereplacedem, getcol.CsName, reqv.Length == 1 ? (object)reqv.FirstOrDefault() : reqv);
}
//ManyToMany
foreach (var prop in tb.Properties) {
if (tb.ColumnsByCs.ContainsKey(prop.Key)) continue;
var tbref = tb.GetTableRef(prop.Key, false);
if (tbref == null) continue;
switch (tbref.RefType) {
case TableRefType.OneToMany: continue;
case TableRefType.ManyToOne:
continue;
case TableRefType.OneToOne:
continue;
case TableRefType.ManyToMany:
var midType = tbref.RefMiddleEnreplacedyType;
var mtb = fsql.CodeFirst.GetTableByEnreplacedy(midType);
var reqv = req.Form[$"mn_{prop.Key}"].ToArray();
var reqvIndex = 0;
var manyVals = new object[reqv.Length];
foreach (var rv in reqv) {
var miditem = Activator.CreateInstance(midType);
foreach (var getcol in tb.Columns.Values) {
if (new[] { typeof(DateTime), typeof(DateTime?) }.Contains(getcol.CsType) && new[] { "create_time", "createtime" }.Contains(getcol.CsName.ToLower()))
fsql.SetEnreplacedyValueWithPropertyName(midType, miditem, getcol.CsName, DateTime.Now);
if (new[] { typeof(DateTime), typeof(DateTime?) }.Contains(getcol.CsType) && new[] { "update_time", "updatetime" }.Contains(getcol.CsName.ToLower()))
fsql.SetEnreplacedyValueWithPropertyName(midType, miditem, getcol.CsName, DateTime.Now);
}
//fsql.SetEnreplacedyValueWithPropertyName(midType, miditem, tbref.MiddleColumns[0].CsName, fsql.GetEnreplacedyKeyValues(enreplacedyType, gereplacedem)[0]);
fsql.SetEnreplacedyValueWithPropertyName(midType, miditem, tbref.MiddleColumns[1].CsName, rv);
manyVals[reqvIndex++] = miditem;
}
var molds = await fsql.Select<object>().AsType(midType).Where(Utils.GetObjectWhereExpression(mtb, midType, tbref.MiddleColumns[0].CsName, fsql.GetEnreplacedyKeyValues(enreplacedyType, gereplacedem)[0])).ToListAsync();
manySave.Add((tbref, manyVals, molds));
continue;
}
}
}
using (var db = fsql.CreateDbContext()) {
var dbset = db.Set<object>();
dbset.AsType(enreplacedyType);
await dbset.AddOrUpdateAsync(gereplacedem);
foreach (var ms in manySave) {
var midType = ms.Item1.RefMiddleEnreplacedyType;
var moldsDic = ms.Item3.ToDictionary(a => fsql.GetEnreplacedyKeyString(midType, a, true));
var manyset = db.Set<object>();
manyset.AsType(midType);
foreach (var msVal in ms.Item2) {
fsql.SetEnreplacedyValueWithPropertyName(midType, msVal, ms.Item1.MiddleColumns[0].CsName, fsql.GetEnreplacedyKeyValues(enreplacedyType, gereplacedem)[0]);
await manyset.AddOrUpdateAsync(msVal);
moldsDic.Remove(fsql.GetEnreplacedyKeyString(midType, msVal, true));
}
manyset.RemoveRange(moldsDic.Values);
}
await db.SaveChangesAsync();
}
gethash = new Dictionary<string, object>();
foreach (var getcol in tb.ColumnsByCs) {
gethash.Add(getcol.Key, tb.Properties[getcol.Key].GetValue(gereplacedem));
}
await Utils.Jsonp(context, new { code = 0, success = true, message = "Success", data = gethash });
}
return true;
case "del":
if (req.Method.ToLower() == "post") {
var delitems = new List<object>();
var reqv = new List<string[]>();
foreach(var delpk in tb.Primarys) {
var reqvs = req.Form[delpk.CsName].ToArray();
if (reqv.Count > 0 && reqvs.Length != reqv[0].Length) throw new Exception("删除失败,联合主键参数传递不对等");
reqv.Add(reqvs);
}
if (reqv[0].Length == 0) return true;
using (var ctx = fsql.CreateDbContext()) {
var dbset = ctx.Set<object>();
dbset.AsType(enreplacedyType);
for (var a = 0; a < reqv[0].Length; a++) {
object delitem = Activator.CreateInstance(enreplacedyType);
var delpkindex = 0;
foreach (var delpk in tb.Primarys)
fsql.SetEnreplacedyValueWithPropertyName(enreplacedyType, delitem, delpk.CsName, reqv[delpkindex++][a]);
dbset.Remove(delitem);
}
await ctx.SaveChangesAsync();
}
await Utils.Jsonp(context, new { code = 0, success = true, message = "Success" });
return true;
}
break;
}
}
return false;
}
19
Source : InternalExtensions.cs
with MIT License
from 2881099
with MIT License
from 2881099
static string DisplayCsharp(this MethodInfo method, bool isOverride)
{
if (method == null) return null;
var sb = new StringBuilder();
if (method.IsPublic) sb.Append("public ");
if (method.Isreplacedembly) sb.Append("internal ");
if (method.IsFamily) sb.Append("protected ");
if (method.IsPrivate) sb.Append("private ");
if (method.IsPrivate) sb.Append("private ");
if (method.IsStatic) sb.Append("static ");
if (method.IsAbstract && method.DeclaringType.IsInterface == false) sb.Append("abstract ");
if (method.IsVirtual && method.DeclaringType.IsInterface == false) sb.Append(isOverride ? "override " : "virtual ");
sb.Append(method.ReturnType.DisplayCsharp()).Append(" ").Append(method.Name);
var genericParameters = method.GetGenericArguments();
if (method.DeclaringType.IsNested && method.DeclaringType.DeclaringType.IsGenericType)
{
var dic = genericParameters.ToDictionary(a => a.Name);
foreach (var nestedGenericParameter in method.DeclaringType.DeclaringType.GetGenericArguments())
if (dic.ContainsKey(nestedGenericParameter.Name))
dic.Remove(nestedGenericParameter.Name);
genericParameters = dic.Values.ToArray();
}
if (genericParameters.Any())
sb.Append("<")
.Append(string.Join(", ", genericParameters.Select(a => a.DisplayCsharp())))
.Append(">");
sb.Append("(").Append(string.Join(", ", method.GetParameters().Select(a => $"{a.ParameterType.DisplayCsharp()} {a.Name}"))).Append(")");
return sb.ToString();
}
19
Source : TypeExtension.cs
with MIT License
from 2881099
with MIT License
from 2881099
public static string ToProxy(this MethodInfo method)
{
if (method == null) return null;
var sb = new StringBuilder();
sb.Append(" public ");
var returnType = method.ReturnType;
var isNoResultAsync = returnType == typeof(Task) || returnType == typeof(ValueTask);
var isGenericAsync = returnType.IsGenericType && (returnType.GetGenericTypeDefinition() == typeof(ValueTask<>) || returnType.GetGenericTypeDefinition() == typeof(Task<>));
var isAsync = isGenericAsync || isNoResultAsync;
if (isAsync)
sb.Append("async ");
var funcInfo = method.ToInterface(false);
sb.AppendLine(funcInfo);
sb.AppendLine(" {");
var isResult = false;
if (isAsync)
{
sb.AppendLine($" await _context.BeforeAsync(typeof(RedisClient).GetMethod({method.Name}))");
}
else
{
sb.AppendLine($" _context.Before(typeof(RedisClient).GetMethod({method.Name}))");
}
if (isAsync)
{
if (isNoResultAsync)
sb.Append(" await _redisClient.").Append(method.Name);
else
{
isResult = true;
sb.Append(" var result = await _redisClient.").Append(method.Name);
}
}
else
{
if (returnType == typeof(void))
{
sb.Append(" _redisClient.").Append(method.Name);
}
else
{
isResult = true;
sb.Append(" var result = _redisClient.").Append(method.Name);
}
}
var genericParameters = method.GetGenericArguments();
if (method.DeclaringType.IsNested && method.DeclaringType.DeclaringType.IsGenericType)
{
var dic = genericParameters.ToDictionary(a => a.Name);
foreach (var nestedGenericParameter in method.DeclaringType.DeclaringType.GetGenericArguments())
if (dic.ContainsKey(nestedGenericParameter.Name))
dic.Remove(nestedGenericParameter.Name);
genericParameters = dic.Values.ToArray();
}
if (genericParameters.Any())
sb.Append("<")
.Append(string.Join(", ", genericParameters.Select(a => a.DisplayCsharp())))
.Append(">");
sb.Append("(").Append(string.Join(", ", method.GetParameters().Select(a => $" {a.Name}"))).AppendLine(");");
if (isAsync)
{
sb.AppendLine($" await _context.AfterAsync(typeof(RedisClient).GetMethod({method.Name}))");
}
else
{
sb.AppendLine($" _context.After(typeof(RedisClient).GetMethod({method.Name}))");
}
if (isResult)
sb.AppendLine(" return result;");
sb.Append(" }\r\n\r\n");
return sb.ToString();
}
19
Source : TypeExtension.cs
with MIT License
from 2881099
with MIT License
from 2881099
public static string ToMethod(this MethodInfo method)
{
if (method == null) return null;
var sb = new StringBuilder();
sb.Append(" public static ");
var returnType = method.ReturnType;
var isNoResultAsync = returnType == typeof(Task) || returnType == typeof(ValueTask);
var isGenericAsync = returnType.IsGenericType && (returnType.GetGenericTypeDefinition() == typeof(ValueTask<>) || returnType.GetGenericTypeDefinition() == typeof(Task<>));
var isAsync = isGenericAsync || isNoResultAsync;
var isResult = false;
if (isAsync)
sb.Append("async ");
var funcInfo = method.ToInterface(false);
sb.AppendLine(funcInfo);
sb.AppendLine(" {");
if (isAsync)
{
if (isNoResultAsync)
sb.Append(" await _redisClient.").Append(method.Name);
else
{
isResult = true;
sb.Append(" var result = await _redisClient.").Append(method.Name);
}
}
else
{
if (returnType == typeof(void))
{
sb.Append(" _redisClient.").Append(method.Name);
}
else
{
isResult = true;
sb.Append(" var result = _redisClient.").Append(method.Name);
}
}
var genericParameters = method.GetGenericArguments();
if (method.DeclaringType.IsNested && method.DeclaringType.DeclaringType.IsGenericType)
{
var dic = genericParameters.ToDictionary(a => a.Name);
foreach (var nestedGenericParameter in method.DeclaringType.DeclaringType.GetGenericArguments())
if (dic.ContainsKey(nestedGenericParameter.Name))
dic.Remove(nestedGenericParameter.Name);
genericParameters = dic.Values.ToArray();
}
if (genericParameters.Any())
sb.Append("<")
.Append(string.Join(", ", genericParameters.Select(a => a.DisplayCsharp())))
.Append(">");
sb.Append("(").Append(string.Join(", ", method.GetParameters().Select(a => $" {a.Name}"))).AppendLine(");");
if (isResult)
sb.AppendLine(" return result;");
sb.Append(" }\r\n\r\n");
return sb.ToString();
}
19
Source : Utils.cs
with MIT License
from 2881099
with MIT License
from 2881099
public static MethodInfo GetLinqContains(Type genericType) {
return _dicGetLinqContains.GetOrAdd(genericType, gt => {
var methods = _dicMethods.GetOrAdd(typeof(Enumerable), gt2 => gt2.GetMethods());
var method = methods.Where(a => a.Name == "Contains" && a.GetParameters().Length == 2).FirstOrDefault();
return method?.MakeGenericMethod(gt);
});
}
19
Source : JsonMapper.cs
with MIT License
from 404Lcc
with MIT License
from 404Lcc
public unsafe static void RegisterILRuntimeCLRRedirection(ILRuntime.Runtime.Enviorment.AppDomain appdomain)
{
foreach(var i in typeof(JsonMapper).GetMethods())
{
if(i.Name == "ToObject" && i.IsGenericMethodDefinition)
{
var param = i.GetParameters();
if(param[0].ParameterType == typeof(string))
{
appdomain.RegisterCLRMethodRedirection(i, JsonToObject);
}
else if(param[0].ParameterType == typeof(JsonReader))
{
appdomain.RegisterCLRMethodRedirection(i, JsonToObject2);
}
else if (param[0].ParameterType == typeof(TextReader))
{
appdomain.RegisterCLRMethodRedirection(i, JsonToObject3);
}
}
}
}
19
Source : CallbackSet.cs
with MIT License
from 404Lcc
with MIT License
from 404Lcc
internal static bool CheckCallbackParameters(TypeModel model, MethodInfo method)
{
ParameterInfo[] args = method.GetParameters();
for (int i = 0; i < args.Length; i++)
{
Type paramType = args[i].ParameterType;
if(paramType == model.MapType(typeof(SerializationContext))) {}
else if(paramType == model.MapType(typeof(System.Type))) {}
#if PLAT_BINARYFORMATTER
else if(paramType == model.MapType(typeof(System.Runtime.Serialization.StreamingContext))) {}
#endif
else return false;
}
return true;
}
19
Source : ValueMember.cs
with MIT License
from 404Lcc
with MIT License
from 404Lcc
public void SetSpecified(MethodInfo getSpecified, MethodInfo setSpecified)
{
if (this.getSpecified != getSpecified || this.setSpecified != setSpecified)
{
if (getSpecified != null)
{
if (getSpecified.ReturnType != model.MapType(typeof(bool))
|| getSpecified.IsStatic
|| getSpecified.GetParameters().Length != 0)
{
throw new ArgumentException("Invalid pattern for checking member-specified", "getSpecified");
}
}
if (setSpecified != null)
{
ParameterInfo[] args;
if (setSpecified.ReturnType != model.MapType(typeof(void))
|| setSpecified.IsStatic
|| (args = setSpecified.GetParameters()).Length != 1
|| args[0].ParameterType != model.MapType(typeof(bool)))
{
throw new ArgumentException("Invalid pattern for setting member-specified", "setSpecified");
}
}
ThrowIfFrozen();
this.getSpecified = getSpecified;
this.setSpecified = setSpecified;
}
}
19
Source : ImmutableCollectionDecorator.cs
with MIT License
from 404Lcc
with MIT License
from 404Lcc
internal static bool IdentifyImmutable(TypeModel model, Type declaredType, out MethodInfo builderFactory, out MethodInfo add, out MethodInfo addRange, out MethodInfo finish)
{
builderFactory = add = addRange = finish = null;
if (model == null || declaredType == null) return false;
#if WINRT || COREFX || PROFILE259
TypeInfo declaredTypeInfo = declaredType.GetTypeInfo();
#else
Type declaredTypeInfo = declaredType;
#endif
// try to detect immutable collections; firstly, they are all generic, and all implement IReadOnlyCollection<T> for some T
if(!declaredTypeInfo.IsGenericType) return false;
#if WINRT || COREFX || PROFILE259
Type[] typeArgs = declaredTypeInfo.GenericTypeArguments, effectiveType;
#else
Type[] typeArgs = declaredTypeInfo.GetGenericArguments(), effectiveType;
#endif
switch (typeArgs.Length)
{
case 1:
effectiveType = typeArgs;
break; // fine
case 2:
Type kvp = model.MapType(typeof(System.Collections.Generic.KeyValuePair<,>));
if (kvp == null) return false;
kvp = kvp.MakeGenericType(typeArgs);
effectiveType = new Type[] { kvp };
break;
default:
return false; // no clue!
}
if (ResolveIReadOnlyCollection(declaredType, null) == null) return false; // no IReadOnlyCollection<T> found
// and we want to use the builder API, so for generic Foo<T> or IFoo<T> we want to use Foo.CreateBuilder<T>
string name = declaredType.Name;
int i = name.IndexOf('`');
if (i <= 0) return false;
name = declaredTypeInfo.IsInterface ? name.Substring(1, i - 1) : name.Substring(0, i);
Type outerType = model.GetType(declaredType.Namespace + "." + name, declaredTypeInfo.replacedembly);
// I hate special-cases...
if (outerType == null && name == "ImmutableSet")
{
outerType = model.GetType(declaredType.Namespace + ".ImmutableHashSet", declaredTypeInfo.replacedembly);
}
if (outerType == null) return false;
#if WINRT || PROFILE259
foreach (MethodInfo method in outerType.GetTypeInfo().DeclaredMethods)
#else
foreach (MethodInfo method in outerType.GetMethods())
#endif
{
if (!method.IsStatic || method.Name != "CreateBuilder" || !method.IsGenericMethodDefinition || method.GetParameters().Length != 0
|| method.GetGenericArguments().Length != typeArgs.Length) continue;
builderFactory = method.MakeGenericMethod(typeArgs);
break;
}
Type voidType = model.MapType(typeof(void));
if (builderFactory == null || builderFactory.ReturnType == null || builderFactory.ReturnType == voidType) return false;
add = Helpers.GetInstanceMethod(builderFactory.ReturnType, "Add", effectiveType);
if (add == null) return false;
finish = Helpers.GetInstanceMethod(builderFactory.ReturnType, "ToImmutable", Helpers.EmptyTypes);
if (finish == null || finish.ReturnType == null || finish.ReturnType == voidType) return false;
if (!(finish.ReturnType == declaredType || Helpers.IsreplacedignableFrom(declaredType, finish.ReturnType))) return false;
addRange = Helpers.GetInstanceMethod(builderFactory.ReturnType, "AddRange", new Type[] { declaredType });
if (addRange == null)
{
Type enumerable = model.MapType(typeof(System.Collections.Generic.IEnumerable<>), false);
if (enumerable != null)
{
addRange = Helpers.GetInstanceMethod(builderFactory.ReturnType, "AddRange", new Type[] { enumerable.MakeGenericType(effectiveType) });
}
}
return true;
}
19
Source : TypeSerializer.cs
with MIT License
from 404Lcc
with MIT License
from 404Lcc
private object InvokeCallback(MethodInfo method, object obj, SerializationContext context)
{
object result = null;
object[] args;
if (method != null)
{ // preplaced in a streaming context if one is needed, else null
bool handled;
ParameterInfo[] parameters = method.GetParameters();
switch (parameters.Length)
{
case 0:
args = null;
handled = true;
break;
default:
args = new object[parameters.Length];
handled = true;
for (int i = 0; i < args.Length; i++)
{
object val;
Type paramType = parameters[i].ParameterType;
if (paramType == typeof(SerializationContext)) val = context;
else if (paramType == typeof(System.Type)) val = constructType;
#if PLAT_BINARYFORMATTER || (SILVERLIGHT && NET_4_0)
else if (paramType == typeof(System.Runtime.Serialization.StreamingContext)) val = (System.Runtime.Serialization.StreamingContext)context;
#endif
else
{
val = null;
handled = false;
}
args[i] = val;
}
break;
}
if(handled)
{
result = method.Invoke(obj, args);
}
else
{
throw Meta.CallbackSet.CreateInvalidCallbackSignature(method);
}
}
return result;
}
19
Source : ReflectionExtensions.cs
with Apache License 2.0
from 42skillz
with Apache License 2.0
from 42skillz
public static bool IsEmpty(this ConstructorInfo constructor)
{
return constructor.GetParameters().Length == 0;
}
19
Source : ReflectionExtensions.cs
with Apache License 2.0
from 42skillz
with Apache License 2.0
from 42skillz
public static IEnumerable<ConstructorInfo> GetConstructorsOrderedByNumberOfParametersDesc(this Type type)
{
var constructors = ((System.Reflection.TypeInfo)type).DeclaredConstructors;
return constructors.OrderByDescending(c => c.GetParameters().Length);
}
19
Source : TypeFuzzer.cs
with Apache License 2.0
from 42skillz
with Apache License 2.0
from 42skillz
private object[] PrepareFuzzedParametersForThisConstructor(ConstructorInfo constructor, int recursionLevel)
{
var parameters = new List<object>();
var parameterInfos = constructor.GetParameters();
foreach (var parameterInfo in parameterInfos)
{
var type = parameterInfo.ParameterType;
// Default .NET types
parameters.Add(FuzzAnyDotNetType(Type.GetTypeCode(type), type, recursionLevel));
}
return parameters.ToArray();
}
19
Source : SurrogateSerializer.cs
with MIT License
from 404Lcc
with MIT License
from 404Lcc
private static bool HasCast(TypeModel model, Type type, Type from, Type to, out MethodInfo op)
{
#if WINRT || PROFILE259
System.Collections.Generic.List<MethodInfo> list = new System.Collections.Generic.List<MethodInfo>();
foreach (var item in type.GetRuntimeMethods())
{
if (item.IsStatic) list.Add(item);
}
MethodInfo[] found = list.ToArray();
#else
const BindingFlags flags = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
MethodInfo[] found = type.GetMethods(flags);
#endif
ParameterInfo[] paramTypes;
Type convertAttributeType = null;
for (int i = 0; i < found.Length; i++)
{
MethodInfo m = found[i];
if (m.ReturnType != to) continue;
paramTypes = m.GetParameters();
if(paramTypes.Length == 1 && paramTypes[0].ParameterType == from)
{
if (convertAttributeType == null)
{
convertAttributeType = model.MapType(typeof(ProtoConverterAttribute), false);
if (convertAttributeType == null)
{ // attribute isn't defined in the source replacedembly: stop looking
break;
}
}
if (m.IsDefined(convertAttributeType, true))
{
op = m;
return true;
}
}
}
for(int i = 0 ; i < found.Length ; i++)
{
MethodInfo m = found[i];
if ((m.Name != "op_Implicit" && m.Name != "op_Explicit") || m.ReturnType != to)
{
continue;
}
paramTypes = m.GetParameters();
if(paramTypes.Length == 1 && paramTypes[0].ParameterType == from)
{
op = m;
return true;
}
}
op = null;
return false;
}
19
Source : Proxy.cs
with MIT License
from 71
with MIT License
from 71
internal static MethodBase FindMatchingMethod(MethodBase[] possibleMethods, string name, params object[] args)
{
for (int i = 0; i < possibleMethods.Length; i++)
{
MethodBase mi = possibleMethods[i];
if (mi.Name != name)
continue;
// Same name, but do the parameters match?
ParameterInfo[] parameters = mi.GetParameters();
if (parameters.Length != args.Length)
continue;
for (int j = 0; j < parameters.Length; j++)
{
object arg = args[j];
ParameterInfo parameter = parameters[j];
if (arg == null)
{
if (parameter.ParameterType.GetTypeInfo().IsValueType)
goto Nope;
continue;
}
if (!parameter.ParameterType.IsInstanceOfType(arg))
goto Nope;
}
return mi;
Nope:;
}
return null;
}
19
Source : ExpressionVisitor`1.cs
with MIT License
from 71
with MIT License
from 71
protected void EnableDynamicVisiting()
{
if (dynamicVisit != null)
return;
Type returnType = typeof(T);
ParameterExpression exprParam = Expression.Parameter(typeof(Expression), "node");
Expression body = Expression.Call(Expression.Constant(this), nameof(DefaultVisit), null, exprParam);
foreach (MethodInfo method in this.GetType().GetTypeInfo().DeclaredMethods)
{
if (method.ReturnType != returnType || !method.Name.StartsWith("Visit"))
continue;
ParameterInfo[] parameters = method.GetParameters();
if (parameters.Length != 1)
continue;
ParameterInfo parameter = parameters[0];
if (!parameter.ParameterType.IsreplacedignableTo(typeof(Expression)))
continue;
// We got this far, it's a valid Visit*() method.
ParameterExpression exprVar = Expression.Parameter(parameter.ParameterType, parameter.Name);
// expr is TExpr newExpr ? newExpr : body
body = Expression.Block(new[] { exprVar },
Expression.replacedign(exprVar, Expression.TypeAs(exprParam, parameter.ParameterType)),
Expression.Condition(
Expression.ReferenceNotEqual(exprVar, Expression.Constant(null)),
exprVar,
body
)
);
}
dynamicVisit = Expression.Lambda<Func<Expression, T>>(body, exprParam).Compile();
}
19
Source : Helpers.cs
with MIT License
from 71
with MIT License
from 71
internal static TDelegate MakeDelegate<TDelegate>(string name, Action<ILGenerator> ilgen, Type owner = null)
where TDelegate : Delegate
{
MethodInfo invokeMethod = typeof(TDelegate).GetMethod("Invoke");
Debug.replacedert(invokeMethod != null);
ParameterInfo[] parameters = invokeMethod.GetParameters();
Type[] parameterTypes = new Type[parameters.Length];
for (int i = 0; i < parameters.Length; i++)
{
parameterTypes[i] = parameters[i].ParameterType;
}
DynamicMethod method = owner == null
? new DynamicMethod(name, invokeMethod.ReturnType, parameterTypes, true)
: new DynamicMethod(name, invokeMethod.ReturnType, parameterTypes, owner, true);
ILGenerator il = method.GetILGenerator();
ilgen(il);
return (TDelegate)method.CreateDelegate(typeof(TDelegate));
}
19
Source : AwaitExpression.cs
with MIT License
from 71
with MIT License
from 71
public static AwaitExpression Await(Expression task, MethodInfo method)
{
Requires.NotNull(task, nameof(task));
if (method == null)
return Await(task);
if (method.ReturnType != typeof(TaskAwaiter)
&& method.ReturnType.GetGenericTypeDefinition() != typeof(TaskAwaiter<>))
throw new ArgumentException("Method does not return a TaskAwaiter.", nameof(method));
ParameterInfo[] parameters = method.GetParameters();
if (method.IsStatic)
{
if (parameters.Length != 1 || parameters[0].ParameterType.GetTypeInfo().IsreplacedignableFrom(task.Type.GetTypeInfo()))
throw new ArgumentException("Invalid method signature.", nameof(method));
}
else
{
if (parameters.Length != 0)
throw new ArgumentException("Invalid method signature.", nameof(method));
}
return new AwaitExpression(task, method);
}
19
Source : StateMachineExpression.cs
with MIT License
from 71
with MIT License
from 71
protected void SetType(Type lambdaType, Type smType)
{
Requires.NotNull(lambdaType, nameof(lambdaType));
Requires.NotNull(smType, nameof(smType));
_type = lambdaType;
_end = Label(lambdaType, "end");
_state = Parameter(smType, "state");
_vsmCtor = smType.GetTypeInfo().DeclaredConstructors.First(x => x.GetParameters().Length == 0);
}
19
Source : MacroExpander.cs
with MIT License
from 71
with MIT License
from 71
public override SyntaxNode VisitInvocationExpression(InvocationExpressionSyntax node)
{
IInvocationExpression invocation = semanticModel.GetOperation(node, cancellationToken) as IInvocationExpression;
if (invocation == null)
return base.VisitInvocationExpression(node);
bool IsMacroMethod(ISymbol methodSymbol, out string error)
{
foreach (var attr in methodSymbol.GetAttributes())
{
if (attr.AttributeClreplaced.MetadataName != nameof(ExpandAttribute))
continue;
if (!methodSymbol.IsStatic)
error = "The target method must be static.";
else
error = null;
return true;
}
error = null;
return false;
}
// Check if it's a call to a macro method
var target = invocation.TargetMethod;
if (!IsMacroMethod(target, out string err))
return base.VisitInvocationExpression(node);
// Make sure it's valid
if (err != null)
throw new DiagnosticException($"Cannot call the specified method as a macro method: {err}.",
invocation.Syntax.GetLocation());
// It is a method, find it
MethodInfo method = target.GetCorrespondingMethod() as MethodInfo;
if (method == null)
throw new DiagnosticException("Cannot find corresponding method.", invocation.Syntax.GetLocation());
// Found it, make the arguments
ParameterInfo[] parameters = method.GetParameters();
object[] arguments = new object[parameters.Length];
for (int i = 0; i < arguments.Length; i++)
{
ParameterInfo param = parameters[i];
Type paramType = param.ParameterType;
if (param.HasDefaultValue)
arguments[i] = param.DefaultValue;
else
arguments[i] = paramType.GetTypeInfo().IsValueType
? Activator.CreateInstance(paramType)
: null;
}
// Set up the context
var statementSyntax = node.FirstAncestorOrSelf<StatementSyntax>();
var statementSymbol = new Lazy<IOperation>(() => semanticModel.GetOperation(statementSyntax, cancellationToken));
var callerSymbol = new Lazy<IMethodSymbol>(() => semanticModel.GetEnclosingSymbol(statementSyntax.SpanStart, cancellationToken) as IMethodSymbol);
var callerInfo = new Lazy<MethodInfo>(() => callerSymbol.Value?.GetCorrespondingMethod() as MethodInfo);
ExpressionSyntax expr;
StatementSyntax stmt;
using (CallBinder.EnterContext(invocation, statementSymbol, node, statementSyntax, method, target, callerInfo, callerSymbol))
{
// Invoke the method
try
{
method.Invoke(null, arguments);
}
catch (Exception e)
{
throw new DiagnosticException($"Exception thrown when expanding the '{method}' macro.", e, invocation.Syntax.GetLocation());
}
(expr, stmt) = CallBinder.Result;
}
// Edit the node accordingly
if (stmt != statementSyntax)
{
// Return the new statement
changes.Add(statementSyntax, stmt.WithTriviaFrom(statementSyntax).Accept(this) as StatementSyntax);
return node;
}
return base.Visit(expr == node ? expr : expr.WithTriviaFrom(node));
}
See More Examples