Condividi tramite


Interlocked.Exchange Metodo

Definizione

Imposta una variabile su un valore specificato come operazione atomica.

Overload

Exchange(UInt16, UInt16)

Imposta un intero con segno a 16 bit su un valore specificato e restituisce il valore originale, come operazione atomica.

Exchange(UInt32, UInt32)

Imposta un intero senza segno a 32 bit su un valore specificato e restituisce il valore originale come operazione atomica.

Exchange(Single, Single)

Imposta un numero a virgola mobile a precisione singola su un valore specificato e restituisce il valore originale come operazione atomica.

Exchange(UIntPtr, UIntPtr)

Imposta un handle o un puntatore specifico della piattaforma su un valore specificato e restituisce il valore originale, come operazione atomica.

Exchange(UInt64, UInt64)

Imposta un intero senza segno a 64 bit su un valore specificato e restituisce il valore originale come operazione atomica.

Exchange(SByte, SByte)

Imposta un intero con segno a 8 bit su un valore specificato e restituisce il valore originale, come operazione atomica.

Exchange(Byte, Byte)

Imposta un intero senza segno a 8 bit su un valore specificato e restituisce il valore originale, come operazione atomica.

Exchange(IntPtr, IntPtr)

Imposta un handle o un puntatore specifico della piattaforma su un valore specificato e restituisce il valore originale, come operazione atomica.

Exchange(Int64, Int64)

Imposta un intero con segno a 64 bit su un valore specificato e restituisce il valore originale, come operazione atomica.

Exchange(Int32, Int32)

Imposta un intero con segno a 32 bit su un valore specificato e restituisce il valore originale, come operazione atomica.

Exchange(Int16, Int16)

Imposta un intero senza segno a 16 bit su un valore specificato e restituisce il valore originale come operazione atomica.

Exchange(Double, Double)

Imposta un numero a virgola mobile a precisione doppia su un valore specificato e restituisce il valore originale, come operazione atomica.

Exchange(Object, Object)

Imposta un oggetto su un valore specificato e restituisce un riferimento all'oggetto originale, come operazione atomica.

Exchange<T>(T, T)

Imposta una variabile del tipo specificato T su un valore specificato e restituisce il valore originale, come operazione atomica.

Exchange(UInt16, UInt16)

Importante

Questa API non è conforme a CLS.

Imposta un intero con segno a 16 bit su un valore specificato e restituisce il valore originale, come operazione atomica.

public:
 static System::UInt16 Exchange(System::UInt16 % location1, System::UInt16 value);
[System.CLSCompliant(false)]
public static ushort Exchange (ref ushort location1, ushort value);
[<System.CLSCompliant(false)>]
static member Exchange : uint16 * uint16 -> uint16
Public Shared Function Exchange (ByRef location1 As UShort, value As UShort) As UShort

Parametri

location1
UInt16

Variabile da impostare sul valore specificato.

value
UInt16

Valore a cui è impostato il parametro location1.

Restituisce

Valore originale di location1.

Attributi

Eccezioni

L'indirizzo di location1 è un puntatore null.

Si applica a

Exchange(UInt32, UInt32)

Origine:
Interlocked.cs
Origine:
Interlocked.cs
Origine:
Interlocked.cs

Importante

Questa API non è conforme a CLS.

Imposta un intero senza segno a 32 bit su un valore specificato e restituisce il valore originale come operazione atomica.

public:
 static System::UInt32 Exchange(System::UInt32 % location1, System::UInt32 value);
[System.CLSCompliant(false)]
public static uint Exchange (ref uint location1, uint value);
[<System.CLSCompliant(false)>]
static member Exchange : uint32 * uint32 -> uint32
Public Shared Function Exchange (ByRef location1 As UInteger, value As UInteger) As UInteger

Parametri

location1
UInt32

Variabile da impostare sul valore specificato.

value
UInt32

Valore a cui è impostato il parametro location1.

Restituisce

Valore originale di location1.

Attributi

Eccezioni

L'indirizzo di location1 è un puntatore null.

Si applica a

Exchange(Single, Single)

