/// <summary>
/// 参数解析
/// </summary>
/// <param name="paramters"></param>
/// <param name="nvs"></param>
/// <returns></returns>
public static object[] Convert(ParameterInfo[] paramters, NameValueCollection nvs)
{
List<object> args = new List<object>();
var obj = ConvertJsonObject(nvs);
foreach (ParameterInfo info in paramters)
{
var type = GetElementType(info.ParameterType);
var property = obj.Properties().SingleOrDefault(p => string.Compare(p.Name, info.Name, true) == 0);
if (property != null)
{
try
{
//获取Json值
var jsonValue = CoreHelper.ConvertJsonValue(type, property.Value.ToString(Formatting.None));
args.Add(jsonValue);
}
catch (Exception ex)
{
throw new RESTfulException((int)HttpStatusCode.BadRequest, string.Format("Parameter [{0}] did not match type [{1}].",
info.Name, CoreHelper.GetTypeName(type)));
}
}
else
{
throw new RESTfulException((int)HttpStatusCode.BadRequest, "Parameter [" + info.Name + "] is not found.");
}
}
return args.ToArray();
}
public static MethodBuilder DefineMethod(this TypeBuilder typeBuilder, MethodInfo method, MethodAttributes? attributes = null, ParameterInfo[] parameters = null)
{
Type[] parametersTypes = null;
MethodBuilder methodBuilder = null;
parameters = parameters ?? method.GetParameters();
parametersTypes = parameters.ToArray(parameter => parameter.ParameterType);
attributes = attributes ?? method.Attributes & ~MethodAttributes.Abstract;
methodBuilder = typeBuilder.DefineMethod(method.Name, attributes.Value, method.ReturnType, parametersTypes);
parameters.ForEach(1, (parameter, i) => {
var parameterBuilder = methodBuilder.DefineParameter(i, parameter.Attributes, parameter.Name);
if (parameter.IsDefined<ParamArrayAttribute>()) {
parameterBuilder.SetCustomAttribute<ParamArrayAttribute>();
}
else if (parameter.IsOut) {
parameterBuilder.SetCustomAttribute<OutAttribute>();
}
else if (parameter.IsOptional) {
parameterBuilder.SetCustomAttribute<OptionalAttribute>()
.SetConstant(parameter.DefaultValue);
}
});
return methodBuilder;
}
public SqlCallProcedureInfo(MethodInfo method, ISerializationTypeInfoProvider typeInfoProvider)
{
if (method == null) {
throw new ArgumentNullException("method");
}
if (typeInfoProvider == null) {
throw new ArgumentNullException("typeInfoProvider");
}
SqlProcAttribute procedure = GetSqlProcAttribute(method);
schemaName = procedure.SchemaName;
name = procedure.Name;
timeout = procedure.Timeout;
deserializeReturnNullOnEmptyReader = procedure.DeserializeReturnNullOnEmptyReader;
deserializeRowLimit = procedure.DeserializeRowLimit;
deserializeCallConstructor = procedure.DeserializeCallConstructor;
SortedDictionary<int, SqlCallParameterInfo> sortedParams = new SortedDictionary<int, SqlCallParameterInfo>();
outArgCount = 0;
foreach (ParameterInfo parameterInfo in method.GetParameters()) {
if ((parameterInfo.GetCustomAttributes(typeof(SqlNameTableAttribute), true).Length > 0) || (typeof(XmlNameTable).IsAssignableFrom(parameterInfo.ParameterType))) {
if (xmlNameTableParameter == null) {
xmlNameTableParameter = parameterInfo;
}
} else {
SqlCallParameterInfo sqlParameterInfo = new SqlCallParameterInfo(parameterInfo, typeInfoProvider, ref outArgCount);
sortedParams.Add(parameterInfo.Position, sqlParameterInfo);
}
}
parameters = sortedParams.Select(p => p.Value).ToArray();
returnTypeInfo = typeInfoProvider.GetSerializationTypeInfo(method.ReturnType);
if ((procedure.UseReturnValue != SqlReturnValue.Auto) || (method.ReturnType != typeof(void))) {
useReturnValue = (procedure.UseReturnValue == SqlReturnValue.ReturnValue) || ((procedure.UseReturnValue == SqlReturnValue.Auto) && (typeInfoProvider.TypeMappingProvider.GetMapping(method.ReturnType).DbType == SqlDbType.Int));
}
}
private static void AddFunctionsForScript(GenericMenu menu, SerializedProperty listener, UnityEventDrawer.ValidMethodMap method, string targetName)
{
PersistentListenerMode mode1 = method.mode;
UnityEngine.Object objectReferenceValue = listener.FindPropertyRelative("m_Target").objectReferenceValue;
string stringValue = listener.FindPropertyRelative("m_MethodName").stringValue;
PersistentListenerMode mode2 = UnityEventDrawer.GetMode(listener.FindPropertyRelative("m_Mode"));
SerializedProperty propertyRelative = listener.FindPropertyRelative("m_Arguments").FindPropertyRelative("m_ObjectArgumentAssemblyTypeName");
StringBuilder stringBuilder = new StringBuilder();
int length = method.methodInfo.GetParameters().Length;
for (int index = 0; index < length; ++index)
{
System.Reflection.ParameterInfo parameter = method.methodInfo.GetParameters()[index];
stringBuilder.Append(string.Format("{0}", (object)UnityEventDrawer.GetTypeName(parameter.ParameterType)));
if (index < length - 1)
{
stringBuilder.Append(", ");
}
}
bool on = objectReferenceValue == method.target && stringValue == method.methodInfo.Name && mode1 == mode2;
if (on && mode1 == PersistentListenerMode.Object && method.methodInfo.GetParameters().Length == 1)
{
on &= method.methodInfo.GetParameters()[0].ParameterType.AssemblyQualifiedName == propertyRelative.stringValue;
}
string formattedMethodName = UnityEventDrawer.GetFormattedMethodName(targetName, method.methodInfo.Name, stringBuilder.ToString(), mode1 == PersistentListenerMode.EventDefined);
menu.AddItem(new GUIContent(formattedMethodName), on, new GenericMenu.MenuFunction2(UnityEventDrawer.SetEventFunction), (object)new UnityEventDrawer.UnityEventFunction(listener, method.target, method.methodInfo, mode1));
}
/// <summary>
/// Get the type of command option from a method parameter info.
/// </summary>
private static ApplicationCommandOptionType TypeFromMethodParameter(ParameterInfo methodParameter)
{
if (methodParameter.ParameterType == _intType || methodParameter.ParameterType == _intNullableType)
{
return(ApplicationCommandOptionType.Integer);
}
if (methodParameter.ParameterType == _stringType)
{
return(ApplicationCommandOptionType.String);
}
if (methodParameter.ParameterType == _boolType || methodParameter.ParameterType == _boolNullableType)
{
return(ApplicationCommandOptionType.Boolean);
}
if (methodParameter.ParameterType.IsAssignableFrom(_guildChannelType))
{
return(ApplicationCommandOptionType.Channel);
}
if (methodParameter.ParameterType.IsAssignableFrom(_rolelType))
{
return(ApplicationCommandOptionType.Role);
}
if (methodParameter.ParameterType.IsAssignableFrom(_guildUserType))
{
return(ApplicationCommandOptionType.User);
}
throw new Exception($"Got parameter type other than int, string, bool, guild, role, or user. {methodParameter.Name}");
}
public object Bind(IDictionary<string, string> parameters, ParameterInfo parameterInfo)
{
if (parameters.ContainsKey(parameterInfo.Name) && !string.IsNullOrEmpty(parameters[parameterInfo.Name]))
return XDocument.Parse(parameters[parameterInfo.Name]);
return null;
}
public bool HasDataFor(System.Reflection.ParameterInfo parameter)
{
Type parameterType = parameter.ParameterType;
MemberInfo method = parameter.Member;
Type fixtureType = method.ReflectedType;
if (!Reflect.HasAttribute(method, NUnitFramework.TheoryAttribute, true))
{
return(false);
}
if (parameterType == typeof(bool) || parameterType.IsEnum)
{
return(true);
}
foreach (MemberInfo member in fixtureType.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance))
{
if (Reflect.HasAttribute(member, DatapointAttribute, true) &&
GetTypeFromMemberInfo(member) == parameterType)
{
return(true);
}
else if (Reflect.HasAttribute(member, DatapointsAttribute, true) &&
GetElementTypeFromMemberInfo(member) == parameterType)
{
return(true);
}
}
return(false);
}
public int CalculateParamPoints(SmartDispatcherController controller, ParameterInfo parameterInfo)
{
if (String.IsNullOrEmpty(parameterName))
parameterName = parameterInfo.Name;
return String.IsNullOrEmpty(controller.Request.Params[parameterName]) ? 0 : 100;
}
private static void AddFunctionsForScript(GenericMenu menu, SerializedProperty listener, ValidMethodMap method, string targetName)
{
PersistentListenerMode mode = method.mode;
UnityEngine.Object objectReferenceValue = listener.FindPropertyRelative("m_Target").objectReferenceValue;
string stringValue = listener.FindPropertyRelative("m_MethodName").stringValue;
PersistentListenerMode mode2 = GetMode(listener.FindPropertyRelative("m_Mode"));
SerializedProperty property = listener.FindPropertyRelative("m_Arguments").FindPropertyRelative("m_ObjectArgumentAssemblyTypeName");
StringBuilder builder = new StringBuilder();
int length = method.methodInfo.GetParameters().Length;
for (int i = 0; i < length; i++)
{
System.Reflection.ParameterInfo info = method.methodInfo.GetParameters()[i];
builder.Append($"{GetTypeName(info.ParameterType)}");
if (i < (length - 1))
{
builder.Append(", ");
}
}
bool on = ((objectReferenceValue == method.target) && (stringValue == method.methodInfo.Name)) && (mode == mode2);
if ((on && (mode == PersistentListenerMode.Object)) && (method.methodInfo.GetParameters().Length == 1))
{
on &= method.methodInfo.GetParameters()[0].ParameterType.AssemblyQualifiedName == property.stringValue;
}
string text = GetFormattedMethodName(targetName, method.methodInfo.Name, builder.ToString(), mode == PersistentListenerMode.EventDefined);
if (< > f__mg$cache1 == null)
{
/// <summary>
/// Gets a customization that associates a <see cref="ListFavoringConstructorQuery"/> with
/// the <see cref="Type"/> of the parameter.
/// </summary>
/// <param name="parameter">The parameter for which the customization is requested.</param>
/// <returns>
/// A customization that associates a <see cref="ListFavoringConstructorQuery"/> with the
/// <see cref="Type"/> of the parameter.
/// </returns>
public override ICustomization GetCustomization(ParameterInfo parameter)
{
if (parameter == null)
throw new ArgumentNullException("parameter");
return new ConstructorCustomization(parameter.ParameterType, new ListFavoringConstructorQuery());
}
private static object HandleArgumentNotResolved(ParsingContext context, ParameterInfo parameterInfo)
{
var attribute = parameterInfo.GetCustomAttribute<ArgumentAttribute>();
if(attribute == null)
{
throw new ArgumentException(string.Format("Could not resolve argument: {0}", parameterInfo.Name));
}
var startPosition = context.CurrentPosition;
var separatorPosition = attribute.Separator == '\0' ? -1 : context.Packet.Data.DataAsString.IndexOf(attribute.Separator, startPosition);
var length = (separatorPosition == -1 ? context.Packet.Data.DataAsString.Length : separatorPosition) - startPosition;
var valueToParse = context.Packet.Data.DataAsString.Substring(startPosition, length);
context.CurrentPosition += length + 1;
switch(attribute.Encoding)
{
case ArgumentAttribute.ArgumentEncoding.HexNumber:
return Parse(parameterInfo.ParameterType, valueToParse, NumberStyles.HexNumber);
case ArgumentAttribute.ArgumentEncoding.DecimalNumber:
return Parse(parameterInfo.ParameterType, valueToParse);
case ArgumentAttribute.ArgumentEncoding.BinaryBytes:
return context.Packet.Data.DataAsBinary.Skip(startPosition).ToArray();
case ArgumentAttribute.ArgumentEncoding.HexBytesString:
return valueToParse.Split(2).Select(x => byte.Parse(x, NumberStyles.HexNumber)).ToArray();
default:
throw new ArgumentException(string.Format("Unsupported argument type: {0}", parameterInfo.ParameterType.Name));
}
}
/// <summary>
/// Build a form to be used as parameters for the specified method
/// </summary>
/// <param name="type"></param>
/// <param name="wrapperTagName"></param>
/// <param name="methodName"></param>
/// <param name="defaults"></param>
/// <param name="registerProxy"></param>
/// <param name="paramCount"></param>
/// <returns></returns>
public TagBuilder MethodForm(Type type, string wrapperTagName, string methodName, Dictionary <string, object> defaults, bool registerProxy, out int paramCount)
{
Args.ThrowIfNull(type, "InvocationType");
if (registerProxy)
{
ServiceProxySystem.Register(type);
}
MethodInfo method = type.GetMethod(methodName);
defaults = defaults ?? new Dictionary <string, object>();
System.Reflection.ParameterInfo[] parameters = method.GetParameters();
paramCount = parameters.Length;
TagBuilder form = new TagBuilder(wrapperTagName);
for (int i = 0; i < parameters.Length; i++)
{
System.Reflection.ParameterInfo parameter = parameters[i];
object defaultValue = defaults.ContainsKey(parameter.Name) ? defaults[parameter.Name] : null;
string defaultString = defaultValue == null ? string.Empty : defaultValue.ToString();
TagBuilder label = new TagBuilder("label")
.Html(string.Format(this.LabelFormat, parameter.Name.PascalSplit(" ")))
.Css(this.LabelCssClass);
bool addLabel = this.AddLabels;
bool addValue = true;
bool wasObject = false;
bool handled = false;
TryBuildPrimitiveInput(parameter, defaultValue, ref addValue, ref handled, out TagBuilder toAdd, out Type paramType);
if (!handled)
{
string legend = GetLegend(paramType);
toAdd = FieldsetFor(paramType, defaultValue, legend);
addLabel = false;
addValue = false;
wasObject = true;
}
toAdd.DataSet("parameter-name", parameter.Name)
.DataSetIf(!wasObject, "type", parameter.ParameterType.Name.ToLowerInvariant())
.ValueIf(!string.IsNullOrEmpty(defaultString) && addValue, defaultString);
if (addLabel)
{
form.Child(label).BrIf(this.Layout == ParameterLayouts.BreakAfterLabels);
}
form.Child(toAdd).BrIf(
this.Layout != ParameterLayouts.NoBreaks &&
i != parameters.Length - 1 &&
!wasObject);
}
return(form.DataSet("method", methodName)
.FirstChildIf(wrapperTagName.Equals("fieldset"), new TagBuilder("legend")
.Text(GetLegend(method))));
}
/// <summary>
/// Get the type of command option from a method parameter info.
/// </summary>
private static ApplicationCommandOptionType TypeFromMethodParameter(ParameterInfo methodParameter)
{
if (methodParameter.ParameterType == typeof(int) || methodParameter.ParameterType == typeof(int?))
{
return(ApplicationCommandOptionType.Integer);
}
if (methodParameter.ParameterType == typeof(string))
{
return(ApplicationCommandOptionType.String);
}
if (methodParameter.ParameterType == typeof(bool) || methodParameter.ParameterType == typeof(bool?))
{
return(ApplicationCommandOptionType.Boolean);
}
if (methodParameter.ParameterType == typeof(SocketGuildChannel))
{
return(ApplicationCommandOptionType.Channel);
}
if (methodParameter.ParameterType == typeof(SocketRole))
{
return(ApplicationCommandOptionType.Role);
}
if (methodParameter.ParameterType == typeof(SocketGuildUser))
{
return(ApplicationCommandOptionType.User);
}
throw new Exception($"Got parameter type other than int, string, bool, guild, role, or user. {methodParameter.Name}");
}
private bool TryInvokeMemberWithNamedParameters(InvokeMemberBinder binder, object[] args, out object result,
MethodInfo method, ParameterInfo[] parameters)
{
var fixedArgs = new List<object>();
for (int i = 0; i < parameters.Length; i++)
{
if (parameters[i].RawDefaultValue == DBNull.Value)
{
fixedArgs.Add(args[i]);
}
else
{
var index = binder.CallInfo.ArgumentNames.IndexOf(parameters[i].Name);
if (index > -1)
{
if (!parameters[i].ParameterType.IsInstanceOfType(args[index]))
{
result = null;
return false;
}
}
else
{
fixedArgs.Add(parameters[i].RawDefaultValue);
}
}
}
result = method.Invoke(_adapter, fixedArgs.ToArray());
return true;
}
private ParameterInputDialog(ParameterInfo[] paramInfo, Object[] paramList)
{
InitializeComponent();
int panelsHeight = 0;
_paramValue = new object[paramInfo.Length];
_paramInfo = paramInfo;
_paramPanel = new ParamInputPanel[paramInfo.Length];
for (int i = 0; i < paramInfo.Length; i++)
{
ParamInputPanel panel = CreatePanelForParameter(
paramInfo[i],
(paramList == null || i >= paramList.Length) ? null : paramList[i]);
parameterInputPanel.Controls.Add(panel);
panel.Location = new Point(0, i * panel.Height);
_paramPanel[i] = panel;
panelsHeight += panel.Height;
}
Height = panelsHeight + 100;
}
internal bool ConvertArgs (object[] args, ParameterInfo[] pinfo, CultureInfo culture, bool exactMatch)
{
if (args == null) {
if (pinfo.Length == 0)
return true;
throw new TargetParameterCountException ();
}
if (pinfo.Length != args.Length)
throw new TargetParameterCountException ();
for (int i = 0; i < args.Length; ++i) {
var arg = args [i];
var pi = pinfo [i];
if (arg == Type.Missing) {
args [i] = pi.DefaultValue;
continue;
}
if (arg != null && arg.GetType () == pi.ParameterType)
continue;
if (exactMatch)
return false;
object v = ChangeType (arg, pi.ParameterType, culture);
if (v == null && args [i] != null)
return false;
args [i] = v;
}
return true;
}
public object Bind(IDictionary<string, string> parameters, ParameterInfo parameterInfo)
{
if (parameters.ContainsKey(parameterInfo.Name) && !string.IsNullOrEmpty(parameters[parameterInfo.Name]))
return new UUID(StringToByteArray(parameters[parameterInfo.Name]));
return null;
}
public bool HasDataFor(System.Reflection.ParameterInfo parameter)
{
Type parameterType = parameter.ParameterType;
MemberInfo method = parameter.Member;
Type fixtureType = method.ReflectedType;
if (!Reflect.HasAttribute(method, NUnitFramework.TheoryAttribute, true))
{
return(false);
}
foreach (FieldInfo field in fixtureType.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance))
{
if (field.FieldType == parameterType)
{
if (Reflect.HasAttribute(field, DatapointAttribute, true))
{
return(true);
}
}
else if (field.FieldType.IsArray && field.FieldType.GetElementType() == parameterType)
{
if (Reflect.HasAttribute(field, DatapointsAttribute, true))
{
return(true);
}
}
}
return(false);
}
private static bool CheckIfParametersEquals(ParameterInfo[] parameters, params Type[] targets)
{
if (parameters.Length != targets.Length)
return false;
return !parameters.Where((each, index) => each.ParameterType != targets[index]).Any();
}
internal override void Analyze(RuleAnalysis analysis, MemberInfo member, CodeExpression targetExpression, RulePathQualifier targetQualifier, CodeExpressionCollection argumentExpressions, ParameterInfo[] parameters, List<CodeExpression> attributedExpressions)
{
if (!analysis.ForWrites)
{
base.AnalyzeReadWrite(analysis, targetExpression, targetQualifier, argumentExpressions, parameters, attributedExpressions);
}
}
private List <Attribute> ReadParameterCustomAttributes(System.Reflection.ParameterInfo parameter)
{
List <Attribute> cachedAttributes = null;
bool getMemberAttributes = false;
// Now edit the attributes returned from the base type
using (new ReadLock(this._lock))
{
if (!this._parameters.TryGetValue(parameter, out cachedAttributes))
{
// If there is nothing for this parameter Cache any attributes for the DeclaringType
if (!this._memberInfos.TryGetValue(parameter.Member.DeclaringType, out cachedAttributes))
{
// If there is nothing for this parameter look to see if the declaring Member has been cached yet?
// need to do it outside of the lock, so set the flag we'll check it in a bit
getMemberAttributes = true;
}
cachedAttributes = null;
}
}
if (getMemberAttributes)
{
GetCustomAttributes(parameter.Member.DeclaringType, EmptyList);
// We should have run the rules for the enclosing parameter so we can again
using (new ReadLock(this._lock))
{
this._parameters.TryGetValue(parameter, out cachedAttributes);
}
}
return(cachedAttributes);
}
internal static object ExtractParameterFromDictionary(ParameterInfo parameterInfo, IDictionary<string, object> parameters, MethodInfo methodInfo)
{
object value;
if (!parameters.TryGetValue(parameterInfo.Name, out value))
{
// the key should always be present, even if the parameter value is null
string message = String.Format(CultureInfo.CurrentCulture, MvcResources.ReflectedActionDescriptor_ParameterNotInDictionary,
parameterInfo.Name, parameterInfo.ParameterType, methodInfo, methodInfo.DeclaringType);
throw new ArgumentException(message, "parameters");
}
if (value == null && !TypeHelpers.TypeAllowsNullValue(parameterInfo.ParameterType))
{
// tried to pass a null value for a non-nullable parameter type
string message = String.Format(CultureInfo.CurrentCulture, MvcResources.ReflectedActionDescriptor_ParameterCannotBeNull,
parameterInfo.Name, parameterInfo.ParameterType, methodInfo, methodInfo.DeclaringType);
throw new ArgumentException(message, "parameters");
}
if (value != null && !parameterInfo.ParameterType.IsInstanceOfType(value))
{
// value was supplied but is not of the proper type
string message = String.Format(CultureInfo.CurrentCulture, MvcResources.ReflectedActionDescriptor_ParameterValueHasWrongType,
parameterInfo.Name, methodInfo, methodInfo.DeclaringType, value.GetType(), parameterInfo.ParameterType);
throw new ArgumentException(message, "parameters");
}
return value;
}
private static void BuildParameter(ParameterBuilder builder, System.Reflection.ParameterInfo paramInfo, int position, int count, CommandService service)
{
var attributes = paramInfo.GetCustomAttributes();
var paramType = paramInfo.ParameterType;
builder.Name = paramInfo.Name;
builder.IsOptional = paramInfo.IsOptional;
builder.DefaultValue = paramInfo.HasDefaultValue ? paramInfo.DefaultValue : null;
foreach (var attribute in attributes)
{
// TODO: C#7 type switch
if (attribute is SummaryAttribute)
{
builder.Summary = (attribute as SummaryAttribute).Text;
}
else if (attribute is OverrideTypeReaderAttribute)
{
builder.TypeReader = GetTypeReader(service, paramType, (attribute as OverrideTypeReaderAttribute).TypeReader);
}
else if (attribute is ParameterPreconditionAttribute)
{
builder.AddPrecondition(attribute as ParameterPreconditionAttribute);
}
else if (attribute is ParamArrayAttribute)
{
builder.IsMultiple = true;
paramType = paramType.GetElementType();
}
else if (attribute is RemainderAttribute)
{
if (position != count - 1)
{
throw new InvalidOperationException("Remainder parameters must be the last parameter in a command.");
}
builder.IsRemainder = true;
}
}
builder.ParameterType = paramType;
if (builder.TypeReader == null)
{
var readers = service.GetTypeReaders(paramType);
TypeReader reader = null;
if (readers != null)
{
reader = readers.FirstOrDefault().Value;
}
else
{
reader = service.GetDefaultTypeReader(paramType);
}
builder.TypeReader = reader;
}
}
public ProcedureParameter(ParameterInfo info)
{
Type = info.ParameterType;
Name = info.Name;
bool hasDefaultValue = info.IsOptional && (info.Attributes & ParameterAttributes.HasDefault) == ParameterAttributes.HasDefault;
DefaultValue = hasDefaultValue ? info.DefaultValue : DBNull.Value;
}
public ReflectionParameter(ParameterInfo parameterInfo, IMember member)
: base(parameterInfo.Name)
{
Type type = parameterInfo.ParameterType;
this.ReturnType = ReflectionReturnType.Create(member, type, false);
if (type.IsByRef && parameterInfo.IsOut) {
this.Modifiers = ParameterModifiers.Out;
} else if (type.IsByRef) {
this.Modifiers = ParameterModifiers.Ref;
}
if (parameterInfo.IsOptional) {
this.Modifiers |= ParameterModifiers.Optional;
}
if (type.IsArray && type != typeof(Array)) {
foreach (CustomAttributeData data in CustomAttributeData.GetCustomAttributes(parameterInfo)) {
if (data.Constructor.DeclaringType.FullName == typeof(ParamArrayAttribute).FullName) {
this.Modifiers |= ParameterModifiers.Params;
break;
}
}
}
}
/// <summary>
/// Gets the property value from the first matched property. The match is made by the name and the type of the specified parameter.
/// </summary>
/// <remarks>The property match is done by the name and type, where the name is matched case insensitive and the type of the
/// parameter type should be assignable from the property type.</remarks>
/// <param name="command">The command.</param>
/// <param name="parameterInfo">The parameter info.</param>
/// <exception cref="ArgumentNullException">Thrown when <i>command</i> or <i>parameterInfo</i> is null.</exception>
/// <returns>The value from the first matched property.</returns>
public static object GetPropertyValueBasedOnParameterInfo(ICommand command, ParameterInfo parameterInfo)
{
if (command == null) throw new ArgumentNullException("command");
if (parameterInfo == null) throw new ArgumentNullException("parameterInfo");
// Initialize result with the default value based on the type.
var type = parameterInfo.ParameterType;
object result = type.IsValueType ? Activator.CreateInstance(type) : null;
// Get all properties that match name of the specified parameter and where the property type
// is assignable from the parameter type.
var query = from prop in command.GetType().GetProperties()
where prop.Name.Equals(parameterInfo.Name, StringComparison.InvariantCultureIgnoreCase) &&
parameterInfo.ParameterType.IsAssignableFrom(prop.PropertyType)
select prop;
// Get the first property, if found.
var propertyInfo = query.FirstOrDefault();
// If there is a property found, get the value from it.
if (propertyInfo != null)
{
result = propertyInfo.GetValue(command, null);
}
return result;
}
public NodeInfo(Type type, string name, MemberTypes mtype, ParameterInfo[] parameters)
{
this.NodeType = type;
this.Name = name;
this.MemberType = mtype;
this.Parameters = parameters;
}
/// <summary>
/// Gets the row of values. Each one will be converted (if posible) to the type of
/// the corresponding argument in the test method.
/// </summary>
/// <param name="parameters">List of parameters.</param>
/// <returns>The row of values.</returns>
public Object[] GetRow(ParameterInfo[] parameters)
{
object[] args = new object[parameters.Length];
// If the lengths are different a TargetParameterCountException exception will be thrown
if (row.Length == parameters.Length)
{
for (int i = 0; i < row.Length; i++)
{
FormatParameter(parameters, args, i);
}
return args;
}
else if (parameters[parameters.Length - 1].ParameterType == typeof(Object[]))
{
// Test function has params object[] argument
for (int i = 0; i < parameters.Length - 1; i++)
{
FormatParameter(parameters, args, i);
}
if (row.Length - parameters.Length > 0)
{
// Copy remaining parameters to object[]
object[] paramsArray = new object[row.Length - (parameters.Length - 1)];
Array.Copy(row, parameters.Length - 1, paramsArray, 0, row.Length - parameters.Length);
args[parameters.Length - 1] = paramsArray;
}
else
{
args[parameters.Length - 1] = new object[0];
}
return args;
}
return row;
}
/// <summary>
/// Calculates the param points. Implementers should return value equals or greater than
/// zero indicating whether the parameter can be bound successfully. The greater the value (points)
/// the more successful the implementation indicates to the framework
/// </summary>
/// <param name="context">The context.</param>
/// <param name="controller">The controller.</param>
/// <param name="controllerContext">The controller context.</param>
/// <param name="parameterInfo">The parameter info.</param>
/// <returns>
/// </returns>
public int CalculateParamPoints(IEngineContext context, IController controller, IControllerContext controllerContext, ParameterInfo parameterInfo)
{
var token = context.Request[parameterName];
if (CanConvert(parameterInfo.ParameterType, token))
return 10;
return 0;
}
private object ResolveMethodParameter(ParameterInfo methodParameterInfo, IDictionary<string, object> queryParameters, NancyContext context)
{
if (IsQueryParameter(methodParameterInfo, queryParameters))
return GetValueFromQueryParameters(methodParameterInfo, queryParameters);
return GetValueFromRequestBody(methodParameterInfo, context);
}
public ParameterWrapper(ActionBinder binder, ParameterInfo info)
: this(binder, info.ParameterType)
{
_name = SymbolTable.StringToId(info.Name ?? "<unknown>");
_isParams = info.IsDefined(typeof(ParamArrayAttribute), false);
}
/// <summary>
/// Gets or creates a new <see cref="CILParameter"/> based on native <see cref="System.Reflection.ParameterInfo"/>.
/// </summary>
/// <param name="param">The native parameter.</param>
/// <param name="ctx">The current reflection context.</param>
/// <returns><see cref="CILParameter"/> wrapping existing native <see cref="System.Reflection.ParameterInfo"/>.</returns>
/// <exception cref="ArgumentNullException">If <paramref name="param"/> or <paramref name="ctx"/> is <c>null</c>.</exception>
public static CILParameter NewWrapper(this System.Reflection.ParameterInfo param, CILReflectionContext ctx)
{
ArgumentValidator.ValidateNotNull("Module", param);
ArgumentValidator.ValidateNotNull("Reflection context", ctx);
return(((CILReflectionContextImpl)ctx).Cache.GetOrAdd(param));
}
public UrlDateTimeHandler(ParameterInfo fromUrlParameter)
{
if (fromUrlParameter != null) {
_fromUrlParamType = fromUrlParameter.ParameterType;
_fromUrlDateTimeProperties = GetDateTimeProperties(_fromUrlParamType);
}
}
/// <summary>
/// 生成模型
/// </summary>
/// <param name="request">请求数据</param>
/// <param name="parameter">参数</param>
/// <returns></returns>
public object BindModel(HttpRequest request, ParameterInfo parameter)
{
var name = parameter.Name;
var targetType = parameter.ParameterType;
if (targetType.IsClass == true && targetType.IsArray == false && targetType != typeof(string))
{
return ConvertToClass(request, parameter);
}
// 转换为数组
var values = request.GetValues(name);
if (targetType.IsArray == true)
{
return Converter.Cast(values, targetType);
}
// 转换为简单类型 保留参数默认值
var value = values.FirstOrDefault();
if (value == null && parameter.DefaultValue != DBNull.Value)
{
return parameter.DefaultValue;
}
return Converter.Cast(value, targetType);
}
private static Expression[] ArgumentConvertHelper(Expression[] arguments, ParameterInfo[] parameters) {
Debug.Assert(arguments != null);
Debug.Assert(arguments != null);
Expression[] clone = null;
for (int arg = 0; arg < arguments.Length; arg++) {
Expression argument = arguments[arg];
if (!CompatibleParameterTypes(parameters[arg].ParameterType, argument.Type)) {
// Clone the arguments array if needed
if (clone == null) {
clone = new Expression[arguments.Length];
// Copy the expressions into the clone
for (int i = 0; i < arg; i++) {
clone[i] = arguments[i];
}
}
argument = ArgumentConvertHelper(argument, parameters[arg].ParameterType);
}
if (clone != null) {
clone[arg] = argument;
}
}
return clone ?? arguments;
}
private static ParameterAnnotationInfo ExtractParameter(Expression expression, ParameterInfo parameter)
{
var methodCallExpression = AssertCallOnSpecialClass(expression);
var methodName = methodCallExpression.Method.Name;
switch (methodName)
{
case nameof(Annotations.FormatString):
return new ParameterAnnotationInfo(parameter.Name, isFormatString: true, isNotNull: true);
case nameof(Annotations.NullableFormatString):
return new ParameterAnnotationInfo(parameter.Name, isFormatString: true, canBeNull: true);
case nameof(Annotations.Some):
return new ParameterAnnotationInfo(parameter.Name);
case nameof(Annotations.NotNull):
return new ParameterAnnotationInfo(parameter.Name, isNotNull: true);
case nameof(Annotations.CanBeNull):
return new ParameterAnnotationInfo(parameter.Name, canBeNull: true);
default:
throw new ArgumentException($"Expression '{expression}' call an unsupported method : {methodName}. {usageInfo}",
nameof(expression));
}
}
public SlackBinding(ParameterInfo parameter, SlackAttribute attribute, SlackConfiguration config, INameResolver nameResolver, BindingProviderContext context)
{
_parameter = parameter;
_attribute = attribute;
_config = config;
_nameResolver = nameResolver;
if(!string.IsNullOrEmpty(_attribute.WebHookUrl))
{
_webHookUrlBindingTemplate = CreateBindingTemplate(_attribute.WebHookUrl, context.BindingDataContract);
}
if (!string.IsNullOrEmpty(_attribute.Text))
{
_textBindingTemplate = CreateBindingTemplate(_attribute.Text, context.BindingDataContract);
}
if (!string.IsNullOrEmpty(_attribute.Username))
{
_usernameBindingTemplate = CreateBindingTemplate(_attribute.Username, context.BindingDataContract);
}
if (!string.IsNullOrEmpty(_attribute.IconEmoji))
{
_iconEmojiBindingTemplate = CreateBindingTemplate(_attribute.IconEmoji, context.BindingDataContract);
}
if (!string.IsNullOrEmpty(_attribute.Channel))
{
_channelBindingTemplate = CreateBindingTemplate(_attribute.Channel, context.BindingDataContract);
}
}
public void Initialize(ParameterInfo parameter)
{
_type = parameter.ParameterType;
MethodInfo m = (MethodInfo)parameter.Member;
Type c = m.DeclaringType;
if (_name == null) _name = c.Namespace + "." + c.Name + "." + m.Name + "(" + parameter.Name + ")";
}
public bool GetParameterValue(ParameterInfo paramInfo, int paramLoc, ref Object parameter)
{
var ParamName = paramInfo.Name;
if (!_hashParams.ContainsKey(ParamName)) return false;
parameter = _hashParams[ParamName];
return true;
}
//This is where ParameterImports will be handled
protected override IEnumerable <object> GetCustomAttributes(System.Reflection.ParameterInfo parameter, IEnumerable <object> declaredAttributes)
{
IEnumerable <object> attributes = base.GetCustomAttributes(parameter, declaredAttributes);
List <Attribute> cachedAttributes = ReadParameterCustomAttributes(parameter);
return(cachedAttributes == null ? attributes : attributes.Concat(cachedAttributes));
}
protected override void ImplementInvokeMethodOnTarget(AbstractTypeEmitter @class, ParameterInfo[] parameters, MethodEmitter invokeMethodOnTarget, MethodInfo callbackMethod, Reference targetField)
{
invokeMethodOnTarget.CodeBuilder.AddStatement(
new ExpressionStatement(
new MethodInvocationExpression(SelfReference.Self, InvocationMethods.EnsureValidTarget)));
base.ImplementInvokeMethodOnTarget(@class, parameters, invokeMethodOnTarget, callbackMethod, targetField);
}
public static CustomPropertyInfo GetFromParamInfo(System.Reflection.ParameterInfo info)
{
if (info == null)
{
return(null);
}
CustomPropertyInfo retInfo = new CustomPropertyInfo();
retInfo.PropertyName = info.Name;
if (info.IsOut || info.ParameterType.IsByRef)
{
retInfo.PropertyType = EngineNS.Rtti.RttiHelper.GetTypeFromTypeFullName(info.ParameterType.FullName.Remove(info.ParameterType.FullName.Length - 1));
}
else
{
//retInfo.PropertyType = CSUtility.Program.GetTypeFromTypeFullName(info.ParameterType.FullName);
retInfo.PropertyType = info.ParameterType;
}
foreach (var att in info.GetCustomAttributes(true))
{
retInfo.PropertyAttributes.Add(att as Attribute);
}
retInfo.DefaultValue = CodeGenerateSystem.Program.GetDefaultValueFromType(retInfo.PropertyType);
retInfo.CurrentValue = retInfo.DefaultValue;
return(retInfo);
}
string GetArgument(bcl.ParameterInfo arg)
{
if (arg.ParameterType.IsGenericParameter)
{
}
return(TypeUtils.ToFriendlyName(arg.ParameterType) + " " + arg.Name);
}
public Parameter(IMember declaringMember, SR.ParameterInfo pinfo, XmlNode docNode)
{
this.name = pinfo.Name;
returnType = new ReturnType(pinfo.ParameterType);
this.declaringMember = declaringMember;
try { LoadXml(docNode); } catch { }
}
public override void GetParameterInfo(int parameter, out string name, out string display, out string description)
{
EnsureParameters();
System.Reflection.ParameterInfo param = parameters[parameter];
name = param.Name;
display = string.Format(System.Globalization.CultureInfo.InstalledUICulture, "{0} {1}", param.ParameterType.Name, param.Name);
description = param.Name;
}
private static void BuildParameter(ParameterBuilder builder, System.Reflection.ParameterInfo paramInfo, int position, int count, CommandService service, IServiceProvider services)
{
var attributes = paramInfo.GetCustomAttributes();
var paramType = paramInfo.ParameterType;
builder.Name = paramInfo.Name;
builder.IsOptional = paramInfo.IsOptional;
builder.DefaultValue = paramInfo.HasDefaultValue ? paramInfo.DefaultValue : null;
foreach (var attribute in attributes)
{
switch (attribute)
{
case SummaryAttribute summary:
builder.Summary = summary.Text;
break;
case OverrideTypeReaderAttribute typeReader:
builder.TypeReader = GetTypeReader(service, paramType, typeReader.TypeReader, services);
break;
case ParamArrayAttribute _:
builder.IsMultiple = true;
paramType = paramType.GetElementType();
break;
case ParameterPreconditionAttribute precon:
builder.AddPrecondition(precon);
break;
case NameAttribute name:
builder.Name = name.Text;
break;
case RemainderAttribute _:
if (position != count - 1)
{
throw new InvalidOperationException($"Remainder parameters must be the last parameter in a command. Parameter: {paramInfo.Name} in {paramInfo.Member.DeclaringType.Name}.{paramInfo.Member.Name}");
}
builder.IsRemainder = true;
break;
default:
builder.AddAttributes(attribute);
break;
}
}
builder.ParameterType = paramType;
if (builder.TypeReader == null)
{
builder.TypeReader = service.GetDefaultTypeReader(paramType)
?? service.GetTypeReaders(paramType)?.FirstOrDefault().Value;
}
}
public static void Dispatch(System.Object target, DynamicServerAction dynamicServerAction)
{
MethodInfo method = getDispatchMethod(target.GetType(), dynamicServerAction);
if (method == null)
{
throw new InvalidActionException();
}
List <string> missingArguments = null;
System.Reflection.ParameterInfo[] methodParams = method.GetParameters();
object[] arguments = new object[methodParams.Length];
if (methodParams.Length == 1 && methodParams[0].ParameterType == typeof(ServerAction))
{
ServerAction serverAction = dynamicServerAction.ToObject <ServerAction>();
serverAction.dynamicServerAction = dynamicServerAction;
arguments[0] = serverAction;
}
else
{
for (int i = 0; i < methodParams.Length; i++)
{
System.Reflection.ParameterInfo pi = methodParams[i];
if (dynamicServerAction.ContainsKey(pi.Name))
{
try {
arguments[i] = dynamicServerAction.GetValue(pi.Name).ToObject(pi.ParameterType);
} catch (ArgumentException ex) {
throw new ToObjectArgumentActionException(
parameterName: pi.Name,
parameterType: pi.ParameterType,
parameterValueAsStr: dynamicServerAction.GetValue(pi.Name).ToString(),
ex: ex
);
}
}
else
{
if (!pi.HasDefaultValue)
{
if (missingArguments == null)
{
missingArguments = new List <string>();
}
missingArguments.Add(pi.Name);
}
arguments[i] = Type.Missing;
}
}
}
if (missingArguments != null)
{
throw new MissingArgumentsActionException(missingArguments);
}
method.Invoke(target, arguments);
}
public string ParseExtraString(string extraString, System.Reflection.ParameterInfo parameterInfo)
{
if (parameterInfo.ParameterType.IsEnum)
{
extraString = extraString.Replace("%values%", string.Join(", ", parameterInfo.ParameterType.GetEnumNames().Select(n => n.ToLower())));
}
return(extraString);
}
protected string BuildParameterDescription(System.Reflection.ParameterInfo parameterInfo)
{
//get parameter name and attribute
string paramName = parameterInfo.Name;
SummaryAttribute summAttrib = parameterInfo.GetCustomAttribute(typeof(SummaryAttribute)) as SummaryAttribute;
//get parameter template
string paramTmpl = _botStrings.getString("common", "parameter_description");
return(String.Format(paramTmpl, paramName, summAttrib.Text));
}
/**
* @brief build dictionary of internal functions from an interface.
* @param iface = interface with function definitions
* @param inclSig = true: catalog by name with arg sig, eg, llSay(integer,string)
* false: catalog by simple name only, eg, state_entry
* @returns dictionary of function definition tokens
*/
public InternalFuncDict(Type iface, bool inclSig)
: base(false)
{
/*
* Loop through list of all methods declared in the interface.
*/
System.Reflection.MethodInfo[] ifaceMethods = iface.GetMethods();
foreach (System.Reflection.MethodInfo ifaceMethod in ifaceMethods)
{
string key = ifaceMethod.Name;
/*
* Only do ones that begin with lower-case letters...
* as any others can't be referenced by scripts
*/
if ((key[0] < 'a') || (key[0] > 'z'))
{
continue;
}
try {
/*
* Create a corresponding TokenDeclVar struct.
*/
System.Reflection.ParameterInfo[] parameters = ifaceMethod.GetParameters();
TokenArgDecl argDecl = new TokenArgDecl(null);
for (int i = 0; i < parameters.Length; i++)
{
System.Reflection.ParameterInfo param = parameters[i];
TokenType type = TokenType.FromSysType(null, param.ParameterType);
TokenName name = new TokenName(null, param.Name);
argDecl.AddArg(type, name);
}
TokenDeclVar declFunc = new TokenDeclVar(null, null, null);
declFunc.name = new TokenName(null, key);
declFunc.retType = TokenType.FromSysType(null, ifaceMethod.ReturnType);
declFunc.argDecl = argDecl;
/*
* Add the TokenDeclVar struct to the dictionary.
*/
this.AddEntry(declFunc);
} catch (Exception except) {
string msg = except.ToString();
int i = msg.IndexOf("\n");
if (i > 0)
{
msg = msg.Substring(0, i);
}
Console.WriteLine("InternalFuncDict*: {0}: {1}", key, msg);
///??? IGNORE ANY THAT FAIL - LIKE UNRECOGNIZED TYPE ???///
}
}
}
/// <summary>
/// Determine, that given parameter needs wrapping.
/// </summary>
/// <param name="par">Parameter which wrapping is determined.</param>
/// <returns>True if parameter needs wrapping, false otherwise.</returns>
private bool needWrapping(System.Reflection.ParameterInfo par)
{
var parType = par.ParameterType;
var instType = typeof(Instance);
var isInstance = instType == parType;
var hasInstanceParent = instType.IsSubclassOf(parType);
return(!isInstance && !hasInstanceParent);
}
public AxParameterData(System.Reflection.ParameterInfo info, bool ignoreByRefs)
{
this.paramInfo = info;
this.Name = info.Name;
this.type = info.ParameterType;
this.typeName = AxWrapperGen.MapTypeName(info.ParameterType);
this.isByRef = info.ParameterType.IsByRef && !ignoreByRefs;
this.isIn = info.IsIn && !ignoreByRefs;
this.isOut = (info.IsOut && !this.isIn) && !ignoreByRefs;
this.isOptional = info.IsOptional;
}
/// <summary>
/// Builds a <see cref="ParameterInfo"/> from a reflected <see cref="System.Reflection.ParameterInfo"/>.
/// </summary>
public static ParameterInfo FromParameter(System.Reflection.ParameterInfo parameter)
{
return(new ParameterInfo
{
Name = parameter.Name,
IsRemainder = parameter.GetCustomAttribute <RemainderAttribute>() != null,
IsParamsArray = parameter.ParameterType.IsArray && parameter.GetCustomAttribute <ParamArrayAttribute>() != null,
Type = parameter.ParameterType,
DefaultValue = parameter.DefaultValue
});
}
internal SimpleParameter(System.Reflection.ParameterInfo para, ParameterAttribute paraConfig) : base(para, paraConfig)
{
if (paraConfig == null)
{
if (para.Name.Length == 1)
{
paraConfig = new ParameterAttribute {
ShortName = (char)para.Name.First()
}
}
}
;
public static void Dispatch(System.Object target, dynamic serverCommand)
{
MethodInfo method = getDispatchMethod(target.GetType(), serverCommand);
if (method == null)
{
throw new InvalidActionException();
}
List <string> missingArguments = null;
System.Reflection.ParameterInfo[] methodParams = method.GetParameters();
object[] arguments = new object[methodParams.Length];
if (methodParams.Length == 1 && methodParams[0].ParameterType == typeof(ServerAction))
{
arguments[0] = serverCommand.ToObject(methodParams[0].ParameterType);
}
else
{
for (int i = 0; i < methodParams.Length; i++)
{
System.Reflection.ParameterInfo pi = methodParams[i];
// allows for passing in a ServerAtion as a dynamic to ProcessControlCommand
if (serverCommand.GetType() == pi.ParameterType)
{
arguments[i] = serverCommand;
}
else if (serverCommand.ContainsKey(pi.Name))
{
arguments[i] = serverCommand[pi.Name].ToObject(pi.ParameterType);
}
else
{
if (!pi.HasDefaultValue)
{
if (missingArguments == null)
{
missingArguments = new List <string>();
}
missingArguments.Add(pi.Name);
}
arguments[i] = Type.Missing;
}
}
}
if (missingArguments != null)
{
throw new MissingArgumentsActionException(missingArguments);
}
method.Invoke(target, arguments);
}
Parameter LoadParameter(System.Reflection.ParameterInfo refParameter)
{
Parameter parameter = new Parameter
{
Name = refParameter.Name,
ParameterType = GetTypeFullName(refParameter.ParameterType),
HasDefaultValue = false, // refParameter.HasDefaultValue,
DefaultValue = null, //(refParameter.HasDefaultValue ? refParameter.DefaultValue : null),
Attributes = refParameter.Attributes,
};
return(parameter);
}
public ParameterBinder(System.Reflection.ParameterInfo pi)
{
Info = pi;
BindAttribute[] bas = Functions.GetParemeterAttributes <BindAttribute>(pi, false);
if (bas.Length > 0)
{
Binder = bas[0];
}
ViewStateAttribute[] vsa = Functions.GetParemeterAttributes <ViewStateAttribute>(pi, false);
if (vsa.Length > 0)
{
ViewState = vsa[0];
}
}
// parse form input
private object[] GetFormArguments(Queue <string> inputValues)
{
object[] result = new object[ParameterInfos.Length]; // holder for results
for (int i = 0; i < ParameterInfos.Length; i++)
{
System.Reflection.ParameterInfo param = ParameterInfos[i];
Type currentParameterType = param.ParameterType;
object parameterValue = GetParameterValue(inputValues, currentParameterType);
result[i] = parameterValue;
}
return(result);
}
static StackObject *get_ParameterType_0(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 1);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
System.Reflection.ParameterInfo instance_of_this_method = (System.Reflection.ParameterInfo) typeof(System.Reflection.ParameterInfo).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags) 0);
__intp.Free(ptr_of_this_method);
var result_of_this_method = instance_of_this_method.ParameterType;
return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method));
}
public bool TryGetProvider(System.Reflection.ParameterInfo pi, ICreationContext context, out Func <object> valueProvider)
{
IComponentRegistration registration;
if (context.TryGetRegistered(pi.ParameterType, out registration))
{
valueProvider = delegate() { return(MatchTypes(pi, context.Get(registration))); };
return(true);
}
else
{
valueProvider = null;
return(false);
}
}