Contract.ForAll Methode

Definition

Namespace:: System.Diagnostics.Contracts

Assemblys:: mscorlib.dll, System.Diagnostics.Contracts.dll

Assemblys:: netstandard.dll, System.Diagnostics.Contracts.dll

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

Name	Beschreibung
ForAll(Int32, Int32, Predicate<Int32>)	Bestimmt, ob eine bestimmte 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 innerhalb einer Funktion vorhanden sind.

ForAll(Int32, Int32, Predicate<Int32>)

Quelle:: Contracts.cs

Quelle:: Contracts.cs

Quelle:: Contracts.cs

Quelle:: Contracts.cs

Quelle:: Contracts.cs

Bestimmt, ob eine bestimmte 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, an die übergeben werden predicatesoll.

toExclusive: Int32

Eine mehr als die letzte ganze Zahl, an die übergeben werden predicatesoll.

predicate: Predicate<Int32>

Die Funktion, die für das Vorhandensein der ganzen Zahlen im angegebenen Bereich ausgewertet werden soll.

Gibt zurück

Boolean

true predicate wenn true für alle ganzen Zahlen zurückgegeben wird, die von fromInclusive - toExclusive 1 beginnen.

Ausnahmen

ArgumentNullException

predicate ist null.

ArgumentException

toExclusive ist kleiner als fromInclusive.

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie die ForAll Methode verwendet wird, um zu bestimmen, 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 eine weitere als die letzte ganze Zahl, um die Verwendung der Länge eines Bereichs von ganzzahligen Zahlen zu erleichtern, beginnend mit 0. Beispielsweise wäre sie für ganze Zahlen 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

Quelle:: Contracts.cs

Quelle:: Contracts.cs

Bestimmt, ob alle Elemente in einer Auflistung innerhalb 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 Typ, der in collection.

Parameter

collection: IEnumerable<T>

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

predicate: Predicate<T>

Die Funktion, die für das Vorhandensein aller Elemente ausgewertet collectionwerden soll.

Gibt zurück

Boolean

true if and only if predicate returns true for all elements of type T in collection.

Ausnahmen

ArgumentNullException

collection oder predicate ist null.

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie die ForAll Methode verwendet wird, um zu bestimmen, 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:

Feedback

War diese Seite hilfreich?