C# IReadOnlyList.First方法代码示例

      private void ReassembleChunksAndDispatch(IReadOnlyList<MultiPartChunkDto> chunks) {
//         Console.WriteLine(chunks.First().MultiPartMessageId.ToString("n").Substring(0, 6) + " Got to reassemble!");
         RemoveAssemblerFromCache(chunks.First().MultiPartMessageId);

         var payloadLength = chunks.Sum(c => c.BodyLength);
         var payloadBytes = new byte[payloadLength];
         for (int i = 0, offset = 0; i < chunks.Count; i++) {
            var chunk = chunks[i];
            Buffer.BlockCopy(chunk.Body, 0, payloadBytes, offset, chunk.BodyLength);
            offset += chunk.BodyLength;
         }

         var e = inboundDataEventPool.TakeObject();
         e.Data = payloadBytes;
         e.DataOffset = 0;
         e.DataLength = payloadLength;

//         Console.WriteLine(chunks.First().MultiPartMessageId.ToString("n").Substring(0, 6) + " Dispatching to HIDE!");
         dispatcher.HandleInboundDataEvent(
            e,
            _ => {
               e.Data = null;
               inboundDataEventPool.ReturnObject(e);
            });
      }

        public virtual ResultSetMapping AppendBulkInsertOperation(
            StringBuilder commandStringBuilder,
            IReadOnlyList<ModificationCommand> modificationCommands,
            int commandPosition)
        {
            Check.NotNull(commandStringBuilder, nameof(commandStringBuilder));
            Check.NotEmpty(modificationCommands, nameof(modificationCommands));

            if ((modificationCommands.Count == 1)
                && modificationCommands[0].ColumnModifications.All(o =>
                    !o.IsKey
                    || !o.IsRead
                    || (o.Property.SqlServer().ValueGenerationStrategy == SqlServerValueGenerationStrategy.IdentityColumn)))
            {
                return AppendInsertOperation(commandStringBuilder, modificationCommands[0], commandPosition);
            }

            var readOperations = modificationCommands[0].ColumnModifications.Where(o => o.IsRead).ToList();
            var writeOperations = modificationCommands[0].ColumnModifications.Where(o => o.IsWrite).ToList();
            var defaultValuesOnly = writeOperations.Count == 0;
            var nonIdentityOperations = defaultValuesOnly
                ? modificationCommands.First().ColumnModifications
                    .Where(o => o.Property.SqlServer().ValueGenerationStrategy != SqlServerValueGenerationStrategy.IdentityColumn)
                    .ToList()
                : new List<ColumnModification>();

            if (defaultValuesOnly)
            {
                if ((nonIdentityOperations.Count == 0)
                    || (readOperations.Count == 0))
                {
                    foreach (var modification in modificationCommands)
                    {
                        AppendInsertOperation(commandStringBuilder, modification, commandPosition);
                    }

                    return readOperations.Count == 0
                        ? ResultSetMapping.NoResultSet
                        : ResultSetMapping.LastInResultSet;
                }

                if (nonIdentityOperations.Count > 1)
                {
                    nonIdentityOperations = new List<ColumnModification> { nonIdentityOperations.First() };
                }
            }

            if (readOperations.Count == 0)
            {
                return AppendBulkInsertWithoutServerValues(commandStringBuilder, modificationCommands, writeOperations);
            }

            if (defaultValuesOnly)
            {
                return AppendBulkInsertWithServerValuesOnly(commandStringBuilder, modificationCommands, commandPosition, nonIdentityOperations, readOperations);
            }

            return AppendBulkInsertWithServerValues(commandStringBuilder, modificationCommands, commandPosition, writeOperations, readOperations);
        }

        public ResultSetMapping AppendBulkInsertOperation(StringBuilder commandStringBuilder, IReadOnlyList<ModificationCommand> modificationCommands,
            int commandPosition)
        {
            Check.NotNull(commandStringBuilder, nameof(commandStringBuilder));
            Check.NotEmpty(modificationCommands, nameof(modificationCommands));

            var name = modificationCommands[0].TableName;
            var schema = modificationCommands[0].Schema;

            // TODO: Support TPH
            var defaultValuesOnly = !modificationCommands.First().ColumnModifications.Any(o => o.IsWrite);
            var statementCount = defaultValuesOnly
                ? modificationCommands.Count
                : 1;
            var valueSetCount = defaultValuesOnly
                ? 1
                : modificationCommands.Count;
            var resultSetCreated = false;
            for (var i = 0; i < statementCount; i++)
            {
                var operations = modificationCommands[i].ColumnModifications;
                var writeOperations = operations.Where(o => o.IsWrite).ToArray();
                var readOperations = operations.Where(o => o.IsRead).ToArray();

                AppendInsertCommandHeader(commandStringBuilder, name, schema, writeOperations);
                /*if (readOperations.Length > 0)
                {
                    AppendOutputClause(commandStringBuilder, readOperations);
                }*/
                AppendValuesHeader(commandStringBuilder, writeOperations);
                AppendValues(commandStringBuilder, writeOperations);
                for (var j = 1; j < valueSetCount; j++)
                {
                    commandStringBuilder.Append(",").AppendLine();
                    AppendValues(commandStringBuilder, modificationCommands[j].ColumnModifications.Where(o => o.IsWrite).ToArray());
                }
                commandStringBuilder.Append(SqlGenerationHelper.StatementTerminator).AppendLine();

                if (readOperations.Length == 0)
                {
                    AppendSelectAffectedCountCommand(commandStringBuilder, name, schema, commandPosition);
                }
                else if (readOperations.Length > 0)
                {
                    AppendOutputClause(commandStringBuilder, readOperations);
                    resultSetCreated = true;
                }
            }

            return resultSetCreated ?
                defaultValuesOnly
                    ? ResultSetMapping.LastInResultSet
                    : ResultSetMapping.NotLastInResultSet
                : ResultSetMapping.NoResultSet;
        }

        public virtual ResultsGrouping AppendBulkInsertOperation(
            StringBuilder commandStringBuilder,
            IReadOnlyList<ModificationCommand> modificationCommands)
        {
            Check.NotNull(commandStringBuilder, nameof(commandStringBuilder));
            Check.NotEmpty(modificationCommands, nameof(modificationCommands));

            var tableName = modificationCommands[0].TableName;
            var schemaName = modificationCommands[0].SchemaName;

            // TODO: Support TPH
            var defaultValuesOnly = !modificationCommands.First().ColumnModifications.Any(o => o.IsWrite);
            var statementCount = defaultValuesOnly
                ? modificationCommands.Count
                : 1;
            var valueSetCount = defaultValuesOnly
                ? 1
                : modificationCommands.Count;

            for (var i = 0; i < statementCount; i++)
            {
                var operations = modificationCommands[i].ColumnModifications;
                var writeOperations = operations.Where(o => o.IsWrite).ToArray();
                var readOperations = operations.Where(o => o.IsRead).ToArray();

                AppendInsertCommandHeader(commandStringBuilder, tableName, schemaName, writeOperations);
                if (readOperations.Length > 0)
                {
                    AppendOutputClause(commandStringBuilder, readOperations);
                }
                AppendValuesHeader(commandStringBuilder, writeOperations);
                AppendValues(commandStringBuilder, writeOperations);
                for (var j = 1; j < valueSetCount; j++)
                {
                    commandStringBuilder.Append(",").AppendLine();
                    AppendValues(commandStringBuilder, modificationCommands[j].ColumnModifications.Where(o => o.IsWrite).ToArray());
                }
                commandStringBuilder.Append(BatchCommandSeparator).AppendLine();

                if (readOperations.Length == 0)
                {
                    AppendSelectAffectedCountCommand(commandStringBuilder, tableName, schemaName);
                }
            }

            return defaultValuesOnly
                ? ResultsGrouping.OneCommandPerResultSet
                : ResultsGrouping.OneResultSet;
        }

 private static IReadOnlyList<ParameterInstances> Expand(IReadOnlyList<ParameterInstances> instancesList, IReadOnlyList<ParameterDefinition> definitions)
 {
     if (definitions.IsNullOrEmpty())
         return instancesList;
     var nextDefinition = definitions.First();
     var newInstancesList = new List<ParameterInstances>();
     foreach (var instances in instancesList)
     {
         foreach (var value in nextDefinition.Values)
         {
             var items = new List<ParameterInstance>();
             items.AddRange(instances.Items);
             items.Add(new ParameterInstance(nextDefinition, value));
             newInstancesList.Add(new ParameterInstances(items));
         }
     }
     return Expand(newInstancesList, definitions.Skip(1).ToArray());
 }

        public override Actuator CreateItem(LegacyMapBuilder context, Tile currentTile, IReadOnlyList<ActuatorItemData> matchedSequence)
        {

            IConstrain constrain = null;
            if (matchedSequence[0].Data == 0)
                constrain = new PartyConstrain();
            else
                constrain = new PartDirectionConstrain((MapDirection)(matchedSequence[0].Data - 1));

            var res = new FloorActuator(context.GetFloorPosition(matchedSequence[0].TilePosition, currentTile), currentTile, constrain,
                matchedSequence.Select(context.GetTargetTile), matchedSequence.Select(x => x.GetActionStateX()));

            res.Graphics = new CubeGraphic
            {
                Position = res.Position,
                DrawFaces = CubeFaces.All,
                Outter = true,
                Scale = new Vector3(0.2f),
                Texture = context.GetTexture(matchedSequence.First(), putOnWall:false) 
            };
            return res;
        }

        public void inking_initialization()
        {

            
            myInkCanvas.Width = rootGrid.ActualWidth;
            myInkCanvas.Height = rootGrid.ActualHeight;

            InkDrawingAttributes drawingAttributes = new InkDrawingAttributes();
            drawingAttributes.Color = Windows.UI.Colors.Black;
            drawingAttributes.Size = new Size(4, 4);
            drawingAttributes.IgnorePressure = false;
            drawingAttributes.FitToCurve = true;


            try
            {
                inkRecognizerContainer = new InkRecognizerContainer();
                recoView = inkRecognizerContainer.GetRecognizers();
                if (recoView.Count > 0)
                {
                    inkRecognizerContainer.SetDefaultRecognizer(recoView.First());
                }
            }
            catch (Exception)
            {
                System.Diagnostics.Debug.WriteLine("Couldn't initialize InkRecognizer");
            }

            myInkCanvas.InkPresenter.UpdateDefaultDrawingAttributes(
                drawingAttributes);
            myInkCanvas.InkPresenter.InputDeviceTypes =
                Windows.UI.Core.CoreInputDeviceTypes.Mouse |
                Windows.UI.Core.CoreInputDeviceTypes.Pen |
                Windows.UI.Core.CoreInputDeviceTypes.Touch;


        }

        private async void MainPage_Loaded(object sender, RoutedEventArgs e)
        {
            var bts = await DeviceInformation.FindAllAsync();
            const string deviceId = @"\\?\BTHLEDevice#{9a66fa00-0800-9191-11e4-012d1540cb8e}_e0144d4f3d49#a&1f09a1af&0&0020#{6e3bb679-4372-40c8-9eaa-4509df260cd8}";

            var device = bts.First(di => di.Name == DeviceName && di.Id == deviceId);
            if (null == device)
                return;
            _service = await GattDeviceService.FromIdAsync(device.Id);
            if (null == _service)
                return;
            _characteristics = _service.GetAllCharacteristics();
            if (null == _characteristics || _characteristics.Count <= 0)
                return;

            var characteristic = _characteristics.First(charact => charact.Uuid == RollingSpiderCharacteristicUuids.Parrot_PowerMotors);

            try
            {
                var charName = CharacteristicUuidsResolver.GetNameFromUuid(characteristic.Uuid);
                Debug.WriteLine(charName);
                for (int i = 0; i < 255; i++)
                {
                    Debug.WriteLine(i);
                    byte[] arr = { (byte)02, (byte)40, (byte)20, (byte)0D, 00, 09, 00, 04, 00, 52, 43, 00, 04, (byte)i, 02, 00, 01, 00, };
                    var writer = new DataWriter();
                    writer.WriteBytes(arr);
                    await characteristic.WriteValueAsync(writer.DetachBuffer(), GattWriteOption.WriteWithoutResponse);

                    await Task.Delay(TimeSpan.FromSeconds(1));
                }
            }
            catch
            {
            }

        }

 static OutputTarget GetOutputTarget(IReadOnlyList<OutputTarget> targets, OutputTargetType type, string name)
 {
     return targets.First(t => t.Type == type && t.Name == name);
 }

        public static IReadOnlyList<AggregateRootEvent> MutateCompleteAggregateHistory
            (IReadOnlyList<IEventMigration> eventMigrations,
             IReadOnlyList<AggregateRootEvent> @events,
             Action<IReadOnlyList<AggregateRootEvent>> eventsAddedCallback = null)
        {            
            if (eventMigrations.None())
            {
                return @events;
            }

            if(@events.None())
            {
                return Seq.Empty<AggregateRootEvent>().ToList();
            }

            var firstEvent = @events.First();
            lock(AggregateLockManager.GetAggregateLockObject(firstEvent.AggregateRootId))
            {

                var mutator = Create(@events.First(), eventMigrations, eventsAddedCallback);

                var result = @events
                    .SelectMany(mutator.Mutate)
                    .Concat(mutator.EndOfAggregate())
                    .ToArray();

                AssertMigrationsAreIdempotent(eventMigrations, result);

                return result;
            }
        }

        public MergeResult StalkUpTo(IReadOnlyList<Commit> commits)
        {
            var mergeFiles = new List<String> ();
            var startingCommit = head.Tip;
            var newCommits = new List<Commit> ();
            MergeResult mergeResult = null;
            var mergeOptions = new MergeOptions ();
            var signature = new Signature (userName, userEmail, DateTime.Now);
            //var checkoutOptions = new CheckoutOptions ();
            //			var commitMsg = new List<String> ();

            commitMsg = (String.Format ("Automated Stalker (StalkUpTo) merge commit from: '{0}' to: '{1}' into {2}", commits.First ().Sha.Substring (0, 6), commits.Last ().Sha.Substring (0, 6), head.Tip.Sha.Substring (0, 6)));
            //			Console.WriteLine ("Working on {0} commits", commits.Count);

            var commit = commits.Last ();
            Array.ForEach (CommitLog (commit, true).ToArray(), Console.WriteLine);

            mergeOptions.FastForwardStrategy = FastForwardStrategy.FastForwardOnly;
            mergeOptions.CommitOnSuccess = true;

            //checkoutOptions.CheckoutModifiers = CheckoutModifiers.None;
            try {
                Console.WriteLine ("Merge FF: {0} : {1}", commit.Sha.Substring (0,6), commit.MessageShort);
                mergeResult = repo.Merge (commit, signature, mergeOptions);
                var tmpMsg = mergeResult.Commit.Message;
                var commitOptions = new CommitOptions ();
                commitOptions.AmendPreviousCommit = true;
                repo.Commit (commitMsg + "\n\n" + tmpMsg, signature, commitOptions);
            } catch {
                Console.WriteLine ("Merge FF Failed: CheckoutFileConflictStrategy.Theirs");
                //commitMsg = CommitLog (commit, true, commitMsg);
                // this will happen as libgit2sharp throws ex if fast forward not possible
                // so lets get a commit message ready
                mergeFiles.AddRange (FilesToMerge (commit));

                mergeOptions.FastForwardStrategy = FastForwardStrategy.NoFastForward;
                mergeOptions.FileConflictStrategy = CheckoutFileConflictStrategy.Theirs;
                mergeOptions.CommitOnSuccess = true;
                try {
                    var fgColor = Console.ForegroundColor;
                    var bgColor = Console.BackgroundColor;
                    Console.ForegroundColor = ConsoleColor.Yellow;
                    Console.WriteLine ("Merging commit : {0}", commit.Sha);
                    Console.WriteLine (" - Info : {0} / {1} / {2}", commit.Author.When, commit.Author.Name, commit.Author.Email);
                    Console.WriteLine (" - Msg : {0}", commit.Message);
                    Console.ForegroundColor = fgColor;
                    Console.BackgroundColor = bgColor;
                    mergeResult = repo.Merge (commit, signature, mergeOptions);
                    var tmpMsg = mergeResult.Commit.Message;
                    var commitOptions = new CommitOptions ();
                    commitOptions.AmendPreviousCommit = true;
                    repo.Commit (commitMsg + "\n\n" + tmpMsg, signature, commitOptions);
                    //Array.ForEach (MergeResultLog (mergeResult).ToArray (), Console.WriteLine);
                } catch (Exception e) {
                    Console.WriteLine (e.Message);
                }
            }
            return mergeResult;
        }

        public async Task SendFileAsync(string deviceId, IReadOnlyList<IStorageItem> storageItems)
        {
            // right now just supporting delivering just one file
            if (storageItems.Count == 0) return;
            StorageFile storageFile = (StorageFile)storageItems.First();
            RfcommDeviceService messageService = await RfcommDeviceService.FromIdAsync(deviceId);
            int result = await ValidateConnection(messageService);
            if (result != 0) return;

            StreamSocket messageSocket;
            lock (this)
            {
                messageSocket = new StreamSocket();
            }
            try
            {
                await messageSocket.ConnectAsync(messageService.ConnectionHostName, messageService.ConnectionServiceName);                
                using (DataWriter messageWriter = new DataWriter(messageSocket.OutputStream))
                {

                    //var prop = await storageFile.GetBasicPropertiesAsync();                    
                    //// send file name length
                    //messageWriter.WriteInt32(storageFile.Name.Length);
                    //// send the file name
                    //messageWriter.WriteString(storageFile.Name);
                    //// send the file length
                    //messageWriter.WriteUInt64(prop.Size);
                    //// send the file
                    //var fileStream = await storageFile.OpenAsync(FileAccessMode.Read);
                    //Windows.Storage.Streams.Buffer buffer = new Windows.Storage.Streams.Buffer((uint)prop.Size);
                    //await fileStream.ReadAsync(buffer, (uint)prop.Size, InputStreamOptions.None);
                    //messageWriter.WriteBuffer(buffer);
                    string text = DateTime.Now.ToString();
                    messageWriter.WriteUInt32((uint)text.Length);
                    await messageWriter.StoreAsync();
                    messageWriter.WriteString(text);
                    //await messageWriter.StoreAsync();
                    //messageWriter.WriteUInt32((uint)buffer.Length);
                    //await messageWriter.StoreAsync();
                    //messageWriter.WriteBuffer(buffer);
                    await messageWriter.FlushAsync();
                    await messageWriter.StoreAsync();
                    await messageSocket.OutputStream.FlushAsync();
                }
            }
            catch (Exception)
            {

                throw;
            }
            finally
            {
                //messageSocket.Dispose();
            }
        }

 private static async Task<IEnumerable<City>> ReadFileOfCities(IReadOnlyList<StorageFile> files)
 {
     var file = files.First(f => f.Name == SETTING_KEY);
     var json = await FileIO.ReadTextAsync(file);
     return JsonConvert.DeserializeObject<City[]>(json);
 }

        /// <summary>
        ///   Join TreeLayouts.
        /// </summary>
        /// <param name="treeLayouts">The TreeLayouts to join.</param>
        /// <param name="sep">Horzontal sep between nodes.</param>
        /// <returns>(Left, Right, TreeRowWidths, Pivots)</returns>
        public static Tuple<double, double, IList<TreeRowWidth>, IReadOnlyList<double>> Join(IReadOnlyList<TreeLayout> treeLayouts, double sep)
        {
            double left = 0;
            double right = treeLayouts.First().Width;
            var rowWidths = treeLayouts.First().RowWidths.ToList();
            var pivots = new List<double>() { treeLayouts.First().Pivot };

            foreach (var layout in treeLayouts.Skip(1))
            {
                double offset = rowWidths.Zip(layout.RowWidths, (l, r) => l.Right + r.Left).Min() - sep;

                pivots.Add(right + layout.Pivot - offset);

                if (layout.RowWidths.Count <= rowWidths.Count)
                {
                    double rightSpace = layout.Width - offset;

                    if (rightSpace < 0)
                    {
                        for (int i = 0; i < layout.RowWidths.Count; i++)
                        {
                            rowWidths[i].Right = layout.RowWidths[i].Right - rightSpace;
                        }
                    }
                    else
                    {
                        // Extend right.
                        right += rightSpace;
                        for (int i = 0; i < layout.RowWidths.Count; i++)
                        {
                            rowWidths[i].Right = layout.RowWidths[i].Right;
                        }
                        for (int i = layout.RowWidths.Count; i < rowWidths.Count; i++)
                        {
                            rowWidths[i].Right += rightSpace;
                        }
                    }
                }
                else
                {
                    double leftSpace = right - left - offset;

                    if (leftSpace <= 0)
                    {
                        // Extend left.
                        left += leftSpace;
                        for (int i = 0; i < rowWidths.Count; i++)
                        {
                            rowWidths[i].Left -= leftSpace;
                            rowWidths[i].Right = layout.RowWidths[i].Right;
                        }
                        rowWidths.AddRange(layout.RowWidths.Skip(rowWidths.Count));
                    }
                    else
                    {
                        for (int i = 0; i < rowWidths.Count; i++)
                        {
                            rowWidths[i].Right = layout.RowWidths[i].Right;
                        }
                        rowWidths.AddRange(layout.RowWidths.Skip(rowWidths.Count).Select(r => new TreeRowWidth(r.Left + leftSpace, r.Right)));
                    }

                    // Extend right.
                    right += layout.Width - offset;
                }
            }

            return Tuple.Create<double, double, IList<TreeRowWidth>, IReadOnlyList<double>>(left, right, rowWidths, pivots);
        }

        public static IEnumerable<Node> OrderChildsBySiblingsDependencies(IReadOnlyList<Node> childs)
        {
            foreach (var child in childs.Where(child => child.Childs.Any()))
            {
                child.SetChildren(OrderChildsBySiblingsDependencies(child.Childs));
            }

            if (!childs.SiblingDependencies().Any())
            {
                if (childs.Any() && childs.First().Parent != null)
                    childs.First().Parent.Orientation = OrientationKind.Horizontal;
                return childs;
            }

            var oldChildList = childs.ToHashSet();
            var newChildOrder = GroupNodes(oldChildList);
            return newChildOrder;
        }