public static bool ExtendsType(MethodInfo method, Type type)
{
var ext = method.GetCustomAttributes(typeof(ExtendsAttribute), true);
if (ext.Length != 0 && ((ExtendsAttribute)ext[0]).Type == type)
{
return true;
}
if (method.GetCustomAttributes(typeof(ExtensionAttribute), true).Length == 0)
{
return false;
}
var pars = method.GetParameters();
if (pars.Length == 0)
{
return false;
}
if (type != pars[0].ParameterType)
{
// maybe test for subclass
return false;
}
return true;
}
public IEnumerable<ExecutionStep> Scan(object testObject, MethodInfo candidateMethod)
{
var executableAttribute = (ExecutableAttribute)candidateMethod.GetCustomAttributes(typeof(ExecutableAttribute), false).FirstOrDefault();
if(executableAttribute == null)
yield break;
string stepTitle = executableAttribute.StepTitle;
if(string.IsNullOrEmpty(stepTitle))
stepTitle = NetToString.Convert(candidateMethod.Name);
var stepAsserts = IsAssertingByAttribute(candidateMethod);
var runStepWithArgsAttributes = (RunStepWithArgsAttribute[])candidateMethod.GetCustomAttributes(typeof(RunStepWithArgsAttribute), false);
if (runStepWithArgsAttributes.Length == 0)
{
yield return new ExecutionStep(GetStepAction(candidateMethod), stepTitle, stepAsserts, executableAttribute.ExecutionOrder, true);
}
foreach (var runStepWithArgsAttribute in runStepWithArgsAttributes)
{
var inputArguments = runStepWithArgsAttribute.InputArguments;
var flatInput = inputArguments.FlattenArrays();
var stringFlatInputs = flatInput.Select(i => i.ToString()).ToArray();
var methodName = stepTitle + " " + string.Join(", ", stringFlatInputs);
if (!string.IsNullOrEmpty(runStepWithArgsAttribute.StepTextTemplate))
methodName = string.Format(runStepWithArgsAttribute.StepTextTemplate, flatInput);
else if (!string.IsNullOrEmpty(executableAttribute.StepTitle))
methodName = string.Format(executableAttribute.StepTitle, flatInput);
yield return new ExecutionStep(GetStepAction(candidateMethod, inputArguments), methodName, stepAsserts, executableAttribute.ExecutionOrder, true);
}
}
/// <summary>
/// Returns a ClientMethod instance to get the name of the class and method name on the client-side JavaScript.
/// </summary>
/// <param name="method">The MethodInfo.</param>
/// <returns>
/// Returns the ClientMethod info, if it is not a AjaxMethod it will return null.
/// </returns>
public static ClientMethod FromMethodInfo(MethodInfo method)
{
if(method.GetCustomAttributes(typeof(AjaxPro.AjaxMethodAttribute), true).Length == 0)
return null;
AjaxPro.AjaxNamespaceAttribute[] classns = (AjaxPro.AjaxNamespaceAttribute[])method.ReflectedType.GetCustomAttributes(typeof(AjaxPro.AjaxNamespaceAttribute), true);
AjaxPro.AjaxNamespaceAttribute[] methodns = (AjaxPro.AjaxNamespaceAttribute[])method.GetCustomAttributes(typeof(AjaxPro.AjaxNamespaceAttribute), true);
ClientMethod cm = new ClientMethod();
if (classns.Length > 0)
cm.ClassName = classns[0].ClientNamespace;
else
{
if (Utility.Settings.UseSimpleObjectNaming)
cm.ClassName = method.ReflectedType.Name;
else
cm.ClassName = method.ReflectedType.FullName;
}
if(methodns.Length > 0)
cm.MethodName += methodns[0].ClientNamespace;
else
cm.MethodName += method.Name;
return cm;
}
public void PublicMethod_ThatReturnsReferenceType_MustBeTaggedWithNotNullOrCanBeNullAttributes(MethodInfo method)
{
bool hasNotNullAttribute = method.GetCustomAttributes(typeof(NotNullAttribute), true).Any();
bool hasCanBeNullAttribute = method.GetCustomAttributes(typeof(CanBeNullAttribute), true).Any();
Assume.That(method.DeclaringType != null);
Assert.That(hasNotNullAttribute || hasCanBeNullAttribute, "Method " + method.Name + " of type " + method.DeclaringType.Name + " must be tagged with [NotNull] or [CanBeNull]");
}
private static string[] GetMethods(MethodInfo methodInfo)
{
var list = new List<string>();
list.AddRange(from customAttribute in methodInfo.GetCustomAttributes<HttpGetAttribute>() from httpMethod in customAttribute.HttpMethods select httpMethod.Method);
list.AddRange(from customAttribute in methodInfo.GetCustomAttributes<HttpPostAttribute>() from httpMethod in customAttribute.HttpMethods select httpMethod.Method);
list.AddRange(from customAttribute in methodInfo.GetCustomAttributes<HttpPutAttribute>() from httpMethod in customAttribute.HttpMethods select httpMethod.Method);
list.AddRange(from customAttribute in methodInfo.GetCustomAttributes<HttpDeleteAttribute>() from httpMethod in customAttribute.HttpMethods select httpMethod.Method);
return list.Distinct().ToArray();
}
public void PrintUsage()
{
foreach (var kv in HandlerMap)
{
Console.WriteLine("/Function=" + kv.Key);
Action <AppOptionValues> Handler = kv.Value;
DescriptionAttribute[] customAttrs = (DescriptionAttribute[])Handler.Method.GetCustomAttributes(typeof(DescriptionAttribute), true);
ArgumentDescAttribute[] customArgDesc = (ArgumentDescAttribute[])Handler.Method.GetCustomAttributes(typeof(ArgumentDescAttribute), true);
if (customAttrs.Length == 0)
{
Object handlerTarget = Handler.Target;
Type handlerTargetType = handlerTarget.GetType();
FieldInfo handlerTargetMethod = handlerTargetType.GetField("handler", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.FlattenHierarchy | System.Reflection.BindingFlags.Instance);
Object handlerTargetHandlerValue = handlerTargetMethod.GetValue(handlerTarget);
PropertyInfo prop = handlerTargetHandlerValue.GetType().GetProperty("Method");
if (prop != null)
{
System.Reflection.MethodInfo trueMethod = (System.Reflection.MethodInfo)prop.GetValue(handlerTargetHandlerValue);
customAttrs = (DescriptionAttribute[])trueMethod.GetCustomAttributes(typeof(DescriptionAttribute), true);
customArgDesc = (ArgumentDescAttribute[])trueMethod.GetCustomAttributes(typeof(ArgumentDescAttribute), true);
}
}
if (customAttrs.Length > 0)
{
foreach (DescriptionAttribute desc in customAttrs)
{
Console.WriteLine(" " + desc.Description);
}
}
else
{
customAttrs = (DescriptionAttribute[])Handler.Method.GetCustomAttributes(typeof(DescriptionAttribute), true);
}
if (customArgDesc.Length > 0)
{
foreach (ArgumentDescAttribute desc in customArgDesc)
{
foreach (String descStr in desc.Description)
{
Console.WriteLine(" " + descStr);
}
}
}
Console.WriteLine();
}
}
public ParameterizedTestMethod(TestFixture testFixture, MethodInfo methodInfo)
: base(testFixture, methodInfo) {
foreach(DataRow dataRow in methodInfo.GetCustomAttributes(typeof(DataRow), true)) {
_dataSource.Add(dataRow);
}
if(_dataSource.Count == 0) {
object[] attrs = methodInfo.GetCustomAttributes(typeof(DataSourceAttribute), true);
if( attrs.Length > 0 ) {
_dataSource.Add(attrs[0] as DataSourceAttribute);
}
}
_expectedParameterNum = MethodInfo.GetParameters().Length;
}
public ActionMethod(MethodInfo methodInfo)
{
_methodInfo = methodInfo;
_filterAttributes = (ActionFilterAttribute[]) methodInfo.GetCustomAttributes(typeof(ActionFilterAttribute), false);
OrderedAttribute.Sort(_filterAttributes);
if (_methodInfo.IsDefined(typeof(LayoutAttribute), false))
_defaultLayoutName = ((LayoutAttribute)_methodInfo.GetCustomAttributes(typeof(LayoutAttribute), false)[0]).LayoutName ?? "";
if (_methodInfo.IsDefined(typeof(ViewAttribute), false))
_defaultViewName = ((ViewAttribute)_methodInfo.GetCustomAttributes(typeof(ViewAttribute), false)[0]).ViewName ?? "";
}
public static bool IsWebMethod(MethodInfo method)
{
object[] customAttributes = method.GetCustomAttributes(typeof(SoapRpcMethodAttribute), true);
if ((customAttributes != null) && (customAttributes.Length > 0))
{
return true;
}
customAttributes = method.GetCustomAttributes(typeof(SoapDocumentMethodAttribute), true);
if ((customAttributes != null) && (customAttributes.Length > 0))
{
return true;
}
customAttributes = method.GetCustomAttributes(typeof(HttpMethodAttribute), true);
return ((customAttributes != null) && (customAttributes.Length > 0));
}
private bool ProceedValidatorAttribute(ICommand command, System.Reflection.MethodInfo methodHandlerAsync)
{
var customAttributes = methodHandlerAsync.GetCustomAttributes(false)
.Where(x => x is EnableValidatorAttribute)
.Select(x => (EnableValidatorAttribute)x);
if (!customAttributes.Any())
{
foreach (var validator in customAttributes)
{
object fluentValidation = serviceProvider.GetService(validator.Type);
ValidationResult validationResult = (ValidationResult)fluentValidation
.GetType()
.GetMethod("Validate", new Type[] { command.GetType() })
.Invoke(fluentValidation, new[] { command });
if (!validationResult.IsValid)
{
// log_error_here
return(false);
}
}
}
return(true);
}
public static bool IsAsyncOperation(MethodInfo method)
{
var name = method.ReturnType.FullName;
if (name == null) return false;
return name.StartsWith(TaskTypeName) ||
method.GetCustomAttributes(false).Any(attr => AsyncAttributeTypeName == attr.GetType().FullName);
}
private static IEnumerable<VariantAttribute> GetCombinations(MethodInfo method)
{
var methodVariants
= method
.GetCustomAttributes(typeof(VariantAttribute), true)
.Cast<VariantAttribute>()
.ToList();
if (methodVariants.Any())
{
return methodVariants;
}
var typeVariants
= method.DeclaringType
.GetCustomAttributes(typeof(VariantAttribute), true)
.Cast<VariantAttribute>()
.ToList();
if (typeVariants.Any())
{
return typeVariants;
}
return new[] { new VariantAttribute(RepositoryProvider.EntityFramework) };
}
private TestType GetTestType(MethodInfo testMethod)
{
var uniqueAttributeTypes = new HashSet<string>();
var allAttributes = testMethod.GetCustomAttributes();
foreach (var attr in allAttributes)
{
uniqueAttributeTypes.Add(attr.GetType().Name);
}
if (uniqueAttributeTypes.Contains(typeof (TestCaseAttribute).Name))
{
if (uniqueAttributeTypes.Contains(typeof (ShouldThrowAttribute).Name))
{
return TestType.TestCasesShouldThrow;
}
return TestType.TestCasesNormal;
}
if (uniqueAttributeTypes.Contains(typeof (ShouldThrowAttribute).Name))
{
return TestType.ShouldThrow;
}
return TestType.Normal;
}
/// <summary>
/// Extracts the RestAttribute from a method's attributes
/// </summary>
/// <param name="method">The method to be inspected</param>
/// <returns>The applied RestAttribute or a default RestAttribute.</returns>
public static RestAttribute GetRestAttribute(MethodInfo method)
{
var customAttributes = method.GetCustomAttributes(typeof(RestAttribute), true);
if (customAttributes.Length <= 0) return new RestAttribute();
var restAttribute = customAttributes[0] as RestAttribute;
return restAttribute ?? new RestAttribute();
}
public IHqlGeneratorForMethod GetMethodGenerator(MethodInfo method)
{
IHqlGeneratorForMethod methodGenerator;
if (method.IsGenericMethod)
{
method = method.GetGenericMethodDefinition();
}
if (_registeredMethods.TryGetValue(method, out methodGenerator))
{
return methodGenerator;
}
// No method generator registered. Look to see if it's a standard LinqExtensionMethod
var attr = method.GetCustomAttributes(typeof (LinqExtensionMethodAttribute), false);
if (attr.Length == 1)
{
// It is
// TODO - cache this? Is it worth it?
return new HqlGeneratorForExtensionMethod((LinqExtensionMethodAttribute) attr[0], method);
}
// Not that either. Let's query each type generator to see if it can handle it
foreach (var typeGenerator in _typeGenerators)
{
if (typeGenerator.SupportsMethod(method))
{
return typeGenerator.GetMethodGenerator(method);
}
}
throw new NotSupportedException(method.ToString());
}
private static string GetReasonForWhyMethodCanNotBeIntercepted(MethodInfo method)
{
if (method.IsFinal)
{
return "Sealed methods can not be intercepted.";
}
if (method.IsStatic)
{
if (method.GetCustomAttributes(typeof(System.Runtime.CompilerServices.ExtensionAttribute), false).Any())
{
return "Extension methods can not be intercepted since they're static.";
}
else
{
return "Static methods can not be intercepted.";
}
}
if (!method.IsVirtual)
{
return "Non virtual methods can not be intercepted.";
}
return null;
}
TestResultBitmap runMethodTest(object instance, MethodInfo method)
{
if (method.IsGenericMethod)
throw new Exception("{0}: is not allowed to be generic".format(method));
var parameters = method.GetParameters();
if (parameters.Length != 1)
throw new Exception("{0}: expect one parameter".format(method));
var firstParameter = parameters[0];
if (firstParameter.ParameterType != typeof(IDrawingContext))
throw new Exception("{0}: expect IDrawingContext as first and only parameter");
var attribute = (BitmapDrawingTestAttribute)method.GetCustomAttributes(typeof (BitmapDrawingTestAttribute), false)[0];
using (var context = new BitmapDrawingContext(attribute.Width, attribute.Height))
{
IDrawingContext drawingContext;
using (context.beginDraw(out drawingContext))
{
method.Invoke(instance, new object[] { drawingContext });
}
return new TestResultBitmap(attribute.Width, attribute.Height, context.extractRawBitmap());
}
}
public bool MustAuthenticate(Type type, MethodInfo method)
{
type.ThrowIfNull("type");
method.ThrowIfNull("method");
return method.GetCustomAttributes(typeof(AuthenticateAttribute), false).Any();
}
private void RemoveActionImplementation(IAuthorizationService authService, MethodInfo method)
{
foreach (CommandHandlerAttribute attr in method.GetCustomAttributes(typeof(CommandHandlerAttribute), true))
{
//authService.UnRegisterCommand(attr.CommandName, GetAuthorizeResourcePath(method));
}
}
public bool HasRights(object t, string command)
{
if (t.GetType().IsClass)//Before check no permission class
{
object[] laClassAttributes = t.GetType().GetCustomAttributes(typeof(RightsAccessAttribute), false);
if (laClassAttributes.Length > 0)
{
return(CheckAttribute(t, laClassAttributes));
}
}
//After check no permission method
System.Reflection.MethodInfo met = t.GetType().GetMethod(command);
if (met != null)
{
object[] laMethodAttributes = met.GetCustomAttributes(typeof(RightsAccessAttribute), false);
if (laMethodAttributes.Length > 0)
{
return(CheckAttribute(t, laMethodAttributes));
}
//ui no need check permission and not attribute login
if (HasUi(t.ToString()))
{
return(true);
}
}
return(false);
}
private void ProcessSwaggerTagsAttribute(SwaggerDocument document, SwaggerOperationDescription operationDescription, MethodInfo methodInfo)
{
dynamic tagsAttribute = methodInfo
.GetCustomAttributes()
.SingleOrDefault(a => a.GetType().Name == "SwaggerTagsAttribute");
if (tagsAttribute != null)
{
var tags = ((string[])tagsAttribute.Tags).ToList();
foreach (var tag in tags)
{
if (operationDescription.Operation.Tags.All(t => t != tag))
operationDescription.Operation.Tags.Add(tag);
if (ObjectExtensions.HasProperty(tagsAttribute, "AddToDocument") && tagsAttribute.AddToDocument)
{
if (document.Tags == null)
document.Tags = new List<SwaggerTag>();
if (document.Tags.All(t => t.Name != tag))
document.Tags.Add(new SwaggerTag { Name = tag });
}
}
}
}
internal static WebMethodAttribute GetAttribute(MethodInfo implementation, MethodInfo declaration)
{
WebMethodAttribute attribute = null;
WebMethodAttribute attribute2 = null;
object[] customAttributes;
if (declaration != null)
{
customAttributes = declaration.GetCustomAttributes(typeof(WebMethodAttribute), false);
if (customAttributes.Length > 0)
{
attribute = (WebMethodAttribute) customAttributes[0];
}
}
customAttributes = implementation.GetCustomAttributes(typeof(WebMethodAttribute), false);
if (customAttributes.Length > 0)
{
attribute2 = (WebMethodAttribute) customAttributes[0];
}
if (attribute == null)
{
return attribute2;
}
if (attribute2 == null)
{
return attribute;
}
if (attribute2.MessageNameSpecified)
{
throw new InvalidOperationException(Res.GetString("ContractOverride", new object[] { implementation.Name, implementation.DeclaringType.FullName, declaration.DeclaringType.FullName, declaration.ToString(), "WebMethod.MessageName" }));
}
return new WebMethodAttribute(attribute2.EnableSessionSpecified ? attribute2.EnableSession : attribute.EnableSession) { TransactionOption = attribute2.TransactionOptionSpecified ? attribute2.TransactionOption : attribute.TransactionOption, CacheDuration = attribute2.CacheDurationSpecified ? attribute2.CacheDuration : attribute.CacheDuration, BufferResponse = attribute2.BufferResponseSpecified ? attribute2.BufferResponse : attribute.BufferResponse, Description = attribute2.DescriptionSpecified ? attribute2.Description : attribute.Description };
}
private void Register(object commandHandler, MethodInfo handlerMethod)
{
foreach (CommandAttribute attr in handlerMethod.GetCustomAttributes<CommandAttribute>())
{
Subscribe(commandHandler, handlerMethod, attr);
}
}
private Attribute GetAsyncStateMachineAttribute(MethodInfo method)
{
foreach (Attribute attribute in method.GetCustomAttributes(false) )
if (attribute.GetType().FullName == "System.Runtime.CompilerServices.AsyncStateMachineAttribute")
return attribute;
return null;
}
public string GetClientMethodCode(MethodInfo method, string url)
{
var model = new ClientMethodModel();
var parameterInfos = method.GetParameters();
var inputParameters = parameterInfos.Select(p => string.Format("{0}: {1}", p.Name, TypeMapper.GetTypeScriptType(p.ParameterType)))
.ToList();
model.Traditional = parameterInfos.Any(p => p.ParameterType.IsArray);
var returnType = method.ReturnType;
if (returnType.Name != "Void")
{
var onSucces = "callback: (data: " + TypeMapper.GetTypeScriptType(returnType) + ") => any";
inputParameters.Add(onSucces);
model.OnSucces = "callback";
}
//hacky
var isPost = method.GetCustomAttributes(typeof(HttpPostAttribute), true).Any() || returnType.IsJsonResult() || returnType == typeof(JsonResult);
model.AjaxMethod = isPost ? "POST" : "";
var allParameters = string.Join(", ", inputParameters);
model.Signature = method.Name + "(" + allParameters + ")";
model.Url = url;
var inputJsonTuples = method.GetParameters().Select(p => string.Format("{0}: {0}", p.Name));
model.Data = "{ " + string.Join(", ", inputJsonTuples) + " }";
var template = GetTemplate("ClientMethod");
return RemoveEmptyLines(Razor.Parse(template, model));//.Split("\r\n".ToCharArray(),StringSplitOptions.RemoveEmptyEntries);
}
private bool ProceedPermisisonAttribute(System.Reflection.MethodInfo methodHandlerAsync)
{
var customAttributes = methodHandlerAsync.GetCustomAttributes(false)
.Where(x => x is HasPermissionAttribute)
.Select(x => (HasPermissionAttribute)x);
if (!customAttributes.Any())
{
return(true);
}
foreach (var hasPermisison in customAttributes)
{
var permissionName = hasPermisison.PermissionName;
var signInUser = (SignInUser)serviceProvider.GetService(typeof(SignInUser));
if (!signInUser.Permissions.Any())
{
return(false);
}
if (signInUser.Permissions.Contains(permissionName))
{
return(true);
}
}
return(false);
}
static void Main(string[] args)
{
Type widgetType = typeof(Widget);
//Gets every HelpAttribute defined for the Widget type
object[] widgetClassAttributes = widgetType.GetCustomAttributes(typeof(HelpAttribute), false);
if (widgetClassAttributes.Length > 0)
{
HelpAttribute attr = (HelpAttribute)widgetClassAttributes[0];
Console.WriteLine($"Widget class help URL : {attr.Url} - Related topic : {attr.Topic}");
}
System.Reflection.MethodInfo displayMethod = widgetType.GetMethod(nameof(Widget.Display));
//Gets every HelpAttribute defined for the Widget.Display method
object[] displayMethodAttributes = displayMethod.GetCustomAttributes(typeof(HelpAttribute), false);
if (displayMethodAttributes.Length > 0)
{
HelpAttribute attr = (HelpAttribute)displayMethodAttributes[0];
Console.WriteLine($"Display method help URL : {attr.Url} - Related topic : {attr.Topic}");
}
Console.ReadLine();
}
private static IEnumerable<VariantAttribute> GetCombinations(MethodInfo method)
{
var methodVariants
= method
.GetCustomAttributes(typeof(VariantAttribute), true)
.Cast<VariantAttribute>()
.ToList();
if (methodVariants.Any())
{
return methodVariants;
}
var typeVariants
= method.DeclaringType
.GetCustomAttributes(typeof(VariantAttribute), true)
.Cast<VariantAttribute>()
.ToList();
if (typeVariants.Any())
{
return typeVariants;
}
return new[] { new VariantAttribute(DatabaseProvider.SqlClient, ProgrammingLanguage.CSharp) };
}
static void Main()
{
double[] a = { 0.0, 0.5, 1.0 };
double[] squares = Apply(a, Square);
double[] sines = Apply(a, Math.Sin);
Multiplier m = new Multiplier(2.0);
double[] doubles = Apply(a, m.Multiply);
Type widgetType = typeof(Widget);
//Gets every HelpAttribute defined for the Widget type
object[] widgetClassAttributes = widgetType.GetCustomAttributes(typeof(HelpAttribute), false);
if (widgetClassAttributes.Length > 0)
{
HelpAttribute attr = (HelpAttribute)widgetClassAttributes[0];
Console.WriteLine($"Widget class help URL : {attr.Url} - Related topic : {attr.Topic}");
}
System.Reflection.MethodInfo displayMethod = widgetType.GetMethod(nameof(Widget.Display));
//Gets every HelpAttribute defined for the Widget.Display method
object[] displayMethodAttributes = displayMethod.GetCustomAttributes(typeof(HelpAttribute), false);
if (displayMethodAttributes.Length > 0)
{
HelpAttribute attr = (HelpAttribute)displayMethodAttributes[0];
Console.WriteLine($"Display method help URL : {attr.Url} - Related topic : {attr.Topic}");
}
Console.ReadLine();
Console.Read();
}
IInterceptor[] IInterceptorSelector.SelectInterceptors(Type type, MethodInfo method, IInterceptor[] interceptors)
{
if (interceptors.Length == 0)
return interceptors;
var markers = new List<MarkerBaseAttribute>();
if (type != null)
markers.AddRange(type.GetCustomAttributes(typeof(MarkerBaseAttribute), true).Cast<MarkerBaseAttribute>());
if (method != null)
markers.AddRange(method.GetCustomAttributes(typeof(MarkerBaseAttribute), true).Cast<MarkerBaseAttribute>());
if (markers.Count == 0) // no marker attributes found, no ordering required
return interceptors;
markers.Sort((a, b) => a.Order.CompareTo(b.Order));
var sorted = new List<IInterceptor>();
for (int i = 0; i < markers.Count; ++i)
{
var providers = interceptors.OfType<IInterceptorMarkerProvider>();
var markerType = markers[i].GetType();
var matchingInterceptor = providers.FirstOrDefault(x => x.MarkerType == markerType) as IInterceptor;
if (matchingInterceptor != null)
sorted.Add(matchingInterceptor);
}
return sorted.ToArray();
}
public override IEnumerable <ITestCase> CreateTests(IFixture fixture, System.Reflection.MethodInfo method)
{
foreach (RowAttribute rowAttribute in method.GetCustomAttributes(typeof(RowAttribute), true))
{
yield return(new RowTestCase(fixture.Name, method, rowAttribute));
}
}
/// <summary>
/// 添加solr
/// </summary>
/// <param name="mi"></param>
/// <param name="prams"></param>
public static void AddHumorLucene(MethodInfo mi, object[] prams)
{
object[] attrs = mi.GetCustomAttributes(typeof(Attr_AddLuceneAttribute), false);
foreach (Attr_AddLuceneAttribute attr in attrs)
{
if (attr == null)
{
continue;
}
int index = attr.PramIndex;
if (index >= 0 && index < prams.Length)
{
//直接是传过来参数
if (string.IsNullOrWhiteSpace(attr.Key))
{
string id = prams[index].ToString();
srv_HumorLucene.AddLuceneHumor(Convert.ToInt32(id));
}
else
{
Type type = attr.Key.GetType();
PropertyInfo pi = type.GetProperty(attr.Key);
var id = pi.GetValue(prams[index], null);
srv_HumorLucene.AddLuceneHumor(Convert.ToInt32(id));
}
}
}
}
private static void RegisterMethod(MethodInfo method)
{
foreach (ScriptableAttribute attribute in method.GetCustomAttributes(typeof(ScriptableAttribute),false))
{
globalmethods[attribute.Name ?? method.Name] = method;
}
}
public override IList<string> GetCategories(MethodInfo method)
{
return (method.GetCustomAttributes(typeof(TraitAttribute), true)
.OfType<TraitAttribute>()
.Where(trait => trait.Name == "Category")
.Select(trait => trait.Value)).ToList();
}
/// <summary>
/// Implementors should collect the transformfilter information
/// and return descriptors instances, or an empty array if none
/// was found.
/// </summary>
/// <param name="methodInfo">The action (MethodInfo)</param>
/// <returns>
/// An array of <see cref="TransformFilterDescriptor"/>
/// </returns>
public TransformFilterDescriptor[] CollectFilters(MethodInfo methodInfo)
{
if (logger.IsDebugEnabled)
{
logger.DebugFormat("Collecting transform filters for {0}", methodInfo.Name);
}
var attributes = methodInfo.GetCustomAttributes(typeof(ITransformFilterDescriptorBuilder), true);
var filters = new List<TransformFilterDescriptor>();
foreach(ITransformFilterDescriptorBuilder builder in attributes)
{
var descs = builder.BuildTransformFilterDescriptors();
if (logger.IsDebugEnabled)
{
foreach(var desc in descs)
{
logger.DebugFormat("Collected transform filter {0} to execute in order {1}", desc.TransformFilterType, desc.ExecutionOrder);
}
}
filters.AddRange(descs);
}
return filters.ToArray();
}
private List<MethodBoundaryAttribute> GetAttributes(MethodInfo methodInfo)
{
List<MethodBoundaryAttribute> attributes = new List<MethodBoundaryAttribute>();
//Method level attributes
MethodBoundaryAttribute[] methodAttributes = (MethodBoundaryAttribute[])methodInfo.GetCustomAttributes(typeof(MethodBoundaryAttribute), false);
//Class level attributes
MethodBoundaryAttribute[] classAttributes = (MethodBoundaryAttribute[])methodInfo.ReflectedType.GetCustomAttributes(typeof(MethodBoundaryAttribute), false);
//add method level
attributes.AddRange(methodAttributes);
//add class attribute if not exist in method
foreach (MethodBoundaryAttribute classAttr in classAttributes)
{
bool exist = false;
foreach (MethodBoundaryAttribute methodAttr in methodAttributes)
{
if (classAttr.TypeId == methodAttr.TypeId)
exist = true;
}
if (!exist)
attributes.Add(classAttr);
}
return attributes;
}
public IEnumerable<Step> Scan(ITestContext testContext, MethodInfo method, Example example)
{
var executableAttribute = (ExecutableAttribute)method.GetCustomAttributes(typeof(ExecutableAttribute), false).FirstOrDefault();
if (executableAttribute == null)
yield break;
string stepTitle = executableAttribute.StepTitle;
if (string.IsNullOrEmpty(stepTitle))
stepTitle = Configurator.Scanners.Humanize(method.Name);
var stepAsserts = IsAssertingByAttribute(method);
var methodParameters = method.GetParameters();
var inputs = new List<object>();
var inputPlaceholders = Regex.Matches(stepTitle, " <(\\w+)> ");
for (int i = 0; i < inputPlaceholders.Count; i++)
{
var placeholder = inputPlaceholders[i].Groups[1].Value;
for (int j = 0; j < example.Headers.Length; j++)
{
if (example.Values.ElementAt(j).MatchesName(placeholder))
{
inputs.Add(example.GetValueOf(j, methodParameters[inputs.Count].ParameterType));
break;
}
}
}
var stepAction = StepActionFactory.GetStepAction(method, inputs.ToArray());
yield return new Step(stepAction, new StepTitle(stepTitle), stepAsserts, executableAttribute.ExecutionOrder, true, new List<StepArgument>());
}
/// <summary>
/// Check to make sure there is a method that has the attribute [EventHandler]
/// </summary>
/// <param name="mi"></param>
/// <returns></returns>
private bool containsHandler(System.Reflection.MethodInfo mi)
{
foreach (object o in mi.GetCustomAttributes(false))
{
if (o.GetType() == typeof(EventHandlerAttribute))
{
return(true);
}
}
return(false);
}
/// <summary>
/// 获取方法特性
/// </summary>
/// <param name="method">The method.</param>
/// <returns></returns>
public static Attribute[] GetAttributes(System.Reflection.MethodInfo method)
{
var list = method.GetCustomAttributes(true);
var attributes = new List <Attribute>(list.Length);
foreach (var i in list)
{
attributes.Add((Attribute)i);
}
return(attributes.ToArray());
}
/// <summary>
/// 根据方法名获取描述
/// </summary>
/// <param name="method">方法名</param>
/// <param name="t">类型</param>
/// <param name="types">参数类型</param>
/// <returns></returns>
public static string GetDescriptionByMethod(this string method, Type t)
{
System.Reflection.MethodInfo fi = t.GetMethod(method);
if (fi != null)
{
DescriptionAttribute[] attributes =
(DescriptionAttribute[])fi.GetCustomAttributes(
typeof(DescriptionAttribute), false);
return(attributes.Length > 0 ? attributes[0].Description : "");
}
return("");
}
private PluginMethod CreateFrom(System.Reflection.MethodInfo method, string logicalname)
{
var result = new PluginMethod();
result.Name = method.Name;
result.method = method;
var parameters = method.GetParameters().ToArray();
result.Parameters = new TypeCache[parameters.Length];
var ix = 0;
foreach (var parameter in parameters)
{
result.Parameters[ix] = TypeCache.ForParameter(parameter, logicalname);
ix++;
}
var sortAttr = method.GetCustomAttributes(Types.SortAttribute, false).SingleOrDefault();
if (sortAttr != null)
{
result.Sort = (int)sortAttr.GetType().GetProperty("Value").GetValue(sortAttr);
}
else
{
result.Sort = 1;
}
var ifAttr = method.GetCustomAttributes(Types.IfAttribute, true).SingleOrDefault();
if (ifAttr is Attributes.IfAttribute ia)
{
result.IfAttribute = ia;
}
return(result);
}
// </AsyncExample>
private static void ReadAttributes()
{
// <ReadAttributes>
Type widgetType = typeof(Widget);
object[] widgetClassAttributes = widgetType.GetCustomAttributes(typeof(HelpAttribute), false);
if (widgetClassAttributes.Length > 0)
{
HelpAttribute attr = (HelpAttribute)widgetClassAttributes[0];
Console.WriteLine($"Widget class help URL : {attr.Url} - Related topic : {attr.Topic}");
}
System.Reflection.MethodInfo displayMethod = widgetType.GetMethod(nameof(Widget.Display));
object[] displayMethodAttributes = displayMethod.GetCustomAttributes(typeof(HelpAttribute), false);
if (displayMethodAttributes.Length > 0)
{
HelpAttribute attr = (HelpAttribute)displayMethodAttributes[0];
Console.WriteLine($"Display method help URL : {attr.Url} - Related topic : {attr.Topic}");
}
// </ReadAttributes>
}
private static bool HasAttribute <TAttribute>(this System.Reflection.MethodInfo methodInfo) where TAttribute : Attribute => methodInfo.GetCustomAttributes().Any(a => a is TAttribute);
public override void Execute(RouteData routeData)
{
//1.得到当前控制器的类型
Type type = this.GetType();
//2.从路由表中取到当前请求的action名称
string actionName = routeData.RouteValue["action"].ToString();
//3.从路由表中取到当前请求的Url参数
object parameter = null;
//url中的参数
if (routeData.RouteValue.ContainsKey("parameters"))
{
parameter = routeData.RouteValue["parameters"];
}
var paramTypes = new List <Type>();
List <object> parameters = new List <object>();
if (parameter != null)
{
var dicParam = (Dictionary <string, string>)parameter;
foreach (var pair in dicParam)
{
parameters.Add(pair.Value);
paramTypes.Add(pair.Value.GetType());
}
}
//4.通过action名称和对应的参数反射对应方法。
//这里第二个参数可以不理会action字符串的大小写，第四个参数决定了当前请求的action的重载参数类型
System.Reflection.MethodInfo mi = type.GetMethod(actionName,
BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase, null, paramTypes.ToArray(), null);
if (mi != null)
{
bool flag = false;
object[] httpMethods = mi.GetCustomAttributes(typeof(HttpMethodAttribute), true);
if (httpMethods != null && httpMethods.Length > 0)
{
foreach (var m in httpMethods)
{
if (((HttpMethodAttribute)m).HttpMethods.Contains(routeData.RouteValue["HttpMethod"]))
{
flag = true;
}
}
}
if (flag)
{
if (mi.ReturnType.Equals(typeof(void)))
{
mi.Invoke(this, parameters.ToArray());
}
else
{
//5.执行该Action方法
var actionResult = mi.Invoke(this, parameters.ToArray()) as ActionResult;
//6.得到action方法的返回值，并执行具体ActionResult的ExecuteResult()方法。
actionResult.ExecuteResult(routeData);
}
}
else
{
HttpResponse response = HttpContext.Current.Response;
response.Write("参数错误：HttpMethod");
response.End();
}
}
else
{
HttpResponse response = HttpContext.Current.Response;
response.Write("找不到Action");
response.End();
}
}
public override object[] GetCustomAttributes(bool inherit)
{
return(_realMethod.GetCustomAttributes(inherit));
}
// 添加函数节点
public static CodeGenerateSystem.Controls.NodeListAttributeClass AddMethodNode(CodeGenerateSystem.Controls.NodesContainerControl.ContextMenuFilterData filterData, System.Reflection.MethodInfo methodInfo, Type parentClassType, CodeGenerateSystem.Controls.NodeListControl hostNodesList, EngineNS.ECSType csType, string attributeName, CodeDomNode.MethodInfoAssist.enHostType hostType)
{
//"CSUtility.Event.Attribute.AllowMember"
//
CodeGenerateSystem.Controls.NodeListAttributeClass attribute = null;
var att = EngineNS.Rtti.AttributeHelper.GetCustomAttribute(methodInfo, attributeName, true);
if (att == null)
{
return(attribute);
}
var path = EngineNS.Rtti.AttributeHelper.GetCustomAttributePropertyValue(att, "Path")?.ToString();
if (string.IsNullOrEmpty(path))
{
path = EngineNS.Rtti.RttiHelper.GetAppTypeString(methodInfo.ReflectedType) + "." + methodInfo.Name;
}
var description = EngineNS.Rtti.AttributeHelper.GetCustomAttributePropertyValue(att, "Description").ToString();
//var refTypeStr = EngineNS.Rtti.RttiHelper.GetAppTypeString(methodInfo.ReflectedType);
//var methodInfoString = GetParamFromMethodInfo(methodInfo, path);
//methodInfoString += "," + csType.ToString() + "," + methodInfo.IsGenericMethodDefinition;
//if (usefulMemberData != null)
//{
// var usefulMemberStr = usefulMemberData.ToString().Replace(usefulMemberData.ClassTypeFullName, refTypeStr);
// methodInfoString += ";" + usefulMemberStr;
// if (!string.IsNullOrEmpty(usefulMemberData.MemberHostName))
// {
// path = usefulMemberData.MemberHostName + "." + path;
// }
// if (usefulMemberData.HostControl != null)
// {
// path = GetNodeName(usefulMemberData) + "." + path;
// }
//}
//path += "(" + refTypeStr + ")";
var csParam = new CodeDomNode.MethodInvokeNode.MethodNodeConstructionParams()
{
CSType = csType,
ConstructParam = "",
MethodInfo = GetMethodInfoAssistFromMethodInfo(methodInfo, parentClassType, hostType, path),
};
var displayatt = methodInfo.GetCustomAttributes(typeof(EngineNS.Editor.DisplayParamNameAttribute), true);
if (displayatt.Length > 0)
{
csParam.DisplayName = ((EngineNS.Editor.DisplayParamNameAttribute)displayatt[0]).DisplayName;
}
var attrs = methodInfo.GetCustomAttributes(typeof(EngineNS.Editor.MacrossPanelPathAttribute), true);
if (attrs.Length == 0)
{
path = path.Replace('.', '/');
}
else
{
path = ((EngineNS.Editor.MacrossPanelPathAttribute)attrs[0]).Path;
}
attribute = hostNodesList.AddNodesFromType(filterData, typeof(CodeDomNode.MethodInvokeNode), path, csParam, description, "", hostNodesList.TryFindResource("Icon_Function") as ImageSource);
return(attribute);
}
private void CreateParticleMethodCategory(string methodname, float x, float y)
{
Macross.NodesControlAssist NodesControlAssist = mLinkedNodesContainer.HostControl as Macross.NodesControlAssist;
//加入列表信息
Macross.Category category;
var csparam = CSParam as ParticleShapeConeControlConstructionParams;
if (!csparam.CategoryDic.TryGetValue(Macross.MacrossPanelBase.GraphCategoryName, out category))
{
return;
}
var HostControl = this.HostNodesContainer.HostControl;
var item = new Macross.CategoryItem(null, category);
item.CategoryItemType = Macross.CategoryItem.enCategoryItemType.OverrideFunction;
var data = new Macross.CategoryItem.InitializeData();
data.Reset();
var MacrossOpPanel = NodesControlAssist.HostControl.MacrossOpPanel;
item.Initialize(MacrossOpPanel.HostControl, data);
//HostControl.CreateNodesContainer(item);
//MainGridItem.Children.Add(item);
item.Name = methodname;
category.Items.Add(item);
//加入结点信息
Type type = typeof(EngineNS.Bricks.Particle.ParticleEmitShapeNode);
System.Reflection.MethodInfo methodInfo = type.GetMethod(methodname);
System.Reflection.ParameterInfo[] paramstype = methodInfo.GetParameters();
//拷貝方法的attribute.
var attrts = methodInfo.GetCustomAttributes(true);
string displayname = "";
for (int i = 0; i < attrts.Length; i++)
{
var displayattr = attrts[i] as System.ComponentModel.DisplayNameAttribute;
if (displayattr != null)
{
displayname = displayattr.DisplayName;
break;
}
}
//var CustomFunctionData = new Macross.ResourceInfos.MacrossResourceInfo.CustomFunctionData();
var methodinfo = CodeDomNode.Program.GetMethodInfoAssistFromMethodInfo(methodInfo, type, CodeDomNode.MethodInfoAssist.enHostType.Base, "");
var nodeType = typeof(CodeDomNode.MethodOverride);
var csParam = new CodeDomNode.MethodOverride.MethodOverrideConstructParam()
{
CSType = mLinkedNodesContainer.CSType,
HostNodesContainer = mLinkedNodesContainer,
ConstructParam = "",
MethodInfo = methodinfo,
DisplayName = displayname,
};
//var center = nodesContainer.NodesControl.GetViewCenter();
var node = mLinkedNodesContainer.AddOrigionNode(nodeType, csParam, x, y);
node.IsDeleteable = true;
//重写双击事件 不需要进入二级编辑
//item.OnDoubleClick -= item.OnDoubleClick;
Type ItemType = item.GetType();
FieldInfo _Field = item.GetType().GetField("OnDoubleClick", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static);
if (_Field != null)
{
object _FieldValue = _Field.GetValue(item);
if (_FieldValue != null && _FieldValue is Delegate)
{
Delegate _ObjectDelegate = (Delegate)_FieldValue;
Delegate[] invokeList = _ObjectDelegate.GetInvocationList();
foreach (Delegate del in invokeList)
{
ItemType.GetEvent("OnDoubleClick").RemoveEventHandler(item, del);
}
}
}
item.OnDoubleClick += (categoryItem) =>
{
mLinkedNodesContainer.FocusNode(node);
};
//NodesControlAssist.Save();
}