Origine:
Interlocked.cs
Origine:
Interlocked.cs
Origine:
Interlocked.cs

Imposta un numero a virgola mobile a precisione singola su un valore specificato e restituisce il valore originale come operazione atomica.

public:
 static float Exchange(float % location1, float value);
public static float Exchange (ref float location1, float value);
static member Exchange : single * single -> single
Public Shared Function Exchange (ByRef location1 As Single, value As Single) As Single

Parametri

location1
Single

Variabile da impostare sul valore specificato.

value
Single

Valore a cui è impostato il parametro location1.

Restituisce

Valore originale di location1.

Eccezioni

L'indirizzo di location1 è un puntatore null.

Vedi anche

Si applica a

Exchange(UIntPtr, UIntPtr)

Origine:
Interlocked.cs
Origine:
Interlocked.cs
Origine:
Interlocked.cs

Importante

Questa API non è conforme a CLS.

Imposta un handle o un puntatore specifico della piattaforma su un valore specificato e restituisce il valore originale, come operazione atomica.

public:
 static UIntPtr Exchange(UIntPtr % location1, UIntPtr value);
[System.CLSCompliant(false)]
public static UIntPtr Exchange (ref UIntPtr location1, UIntPtr value);
[<System.CLSCompliant(false)>]
static member Exchange : unativeint * unativeint -> unativeint
Public Shared Function Exchange (ByRef location1 As UIntPtr, value As UIntPtr) As UIntPtr

Parametri

location1
UIntPtr

unativeint

Variabile da impostare sul valore specificato.

value
UIntPtr

unativeint

Valore a cui è impostato il parametro location1.

Restituisce

UIntPtr

unativeint

Valore originale di location1.

Attributi

Eccezioni

L'indirizzo di location1 è un puntatore null.

Si applica a

Exchange(UInt64, UInt64)

Origine:
Interlocked.cs
Origine:
Interlocked.cs
Origine:
Interlocked.cs

Importante

Questa API non è conforme a CLS.

Imposta un intero senza segno a 64 bit su un valore specificato e restituisce il valore originale come operazione atomica.

public:
 static System::UInt64 Exchange(System::UInt64 % location1, System::UInt64 value);
[System.CLSCompliant(false)]
public static ulong Exchange (ref ulong location1, ulong value);
[<System.CLSCompliant(false)>]
static member Exchange : uint64 * uint64 -> uint64
Public Shared Function Exchange (ByRef location1 As ULong, value As ULong) As ULong

Parametri

location1
UInt64

Variabile da impostare sul valore specificato.

value
UInt64

Valore a cui è impostato il parametro location1.

Restituisce

Valore originale di location1.

Attributi

Eccezioni

L'indirizzo di location1 è un puntatore null.

Si applica a

Exchange(SByte, SByte)

Importante

Questa API non è conforme a CLS.

Imposta un intero con segno a 8 bit su un valore specificato e restituisce il valore originale, come operazione atomica.

public:
 static System::SByte Exchange(System::SByte % location1, System::SByte value);
[System.CLSCompliant(false)]
public static sbyte Exchange (ref sbyte location1, sbyte value);
[<System.CLSCompliant(false)>]
static member Exchange : sbyte * sbyte -> sbyte
Public Shared Function Exchange (ByRef location1 As SByte, value As SByte) As SByte

Parametri

location1
SByte

Variabile da impostare sul valore specificato.

value
SByte

Valore a cui è impostato il parametro location1.

Restituisce

Valore originale di location1.

Attributi

Eccezioni

L'indirizzo di location1 è un puntatore null.

Si applica a

Exchange(Byte, Byte)

Imposta un intero senza segno a 8 bit su un valore specificato e restituisce il valore originale, come operazione atomica.

public:
 static System::Byte Exchange(System::Byte % location1, System::Byte value);
public static byte Exchange (ref byte location1, byte value);
static member Exchange : byte * byte -> byte
Public Shared Function Exchange (ByRef location1 As Byte, value As Byte) As Byte

Parametri

location1
Byte

Variabile da impostare sul valore specificato.

