C# Func.AssertNotNull方法代码示例

        public MainViewModel(
            Func<ExerciseProgramsViewModel> exerciseProgramsViewModelFactory)
        {
            exerciseProgramsViewModelFactory.AssertNotNull(nameof(exerciseProgramsViewModelFactory));

            this.router = new RoutingState();
            this.exerciseProgramsViewModelFactory = exerciseProgramsViewModelFactory;
        }

 public Codebase Redirect(Func<MethodBase, bool> filter, Func<MethodBase, ReadOnlyCollection<Expression>, MethodBase> map_m, Func<MethodBase, ReadOnlyCollection<Expression>, IEnumerable<Expression>> map_args) { _redirects.Add(filter.AssertNotNull(), Tuple.New(map_m.AssertNotNull(), map_args.AssertNotNull())); return this; }

 public Codebase Special(Func<MethodBase, bool> filter) { _special.Add(filter.AssertNotNull()); return this; }

 public Codebase OptOut(Func<MethodBase, bool> filter) { _optOut.Add(filter.AssertNotNull()); return this; }

        private void InitializeCore(
            BaseControlFlowGraph source,
            Func<ControlFlowBlock, bool> vertexFilter,
            Func<ControlFlowEdge, bool> edgeFilter,
            Action<ControlFlowEdge, ViewOfControlFlowGraph> onAlienEdge)
        {
            Source = source.AssertNotNull();
            HookUpVertexPostprocessors();

            _vertexFilter = vertexFilter.AssertNotNull();
            _edgeFilter = edgeFilter.AssertNotNull();

            _cachedVertices = _hardcodedVertices != null ? null : source.Vertices.Where(_vertexFilter).ToList();
            (_cachedVertices ?? _hardcodedVertices.AsEnumerable()).ForEach(OnVertexAdded);

            ReadOnlyCollection<ControlFlowEdge> alienEdges = null;
            if (_hardcodedEdges != null)
            {
                var edgeVertices = _hardcodedEdges.SelectMany(e => new []{e.Source, e.Target}).ToHashSet();
                edgeVertices.ExceptWith(_cachedVertices ?? _hardcodedVertices.AsEnumerable());
                edgeVertices.AssertEmpty();
            }
            else
            {
                _edgeFilter = e => edgeFilter(e) && _vertexFilter(e.Source) && _vertexFilter(e.Target);

                var relatedEdges = source.Edges(_vertexFilter, null).Concat(source.Edges(null, _vertexFilter)).Distinct();
                var parts = relatedEdges.GroupBy(e => _edgeFilter(e)).ToDictionary(g => g.Key, g => g.AsEnumerable());
                _cachedEdges = (parts.GetOrDefault(true, Seq.Empty<ControlFlowEdge>)).ToList();
                alienEdges = parts.GetOrDefault(false, Seq.Empty<ControlFlowEdge>).ToReadOnly();
            }
            (_cachedEdges ?? _hardcodedEdges.AsEnumerable()).ForEach(OnEdgeAdded);

            Action<ControlFlowBlock> cacheVertex = v => { if (_cachedVertices != null) _cachedVertices.Add(v); else throw AssertionHelper.Fail(); };
            Action<ControlFlowBlock> uncacheVertex = v => { if (_cachedVertices != null) _cachedVertices.Remove(v); else _hardcodedVertices.Remove(v); };
            source.VertexAdded += v => { if (_vertexFilter(v)) { cacheVertex(v); OnVertexAdded(v); } };
            source.VertexRemoved += v => { if (_vertexFilter(v)) { uncacheVertex(v); OnVertexRemoved(v); } };

            Action<ControlFlowEdge> cacheEdge = e => { if (_cachedEdges != null) _cachedEdges.Add(e); else throw AssertionHelper.Fail(); };
            Action<ControlFlowEdge> uncacheEdge = e => { if (_cachedEdges != null) _cachedEdges.Remove(e); else _hardcodedEdges.Remove(e); };
            source.EdgeAdded += e => { if (_edgeFilter(e)) { cacheEdge(e); OnEdgeAdded(e); } };
            source.EdgeRemoved += e => { if (_edgeFilter(e)) { uncacheEdge(e); OnEdgeRemoved(e); } };

            __vertices = new VirtualList<ControlFlowBlock>(
                () => (_hardcodedVertices ?? (IEnumerable<ControlFlowBlock>)_cachedVertices).Concat(_eigenVertices),
                (i, v) =>
                {
                    if (_eigenVertices.Contains(v))
                    {
                        // do nothing - the vertex has just been created by AddEigenVertex
                    }
                    else
                    {
                        _vertexFilter(v).AssertTrue();
                        (_cachedVertices != null && i == _cachedVertices.Count()).AssertTrue();
                        Source.AddVertex(v);
                    }
                },
                (i, v) => { _vertexFilter(v).AssertTrue(); throw AssertionHelper.Fail(); },
                i =>
                {
                    if (i < _cachedEdges.Count())
                    {
                        var v = _cachedVertices[i];
                        Source.RemoveVertex(v);
                    }
                    else
                    {
                        throw AssertionHelper.Fail();
                    }
                });

            __edges = new VirtualList<ControlFlowEdge>(
                () => (_hardcodedEdges ?? (IEnumerable<ControlFlowEdge>)_cachedEdges).Concat(_eigenEdges),
                (i, e) =>
                {
                    if (_eigenEdges.Contains(e))
                    {
                        // do nothing - the edge has just been created by AddEigenEdge
                    }
                    else
                    {
                        _edgeFilter(e).AssertTrue();
                        (_cachedEdges != null && i == _cachedEdges.Count()).AssertTrue();
                        Source.AddEdge(e);
                    }
                },
                (i, e) => { _edgeFilter(e).AssertTrue(); throw AssertionHelper.Fail(); },
                i =>
                {
                    if (i < _cachedEdges.Count())
                    {
                        var e = _cachedEdges[i];
                        Source.RemoveEdge(e);
                    }
                    else
                    {
                        var e = _eigenEdges[i - _cachedEdges.Count()];
                        _eigenEdges.Remove(e);
                    }
//.........这里部分代码省略.........

        /// <summary>
        /// Asynchronously writes all rows in <paramref name="this"/> to <paramref name="csvWriter"/>.
        /// </summary>
        /// <remarks>
        /// </remarks>
        /// <param name="this">
        /// The <see cref="DataTable"/>.
        /// </param>
        /// <param name="csvWriter">
        /// The <see cref="CsvWriter"/>.
        /// </param>
        /// <param name="writeHeaderRecord">
        /// If <see langword="true"/>, a header record will also be written, which will be comprised of the column names defined for <paramref name="this"/>.
        /// </param>
        /// <param name="maximumRows">
        /// The maximum number of rows from <paramref name="this"/> that should be written to <paramref name="csvWriter"/>.
        /// </param>
        /// <param name="objectToStringConverter">
        /// Provides a means of converting values in the <see cref="DataRow"/>s to <see cref="String"/>s.
        /// </param>
        /// <returns>
        /// The actual number of rows from <paramref name="this"/> written to <paramref name="csvWriter"/>.
        /// </returns>
        public async static Task<int> WriteCsvAsync(this DataTable @this, CsvWriter csvWriter, bool writeHeaderRecord, int? maximumRows, Func<object, string> objectToStringConverter)
        {
            @this.AssertNotNull("@this");
            csvWriter.AssertNotNull("csvWriter");
            objectToStringConverter.AssertNotNull("objectToStringConverter");

            var num = 0;

            if (writeHeaderRecord)
            {
                var columnNames = new string[@this.Columns.Count];

                for (var i = 0; i < columnNames.Length; ++i)
                {
                    columnNames[i] = @this.Columns[i].ColumnName;
                }

                await csvWriter.WriteRecordAsync(columnNames).ConfigureAwait(false);
            }

            var maximum = maximumRows.GetValueOrDefault(int.MaxValue);
            var buffer = new DataRecord[16];
            var bufferOffset = 0;

            foreach (DataRow row in @this.Rows)
            {
                var record = new DataRecord();

                for (var i = 0; i < row.ItemArray.Length; ++i)
                {
                    record.Add(objectToStringConverter(row.ItemArray[i]));
                }

                buffer[bufferOffset++] = record;

                if (bufferOffset == buffer.Length)
                {
                    // buffer full
                    await csvWriter.WriteRecordsAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
                    bufferOffset = 0;
                }

                if (++num == maximum)
                {
                    break;
                }
            }

            // write any outstanding data in buffer
            await csvWriter.WriteRecordsAsync(buffer, 0, bufferOffset).ConfigureAwait(false);

            return num;
        }

 public TypeRule(Func<Type, bool> filter) { Filter = filter.AssertNotNull(); }

 protected Rule(Func<PropertyInfo, bool> property)
 {
     property.AssertNotNull();
     Filter = mi => mi is PropertyInfo && property(mi.AssertCast<PropertyInfo>());
     Hash = new Dictionary<Object, Object>();
 }