Esporta (0) Stampa
Espandi tutto

Array.BinarySearch (metodo generico) (T[], T, IComparer generico)

Nota: questo metodo è stato introdotto con .NET Framework versione 2.0.

Mediante l'interfaccia generica IComparer specificata, esegue la ricerca di un valore all'interno di un oggetto Array unidimensionale e ordinato.

Spazio dei nomi: System
Assembly: mscorlib (in mscorlib.dll)

public static int BinarySearch<T> (
	T[] array,
	T value,
	IComparer<T> comparer
)
J# supporta l'utilizzo di tipi e metodi generici ma non la dichiarazione di nuovi.
JScript non supporta tipi e metodi generici.

Parametri di tipo

T

Tipo degli elementi della matrice.

Parametri

array

Oggetto Array ordinato, unidimensionale e in base zero in cui effettuare la ricerca.

value

Oggetto da cercare.

comparer

Implementazione IComparer da utilizzare quando si confrontano gli elementi.

-oppure-

riferimento null (Nothing in Visual Basic) per utilizzare l'implementazione IComparable di ciascun elemento.

Valore restituito

Indice del value specificato nella array specificata, se value è stato trovato. Se value non viene trovato e value è minore di uno o più elementi di array, un numero negativo che corrisponde al complemento bit per bit dell'indice del primo elemento maggiore di value. Se value non viene trovato e value è maggiore di qualsiasi elemento di array, un numero negativo che corrisponde al complemento bit per bit dell'indice dell'ultimo elemento + 1.

Tipo di eccezioneCondizione

ArgumentNullException

array è riferimento null (Nothing in Visual Basic).

ArgumentException

comparer è riferimento null (Nothing in Visual Basic), e value è di un tipo non compatibile con gli elementi di array.

InvalidOperationException

Il valore specificato nel parametro comparer è riferimento null (Nothing in Visual Basic), il parametro value non implementa l'interfaccia generica IComparable e durante la ricerca viene rilevato un elemento che non implementa l'interfaccia generica IComparable.

Se Array non contiene il valore specificato, dal metodo verrà restituito un integer negativo. È possibile applicare l'operatore di complemento bit per bit (~) al risultato negativo (in Visual Basic Xor il risultato negativo con -1) per produrre un indice. Se questo indice è maggiore o uguale alla dimensione della matrice, quest'ultima non conterrà elementi maggiori di value. In caso contrario, si tratta dell'indice del primo elemento maggiore di value.

L'operatore di confronto consente di personalizzare la modalità di confronto degli elementi. È possibile, ad esempio, utilizzare System.Collections.CaseInsensitiveComparer come operatore di confronto per effettuare ricerche in stringhe senza distinzione tra maiuscole e minuscole.

Se comparer non è riferimento null (Nothing in Visual Basic), gli elementi di array verranno confrontati con il valore specificato mediante l'implementazione dell'interfaccia generica IComparer specificata. Gli elementi di array devono essere già elencati in ordine crescente in base all'ordinamento definito dal parametro comparer; in caso contrario, il risultato potrebbe essere errato.

Se comparer è riferimento null (Nothing in Visual Basic), il confronto verrà eseguito mediante l'implementazione dell'interfaccia generica IComparable fornita dall'elemento stesso o dal valore specificato. Gli elementi di array devono essere già ordinati nell'aumento del valore in base all'ordinamento definito dall'implementazione dell'oggetto IComparable; in caso contrario, il risultato potrebbe essere errato.

NotaNota

Se comparer è riferimento null (Nothing in Visual Basic) e value non implementa l'interfaccia generica IComparable, non verrà eseguita la verifica degli elementi di array in base a IComparable prima dell'inizio della ricerca. Viene generata un'eccezione se durante la ricerca viene rilevato un elemento che non implementa IComparable.

Sono consentiti gli elementi duplicati. Se l'oggetto Array contiene più di un elemento uguale a value, il metodo restituirà l'indice di una sola occorrenza e non necessariamente la prima.

riferimento null (Nothing in Visual Basic) può sempre essere confrontato con qualsiasi altro tipo di riferimento, pertanto i confronti con riferimento null (Nothing in Visual Basic) non generano un'eccezione. Durante l'ordinamento, riferimento null (Nothing in Visual Basic) viene considerato minore rispetto a qualsiasi altro oggetto.

NotaNota

   Per ogni elemento verificato, value viene passato all'implementazione appropriata di IComparable, anche se value è impostato su riferimento null (Nothing in Visual Basic). L'implementazione IComparable determina la modalità di confronto tra un dato elemento e riferimento null (Nothing in Visual Basic).

