Contract.ForAll Methode

Referenz

Definition

Namespace:: System.Diagnostics.Contracts

Assembly:: System.Diagnostics.Contracts.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Überlädt

ForAll(Int32, Int32, Predicate<Int32>)	Bestimmt, ob eine angegebene Bedingung für alle ganzen Zahlen in einem angegebenen Bereich gültig ist.
ForAll<T>(IEnumerable<T>, Predicate<T>)	Bestimmt, ob alle Elemente in einer Auflistung in einer Funktion vorhanden sind.

ForAll(Int32, Int32, Predicate<Int32>)

Quelle:: Contracts.cs

Quelle:: Contracts.cs

Quelle:: Contracts.cs

Bestimmt, ob eine angegebene Bedingung für alle ganzen Zahlen in einem angegebenen Bereich gültig ist.

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

Parameter

fromInclusive: Int32

Die erste ganze Zahl, die an predicate übergeben werden soll.

toExclusive: Int32

Die letzte ganze Zahl, die an predicate übergeben werden soll, +1.

predicate: Predicate<Int32>

Die Funktion, mit der überprüft wird, ob die ganzen Zahlen im angegebenen Bereich vorhanden sind.

Gibt zurück

Boolean

true, wenn predicate für alle ganzen Zahlen zwischen fromInclusive und toExclusive -1 true zurückgibt.

Ausnahmen

ArgumentNullException

predicate ist null.

ArgumentException

toExclusive ist kleiner als fromInclusive.

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie mithilfe der ForAll -Methode ermittelt wird, ob ein Array über ein NULL-Element verfügt.

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

Hinweise

Der toExclusive Parameter ist ein Wert mehr als die letzte ganze Zahl, um die Verwendung der Länge eines Bereichs von ganzzahligen Zahlen ab 0 zu erleichtern. Sie würde z. B. für ganze Zahlen von 0 bis 4 auf 5 festgelegt.

Weitere Informationen

TrueForAll(Predicate<T>)

Gilt für:

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

Quelle:: Contracts.cs

Quelle:: Contracts.cs

Quelle:: Contracts.cs

Bestimmt, ob alle Elemente in einer Auflistung in einer Funktion vorhanden sind.

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

Typparameter

T

Der in collection enthaltene Typ.

Parameter

collection: IEnumerable<T>

Die Auflistung, aus der Elemente des Typs T gezeichnet werden, um an zu predicateübergeben.

predicate: Predicate<T>

Die Funktion, mit der überprüft wird, ob alle Elemente in collection vorhanden sind.

Gibt zurück

Boolean

true, wenn predicate für alle Elemente des Typs T in collection den Wert true zurückgibt.

Ausnahmen

ArgumentNullException

collection oder predicate ist null.

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie mithilfe der ForAll -Methode ermittelt wird, ob eine Auflistung über ein NULL-Element verfügt.

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

Weitere Informationen

TrueForAll(Predicate<T>)

Gilt für:

Freigeben über

Contract.ForAll Methode

Definition

Überlädt

ForAll(Int32, Int32, Predicate<Int32>)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

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

Typparameter

Parameter

Gibt zurück

Ausnahmen

Beispiele

Weitere Informationen

Gilt für:

Zusätzliche Ressourcen