Contract.ForAll Metoda

Odwołanie

Definicja

Przestrzeń nazw:: System.Diagnostics.Contracts

Zestaw:: System.Diagnostics.Contracts.dll

Zestaw:: mscorlib.dll

Zestaw:: netstandard.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Przeciążenia

ForAll(Int32, Int32, Predicate<Int32>)	Określa, czy określony warunek jest prawidłowy dla wszystkich liczb całkowitych w określonym zakresie.
ForAll<T>(IEnumerable<T>, Predicate<T>)	Określa, czy wszystkie elementy w kolekcji istnieją w ramach funkcji.

ForAll(Int32, Int32, Predicate<Int32>)

Źródło:: Contracts.cs

Źródło:: Contracts.cs

Źródło:: Contracts.cs

Określa, czy określony warunek jest prawidłowy dla wszystkich liczb całkowitych w określonym zakresie.

public:
 static bool ForAll(int fromInclusive, int toExclusive, Predicate<int> ^ predicate);

public static bool ForAll (int fromInclusive, int toExclusive, Predicate<int> predicate);

static member ForAll : int * int * Predicate<int> -> bool

Public Shared Function ForAll (fromInclusive As Integer, toExclusive As Integer, predicate As Predicate(Of Integer)) As Boolean

Parametry

fromInclusive: Int32

Pierwsza liczba całkowita, która ma być przekazywana do predicateelementu .

toExclusive: Int32

Co najmniej jedna liczba całkowita, która ma być przekazywana do predicateelementu .

predicate: Predicate<Int32>

Funkcja do oceny istnienia liczb całkowitych w określonym zakresie.

Zwraca

Boolean

true jeśli predicate zwraca wartość true dla wszystkich liczb całkowitych rozpoczynających się od fromInclusive do toExclusive - 1.

Wyjątki

ArgumentNullException

predicate to null.

ArgumentException

toExclusive wartość jest mniejsza niż fromInclusive.

Przykłady

W poniższym przykładzie pokazano, jak za pomocą ForAll metody określić, czy tablica ma element null.

using System;
using System.Diagnostics.Contracts;
using System.Collections.Generic;
namespace AssumeEx
{
    class Program
    {
        // Start application with at least two arguments
        static void Main(string[] args)
        {
            args[1] = null;
            Contract.Requires(args != null && Contract.ForAll(0, args.Length, i => args[i] != null));
            // test the ForAll method.  This is only for purpose of demonstrating how ForAll works.
            CheckIndexes(args);
            Stack<string> numbers = new Stack<string>();
            numbers.Push("one");
            numbers.Push("two");
            numbers.Push(null);
            numbers.Push("four");
            numbers.Push("five");
            Contract.Requires(numbers != null && !Contract.ForAll(numbers, (String x) => x != null));
            // test the ForAll generic overload.  This is only for purpose of demonstrating how ForAll works.
            CheckTypeArray(numbers);
        }

        private static bool CheckIndexes(string[] args)
        {
            try
            {
                if (args != null && !Contract.ForAll(0, args.Length, i => args[i] != null))
                    throw new ArgumentException("The parameter array has a null element", "args");
                return true;
            }
            catch (ArgumentException e)
            {
                Console.WriteLine(e.Message);
                return false;
            }
        }
        private static bool CheckTypeArray(IEnumerable<String> xs)
        {
            try
            {
                if (xs != null && !Contract.ForAll(xs, (String x) => x != null))
                    throw new ArgumentException("The parameter array has a null element", "indexes");
                return true;
            }
            catch (ArgumentException e)
            {
                Console.WriteLine(e.Message);
                return false;
            }
        }
    }
}

Imports System.Diagnostics.Contracts
Imports System.Collections.Generic


Class Program

    ' Start application with at least two arguments.
    Shared Sub Main(ByVal args() As String)
        args(1) = Nothing
        Contract.Requires(Not (args Is Nothing) AndAlso Contract.ForAll(args, Function(s) s Is Nothing))
        ' test the ForAll method.  This is only for purpose of demonstrating how ForAll works.
        CheckIndexes(args)
        Dim numbers As New Stack(Of String)
        numbers.Push("one")
        numbers.Push("two")
        numbers.Push("three")
        numbers.Push("four")
        numbers.Push("five")

        Contract.Requires(Not (numbers Is Nothing) AndAlso Not Contract.ForAll(numbers, Function(s) s Is Nothing))
        ' test the ForAll generic overload. This is only for purpose of demonstrating how ForAll works.
        CheckTypeArray(numbers)

    End Sub


    Private Shared Function CheckIndexes(ByVal args() As String) As Boolean
        Try
            If Not (args Is Nothing) AndAlso Not Contract.ForAll(0, args.Length, Function(i) args(i) Is Nothing) Then
                Throw New ArgumentException("The parameter array has a null element", "args")
            End If
            Return True
        Catch e As ArgumentException
            Console.WriteLine(e.Message)
            Return False
        End Try

    End Function 'CheckIndexes

    Private Shared Function CheckTypeArray(ByVal xs As Stack(Of String)) As Boolean

        Try
            If Not (xs Is Nothing) AndAlso Not Contract.ForAll(xs, Function(s) s Is Nothing) Then

                Throw New ArgumentException("The parameter array has a null element", "Stack")
            End If
            Return True

        Catch e As ArgumentException
            Console.WriteLine(e.Message)
            Return False
        End Try

    End Function 'CheckTypeArray
End Class

Uwagi