Questo metodo rappresenta un'operazione O(log n), dove n è la proprietà Length di array.

Nell'esempio di codice riportato di seguito viene illustrato l'overload dei metodi generici Sort(J[],IComparer generico) e BinarySearch(J[],J,IComparer generico).

Nell'esempio di codice viene definito un operatore di confronto alternativo per le stringhe denominato ReverseCompare, che implementa l'interfaccia generica IComparer<string> (IComparer(Of String) in Visual Basic, IComparer<String^> in Visual C++). L'operatore di confronto chiama il metodo CompareTo(String), invertendo l'ordine dei termini del confronto in modo che le stringhe siano ordinate dall'alto verso il basso, anziché dal basso verso l'alto.

La matrice viene visualizzata, ordinata e nuovamente visualizzata. Per poter utilizzare il metodo BinarySearch, è necessario ordinare le matrici.

NotaNota

Le chiamate ai metodi generici Sort(J[],IComparer generico) e BinarySearch(J[],J,IComparer generico) sono praticamente identiche alle chiamate alle controparti non generiche, perché Visual Basic, C# e C++ derivano il tipo di parametro di tipo generico dal tipo del primo argomento. Se si utilizza Disassembler MSIL (Ildasm.exe) per esaminare MSIL (Microsoft Intermediate Language), è possibile notare che i metodi generici vengono chiamati.

L'overload del metodo generico BinarySearch(J[],J,IComparer generico) viene quindi utilizzata per cercare due stringhe, uno non compreso e l'altro compreso nella matrice. La matrice e il valore restituito del metodo BinarySearch(J[],J,IComparer generico) vengono passati al metodo generico ShowWhere, che visualizza il valore di indice se viene trovata la stringa oppure gli elementi in cui sarebbe compresa la stringa di ricerca se fosse inclusa nella matrice. L'indice è negativo se la stringa non è inclusa nella matrice, pertanto il metodo ShowWhere accetta il complemento bit per bit, ovvero l'operatore ~ in C# e Visual C++ e Xor -1 in Visual Basic, per ottenere l'indice del primo elemento dell'elenco maggiore della stringa di ricerca.

using System;
using System.Collections.Generic;

public class ReverseComparer: IComparer<string>
{
    public int Compare(string x, string y)
    {
        // Compare y and x in reverse order.
        return y.CompareTo(x);
    }
}

public class Example
{
    public static void Main()
    {
        string[] dinosaurs = {"Pachycephalosaurus", 
                              "Amargasaurus", 
                              "Tyrannosaurus", 
                              "Mamenchisaurus", 
                              "Deinonychus", 
                              "Edmontosaurus"};

        Console.WriteLine();
        foreach( string dinosaur in dinosaurs )
        {
            Console.WriteLine(dinosaur);
        }

        ReverseComparer rc = new ReverseComparer();

        Console.WriteLine("\nSort");
        Array.Sort(dinosaurs, rc);

        Console.WriteLine();
        foreach( string dinosaur in dinosaurs )
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("\nBinarySearch for 'Coelophysis':");
        int index = Array.BinarySearch(dinosaurs, "Coelophysis", rc);
        ShowWhere(dinosaurs, index);

        Console.WriteLine("\nBinarySearch for 'Tyrannosaurus':");
        index = Array.BinarySearch(dinosaurs, "Tyrannosaurus", rc);
        ShowWhere(dinosaurs, index);
    }

    private static void ShowWhere<T>(T[] array, int index)
    {
        if (index<0)
        {
            // If the index is negative, it represents the bitwise
            // complement of the next larger element in the array.
            //
            index = ~index;

            Console.Write("Not found. Sorts between: ");

            if (index == 0)
                Console.Write("beginning of array and ");
            else
                Console.Write("{0} and ", array[index-1]);

            if (index == array.Length)
                Console.WriteLine("end of array.");
            else
                Console.WriteLine("{0}.", array[index]);
        }
        else
        {
            Console.WriteLine("Found at index {0}.", index);
        }
    }
}

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Tyrannosaurus
Mamenchisaurus
Deinonychus
Edmontosaurus

Sort

Tyrannosaurus
Pachycephalosaurus
Mamenchisaurus
Edmontosaurus
Deinonychus
Amargasaurus

BinarySearch for 'Coelophysis':
Not found. Sorts between: Deinonychus and Amargasaurus.

BinarySearch for 'Tyrannosaurus':
Found at index 0.
 */

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema.

.NET Framework

Supportato in: 2.0

.NET Compact Framework

Supportato in: 2.0

Aggiunte alla community

AGGIUNGI
Mostra:
© 2015 Microsoft