public TypeMetric( bool isAbstract, TypeMetricKind kind, AccessModifierKind accessModifier, IEnumerable<IMemberMetric> memberMetrics, int linesOfCode, int cyclomaticComplexity, double maintainabilityIndex, int depthOfInheritance, IEnumerable<ITypeCoupling> classCouplings, string name, int afferentCoupling, int efferentCoupling, double instability, ITypeDocumentation documentation) { IsAbstract = isAbstract; Kind = kind; AccessModifier = accessModifier; MemberMetrics = memberMetrics; LinesOfCode = linesOfCode; CyclomaticComplexity = cyclomaticComplexity; MaintainabilityIndex = maintainabilityIndex; DepthOfInheritance = depthOfInheritance; ClassCouplings = classCouplings.AsArray(); Name = name; AfferentCoupling = afferentCoupling; EfferentCoupling = efferentCoupling; Instability = instability; Documentation = documentation; }
public INamespaceMetric CalculateFrom(NamespaceDeclarationSyntaxInfo namespaceNode, IEnumerable<ITypeMetric> metrics) { const string DocumentationTypeName = "NamespaceDoc"; var typeMetrics = metrics.AsArray(); var documentationType = typeMetrics.FirstOrDefault(x => x.Name == DocumentationTypeName); IDocumentation documentation = null; if (documentationType != null) { documentation = documentationType.Documentation; typeMetrics = typeMetrics.Where(x => x.Name != DocumentationTypeName).AsArray(); } var linesOfCode = typeMetrics.Sum(x => x.LinesOfCode); var source = typeMetrics.SelectMany(x => x.ClassCouplings) .GroupBy(x => x.ToString()) .Select(x => new TypeCoupling(x.First().TypeName, x.First().Namespace, x.First().Assembly, x.SelectMany(y => y.UsedMethods), x.SelectMany(y => y.UsedProperties), x.SelectMany(y => y.UsedEvents))) .Where(x => x.Namespace != namespaceNode.Name) .OrderBy(x => x.Assembly + x.Namespace + x.TypeName) .AsArray(); var maintainabilitySource = typeMetrics.Select(x => new Tuple<int, double>(x.LinesOfCode, x.MaintainabilityIndex)).AsArray(); var maintainabilityIndex = linesOfCode > 0 && maintainabilitySource.Any() ? maintainabilitySource.Sum(x => x.Item1 * x.Item2) / linesOfCode : 100.0; var cyclomaticComplexity = typeMetrics.Sum(x => x.CyclomaticComplexity); var depthOfInheritance = typeMetrics.Any() ? typeMetrics.Max(x => x.DepthOfInheritance) : 0; return new NamespaceMetric( maintainabilityIndex, cyclomaticComplexity, linesOfCode, source, depthOfInheritance, namespaceNode.Name, typeMetrics, documentation); }
public MemberMetric( string codeFile, AccessModifierKind accessModifier, IHalsteadMetrics halstead, int lineNumber, int linesOfCode, double maintainabilityIndex, int cyclomaticComplexity, string name, IEnumerable<ITypeCoupling> classCouplings, int numberOfParameters, int numberOfLocalVariables, int afferentCoupling, IMemberDocumentation documentation) { _halstead = halstead; CodeFile = codeFile; AccessModifier = accessModifier; LineNumber = lineNumber; LinesOfCode = linesOfCode; MaintainabilityIndex = maintainabilityIndex; CyclomaticComplexity = cyclomaticComplexity; Name = name; ClassCouplings = classCouplings.AsArray(); NumberOfParameters = numberOfParameters; NumberOfLocalVariables = numberOfLocalVariables; AfferentCoupling = afferentCoupling; Documentation = documentation; }
public async Task<ITypeMetric> CalculateFrom(TypeDeclarationSyntaxInfo typeNode, IEnumerable<IMemberMetric> metrics) { var memberMetrics = metrics.AsArray(); var type = typeNode.Syntax; var symbol = Model.GetDeclaredSymbol(type); var documentation = await _documentationFactory.Create(symbol, CancellationToken.None); var metricKind = GetMetricKind(type); var source = CalculateClassCoupling(type, memberMetrics); var depthOfInheritance = CalculateDepthOfInheritance(type); var cyclomaticComplexity = memberMetrics.Sum(x => x.CyclomaticComplexity); var linesOfCode = memberMetrics.Sum(x => x.LinesOfCode); var maintainabilityIndex = CalculateAveMaintainabilityIndex(memberMetrics); var afferentCoupling = await CalculateAfferentCoupling(type); var efferentCoupling = GetEfferentCoupling(type, symbol); var instability = (double)efferentCoupling / (efferentCoupling + afferentCoupling); var modifier = GetAccessModifier(type.Modifiers); return new TypeMetric( symbol.IsAbstract, metricKind, modifier, memberMetrics, linesOfCode, cyclomaticComplexity, maintainabilityIndex, depthOfInheritance, source, type.GetName(), afferentCoupling, efferentCoupling, instability, documentation); }
public virtual bool CanResolve(Type type, object context, IEnumerable <object> args) { if (type == null) { throw new ArgumentNullException(nameof(type)); } return(Mappings.CanResolve(this, type, args?.AsArray())); }
public TypeDocumentation(string summary, string code, string example, string remarks, string returns, IEnumerable<TypeParameterDocumentation> typeParameters) { Summary = summary; Code = code; Example = example; Remarks = remarks; Returns = returns; TypeParameters = typeParameters.AsArray(); }
/// <summary> /// Initializes a new instance of the <see cref="ComposablePartCatalogChangeEventArgs"/>. /// </summary> /// <param name="addedDefinitions"> /// An <see cref="IEnumerable{T}"/> of <see cref="ComposablePartDefinition"/> objects that /// are being added to the <see cref="ComposablePartCatalog"/>. /// </param> /// <param name="removedDefinitions"> /// An <see cref="IEnumerable{T}"/> of <see cref="ComposablePartDefinition"/> objects that /// are being removed from the <see cref="ComposablePartCatalog"/>. /// </param> /// <param name="atomicComposition"> /// A <see cref="AtomicComposition"/> representing all tentative changes that will /// be completed if the change is successful, or discarded if it is not. /// <see langword="null"/> if being applied outside a <see cref="AtomicComposition"/> /// or during a <see cref="INotifyComposablePartCatalogChanged.Changed"/> event. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="addedDefinitions"/> or <paramref name="removedDefinitions"/> is <see langword="null"/>. /// </exception> public ComposablePartCatalogChangeEventArgs(IEnumerable<ComposablePartDefinition> addedDefinitions, IEnumerable<ComposablePartDefinition> removedDefinitions, AtomicComposition atomicComposition) { Requires.NotNull(addedDefinitions, "addedDefinitions"); Requires.NotNull(removedDefinitions, "removedDefinitions"); this.AddedDefinitions = addedDefinitions.AsArray(); this.RemovedDefinitions = removedDefinitions.AsArray(); this.AtomicComposition = atomicComposition; }
/// <summary> /// Initializes a new instance of the <see cref="ExportsChangeEventArgs"/> class with /// the specified changed export definitions. /// </summary> /// <param name="addedExports"> /// An <see cref="IEnumerable{T}"/> of <see cref="ExportDefinition"/>s of the exports /// that have been added. /// </param> /// <param name="removedExports"> /// An <see cref="IEnumerable{T}"/> of <see cref="ExportDefinition"/>s of the exports /// that have been removed. /// </param> /// <param name="atomicComposition"> /// A <see cref="AtomicComposition"/> representing all tentative changes that will /// be completed if the change is successful, or discarded if it is not. /// <see langword="null"/> if being applied outside a <see cref="AtomicComposition"/> /// or during a <see cref="ExportProvider.ExportsChanged"/> event. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="addedExports"/> or <paramref name="removedExports"/> is <see langword="null"/>. /// </exception> public ExportsChangeEventArgs(IEnumerable<ExportDefinition> addedExports, IEnumerable<ExportDefinition> removedExports, AtomicComposition atomicComposition) { Requires.NotNull(addedExports, "addedExports"); Requires.NotNull(removedExports, "removedExports"); this.AddedExports = addedExports.AsArray(); this.RemovedExports = removedExports.AsArray(); this.AtomicComposition = atomicComposition; }
public async Task<IEnumerable<INamespaceMetric>> Calculate(IEnumerable<SyntaxTree> syntaxTrees, params Assembly[] references) { var trees = syntaxTrees.AsArray(); var declarations = _syntaxCollector.GetDeclarations(trees); var statementMembers = declarations.Statements.Select(s => s is StatementSyntax ? SyntaxFactory.MethodDeclaration( SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword)), Guid.NewGuid().ToString("N")) .WithBody(SyntaxFactory.Block((StatementSyntax)s)) : s); var members = declarations.MemberDeclarations.Concat(statementMembers).AsArray(); var anonClass = members.Any() ? new[] { SyntaxFactory.ClassDeclaration( "UnnamedClass") .WithModifiers( SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword))) .WithMembers(SyntaxFactory.List(members)) } : new TypeDeclarationSyntax[0]; var array = declarations.TypeDeclarations .Concat(anonClass) .Cast<MemberDeclarationSyntax>() .AsArray(); var anonNs = array.Any() ? new[] { SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName("Unnamed")) .WithMembers(SyntaxFactory.List(array)) } : new NamespaceDeclarationSyntax[0]; var namespaceDeclarations = declarations .NamespaceDeclarations .Concat(anonNs) .Select(x => new NamespaceDeclarationSyntaxInfo { Name = x.GetName(x), Syntax = x }) .GroupBy(x => x.Name) .Select(g => new NamespaceDeclaration { Name = g.Key, SyntaxNodes = g.AsArray() }) .AsArray(); var metadataReferences = (references.Any() ? references : new[] { typeof(object).Assembly }).Select(a => MetadataReference.CreateFromFile(a.Location)).ToArray(); var commonCompilation = CSharpCompilation.Create("x", syntaxTrees: trees, references: metadataReferences); var namespaceMetrics = await CalculateNamespaceMetrics(namespaceDeclarations, commonCompilation, null).ConfigureAwait(false); return namespaceMetrics; }
public MemberDocumentation(string summary, string code, string example, string remarks, string returns, IEnumerable<TypeParameterDocumentation> typeParameters, IEnumerable<ParameterDocumentation> parameters, IEnumerable<ExceptionDocumentation> exceptions) { Summary = summary; Code = code; Example = example; Remarks = remarks; Returns = returns; TypeParameters = typeParameters.AsArray(); Parameters = parameters.AsArray(); Exceptions = exceptions.AsArray(); }
/// <summary> /// Initializes a new instance of the <see cref="HttpDirectRoute" /> class. /// </summary> /// <param name="routeTemplate">The route template.</param> /// <param name="defaults">The default values.</param> /// <param name="constraints">The route constraints.</param> /// <param name="actions">The actions that are reachable via this route.</param> public HttpDirectRoute( string routeTemplate, HttpRouteValueDictionary defaults, HttpRouteValueDictionary constraints, IEnumerable<ReflectedHttpActionDescriptor> actions) : base(routeTemplate, defaults: defaults, constraints: constraints, dataTokens: null, handler: null) { if (actions != null) { Actions = actions.AsArray(); DataTokens[RouteKeys.ActionsDataTokenKey] = Actions; } }
public Task<IEnumerable<IModelNode>> Transform(IEnumerable<IModelNode> source, IEnumerable<TransformRule> rules, CancellationToken cancellationToken) { return Task.Factory.StartNew( () => { var allRules = rules.AsArray(); var transformedVertices = from vertex in source select TransformVertexRecursive(vertex, allRules); return transformedVertices.AsArray().AsEnumerable(); }, cancellationToken); }
public ProjectMetric(string name, IEnumerable<INamespaceMetric> namespaceMetrics, IEnumerable<string> referencedProjects, double relationalCohesion) { Name = name; RelationalCohesion = relationalCohesion; Dependencies = referencedProjects.AsArray(); EfferentCoupling = Dependencies.Count(); NamespaceMetrics = namespaceMetrics.AsArray(); LinesOfCode = NamespaceMetrics.Sum(x => x.LinesOfCode); MaintainabilityIndex = LinesOfCode == 0 ? 100 : NamespaceMetrics.Sum(x => x.MaintainabilityIndex * x.LinesOfCode) / LinesOfCode; CyclomaticComplexity = LinesOfCode == 0 ? 0 : NamespaceMetrics.Sum(x => x.CyclomaticComplexity * x.LinesOfCode) / LinesOfCode; ClassCouplings = NamespaceMetrics.SelectMany(x => x.ClassCouplings).Where(x => x.Assembly != Name).Distinct(Comparer).AsArray(); Dependendants = ClassCouplings.Select(x => x.Assembly) .Distinct() .AsArray(); AfferentCoupling = Dependendants.Count(); var typeMetrics = NamespaceMetrics.SelectMany(x => x.TypeMetrics).AsArray(); Abstractness = typeMetrics.Count(x => x.IsAbstract) / (double)typeMetrics.Count(); }
public SyntaxDeclarations GetDeclarations(IEnumerable<SyntaxTree> trees) { var syntaxTrees = trees.AsArray(); foreach (var root in syntaxTrees.Select(syntaxTree => syntaxTree.GetRoot())) { Visit(root); CheckStatementSyntax(root); } return new SyntaxDeclarations { MemberDeclarations = _members.AsArray(), NamespaceDeclarations = _namespaces.AsArray(), Statements = _statements.AsArray(), TypeDeclarations = _types.AsArray() }; }
public NamespaceMetric( double maintainabilityIndex, int cyclomaticComplexity, int linesOfCode, IEnumerable<ITypeCoupling> classCouplings, int depthOfInheritance, string name, IEnumerable<ITypeMetric> typeMetrics, IDocumentation documentation) { MaintainabilityIndex = maintainabilityIndex; CyclomaticComplexity = cyclomaticComplexity; LinesOfCode = linesOfCode; ClassCouplings = classCouplings; DepthOfInheritance = depthOfInheritance; Name = name; Documentation = documentation; TypeMetrics = typeMetrics.AsArray(); Abstractness = TypeMetrics.Count(x => x.IsAbstract) / (double)TypeMetrics.Count(); }
/// <summary> /// Builds an <see cref="IHttpRoute"/> for a particular action. /// </summary> /// <param name="routeTemplate">The tokenized route template for the route.</param> /// <param name="httpMethods">The HTTP methods supported by the route.</param> /// <param name="actions">The actions to invoke for the route.</param> /// <returns>The generated <see cref="IHttpRoute"/>.</returns> public virtual IHttpRoute BuildHttpRoute( string routeTemplate, IEnumerable<HttpMethod> httpMethods, IEnumerable<ReflectedHttpActionDescriptor> actions) { if (routeTemplate == null) { throw Error.ArgumentNull("routeTemplate"); } HttpRouteValueDictionary defaults = new HttpRouteValueDictionary(); HttpRouteValueDictionary constraints = new HttpRouteValueDictionary(); if (httpMethods != null) { // Current method constraint implementation is inefficient since it matches before running the constraint. // Consider checking the HTTP method first in a custom route as a performance optimization. constraints["httpMethod"] = new HttpMethodConstraint(httpMethods.AsArray()); } string detokenizedRouteTemplate = InlineRouteTemplateParser.ParseRouteTemplate(routeTemplate, defaults, constraints, ConstraintResolver); return BuildHttpRoute(detokenizedRouteTemplate, defaults, constraints, actions); }
public static ReadOnlyCollection <T> ToReadOnlyCollection <T>(this IEnumerable <T> source) { Assumes.NotNull(source); return(new ReadOnlyCollection <T>(source.AsArray())); }
/// <summary> /// Initializes a new instance of the <see cref="AggregateExportProvider"/> class. /// </summary> /// <param name="providers">The prioritized list of export providers. The providers are consulted in order in which they are supplied.</param> /// <remarks> /// <para> /// The <see cref="AggregateExportProvider"/> will consult the providers in the order they have been specfied when /// executing <see cref="ExportProvider.GetExports(ImportDefinition,AtomicComposition)"/>. /// </para> /// <para> /// The <see cref="AggregateExportProvider"/> does not take ownership of the specified providers. /// That is, it will not try to dispose of any of them when it gets disposed. /// </para> /// </remarks> public AggregateExportProvider(IEnumerable<ExportProvider> providers) : this((providers!= null) ? providers.AsArray() : null) { }
/// <summary> /// Initializes a new instance of the <see cref="AggregateExportProvider"/> class. /// </summary> /// <param name="providers">The prioritized list of export providers. The providers are consulted in order in which they are supplied.</param> /// <remarks> /// <para> /// The <see cref="AggregateExportProvider"/> will consult the providers in the order they have been specfied when /// executing <see cref="ExportProvider.GetExports(ImportDefinition,AtomicComposition)"/>. /// </para> /// <para> /// The <see cref="AggregateExportProvider"/> does not take ownership of the specified providers. /// That is, it will not try to dispose of any of them when it gets disposed. /// </para> /// </remarks> public AggregateExportProvider(IEnumerable <ExportProvider>?providers) : this(providers?.AsArray()) { }
public virtual LangElement New(Span span, TypeRef classNameRef, IEnumerable <ActualParam> argsOpt, Span argsPosition) { return(new NewEx(span, classNameRef, argsOpt.AsArray(), argsPosition)); }
public ComparisonResult(ComparisonResultKind kind, IModelNode pattern, IEnumerable<IModelNode> matches) { Kind = kind; Pattern = pattern; Matches = matches == null ? null : matches.AsArray(); }
private static bool TryGetGenericTypeParameters(IEnumerable<object> genericParameters, out Type[] genericTypeParameters) { genericTypeParameters = genericParameters as Type[]; if (genericTypeParameters == null) { object[] genericParametersAsArray = genericParameters.AsArray(); genericTypeParameters = new Type[genericParametersAsArray.Length]; for (int i = 0; i < genericParametersAsArray.Length; i++) { genericTypeParameters[i] = genericParametersAsArray[i] as Type; if (genericTypeParameters[i] == null) { return false; } } } return true; }
public virtual LangElement NewArray(Span span, IEnumerable <Item> itemsOpt, bool isOldNotation) { var items = itemsOpt.AsArray(); return(ArrayEx.CreateArray(span, IsAllNull(items) ? null : items, !isOldNotation)); }
public void ShouldCheckEnumerableToArrayConversion(IEnumerable <int> source, int[] expected) { Assert.Equal(expected, source.AsArray()); }
public static ushort FromBe(IEnumerable <byte> b) { return(BitConverter.ToUInt16(BitConverter.IsLittleEndian ? b.Reverse().AsArray() : b.AsArray(), 0)); }
/// <summary> /// Initializes a new instance of the <see cref="AggregateExportProvider"/> class. /// </summary> /// <param name="providers">The prioritized list of export providers. The providers are consulted in order in which they are supplied.</param> /// <remarks> /// <para> /// The <see cref="AggregateExportProvider"/> will consult the providers in the order they have been specfied when /// executing <see cref="ExportProvider.GetExports(ImportDefinition,AtomicComposition)"/>. /// </para> /// <para> /// The <see cref="AggregateExportProvider"/> does not take ownership of the specified providers. /// That is, it will not try to dispose of any of them when it gets disposed. /// </para> /// </remarks> public AggregateExportProvider(IEnumerable <ExportProvider> providers) : this((providers != null) ? providers.AsArray() : null) { }
private static MediaTypeFormatter[] GetWritingFormatters(IEnumerable <MediaTypeFormatter> formatters) { Debug.Assert(formatters != null); return(formatters.AsArray()); }
public void HandleDisplayedItemsChanged(IEnumerable <ILookupItem> displayedItems) { _lastDisplayedItems = displayedItems.AsArray(); }
private IChangeSet <TObject, TKey> ProcessResult(IEnumerable <UpdateWithFilter> source) { var result = source.AsArray(); //Have to process one item at a time as an item can be included multiple //times in any batch foreach (var item in result) { var matches = item.IsMatch; var key = item.Change.Key; var u = item.Change; switch (item.Change.Reason) { case ChangeReason.Add: { if (matches) { _cache.AddOrUpdate(u.Current, u.Key); } } break; case ChangeReason.Update: { if (matches) { _cache.AddOrUpdate(u.Current, u.Key); } else { _cache.Remove(u.Key); } } break; case ChangeReason.Remove: _cache.Remove(u.Key); break; case ChangeReason.Evaluate: { var exisiting = _cache.Lookup(key); if (matches) { if (!exisiting.HasValue) { _cache.AddOrUpdate(u.Current, u.Key); } else { _cache.Evaluate(); } } else { if (exisiting.HasValue) { _cache.Remove(u.Key); } } } break; } } return(_cache.CaptureChanges()); }
public static ReadOnlyCollection<T> ToReadOnlyCollection<T>(this IEnumerable<T> source) { ArgumentNullException.ThrowIfNull(source); return new ReadOnlyCollection<T>(source.AsArray()); }
public virtual TypeRef AnonymousTypeReference(Span span, Span headingSpan, bool conditional, PhpMemberAttributes attributes, IEnumerable <FormalTypeParam> typeParamsOpt, INamedTypeRef baseClassOpt, IEnumerable <INamedTypeRef> implements, IEnumerable <LangElement> members, Span bodySpan) { Debug.Assert(members != null && implements != null); return(new AnonymousTypeRef(span, new AnonymousTypeDecl(span, headingSpan, conditional, attributes, false, typeParamsOpt.AsArray(), baseClassOpt, implements.AsArray(), members.CastToArray <TypeMemberDecl>(), bodySpan))); }
public static int FromBeToInt(IEnumerable <byte> b) { return(BitConverter.ToInt32(BitConverter.IsLittleEndian ? b.Reverse().AsArray() : b.AsArray(), 0)); }
public virtual LangElement TraitAdaptationPrecedence(Span span, Tuple <TypeRef, NameRef> name, IEnumerable <TypeRef> precedences) { Debug.Assert(precedences != null); return(new TraitsUse.TraitAdaptationPrecedence(span, name, precedences.AsArray())); }
private static MediaTypeFormatter[] GetWritingFormatters(IEnumerable<MediaTypeFormatter> formatters) { Contract.Assert(formatters != null); MediaTypeFormatterCollection formatterCollection = formatters as MediaTypeFormatterCollection; if (formatterCollection != null) { return formatterCollection.WritingFormatters; } return formatters.AsArray(); }
public virtual LangElement TraitUse(Span span, IEnumerable <TypeRef> traits, LangElement adaptationsBlock) { Debug.Assert(traits != null); return(new TraitsUse(span, traits.AsArray(), (TraitAdaptationBlock)adaptationsBlock)); }
private void UpdateTurnaroundThresholds(FractionViewModel fraction, IEnumerable <BuildingViewModel> buildings) { if (fraction == null) { return; } if (buildings == null) { return; } var componentArray = buildings.AsArray(); var allProductionChains = componentArray .Select(x => x.ProductionChain).Where(x => x != null) .Distinct(new ExpressionComparer <ProductionChainViewModel>(x => x.Model)) .ToArray(); var factionGroups = fraction.Items.ToDictionary(x => x.Model); var chainCounts = allProductionChains.ToDictionary(x => x.Model, x => x.Count); var capacities = from populationGroup in mRepository.GetAll <PopulationGroup>() where populationGroup.Fraction == fraction.Model let groupChains = from chain in allProductionChains let consumable = chain.OutputGood as ConsumableGood where consumable != null let consumingGroups = consumable.ProvisionCapacities let orderedConsumerGroups = from consumingGroup in consumingGroups where consumingGroup.PopulationGroup.Fraction == fraction.Model orderby consumingGroup.PopulationGroup.Tier select consumingGroup.PopulationGroup let principalGroup = orderedConsumerGroups.FirstOrDefault() where principalGroup != null where principalGroup == populationGroup select chain let provisionCapacities = from chain in groupChains let consumable = chain.OutputGood as ConsumableGood where consumable != null let provisionCapacities = consumable.ProvisionCapacities from provisionCapacity in provisionCapacities select new { provisionCapacity.PopulationGroup, Count = provisionCapacity.Count * chainCounts.GetValueByKeyOrDefault(chain.Model) } select new { PopulationGroup = populationGroup, Capacity = provisionCapacities.OrderBy(x => x.Count).FirstOrDefault()?.Count ?? 0 }; var capacityToCount = capacities.ToDictionary(x => x.PopulationGroup); foreach (var group in capacityToCount.Keys) { var viewModel = factionGroups.GetValueByKeyOrDefault(group); if (viewModel == null) { continue; } viewModel.TurnaroundThreshold = capacityToCount[group].Capacity; } }
private static MediaTypeFormatter[] GetWritingFormatters(IEnumerable<MediaTypeFormatter> formatters) { Debug.Assert(formatters != null); return formatters.AsArray(); }
/// <summary> /// Initializes a new instance of the <see cref="HttpRoute" /> class. /// </summary> /// <param name="routeTemplate">The route template.</param> /// <param name="order">The subroute order.</param> /// <param name="defaults">The default values.</param> /// <param name="constraints">The route constraints.</param> /// <param name="actions">The actions that are reachable via this route.</param> public static HttpRoute BuildDirectRoute( string routeTemplate, int order, HttpRouteValueDictionary defaults, HttpRouteValueDictionary constraints, IEnumerable<ReflectedHttpActionDescriptor> actions) { HttpRoute route = new HttpRoute(routeTemplate, defaults: defaults, constraints: constraints, dataTokens: null, handler: null); if (actions != null) { route.DataTokens[RouteKeys.OrderDataTokenKey] = order; route.DataTokens[RouteKeys.PrecedenceDataTokenKey] = route.ParsedRoute.GetPrecedence(constraints); route.DataTokens[RouteKeys.ActionsDataTokenKey] = actions.AsArray(); } return route; }
public virtual LangElement Use(Span span, IEnumerable <UseBase> uses, AliasKind kind) { return(new UseStatement(span, uses.AsArray(), kind)); }
private void ValidateThis(HttpActionContext actionContext, ModelValidationNode parentNode) { ModelStateDictionary modelState = actionContext.ModelState; if (!modelState.IsValidField(ModelStateKey)) { return; // short-circuit } // If 'this' is null and there is no parent, we cannot validate, and // the DataAnnotationsModelValidator will throw. So we intercept here // to provide a catch-all value-required validation error if (parentNode == null && ModelMetadata.Model == null) { string trueModelStateKey = ModelBindingHelper.CreatePropertyModelName(ModelStateKey, ModelMetadata.GetDisplayName()); modelState.AddModelError(trueModelStateKey, SRResources.Validation_ValueNotFound); return; } _validators = actionContext.GetValidators(ModelMetadata); object container = TryConvertContainerToMetadataType(parentNode); // Optimize for the common case where the validators are in an array ModelValidator[] validators = _validators.AsArray(); for (int i = 0; i < validators.Length; i++) { ModelValidator validator = validators[i]; foreach (ModelValidationResult validationResult in validator.Validate(ModelMetadata, container)) { string trueModelStateKey = ModelBindingHelper.CreatePropertyModelName(ModelStateKey, validationResult.MemberName); modelState.AddModelError(trueModelStateKey, validationResult.Message); } } }
public virtual LangElement List(Span span, IEnumerable <Item> targets, bool isOldNotation) { var items = targets.AsArray(); return(ArrayEx.CreateList(span, IsAllNull(items) ? null : items, !isOldNotation)); }
/// <summary> /// Sets the value for the <see cref="RecordBase.Content" /> property. /// </summary> /// <param name="newData">The new data.</param> /// <exception cref="ArgumentOutOfRangeException">The new data is too big.</exception> protected void SetContentProperty(IEnumerable <byte> newData) { base.Content = newData.AsArray(); }
public ComparisonResult(ComparisonResultKind kind, IModelNode pattern, IEnumerable <IModelNode> matches) { Kind = kind; Pattern = pattern; Matches = matches == null ? null : matches.AsArray(); }
public ReferencedSymbol(ISymbol symbol, IEnumerable<ReferenceLocation> locations) { Symbol = symbol; Locations = locations.AsArray(); }
/// <summary> /// Creates a <see cref="string"/> from the specified sequence of Unicode characters. /// </summary> /// <param name="chars">The sequence of Unicode characters from which to create the string.</param> /// <returns>A string that corresponds to <paramref name="chars"/>.</returns> /// <exception cref="ArgumentNullException"><paramref name="chars"/> is <see langword="null"/>.</exception> public static string AsString(this IEnumerable <char> chars) { ArgumentValidate.NotNull(chars, nameof(chars)); return(chars as string ?? new string(chars.AsArray())); }
public ReferencedSymbol(ISymbol symbol, IEnumerable <ReferenceLocation> locations) { Symbol = symbol; Locations = locations.AsArray(); }