C# IReadOnlyCollection.OfType方法代码示例

        public IReadOnlyCollection<IEvent> ExecuteCommands(IReadOnlyCollection<ICommand> commands)
        {
            if (commands.OfType<DropViewsCommand>().Any())
            {
                var database = _sqlConnection.GetDatabase();
                var views = database.Views.Cast<View>().Where(v => v != null && !v.IsSystemObject).ToArray();

                var viewsToRestore = new List<StringCollection>();
                foreach (var view in views)
                {
                    viewsToRestore.Add(view.Script());
                    view.Drop();
                }

                return new[] { new ViewsDroppedEvent(viewsToRestore) };
            }

            var restoreViewsCommand = commands.OfType<RestoreViewsCommand>().SingleOrDefault();
            if (restoreViewsCommand != null)
            {
                foreach (var view in restoreViewsCommand.ViewsToRestore)
                {
                    foreach (var script in view)
                    {
                        var command = new SqlCommand(script, _sqlConnection) { CommandTimeout = _commandTimeout };
                        command.ExecuteNonQuery();
                    }
                }
            }

            return Array.Empty<IEvent>();
        }

        public IReadOnlyCollection<IEvent> ExecuteCommands(IReadOnlyCollection<ICommand> commands)
        {
            if (commands.OfType<DisableConstraintsCommand>().Any())
            {
                var tables = GetTables();

                var checks = tables.SelectMany(x => x.Checks.Cast<Check>()).ToArray();
                var checksToRestore = new List<StringCollection>();
                foreach (var check in checks)
                {
                    checksToRestore.Add(check.Script());
                    check.Drop();
                }

                var foreignKeys = tables.SelectMany(x => x.ForeignKeys.Cast<ForeignKey>()).ToArray();
                var foreignKeysToRestore = new List<StringCollection>();
                foreach (var foreignKey in foreignKeys)
                {
                    foreignKeysToRestore.Add(foreignKey.Script());
                    foreignKey.Drop();
                }

                return new[] { new ConstraintsDisabledEvent(checksToRestore, foreignKeysToRestore) };
            }

            var enableCommand = commands.OfType<EnableConstraintsCommand>().SingleOrDefault();
            if (enableCommand != null)
            {
                foreach (var check in enableCommand.ChecksToRestore)
                {
                    foreach (var script in check)
                    {
                        var command = new SqlCommand(script, _sqlConnection) { CommandTimeout = _commandTimeout };
                        command.ExecuteNonQuery();
                    }
                }

                foreach (var foreinKey in enableCommand.ForeignKeysToRestore)
                {
                    foreach (var script in foreinKey)
                    {
                        var command = new SqlCommand(script, _sqlConnection) { CommandTimeout = _commandTimeout };
                        command.ExecuteNonQuery();
                    }
                }
            }

            return Array.Empty<IEvent>();
        }

        public IReadOnlyCollection<IEvent> ExecuteCommands(IReadOnlyCollection<ICommand> commands)
        {
            var command = commands.OfType<TruncateTableCommand>().SingleOrDefault();
            if (command != null)
            {
                ExecuteTruncate(command.Table);
            }

            return Array.Empty<IEvent>();
        }

        public IReadOnlyCollection<IEvent> ExecuteCommands(IReadOnlyCollection<ICommand> commands)
        {
            var enableCommand = commands.OfType<EnableIndexesCommand>().SingleOrDefault();
            if (enableCommand != null)
            {
                _indexManager.EnableIndexes(enableCommand.Table);
            }

            return Array.Empty<IEvent>();
        }

        public IReadOnlyCollection<IEvent> ExecuteCommands(IReadOnlyCollection<ICommand> commands)
        {
            var command = commands.OfType<UpdateTableStatisticsCommand>().SingleOrDefault();
            if (command == null)
            {
                return Array.Empty<IEvent>();
            }

            try
            {
                var database = _sqlConnection.GetDatabase();
                var table = string.IsNullOrEmpty(command.Table.Schema) ? database.Tables[command.Table.Table] : database.Tables[command.Table.Table, command.Table.Schema];
                table.UpdateStatistics();

                return Array.Empty<IEvent>();
            }
            catch (Exception ex)
            {
                throw new DataException($"Error occured while statistics updating for table {command.Table}", ex);
            }
        }

        private Expression BuildColumnExpression(
            IReadOnlyCollection<Expression> projections,
            TableExpressionBase tableExpression,
            IProperty property,
            IQuerySource querySource)
        {
            Check.NotNull(property, nameof(property));

            if (projections.Count == 0)
            {
                return new ColumnExpression(
                    _relationalAnnotationProvider.For(property).ColumnName,
                    property,
                    tableExpression);
            }

            var aliasExpressions
                = projections
                    .OfType<AliasExpression>()
                    .Where(p => p.TryGetColumnExpression()?.Property == property)
                    .ToList();

            var aliasExpression
                = aliasExpressions.Count == 1
                    ? aliasExpressions[0]
                    : aliasExpressions.Last(ae => ae.TryGetColumnExpression().Table.QuerySource == querySource);

            return new ColumnExpression(
                aliasExpression.Alias ?? aliasExpression.TryGetColumnExpression().Name,
                property,
                tableExpression);
        }

        private Expression BuildColumnExpression(
            IReadOnlyCollection<Expression> projections,
            TableExpressionBase tableExpression,
            IProperty property)
        {
            Check.NotNull(property, nameof(property));

            if (projections.Count == 0)
            {
                return new ColumnExpression(
                    _queryCompilationContext.GetColumnName(property),
                    property,
                    tableExpression);
            }

            var matchingColumnExpression
                = projections
                    .OfType<AliasExpression>()
                    .Last(p => p.TryGetColumnExpression()?.Property == property);

            return new ColumnExpression(
                matchingColumnExpression.Alias ?? matchingColumnExpression.TryGetColumnExpression().Name,
                property,
                tableExpression);
        }

        private static IReadOnlyCollection<ICommand> CreateSchemaChangesCompensationalCommands(IReadOnlyCollection<IEvent> events)
        {
            var commands = new List<ICommand>();

            var constraintsDisabledEvent = events.OfType<ConstraintsDisabledEvent>().SingleOrDefault();
            if (constraintsDisabledEvent != null)
            {
                commands.Add(new EnableConstraintsCommand(constraintsDisabledEvent.Checks, constraintsDisabledEvent.ForeignKeys));
            }

            var viewsDroppedEvent = events.OfType<ViewsDroppedEvent>().SingleOrDefault();
            if (viewsDroppedEvent != null)
            {
                commands.Add(new RestoreViewsCommand(viewsDroppedEvent.ViewsToRestore));
            }

            return commands;
        }

 private IReadOnlyCollection<ILaunchableContent> HandleAia(
     IReadOnlyCollection<ILaunchableContent> content) {
     var info = new AiaInfo(content.OfType<IHavePackageName>().ToArray());
     var newModsList = content.ToList();
     if (info.HasAia() && info.HasCup()) {
         //    if (aiaSpecific != null || aiaSpecificLite != null)
         //      newModsList.Remove(Cup);
         //                else
         newModsList.RemoveAll(info.IsAia);
     }
     if (info.HasCup() || info.HasAia())
         newModsList.RemoveAll(info.IsA3Mp);
     return newModsList;
 }