C# IReadOnlyList.ToDictionary方法代码示例

 public BenchmarkRun(IReadOnlyList<MeasureBucket> measures, IReadOnlyList<Counter> counters)
 {
     Contract.Requires(measures != null);
     Contract.Requires(counters != null);
     Measures = measures;
     MeasureCount = measures.Count;
     Counters = counters.ToDictionary(key => key.Name, v => v);
     Context = new BenchmarkContext(Counters);
 }

 public AppsContextConnector(IAppsClient appsClient, ISandboxesClient sandboxesClient,
     IReadOnlyList<App> apps, SandboxCollection sandboxes, string serviceName,
     string[] excludePrefixes)
     : base(serviceName, excludePrefixes)
 {
     this.appsClient = appsClient;
     this.sandboxesClient = sandboxesClient;
     this.apps = apps;
     this.indexedApps = apps.ToDictionary(app => app.Id);
     this.sandboxes = sandboxes ?? EmptySandboxCollection;
 }

        public LiquidRenderer(string tag, IReadOnlyList<Category> categories, IEnumerable<Issue> issues)
        {
            if (categories == null || !categories.Any())
                categories = Defaults.Categories;

            var issuesVariable = categories.ToDictionary(
                cat => cat.Id,
                cat => issues.Where(issue => issue.Labels.Any(label => label.MatchesAny(cat.Labels)))
                    .Select(issue => new IssueDrop(issue, cat.Labels)));
            var categoriesVariable = categories.Select(category => new CategoryDrop(category.Id, category.Title,
                issuesVariable.ContainsKey(category.Id) && issuesVariable[category.Id].Any()));

            _variables = new Hash
            {
                {"tag", tag},
                {"categories", categoriesVariable},
                {"issues", issuesVariable}
            };
        }

        public DataPreview(SchemaMapping[] schemas)
        {
            InitializeComponent();

            tables = schemas
                .SortDependencies(sm => sm.Schema)
                .Reverse()
                .Select(sm => new LoadableTable(context, sm))
                .ToList();
            schemaTables = tables.ToDictionary(t => t.Schema);

            schemaTree.BeginUnboundLoad();
            schemaTree.ClearNodes();

            foreach (var table in tables) {
                AddSchemaTree(table, null);
            }
            schemaTree.BestFitColumns();
            schemaTree.EndUnboundLoad();
        }

 public DslModel(IEnumerable<DslCategory> categories)
 {
     Categories = new List<DslCategory>(categories);
     _cache = Categories.ToDictionary(x => x.Slug, x => x, StringComparer.OrdinalIgnoreCase);
 }

		public OracleTraceEvent(int eventCode, string title, TraceEventScope scope, string enableEventTraceParameter, string disableEventTraceParameter, bool requiresDbaPrivilege, IReadOnlyList<OracleTraceEventLevel> supportedLevels)
		{
			EventCode = eventCode;
			Title = title;
			Scope = scope;
			_enableEventTraceParameter = enableEventTraceParameter;
			_disableEventTraceParameter = disableEventTraceParameter;
			RequiresDbaPrivilege = requiresDbaPrivilege;
			_supportedLevels = supportedLevels.ToDictionary(l => l.Value);
		}

		internal InboxHttpHandlerMock(IReadOnlyList<Endpoint> recipients) {
			this.recipients = recipients.ToDictionary(r => r, r => new List<Tuple<DateTime, byte[]>>());
		}

 public CandidateResolver(IReadOnlyList<RuntimeLibrary> dependencies, ISet<string> referenceAssemblies)
 {
     _dependencies = dependencies
         .ToDictionary(d => d.Name, d => CreateDependency(d, referenceAssemblies), StringComparer.OrdinalIgnoreCase);
 }

        /// <summary>
        ///     Calculates and gets the best line farming location.
        /// </summary>
        /// <param name="minionsList">
        ///     The Minions
        /// </param>
        /// <param name="width">
        ///     The Width
        /// </param>
        /// <param name="range">
        ///     The Range
        /// </param>
        /// <returns>
        ///     The Farming Location Container.
        /// </returns>
        private static FarmingLocation GetBestLineFarmLocation(
            IReadOnlyList<Obj_AI_Minion> minionsList, 
            float width, 
            float range)
        {
            var result = new Vector2();
            var minionCount = 0;
            var startPos = ObjectManager.Player.ServerPosition.To2D();
            var minions =
                minionsList.ToDictionary<Obj_AI_Minion, Obj_AI_Minion, IDictionary<int, Vector2>>(
                    minion => minion,
                    minion => new Dictionary<int, Vector2> { { 0, minion.Position.To2D() } });
            var minionsCollection = new List<Obj_AI_Minion>();

            var max = minionsList.Count;
            for (var i = 0; i < max; i++)
            {
                for (var j = 0; j < max; j++)
                {
                    if (minionsList[j].Position.To2D() != minionsList[i].Position.To2D())
                    {
                        minions[minionsList[j]].Add(
                            minions[minionsList[j]].Count,
                            (minionsList[j].Position.To2D() + minionsList[i].Position.To2D()) / 2);
                    }
                }
            }

            foreach (var minion in minions)
            {
                foreach (var pos in minion.Value.Values)
                {
                    if (pos.Distance(startPos, true) <= range * range)
                    {
                        var endPos = startPos + range * (pos - startPos).Normalized();

                        var minionsCount =
                            minionsList.Where(
                                pos2 => pos2.Position.To2D().Distance(startPos, endPos, true, true) <= width * width)
                                .ToList();

                        if (minionsCount.Count() >= minionCount)
                        {
                            result = endPos;
                            minionCount = minionsCount.Count();
                            minionsCollection = minionsCount;
                        }
                    }
                }
            }

            return new FarmingLocation(result, minionCount, minionsCollection);
        }

 /// <summary>
 /// The function to calculate the average grade for each of students
 /// </summary>
 /// <param name="students">Receives the collection of students with their marks</param>
 /// <returns>the dictionary of students with related average mark</returns>
 public IReadOnlyDictionary<IStudent, double> AverageMarkPerStudent(IReadOnlyList<IStudent> students)
 {
     //Just get the average mark per student
     var averageMarks = students.ToDictionary(student => student,
         student => student.GetAllMarks().Average(mark => (int)mark.Value));
     return averageMarks;
 }