value
Byte

Valore a cui è impostato il parametro location1.

Restituisce

Valore originale di location1.

Eccezioni

L'indirizzo di location1 è un puntatore null.

Si applica a

Exchange(IntPtr, IntPtr)

Origine:
Interlocked.cs
Origine:
Interlocked.cs
Origine:
Interlocked.cs

Imposta un handle o un puntatore specifico della piattaforma su un valore specificato e restituisce il valore originale, come operazione atomica.

public:
 static IntPtr Exchange(IntPtr % location1, IntPtr value);
public static IntPtr Exchange (ref IntPtr location1, IntPtr value);
static member Exchange : nativeint * nativeint -> nativeint
Public Shared Function Exchange (ByRef location1 As IntPtr, value As IntPtr) As IntPtr

Parametri

location1
IntPtr

nativeint

Variabile da impostare sul valore specificato.

value
IntPtr

nativeint

Valore a cui è impostato il parametro location1.

Restituisce

IntPtr

nativeint

Valore originale di location1.

Eccezioni

L'indirizzo di location1 è un puntatore null.

Vedi anche

Si applica a

Exchange(Int64, Int64)

Origine:
Interlocked.cs
Origine:
Interlocked.cs
Origine:
Interlocked.CoreCLR.cs

Imposta un intero con segno a 64 bit su un valore specificato e restituisce il valore originale, come operazione atomica.

public:
 static long Exchange(long % location1, long value);
public static long Exchange (ref long location1, long value);
static member Exchange : int64 * int64 -> int64
Public Shared Function Exchange (ByRef location1 As Long, value As Long) As Long

Parametri

location1
Int64

Variabile da impostare sul valore specificato.

value
Int64

Valore a cui è impostato il parametro location1.

Restituisce

Valore originale di location1.

Eccezioni

L'indirizzo di location1 è un puntatore null.

Vedi anche

Si applica a

Exchange(Int32, Int32)

Origine:
Interlocked.cs
Origine:
Interlocked.cs
Origine:
Interlocked.CoreCLR.cs

Imposta un intero con segno a 32 bit su un valore specificato e restituisce il valore originale, come operazione atomica.

public:
 static int Exchange(int % location1, int value);
public static int Exchange (ref int location1, int value);
static member Exchange : int * int -> int
Public Shared Function Exchange (ByRef location1 As Integer, value As Integer) As Integer

Parametri

location1
Int32

Variabile da impostare sul valore specificato.

value
Int32

Valore a cui è impostato il parametro location1.

Restituisce

Valore originale di location1.

Eccezioni

L'indirizzo di location1 è un puntatore null.

L'indirizzo di location1 è un puntatore null.

Esempio

L'esempio di codice seguente illustra un meccanismo di blocco delle risorse thread-safe.

using namespace System;
using namespace System::Threading;

const int numThreads = 10;
const int numThreadIterations = 5;
ref class MyInterlockedExchangeExampleClass
{
public:
   static void MyThreadProc()
   {
      for ( int i = 0; i < numThreadIterations; i++ )
      {
         UseResource();
         
         //Wait 1 second before next attempt.
         Thread::Sleep( 1000 );

      }
   }


private:
   //A simple method that denies reentrancy.
   static bool UseResource()
   {
      
      //0 indicates that the method is not in use.
      if ( 0 == Interlocked::Exchange( usingResource, 1 ) )
      {
         Console::WriteLine( " {0} acquired the lock", Thread::CurrentThread->Name );
         
         //Code to access a resource that is not thread safe would go here.
         //Simulate some work
         Thread::Sleep( 500 );
         Console::WriteLine( " {0} exiting lock", Thread::CurrentThread->Name );
         
         //Release the lock
         Interlocked::Exchange( usingResource, 0 );
         return true;
      }
      else
      {
         Console::WriteLine( " {0} was denied the lock", Thread::CurrentThread->Name );
         return false;
      }
   }


   //0 for false, 1 for true.
   static int usingResource;
};