Parametr toExclusive jest jedną więcej niż ostatnią liczbą całkowitą, która ułatwia korzystanie z długości zakresu liczb całkowitych rozpoczynających się od 0. Na przykład dla liczby całkowitej od 0 do 4 zostanie ustawiona wartość 5.

Zobacz też

TrueForAll(Predicate<T>)

Dotyczy

ForAll<T>(IEnumerable<T>, Predicate<T>)

Źródło:: Contracts.cs

Źródło:: Contracts.cs

Źródło:: Contracts.cs

Określa, czy wszystkie elementy w kolekcji istnieją w ramach funkcji.

public:
generic <typename T>
 static bool ForAll(System::Collections::Generic::IEnumerable<T> ^ collection, Predicate<T> ^ predicate);

public static bool ForAll<T> (System.Collections.Generic.IEnumerable<T> collection, Predicate<T> predicate);

static member ForAll : seq<'T> * Predicate<'T> -> bool

Public Shared Function ForAll(Of T) (collection As IEnumerable(Of T), predicate As Predicate(Of T)) As Boolean

Parametry typu

T

Typ, który znajduje się w elemecie collection.

Parametry

collection: IEnumerable<T>

Kolekcja, z której będą rysowane elementy typu T , które mają zostać przekazane do predicateelementu .

predicate: Predicate<T>

Funkcja do oceny istnienia wszystkich elementów w elemecie collection.

Zwraca

Boolean

true if i tylko wtedy, gdy predicate zwraca true wszystkie elementy typu T w collection.

Wyjątki

ArgumentNullException

collection lub predicate to null.

Przykłady

W poniższym przykładzie pokazano, jak za pomocą ForAll metody określić, czy kolekcja ma element null.

using System;
using System.Diagnostics.Contracts;
using System.Collections.Generic;
namespace AssumeEx
{
    class Program
    {
        // Start application with at least two arguments
        static void Main(string[] args)
        {
            args[1] = null;
            Contract.Requires(args != null && Contract.ForAll(0, args.Length, i => args[i] != null));
            // test the ForAll method.  This is only for purpose of demonstrating how ForAll works.
            CheckIndexes(args);
            Stack<string> numbers = new Stack<string>();
            numbers.Push("one");
            numbers.Push("two");
            numbers.Push(null);
            numbers.Push("four");
            numbers.Push("five");
            Contract.Requires(numbers != null && !Contract.ForAll(numbers, (String x) => x != null));
            // test the ForAll generic overload.  This is only for purpose of demonstrating how ForAll works.
            CheckTypeArray(numbers);
        }

        private static bool CheckIndexes(string[] args)
        {
            try
            {
                if (args != null && !Contract.ForAll(0, args.Length, i => args[i] != null))
                    throw new ArgumentException("The parameter array has a null element", "args");
                return true;
            }
            catch (ArgumentException e)
            {
                Console.WriteLine(e.Message);
                return false;
            }
        }
        private static bool CheckTypeArray(IEnumerable<String> xs)
        {
            try
            {
                if (xs != null && !Contract.ForAll(xs, (String x) => x != null))
                    throw new ArgumentException("The parameter array has a null element", "indexes");
                return true;
            }
            catch (ArgumentException e)
            {
                Console.WriteLine(e.Message);
                return false;
            }
        }
    }
}

Imports System.Diagnostics.Contracts
Imports System.Collections.Generic


Class Program

    ' Start application with at least two arguments.
    Shared Sub Main(ByVal args() As String)
        args(1) = Nothing
        Contract.Requires(Not (args Is Nothing) AndAlso Contract.ForAll(args, Function(s) s Is Nothing))
        ' test the ForAll method.  This is only for purpose of demonstrating how ForAll works.
        CheckIndexes(args)
        Dim numbers As New Stack(Of String)
        numbers.Push("one")
        numbers.Push("two")
        numbers.Push("three")
        numbers.Push("four")
        numbers.Push("five")

        Contract.Requires(Not (numbers Is Nothing) AndAlso Not Contract.ForAll(numbers, Function(s) s Is Nothing))
        ' test the ForAll generic overload. This is only for purpose of demonstrating how ForAll works.
        CheckTypeArray(numbers)

    End Sub


    Private Shared Function CheckIndexes(ByVal args() As String) As Boolean
        Try
            If Not (args Is Nothing) AndAlso Not Contract.ForAll(0, args.Length, Function(i) args(i) Is Nothing) Then
                Throw New ArgumentException("The parameter array has a null element", "args")
            End If
            Return True
        Catch e As ArgumentException
            Console.WriteLine(e.Message)
            Return False
        End Try

    End Function 'CheckIndexes

    Private Shared Function CheckTypeArray(ByVal xs As Stack(Of String)) As Boolean

        Try
            If Not (xs Is Nothing) AndAlso Not Contract.ForAll(xs, Function(s) s Is Nothing) Then

                Throw New ArgumentException("The parameter array has a null element", "Stack")
            End If
            Return True

        Catch e As ArgumentException
            Console.WriteLine(e.Message)
            Return False
        End Try

    End Function 'CheckTypeArray
End Class

Zobacz też

TrueForAll(Predicate<T>)

Dotyczy

Udostępnij za pośrednictwem

Contract.ForAll Metoda

Definicja

Przeciążenia

ForAll(Int32, Int32, Predicate<Int32>)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

ForAll<T>(IEnumerable<T>, Predicate<T>)

Parametry typu

Parametry

Zwraca

Wyjątki

Przykłady

Zobacz też

Dotyczy

Dodatkowe zasoby