private void GenerateConstructors(GeneratedData toGenerate, CodeGenerationStore store) { foreach (var cls in toGenerate.Classes) { var type = cls.Key; var node = cls.Value; var fields = store.Fields[type].Select(x => (x, x.Name)) .ToDictionary(x => x.Name, x => x.x); foreach (IConstructorBuilder constructor in store.Constructors[type]) { var generator = constructor.GetILGenerator(); var parameters = toGenerate.Constructors[constructor].Parameters .Select((p, i) => (i, store.Types[p.Type], p.Name)) .ToDictionary(x => x.Name, x => ((short)x.i, x.Item2)); var methodInfo = new CurrentMethodInfo(type, typeChecker !.VoidType, false, parameters, fields); var generation = new ILGeneration(generator, store, methodInfo, delegateConstructorTypes !, baseConstructorInfo !, typeChecker !); GenerateMethod(generation, toGenerate.Constructors[constructor].Statements); } } }
private void GenerateMethods(GeneratedData toGenerate, CodeGenerationStore store) { foreach (var cls in toGenerate.Classes) { var type = cls.Key; var node = cls.Value; var fields = store.Fields[type].Select(x => (x, x.Name)) .ToDictionary(x => x.Name, x => x.x); foreach (IMethodBuilder method in store.Methods[type]) { var generator = method.GetILGenerator(); int offset = method.IsStatic ? 0 : 1; var parameters = toGenerate.Methods[method].Parameters .Select((p, i) => (i + offset, store.Types[p.Type], p.Name)) .ToDictionary(x => x.Name, x => ((short)x.Item1, x.Item2)); var methodInfo = new CurrentMethodInfo(type, method.ReturnType, method.IsStatic, parameters, fields); var generation = new ILGeneration(generator, store, methodInfo, delegateConstructorTypes !, baseConstructorInfo !, typeChecker !); GenerateMethod(generation, toGenerate.Methods[method].Statements); } } }
private static int Calculate(List <int> numbers, int count) { var memory = numbers .Select((character, index) => (character, index)) .ToDictionary(x => x.character, x => (-1, x.index)); var lastNumber = memory.Last().Key; for (var i = numbers.Count; i < count; i++) { if (memory.TryGetValue(lastNumber, out var lastIndex)) { if (lastIndex.Item1 == -1) { lastNumber = 0; } else { lastNumber = lastIndex.index - lastIndex.Item1; } } if (memory.ContainsKey(lastNumber)) { memory[lastNumber] = (memory[lastNumber].index, i); } else { memory[lastNumber] = (-1, i); } } return(lastNumber); }
private int Run(int limit) { var numbers = lines[0].Split(",") .Select((number, index) => (index: index + 1, number: int.Parse(number))) .ToDictionary(number => number.number, number => (number.index, previousIndex: 0)); var lastNumber = numbers.Keys.Last(); for (var i = numbers.Count + 1; i <= limit; i++) { if (numbers.TryGetValue(lastNumber, out var value) && value.previousIndex > 0) { AddNumber(value.index - value.previousIndex, i); } else { AddNumber(0, i); } } void AddNumber(int number, int index) { if (numbers.TryGetValue(number, out var value)) { numbers[number] = (index, value.Item1); } else { numbers[number] = (index, 0); } lastNumber = number; } return(lastNumber); }
public async Task <int> RunAsync() { if (!base.DoCommonSetup()) { return(-1); } var artifacts = OptionDefinition.PrintPullRequestSizeChanges.NamedArtifactPaths.ValueFrom(this.baseCommand) .Split(';') .Select(artifactToken => new ArtifactEntryInfo(artifactToken)) .ToList(); var referenceBuilds = await this.GetReferenceBuildsByCommitId(); var referenceBuildsWithSize = referenceBuilds .Select(buildByCommit => ( Commit: buildByCommit.Key, Build: buildByCommit.Value, Size: (Dictionary <string, int>)null)) .ToDictionary( group => group.Commit, group => (group.Build, group.Size)); var pullRequestsWithBuilds = await this.GetPullRequestsWithBuildsAsync(); foreach (var prBuildEntry in pullRequestsWithBuilds) { await this.CheckPullRequestBuildAsync(prBuildEntry, referenceBuildsWithSize, artifacts); } return(0); }
private static int FindNumberAtTurn(IList <int> numbers, int turn) { IDictionary <int, (int, int)> numberToTurns = numbers .Select((numbers, idx) => (numbers, idx)) .ToDictionary(t => t.Item1, t => (-1, t.Item2)); foreach (int currentTurn in Enumerable.Range(numbers.Count, turn - numbers.Count)) { int lastNumber = numbers.Last(); (int secondLastTurn, int lastTurn) = numberToTurns[lastNumber]; int number = secondLastTurn != -1 ? lastTurn - secondLastTurn : 0; if (!numberToTurns.ContainsKey(number)) { numberToTurns[number] = (-1, currentTurn); } else { numberToTurns[number] = (numberToTurns[number].Item2, currentTurn); } numbers.Add(number); } return(numbers.Last()); }
private async Task OkAsync() { var daysDictionary = Days !.ToDictionary(x => x.DayOfWeek, x => (x.SpecificRecipe?.ID ?? x.Recipe?.ID, x.Garnish?.ID)); await dayService.CreateWeekAsync(WeekStart, daysDictionary); regionManager.NavigateMain(view: nameof(WeekView), parameters: (Consts.ReloadWeekParameter, true)); }
public override async Task Execute(IConfiguration config, ILogger logger, bool useTestData) { var input = await GetInputLines(useTestData); // Parse the input, get a collection of bags and the bags that they contain var bags = input .Select(line => line.Trim('.').Split(" bags contain ")) .Select(splits => (splits[0], splits[1].Replace(" bags", "").Replace(" bag", ""))) .ToDictionary(m => m.Item1, m => m.Item2.StartsWith("no other") ? new (int, string)[] {}
public static Summary[] Run(BenchmarkRunInfo[] benchmarkRunInfos, IConfig commonSettingsConfig, bool summaryPerType) { var resolver = DefaultResolver; var artifactsToCleanup = new List <string>(); var title = GetTitle(benchmarkRunInfos); var rootArtifactsFolderPath = (commonSettingsConfig?.ArtifactsPath ?? DefaultConfig.Instance.ArtifactsPath).CreateIfNotExists(); using (var logStreamWriter = Portability.StreamWriter.FromPath(Path.Combine(rootArtifactsFolderPath, title + ".log"))) { var logger = new CompositeLogger(commonSettingsConfig.GetCompositeLogger(), new StreamLogger(logStreamWriter)); var supportedBenchmarks = GetSupportedBenchmarks(benchmarkRunInfos, logger, resolver); var validationErrors = Validate(supportedBenchmarks, logger); if (validationErrors.Any(validationError => validationError.IsCritical)) { return new [] { Summary.CreateFailed( supportedBenchmarks.SelectMany(b => b.Benchmarks).ToArray(), title, HostEnvironmentInfo.GetCurrent(), commonSettingsConfig, GetResultsFolderPath(rootArtifactsFolderPath), validationErrors) } } ; var buildPartitions = BenchmarkPartitioner.CreateForBuild(supportedBenchmarks, resolver); logger.WriteLineHeader("// ***** BenchmarkRunner: Start *****"); var globalChronometer = Chronometer.Start(); var buildResults = BuildInParallel(logger, rootArtifactsFolderPath, buildPartitions, ref globalChronometer); try { var results = new List <Summary>(); var benchmarkToBuildResult = buildResults .SelectMany(buildResult => buildResult.Key.Benchmarks.Select(buildInfo => (buildInfo.Benchmark, buildInfo.Id, buildResult.Value))) .ToDictionary(info => info.Benchmark, info => (info.Id, info.Value)); foreach (var benchmarkRunInfo in supportedBenchmarks) // we run them in the old order now using the new build artifacts { results.Add(Run(benchmarkRunInfo, benchmarkToBuildResult, resolver, logger, artifactsToCleanup, rootArtifactsFolderPath, ref globalChronometer)); } return(results.ToArray()); } finally { logger.WriteLineHeader("// * Artifacts cleanup *"); Cleanup(new HashSet <string>(artifactsToCleanup.Distinct())); } } }
static void Main(string[] args) { var input = args.DefaultIfEmpty("14,3,1,0,9,5") .First() .Split(',') .Select(int.Parse) .ToArray(); var history = input.Select((n, i) => (num: n, turn: i + 1)) .ToDictionary(x => x.num, x => (last: x.turn, prev: default(int?))); var currentTurn = input.Length + 1; var lastNumber = input.Last(); while (currentTurn <= 30000000) { int nextNumber; var(lastTurnNumber, previousTurnNumber) = history[lastNumber]; if (previousTurnNumber.HasValue) { nextNumber = lastTurnNumber - previousTurnNumber.Value; } else { nextNumber = 0; } if (history.TryGetValue(nextNumber, out var nextHumberHistory)) { history[nextNumber] = (currentTurn, nextHumberHistory.last); } else { history[nextNumber] = (currentTurn, null); } if (currentTurn == 2020) { Console.WriteLine($"Part 1 Result = {nextNumber}"); } lastNumber = nextNumber; ++currentTurn; } Console.WriteLine($"Part 2 Result = {lastNumber}"); }
protected TransportOutputChannel(ChannelManagerBase channelManager, EndpointAddress to, Uri via, bool manualAddressing, MessageVersion messageVersion) : base(channelManager) { this.manualAddressing = manualAddressing; this.messageVersion = messageVersion; this.to = to; this.via = via; if (!manualAddressing && to != null) { Uri toUri; if (to.IsAnonymous) { toUri = this.messageVersion.Addressing.AnonymousUri; } else if (to.IsNone) { toUri = this.messageVersion.Addressing.NoneUri; } else { toUri = to.Uri; } if (toUri != null) { XmlDictionaryString dictionaryTo = new ToDictionary(toUri.AbsoluteUri).To; toHeader = ToHeader.Create(toUri, dictionaryTo, messageVersion.Addressing); } anyHeadersToAdd = to.Headers.Count > 0; } }
public void Test_5() { ToDictionary.eingabe(""); string ergebnis = ToDictionary.auslesen(""); Assert.AreEqual("", ergebnis); }
protected TransportOutputChannel(IDefaultCommunicationTimeouts timeouts, EndpointAddress to, Uri via, bool manualAddressing, MessageVersion messageVersion) : base(timeouts) { ManualAddressing = manualAddressing; MessageVersion = messageVersion; _to = to; _via = via; if (!manualAddressing && _to != null) { Uri toUri; if (_to.IsAnonymous) { toUri = MessageVersion.Addressing.AnonymousUri; } else if (_to.IsNone) { toUri = MessageVersion.Addressing.NoneUri; } else { toUri = _to.Uri; } if (toUri != null) { XmlDictionaryString dictionaryTo = new ToDictionary(toUri.AbsoluteUri).To; _toHeader = ToHeader.Create(toUri, dictionaryTo, messageVersion.Addressing); } _anyHeadersToAdd = _to.Headers.Count > 0; } }
public static Dictionary <TKey, TSource> ToDictionary <TSource, TKey>(this TSource[] source, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> comparer = null) { var aggregate = new ToDictionary <TSource, TKey>(keySelector, comparer); ArrayNode.ProcessArray(source, ref aggregate); return(aggregate.GetResult()); }
public static Dictionary <TKey, TValue> ToDictionary <TSource, TKey, TValue>(this ReadOnlyMemory <TSource> source, Func <TSource, TKey> keySelector, Func <TSource, TValue> elementSelector, IEqualityComparer <TKey> comparer = null) { var aggregate = new ToDictionary <TSource, TKey, TValue>(keySelector, elementSelector, comparer); MemoryNode.ProcessMemory(source, ref aggregate); return(aggregate.GetResult()); }
protected TransportOutputChannel(ChannelManagerBase channelManager, EndpointAddress to, Uri via, bool manualAddressing, System.ServiceModel.Channels.MessageVersion messageVersion) : base(channelManager) { this.manualAddressing = manualAddressing; this.messageVersion = messageVersion; this.to = to; this.via = via; if (!manualAddressing && (to != null)) { Uri anonymousUri; if (to.IsAnonymous) { anonymousUri = this.messageVersion.Addressing.AnonymousUri; } else if (to.IsNone) { anonymousUri = this.messageVersion.Addressing.NoneUri; } else { anonymousUri = to.Uri; } XmlDictionaryString dictionaryTo = new ToDictionary(anonymousUri.AbsoluteUri).To; this.toHeader = ToHeader.Create(anonymousUri, dictionaryTo, messageVersion.Addressing); this.anyHeadersToAdd = to.Headers.Count > 0; } }
public void Test_6() { ToDictionary.eingabe("eggg==23"); string ergebnis = ToDictionary.auslesen("eggg"); Assert.AreEqual("=23", ergebnis); }
private static long Play(IReadOnlyCollection <int> numbers, int iterations) { var dict = numbers .Select((x, i) => (key: x, value: i + 1)) .ToDictionary(x => x.key, x => (lastIndex: x.value, lastBeforeIndex: (int?)null)); var lastNumberSpoken = numbers.Last(); for (var i = numbers.Count + 1; i <= iterations; i++) { var(lastIndex, lastBeforeIndex) = dict[lastNumberSpoken]; var newNumberSpoken = lastBeforeIndex == null ? 0 : lastIndex - lastBeforeIndex ?? 0; dict[newNumberSpoken] = dict.ContainsKey(newNumberSpoken) ? dict[newNumberSpoken] = (i, dict[newNumberSpoken].lastIndex)
public void Test_7() { ToDictionary.eingabe("g=8;;h=2"); string ergebnis = ToDictionary.auslesen("h"); Assert.AreEqual("2", ergebnis); }
private int SolveGame(int target) { Dictionary <int, (int num, int index)> spoken = _parsedInput.Select((number, index) => (number, index)) .ToDictionary(x => x.number, x => (-1, x.index)); var last = spoken.Last().Key; for (var i = _parsedInput.Length; i < target; i++) { if (spoken.TryGetValue(last, out var lastIndex)) { last = lastIndex.num != -1 ? lastIndex.index - lastIndex.num : 0; } spoken[last] = spoken.ContainsKey(last) ? (spoken[last].index, i) : (-1, i); } return(last); }
static void Main(string[] args) { ToDictionary.eingabe("g=2;h=2"); string ergebnis = ToDictionary.auslesen("b"); Console.WriteLine(ergebnis); Console.ReadLine(); }
#pragma warning disable S1144 // Dynamically activate type per generic type public ReadOnlyCollectionConverter() { _properties = typeof(T) .GetProperties() .Select(x => new { Property = x, CollectionInterface = x.CanWrite ? null : GetReadOnlyCollectionInterface(x.PropertyType) }) .Where(x => x.Property.CanWrite || !(x.CollectionInterface is null)) .Select(x => { var typeParameter = Expression.Parameter(typeof(T)); var valueParameter = Expression.Parameter(typeof(object)); Action <T, object> handler; if (x.Property.CanWrite) { var assign = Expression.Assign( Expression.Property(typeParameter, x.Property), Expression.Convert(valueParameter, x.Property.PropertyType)); handler = Expression.Lambda <Action <T, object> >(assign, typeParameter, valueParameter).Compile(); } else { var add = Expression.Call( Expression.Property(typeParameter, x.Property), x.CollectionInterface !.GetMethod(nameof(ICollection <T> .Add)), Expression.Convert(valueParameter, x.CollectionInterface.GetGenericArguments().First())); handler = Expression.Lambda <Action <T, object> >(add, typeParameter, valueParameter).Compile(); } return(new { PropertyName = x.Property.Name, x.Property.PropertyType, CollectionElementType = x.CollectionInterface?.GetGenericArguments()?.First(), Handler = handler }); }) .ToDictionary(x => x.PropertyName, x => (x.PropertyType, x.CollectionElementType, x.Handler)); }
public string GetSolution() { var gameData = _inputService .GetInput(resourceLocation)[0] .Split(',') .Select((value, index) => (long.Parse(value), index + 1)) .ToDictionary(x => x.Item1, x => (x.Item2, -1)); var lastNumber = gameData.Last().Key; for (var turn = gameData.Count + 1; turn <= 30000000; turn++) { if (gameData.ContainsKey(lastNumber)) { lastNumber = GetLastNumber(gameData, lastNumber); if (gameData.ContainsKey(lastNumber)) { gameData[lastNumber] = (turn, gameData[lastNumber].Item1);
public void TestRightJoin() { //--Arrange var left = Enumerable.Range(5, 10).Select(x => (x, nameL: x.ToString())).ToList(); var right = Enumerable.Range(0, 10).Select(x => (x, nameR: x.ToString())).ToList(); //--Act var joined = left.RightJoin(right, l => l.x, r => r.x, (l, r) => (r.x, l.nameL, r.nameR)) .ToDictionary(lr => lr.x, lr => (lr.nameL, lr.nameR)); //--Assert Assert.AreEqual(10, joined.Count); foreach (var key in Enumerable.Range(0, 10)) { Assert.IsTrue(joined.TryGetValue(key, out var lr)); Assert.AreEqual(key.ToString(), lr.nameR); Assert.AreEqual(key < 5 ? null : key.ToString(), lr.nameL); } }
/// <summary> /// Compile a function to build an object from an object graph /// </summary> public static Func <ObjectGraph, IPropMapValueCache, ILogger, T> CompileObjectBuilder <T>() { var type = typeof(T); // compile setter for each property var propSetters = type .GetFieldsAndProperties() .Where(p => !p.readOnly) .Select(p => (p.name, PropertySetters.GetPropertySetter <T>(p.type, p.name), p.type)) .ToDictionary(x => x.Item1, x => (setter: x.Item2, type: x.Item3)); // compile getters for each constructor type var cArgGetters = type .GetConstructors() .Select(c => c.GetParameters().Select(p => p.ParameterType).ToArray()) .ToDictionary(x => x, x => x.Select(BuildValueGetter).ToArray(), ArrayComparer <Type> .Instance); T build(ObjectGraph vals, IPropMapValueCache propMapValueCache, ILogger logger) => BuildObjectWithExceptionHandling(cArgGetters, propSetters, vals, propMapValueCache, logger); return(build); }
private static int Play(IReadOnlyCollection <int> startNumbers, int stop) { var spoken = startNumbers .Select((n, i) => (Number: n, Index: i)) .ToDictionary( t => t.Number, t => (Current: t.Index, Previous: t.Index)); var previous = startNumbers.Last(); for (var i = startNumbers.Count; i < stop; i++) { var(cur, prev) = spoken[previous]; var next = cur - prev; if (!spoken.ContainsKey(next)) { spoken[next] = (i, i); } else { spoken[next] = (i, spoken[next].Current);
public string Solve2() { var input = File.ReadAllText(@"Day15\input.txt").Split(',').Select(int.Parse).ToArray(); var step = input.Length + 1; var dict = input.Select((c, i) => (c, i)).ToDictionary(o => o.c, o => (-1, o.i + 1)); var lastNumber = input.Last(); while (step <= 30000000) { if (dict[lastNumber].Item1 == -1) { lastNumber = 0; Speak(dict, lastNumber, step); } else { lastNumber = dict[lastNumber].Item2 - dict[lastNumber].Item1; Speak(dict, lastNumber, step); } step++; } return(lastNumber.ToString()); }
protected TransportOutputChannel(ChannelManagerBase channelManager, EndpointAddress to, Uri via, bool manualAddressing, MessageVersion messageVersion) : base(channelManager) { _manualAddressing = manualAddressing; _messageVersion = messageVersion; _to = to; _via = via; if (!manualAddressing && to != null) { Uri toUri; if (to.IsAnonymous) { toUri = _messageVersion.Addressing.AnonymousUri; } else if (to.IsNone) { toUri = _messageVersion.Addressing.NoneUri; } else { toUri = to.Uri; } if (toUri != null) { XmlDictionaryString dictionaryTo = new ToDictionary(toUri.AbsoluteUri).To; _toHeader = ToHeader.Create(toUri, dictionaryTo, messageVersion.Addressing); } _anyHeadersToAdd = to.Headers.Count > 0; } if (FxTrace.Trace.IsEnd2EndActivityTracingEnabled) { _channelEventTraceActivity = EventTraceActivity.GetFromThreadOrCreate(); } }
internal static Summary[] Run(BenchmarkRunInfo[] benchmarkRunInfos) { var resolver = DefaultResolver; var artifactsToCleanup = new List <string>(); var title = GetTitle(benchmarkRunInfos); var rootArtifactsFolderPath = GetRootArtifactsFolderPath(benchmarkRunInfos); var resultsFolderPath = GetResultsFolderPath(rootArtifactsFolderPath, benchmarkRunInfos); var logFilePath = Path.Combine(rootArtifactsFolderPath, title + ".log"); using (var streamLogger = new StreamLogger(new StreamWriter(logFilePath, append: false))) { var compositeLogger = CreateCompositeLogger(benchmarkRunInfos, streamLogger); var supportedBenchmarks = GetSupportedBenchmarks(benchmarkRunInfos, compositeLogger, resolver); if (!supportedBenchmarks.Any(benchmarks => benchmarks.BenchmarksCases.Any())) { return new [] { Summary.NothingToRun(title, resultsFolderPath, logFilePath) } } ; var validationErrors = Validate(supportedBenchmarks, compositeLogger); if (validationErrors.Any(validationError => validationError.IsCritical)) { return new [] { Summary.ValidationFailed(title, resultsFolderPath, logFilePath, validationErrors) } } ; var benchmarksToRunCount = supportedBenchmarks.Sum(benchmarkInfo => benchmarkInfo.BenchmarksCases.Length); compositeLogger.WriteLineHeader("// ***** BenchmarkRunner: Start *****"); compositeLogger.WriteLineHeader($"// ***** Found {benchmarksToRunCount} benchmark(s) in total *****"); var globalChronometer = Chronometer.Start(); var buildPartitions = BenchmarkPartitioner.CreateForBuild(supportedBenchmarks, resolver); var buildResults = BuildInParallel(compositeLogger, rootArtifactsFolderPath, buildPartitions, ref globalChronometer); try { var results = new List <Summary>(); var benchmarkToBuildResult = buildResults .SelectMany(buildResult => buildResult.Key.Benchmarks.Select(buildInfo => (buildInfo.BenchmarkCase, buildInfo.Id, buildResult.Value))) .ToDictionary(info => info.BenchmarkCase, info => (info.Id, info.Value)); foreach (var benchmarkRunInfo in supportedBenchmarks) // we run them in the old order now using the new build artifacts { var runChronometer = Chronometer.Start(); var summary = Run(benchmarkRunInfo, benchmarkToBuildResult, resolver, compositeLogger, artifactsToCleanup, resultsFolderPath, logFilePath, ref runChronometer); if (!benchmarkRunInfo.Config.Options.IsSet(ConfigOptions.JoinSummary)) { PrintSummary(compositeLogger, benchmarkRunInfo.Config, summary); } benchmarksToRunCount -= benchmarkRunInfo.BenchmarksCases.Length; compositeLogger.WriteLineHeader($"// ** Remained {benchmarksToRunCount} benchmark(s) to run **"); LogTotalTime(compositeLogger, runChronometer.GetElapsed().GetTimeSpan(), summary.GetNumberOfExecutedBenchmarks(), message: "Run time"); compositeLogger.WriteLine(); results.Add(summary); if (benchmarkRunInfo.Config.Options.IsSet(ConfigOptions.StopOnFirstError) && summary.Reports.Any(report => !report.Success)) { break; } } if (supportedBenchmarks.Any(b => b.Config.Options.IsSet(ConfigOptions.JoinSummary))) { var joinedSummary = Summary.Join(results, globalChronometer.GetElapsed()); PrintSummary(compositeLogger, supportedBenchmarks.First(b => b.Config.Options.IsSet(ConfigOptions.JoinSummary)).Config, joinedSummary); results.Clear(); results.Add(joinedSummary); } var totalTime = globalChronometer.GetElapsed().GetTimeSpan(); int totalNumberOfExecutedBenchmarks = results.Sum(summary => summary.GetNumberOfExecutedBenchmarks()); LogTotalTime(compositeLogger, totalTime, totalNumberOfExecutedBenchmarks, "Global total time"); return(results.ToArray()); } finally { compositeLogger.WriteLineHeader("// * Artifacts cleanup *"); Cleanup(new HashSet <string>(artifactsToCleanup.Distinct())); compositeLogger.Flush(); } } }
/// <summary> /// Builds a <see cref="BinaryDeserializer{T}" /> for a <see cref="RecordSchema" />. /// </summary> /// <returns> /// A successful <see cref="BinaryDeserializerBuilderCaseResult" /> if <paramref name="type" /> /// is not an array or primitive type and <paramref name="schema" /> is a <see cref="RecordSchema" />; /// an unsuccessful <see cref="BinaryDeserializerBuilderCaseResult" /> otherwise. /// </returns> /// <inheritdoc /> public virtual BinaryDeserializerBuilderCaseResult BuildExpression(Type type, Schema schema, BinaryDeserializerBuilderContext context) { if (schema is RecordSchema recordSchema) { var underlying = Nullable.GetUnderlyingType(type) ?? type; if (!underlying.IsArray && !underlying.IsPrimitive) { // since record deserialization is potentially recursive, create a top-level // reference: var parameter = Expression.Parameter( Expression.GetDelegateType(context.Reader.Type.MakeByRefType(), underlying)); if (!context.References.TryGetValue((recordSchema, type), out var reference)) { context.References.Add((recordSchema, type), reference = parameter); } // then build/set the delegate if it hasn’t been built yet: if (parameter == reference) { Expression expression; if (GetRecordConstructor(underlying, recordSchema) is ConstructorInfo constructor) { var parameters = constructor.GetParameters(); // map constructor parameters to fields: var mapping = recordSchema.Fields .Select(field => { // there will be a match or we wouldn’t have made it this far: var match = parameters.Single(parameter => IsMatch(field, parameter.Name)); var parameter = Expression.Parameter(match.ParameterType); return( Match: match, Parameter: parameter, Assignment: (Expression)Expression.Assign( parameter, DeserializerBuilder.BuildExpression(match.ParameterType, field.Type, context))); }) .ToDictionary(r => r.Match, r => (r.Parameter, r.Assignment)); expression = Expression.Block( mapping .Select(d => d.Value.Parameter), mapping .Select(d => d.Value.Assignment) .Concat(new[] { Expression.New( constructor, parameters .Select(parameter => mapping.ContainsKey(parameter) ? (Expression)mapping[parameter].Parameter : Expression.Constant(parameter.DefaultValue))), })); } else { var members = underlying.GetMembers(MemberVisibility); // support dynamic deserialization: var value = Expression.Parameter( underlying.IsAssignableFrom(typeof(ExpandoObject)) ? typeof(ExpandoObject) : underlying); expression = Expression.Block( new[] { value }, new[] { (Expression)Expression.Assign(value, Expression.New(value.Type)) } .Concat(recordSchema.Fields.Select(field => { var match = members.SingleOrDefault(member => IsMatch(field, member)); Expression expression; if (match == null) { // always deserialize fields to advance the reader: expression = DeserializerBuilder.BuildExpression(typeof(object), field.Type, context); // fall back to a dynamic setter if the value supports it: if (typeof(IDynamicMetaObjectProvider).IsAssignableFrom(value.Type)) { var flags = CSharpBinderFlags.None; var infos = new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }; var binder = Binder.SetMember(flags, field.Name, value.Type, infos); expression = Expression.Dynamic(binder, typeof(void), value, expression); } } else { Expression inner; try { inner = DeserializerBuilder.BuildExpression( match switch { FieldInfo fieldMatch => fieldMatch.FieldType, PropertyInfo propertyMatch => propertyMatch.PropertyType, MemberInfo unknown => throw new InvalidOperationException($"Record fields can only be mapped to fields and properties."), }, field.Type, context); } catch (Exception exception) { throw new UnsupportedTypeException(type, $"The {match.Name} member on {type} could not be mapped to the {field.Name} field on {recordSchema.FullName}.", exception); } expression = Expression.Assign( Expression.PropertyOrField(value, match.Name), inner); } return(expression); }))
[PublicAPI] public static Summary[] Run(BenchmarkRunInfo[] benchmarkRunInfos, [CanBeNull] IConfig commonSettingsConfig) { if (commonSettingsConfig == null) { commonSettingsConfig = DefaultConfig.Instance; } var resolver = DefaultResolver; var artifactsToCleanup = new List <string>(); string title = GetTitle(benchmarkRunInfos); string rootArtifactsFolderPath = (commonSettingsConfig?.ArtifactsPath ?? DefaultConfig.Instance.ArtifactsPath).CreateIfNotExists(); using (var logStreamWriter = StreamWriter.FromPath(Path.Combine(rootArtifactsFolderPath, title + ".log"))) { var logger = new CompositeLogger(commonSettingsConfig.GetCompositeLogger(), new StreamLogger(logStreamWriter)); var supportedBenchmarks = GetSupportedBenchmarks(benchmarkRunInfos, logger, resolver); if (!supportedBenchmarks.Any(benchmarks => benchmarks.BenchmarksCases.Any())) { return new [] { Summary.CreateFailed( supportedBenchmarks.SelectMany(b => b.BenchmarksCases).ToArray(), title, HostEnvironmentInfo.GetCurrent(), commonSettingsConfig, GetResultsFolderPath(rootArtifactsFolderPath), Array.Empty <ValidationError>()) } } ; var validationErrors = Validate(supportedBenchmarks, logger); if (validationErrors.Any(validationError => validationError.IsCritical)) { return new [] { Summary.CreateFailed( supportedBenchmarks.SelectMany(b => b.BenchmarksCases).ToArray(), title, HostEnvironmentInfo.GetCurrent(), commonSettingsConfig, GetResultsFolderPath(rootArtifactsFolderPath), validationErrors) } } ; var buildPartitions = BenchmarkPartitioner.CreateForBuild(supportedBenchmarks, resolver); logger.WriteLineHeader("// ***** BenchmarkRunner: Start *****"); var globalChronometer = Chronometer.Start(); var buildResults = BuildInParallel(logger, rootArtifactsFolderPath, buildPartitions, ref globalChronometer); try { var results = new List <Summary>(); var benchmarkToBuildResult = buildResults .SelectMany(buildResult => buildResult.Key.Benchmarks.Select(buildInfo => (buildInfo.BenchmarkCase, buildInfo.Id, buildResult.Value))) .ToDictionary(info => info.BenchmarkCase, info => (info.Id, info.Value)); foreach (var benchmarkRunInfo in supportedBenchmarks) // we run them in the old order now using the new build artifacts { var runChronometer = Chronometer.Start(); var summary = Run(benchmarkRunInfo, benchmarkToBuildResult, resolver, logger, artifactsToCleanup, rootArtifactsFolderPath, ref runChronometer); if (commonSettingsConfig == null || commonSettingsConfig.SummaryPerType) { PrintSummary(logger, benchmarkRunInfo.Config, summary); } LogTotalTime(logger, runChronometer.GetElapsed().GetTimeSpan(), summary.GetNumberOfExecutedBenchmarks(), message: "Run time"); logger.WriteLine(); results.Add(summary); } if (commonSettingsConfig != null && !commonSettingsConfig.SummaryPerType) { var joinedSummary = Summary.Join(results, commonSettingsConfig, globalChronometer.GetElapsed()); PrintSummary(logger, commonSettingsConfig, joinedSummary); results.Clear(); results.Add(joinedSummary); } return(results.ToArray()); } finally { logger.WriteLineHeader("// * Artifacts cleanup *"); Cleanup(new HashSet <string>(artifactsToCleanup.Distinct())); } } }