int main()
{
   Thread^ myThread;
   Random^ rnd = gcnew Random;
   for ( int i = 0; i < numThreads; i++ )
   {
      myThread = gcnew Thread( gcnew ThreadStart( MyInterlockedExchangeExampleClass::MyThreadProc ) );
      myThread->Name = String::Format( "Thread {0}", i + 1 );
      
      //Wait a random amount of time before starting next thread.
      Thread::Sleep( rnd->Next( 0, 1000 ) );
      myThread->Start();

   }
}
using System;
using System.Threading;

namespace InterlockedExchange_Example
{
    class MyInterlockedExchangeExampleClass
    {
        //0 for false, 1 for true.
        private static int usingResource = 0;

        private const int numThreadIterations = 5;
        private const int numThreads = 10;

        static void Main()
        {
            Thread myThread;
            Random rnd = new Random();

            for(int i = 0; i < numThreads; i++)
            {
                myThread = new Thread(new ThreadStart(MyThreadProc));
                myThread.Name = String.Format("Thread{0}", i + 1);
            
                //Wait a random amount of time before starting next thread.
                Thread.Sleep(rnd.Next(0, 1000));
                myThread.Start();
            }
        }

        private static void MyThreadProc()
        {
            for(int i = 0; i < numThreadIterations; i++)
            {
                UseResource();
            
                //Wait 1 second before next attempt.
                Thread.Sleep(1000);
            }
        }

        //A simple method that denies reentrancy.
        static bool UseResource()
        {
            //0 indicates that the method is not in use.
            if(0 == Interlocked.Exchange(ref usingResource, 1))
            {
                Console.WriteLine("{0} acquired the lock", Thread.CurrentThread.Name);
            
                //Code to access a resource that is not thread safe would go here.
            
                //Simulate some work
                Thread.Sleep(500);

                Console.WriteLine("{0} exiting lock", Thread.CurrentThread.Name);
            
                //Release the lock
                Interlocked.Exchange(ref usingResource, 0);
                return true;
            }
            else
            {
                Console.WriteLine("   {0} was denied the lock", Thread.CurrentThread.Name);
                return false;
            }
        }
    }
}
Imports System.Threading

Namespace InterlockedExchange_Example
    Class MyInterlockedExchangeExampleClass
        '0 for false, 1 for true.
        Private Shared usingResource As Integer = 0

        Private Const numThreadIterations As Integer = 5
        Private Const numThreads As Integer = 10

        <MTAThread> _
        Shared Sub Main()
            Dim myThread As Thread
            Dim rnd As New Random()

            Dim i As Integer
            For i = 0 To numThreads - 1
                myThread = New Thread(AddressOf MyThreadProc)
                myThread.Name = String.Format("Thread{0}", i + 1)

                'Wait a random amount of time before starting next thread.
                Thread.Sleep(rnd.Next(0, 1000))
                myThread.Start()
            Next i
        End Sub

        Private Shared Sub MyThreadProc()
            Dim i As Integer
            For i = 0 To numThreadIterations - 1
                UseResource()

                'Wait 1 second before next attempt.
                Thread.Sleep(1000)
            Next i
        End Sub 

        'A simple method that denies reentrancy.
        Shared Function UseResource() As Boolean
            '0 indicates that the method is not in use.
            If 0 = Interlocked.Exchange(usingResource, 1) Then
                Console.WriteLine("{0} acquired the lock", Thread.CurrentThread.Name)

                'Code to access a resource that is not thread safe would go here.
                'Simulate some work
                Thread.Sleep(500)

                Console.WriteLine("{0} exiting lock", Thread.CurrentThread.Name)

                'Release the lock
                Interlocked.Exchange(usingResource, 0)
                Return True
            Else
                Console.WriteLine("   {0} was denied the lock", Thread.CurrentThread.Name)
                Return False
            End If
        End Function 
    End Class 
End Namespace

Vedi anche

Si applica a

Exchange(Int16, Int16)

Imposta un intero senza segno a 16 bit su un valore specificato e restituisce il valore originale come operazione atomica.

public:
 static short Exchange(short % location1, short value);
