public ActionMetadata(MethodInfo action, ParameterMetadata[] parameters, int cancellationTokenIndex, Type resultType, bool hasSerializableParameters) { Action = action; Parameters = parameters; CancellationTokenIndex = cancellationTokenIndex; ResultType = resultType; HasSerializableParameters = hasSerializableParameters; }
/********* ** Public methods *********/ /// <summary>Get an error message indicating why the usage is invalid (or <c>null</c> if usage is valid).</summary> /// <param name="parameter">Represents a parameter annotated by a single contract annotation.</param> public string GetError(ParameterMetadata parameter) { if (!this.IsAllowedType(parameter.ParameterQualifiedType, parameter.ParameterTypeIsUnknown)) { return String.Format( "This annotation is used incorrectly and will be ignored: {0} on the {1}::{2}({3}) parameter. The contract is only compatible with reference types.", parameter.Annotation.GetType(), parameter.TypeName, parameter.MethodName, parameter.Name ); } return null; }
private static IEnumerable<ParameterMetadata> GetRouteParameters(ServiceMethodMetadata metadata, IProxyMetadata proxyMetadata) { var routeParameters = new List<ParameterMetadata>(); foreach (ParameterInfo parameter in metadata.MethodInfo.GetParameters()) { if (metadata.UrlInfo.UrlTemplate.IndexOf(String.Concat("{", parameter.Name, "}"), StringComparison.OrdinalIgnoreCase) < 0) { continue; } ParameterMetadata parameterMetadata = proxyMetadata != null ? proxyMetadata.GetParameter(metadata.MethodInfo, parameter.Name, RequestParameterType.Route) : null; var routeParameter = new ParameterMetadata { Name = parameter.Name.ToLowerInvariant(), ParameterType = RequestParameterType.Route, Type = parameter.ParameterType, IsOptionalParameter = parameter.DefaultValue != DBNull.Value, RegexConstraint = GetParameterConstraint(parameter), ExampleValue = parameterMetadata != null ? parameterMetadata.ExampleValue : null, AllowedValues = parameterMetadata != null ? parameterMetadata.AllowedValues : null }; routeParameters.Add(routeParameter); } return routeParameters; }
/// <summary> /// Get cmdlets from the given assembly /// </summary> /// <param name="assemblyPath"></param> /// <returns></returns> public IList<CmdletSignatureMetadata> GetCmdlets(string assemblyPath) { IList<CmdletSignatureMetadata> result = new List<CmdletSignatureMetadata>(); try { var assembly = Assembly.LoadFrom(assemblyPath); foreach (var type in assembly.GetCmdletTypes()) { var cmdlet = type.GetAttribute<CmdletAttribute>(); var outputs = type.GetAttributes<OutputTypeAttribute>(); var parameters = type.GetParameters(); var cmdletMetadata = new CmdletSignatureMetadata { VerbName = cmdlet.VerbName, NounName = cmdlet.NounName, ConfirmImpact = cmdlet.ConfirmImpact, SupportsShouldProcess = cmdlet.SupportsShouldProcess, ClassName = type.FullName, AssemblyName = assembly.FullName }; foreach (var output in outputs) { foreach (var outputType in output.Type) { var outputMetadata = new OutputMetadata { Type = outputType.Type }; outputMetadata.ParameterSets.AddRange(output.ParameterSetName); } } foreach (var parameter in parameters) { if ( parameter.Name == "Force" && parameter.PropertyType == typeof (SwitchParameter)) { cmdletMetadata.HasForceSwitch = true; } var parameterData = new ParameterMetadata { Type = parameter.PropertyType, Name = parameter.Name }; if (parameter.HasAttribute<AliasAttribute>()) { var aliases = parameter.GetAttributes<AliasAttribute>(); parameterData.AliasList.AddRange( aliases.SelectMany(a => a.AliasNames)); } cmdletMetadata.Parameters.Add(parameterData); } result.Add(cmdletMetadata); } } catch { } return result; }