public static short Exchange (ref short location1, short value);
static member Exchange : int16 * int16 -> int16
Public Shared Function Exchange (ByRef location1 As Short, value As Short) As Short

Parametri

location1
Int16

Variabile da impostare sul valore specificato.

value
Int16

Valore a cui è impostato il parametro location1.

Restituisce

Valore originale di location1.

Eccezioni

L'indirizzo di location1 è un puntatore null.

Si applica a

Exchange(Double, Double)

Origine:
Interlocked.cs
Origine:
Interlocked.cs
Origine:
Interlocked.cs

Imposta un numero a virgola mobile a precisione doppia su un valore specificato e restituisce il valore originale, come operazione atomica.

public:
 static double Exchange(double % location1, double value);
public static double Exchange (ref double location1, double value);
static member Exchange : double * double -> double
Public Shared Function Exchange (ByRef location1 As Double, value As Double) As Double

Parametri

location1
Double

Variabile da impostare sul valore specificato.

value
Double

Valore a cui è impostato il parametro location1.

Restituisce

Valore originale di location1.

Eccezioni

L'indirizzo di location1 è un puntatore null.

Vedi anche

Si applica a

Exchange(Object, Object)

Origine:
Interlocked.cs
Origine:
Interlocked.cs
Origine:
Interlocked.CoreCLR.cs

Imposta un oggetto su un valore specificato e restituisce un riferimento all'oggetto originale, come operazione atomica.

public:
 static System::Object ^ Exchange(System::Object ^ % location1, System::Object ^ value);
public static object Exchange (ref object location1, object value);
public static object? Exchange (ref object? location1, object? value);
static member Exchange : obj * obj -> obj
Public Shared Function Exchange (ByRef location1 As Object, value As Object) As Object

Parametri

location1
Object

Variabile da impostare sul valore specificato.

value
Object

Valore a cui è impostato il parametro location1.

Restituisce

Valore originale di location1.

Eccezioni

L'indirizzo di location1 è un puntatore null.

L'indirizzo di location1 è un puntatore null.

Commenti

Importante

A partire da .NET Framework 2.0, l'overload del metodo Exchange<T>(T, T) fornisce un'alternativa indipendente dai tipi di riferimento. È consigliabile chiamarla invece di questo overload.

Vedi anche

Si applica a

Exchange<T>(T, T)

Origine:
Interlocked.CoreCLR.cs
Origine:
Interlocked.CoreCLR.cs
Origine:
Interlocked.CoreCLR.cs

Imposta una variabile del tipo specificato T su un valore specificato e restituisce il valore originale, come operazione atomica.

public:
generic <typename T>
 where T : class static T Exchange(T % location1, T value);
public static T Exchange<T> (ref T location1, T value) where T : class;
[System.Runtime.InteropServices.ComVisible(false)]
public static T Exchange<T> (ref T location1, T value) where T : class;
static member Exchange : 'T * 'T -> 'T (requires 'T : null)
[<System.Runtime.InteropServices.ComVisible(false)>]
static member Exchange : 'T * 'T -> 'T (requires 'T : null)
Public Shared Function Exchange(Of T As Class) (ByRef location1 As T, value As T) As T

Parametri di tipo

T

Tipo da utilizzare per location1 e value. Questo tipo deve essere un tipo riferimento.

Parametri

location1
T

Variabile da impostare sul valore specificato. Si tratta di un parametro di riferimento (ref in C#, ByRef in Visual Basic).

value
T

Valore a cui è impostato il parametro location1.

Restituisce

T

Valore originale di location1.

Attributi

Eccezioni

L'indirizzo di location1 è un puntatore null.

Viene specificato un T non supportato.

Commenti

Questo metodo supporta solo i tipi riferimento. Esistono overload del metodo Exchange per i tipi di valore Int32, Int64, IntPtr, Singlee Double , ma non è disponibile alcun supporto per altri tipi di valore.

Nota

Questo overload del metodo è preferibile all'overload del metodo Exchange(Object, Object), perché quest'ultimo richiede l'accesso con associazione tardiva all'oggetto di destinazione .

Si applica a