BitVector32 (Estructura) (System.Collections.Specialized)

Cambiar vista

Contraer todo

Filtro de lenguage

Esta página es específica de

Microsoft Visual Studio 2005/.NET Framework 2.0

Hay además otras versiones disponibles para:

Microsoft Visual Studio 2008/.NET Framework 3.5

Biblioteca de clases de .NET Framework

BitVector32 (Estructura)

Proporciona una estructura simple que almacena valores booleanos y pequeños enteros en 32 bits de memoria.

Espacio de nombres: System.Collections.Specialized
Ensamblado: System (en system.dll)

Sintaxis

Visual Basic (Declaración)

Public Structure BitVector32

Visual Basic (Uso)

Dim instance As BitVector32

public struct BitVector32

C++

public value class BitVector32

public final class BitVector32 extends ValueType

JScript

JScript admite el uso de estructuras, pero no admite la declaración de estructuras nuevas.

Comentarios

BitVector32 es más eficaz que BitArray con los valores booleanos y los pequeños enteros que se usan internamente. BitArray puede aumentar indefinidamente según se necesite, pero tiene la memoria y el rendimiento adicionales que requiere una instancia de clase. En cambio, BitVector32 sólo usa 32 bits.

Una estructura BitVector32 puede configurarse para contener secciones de pequeños enteros o bien indicadores de bits para booleanos, pero no los dos al mismo tiempo. Una estructura BitVector32.Section es una ventana dentro de la estructura BitVector32 y se compone del menor número de bits consecutivos que pueden contener el valor máximo especificado en el método CreateSection. Por ejemplo, una sección con un valor máximo de 1 se compone de un solo bit, mientras que una sección con un valor máximo de 5 se compone de tres bits. Se puede crear una estructura BitVector32.Section con un valor máximo de 1 para servir de valor booleano, con lo que se permite el almacenamiento de valores enteros y booleanos en la misma estructura BitVector32.

Algunos miembros pueden utilizarse en BitVector32, que está configurado en secciones, mientras que otros miembros pueden utilizarse en un vector que esté configurado en indicadores de bits. Por ejemplo, la propiedad BitVector32.Item es el indizador para una estructura BitVector32 que está configurada en secciones, y la propiedad BitVector32.Item es el indizador para una estructura BitVector32 que está configurada en indicadores de bits. El método CreateMask crea una serie de máscaras que pueden utilizarse para obtener acceso a los bits individuales de una estructura BitVector32 que esté configurada en indicadores de bits.

Utilizar una máscara en BitVector32, que está configurado en secciones, puede dar lugar a resultados inesperados.

Ejemplo

En el siguiente ejemplo de código se utiliza BitVector32 como una colección de indicadores de bit.

Visual Basic

Imports System
Imports System.Collections.Specialized

Public Class SamplesBitVector32

   Public Shared Sub Main()

      ' Creates and initializes a BitVector32 with all bit flags set to FALSE.
      Dim myBV As New BitVector32(0)

      ' Creates masks to isolate each of the first five bit flags.
      Dim myBit1 As Integer = BitVector32.CreateMask()
      Dim myBit2 As Integer = BitVector32.CreateMask(myBit1)
      Dim myBit3 As Integer = BitVector32.CreateMask(myBit2)
      Dim myBit4 As Integer = BitVector32.CreateMask(myBit3)
      Dim myBit5 As Integer = BitVector32.CreateMask(myBit4)

      ' Sets the alternating bits to TRUE.
      Console.WriteLine("Setting alternating bits to TRUE:")
      Console.WriteLine("   Initial:         {0}", myBV.ToString())
      myBV(myBit1) = True
      Console.WriteLine("   myBit1 = TRUE:   {0}", myBV.ToString())
      myBV(myBit3) = True
      Console.WriteLine("   myBit3 = TRUE:   {0}", myBV.ToString())
      myBV(myBit5) = True
      Console.WriteLine("   myBit5 = TRUE:   {0}", myBV.ToString())
   End Sub 'Main 
End Class 'SamplesBitVector32


' This code produces the following output.
'
' Setting alternating bits to TRUE:
'    Initial:         BitVector32{00000000000000000000000000000000}
'    myBit1 = TRUE:   BitVector32{00000000000000000000000000000001}
'    myBit3 = TRUE:   BitVector32{00000000000000000000000000000101}
'    myBit5 = TRUE:   BitVector32{00000000000000000000000000010101}

using System;
using System.Collections.Specialized;


public class SamplesBitVector32  {

   public static void Main()  {

      // Creates and initializes a BitVector32 with all bit flags set to FALSE.
      BitVector32 myBV = new BitVector32( 0 );

      // Creates masks to isolate each of the first five bit flags.
      int myBit1 = BitVector32.CreateMask();
      int myBit2 = BitVector32.CreateMask( myBit1 );
      int myBit3 = BitVector32.CreateMask( myBit2 );
      int myBit4 = BitVector32.CreateMask( myBit3 );
      int myBit5 = BitVector32.CreateMask( myBit4 );

      // Sets the alternating bits to TRUE.
      Console.WriteLine( "Setting alternating bits to TRUE:" );
      Console.WriteLine( "   Initial:         {0}", myBV.ToString() );
      myBV[myBit1] = true;
      Console.WriteLine( "   myBit1 = TRUE:   {0}", myBV.ToString() );
      myBV[myBit3] = true;
      Console.WriteLine( "   myBit3 = TRUE:   {0}", myBV.ToString() );
      myBV[myBit5] = true;
      Console.WriteLine( "   myBit5 = TRUE:   {0}", myBV.ToString() );

   }

}

/*
This code produces the following output.

Setting alternating bits to TRUE:
   Initial:         BitVector32{00000000000000000000000000000000}
   myBit1 = TRUE:   BitVector32{00000000000000000000000000000001}
   myBit3 = TRUE:   BitVector32{00000000000000000000000000000101}
   myBit5 = TRUE:   BitVector32{00000000000000000000000000010101}


*/

C++

#using <system.dll>

using namespace System;
using namespace System::Collections::Specialized;
int main()
{
   
   // Creates and initializes a BitVector32 with all bit flags set to FALSE.
   BitVector32 myBV(0);
   
   // Creates masks to isolate each of the first five bit flags.
   int myBit1 = BitVector32::CreateMask();
   int myBit2 = BitVector32::CreateMask( myBit1 );
   int myBit3 = BitVector32::CreateMask( myBit2 );
   int myBit4 = BitVector32::CreateMask( myBit3 );
   int myBit5 = BitVector32::CreateMask( myBit4 );
   
   // Sets the alternating bits to TRUE.
   Console::WriteLine( "Setting alternating bits to TRUE:" );
   Console::WriteLine( "   Initial:       {0}", myBV );
   myBV[ myBit1 ] = true;
   Console::WriteLine( "   myBit1 = TRUE: {0}", myBV );
   myBV[ myBit3 ] = true;
   Console::WriteLine( "   myBit3 = TRUE: {0}", myBV );
   myBV[ myBit5 ] = true;
   Console::WriteLine( "   myBit5 = TRUE: {0}", myBV );
}

/*
This code produces the following output.

Setting alternating bits to TRUE:
Initial:         BitVector32 {00000000000000000000000000000000}
myBit1 = TRUE:   BitVector32 {00000000000000000000000000000001}
myBit3 = TRUE:   BitVector32 {00000000000000000000000000000101}
myBit5 = TRUE:   BitVector32 {00000000000000000000000000010101}


*/

import System.*;
import System.Collections.Specialized.*;

public class SamplesBitVector32
{
    public static void main(String[] args)
    {
        // Creates and initializes a BitVector32 with all bit flags set to FALSE.
        BitVector32 myBV = new BitVector32(0);
      
        // Creates masks to isolate each of the first five bit flags.
        int myBit1 = BitVector32.CreateMask();
        int myBit2 = BitVector32.CreateMask(myBit1);
        int myBit3 = BitVector32.CreateMask(myBit2);
        int myBit4 = BitVector32.CreateMask(myBit3);
        int myBit5 = BitVector32.CreateMask(myBit4);
          
        // Sets the alternating bits to TRUE.
        Console.WriteLine("Setting alternating bits to TRUE:");
        Console.WriteLine("   Initial:         {0}", myBV.ToString());
        myBV.set_Item(myBit1, true);
        Console.WriteLine("   myBit1 = TRUE:   {0}", myBV.ToString());
        myBV.set_Item(myBit3, true);
        Console.WriteLine("   myBit3 = TRUE:   {0}", myBV.ToString());
        myBV.set_Item(myBit5, true);
        Console.WriteLine("   myBit5 = TRUE:   {0}", myBV.ToString());
    } //main
} //SamplesBitVector32

/*
This code produces the following output.

Setting alternating bits to TRUE:
   Initial:         BitVector32{00000000000000000000000000000000}
   myBit1 = TRUE:   BitVector32{00000000000000000000000000000001}
   myBit3 = TRUE:   BitVector32{00000000000000000000000000000101}
   myBit5 = TRUE:   BitVector32{00000000000000000000000000010101}


*/

En el siguiente ejemplo de código se utiliza BitVector32 como una colección de secciones.

Visual Basic

Imports System
Imports System.Collections.Specialized

Public Class SamplesBitVector32
   
   Public Shared Sub Main()
      
      ' Creates and initializes a BitVector32.
      Dim myBV As New BitVector32(0)
      
      ' Creates four sections in the BitVector32 with maximum values 6, 3, 1, and 15.
      ' mySect3, which uses exactly one bit, can also be used as a bit flag.
      Dim mySect1 As BitVector32.Section = BitVector32.CreateSection(6)
      Dim mySect2 As BitVector32.Section = BitVector32.CreateSection(3, mySect1)
      Dim mySect3 As BitVector32.Section = BitVector32.CreateSection(1, mySect2)
      Dim mySect4 As BitVector32.Section = BitVector32.CreateSection(15, mySect3)
      
      ' Displays the values of the sections.
      Console.WriteLine("Initial values:")
      Console.WriteLine(ControlChars.Tab + "mySect1: {0}", myBV(mySect1))
      Console.WriteLine(ControlChars.Tab + "mySect2: {0}", myBV(mySect2))
      Console.WriteLine(ControlChars.Tab + "mySect3: {0}", myBV(mySect3))
      Console.WriteLine(ControlChars.Tab + "mySect4: {0}", myBV(mySect4))
      
      ' Sets each section to a new value and displays the value of the BitVector32 at each step.
      Console.WriteLine("Changing the values of each section:")
      Console.WriteLine(ControlChars.Tab + "Initial:    " + ControlChars.Tab + "{0}", myBV.ToString())
      myBV(mySect1) = 5
      Console.WriteLine(ControlChars.Tab + "mySect1 = 5:" + ControlChars.Tab + "{0}", myBV.ToString())
      myBV(mySect2) = 3
      Console.WriteLine(ControlChars.Tab + "mySect2 = 3:" + ControlChars.Tab + "{0}", myBV.ToString())
      myBV(mySect3) = 1
      Console.WriteLine(ControlChars.Tab + "mySect3 = 1:" + ControlChars.Tab + "{0}", myBV.ToString())
      myBV(mySect4) = 9
      Console.WriteLine(ControlChars.Tab + "mySect4 = 9:" + ControlChars.Tab + "{0}", myBV.ToString())
      
      ' Displays the values of the sections.
      Console.WriteLine("New values:")
      Console.WriteLine(ControlChars.Tab + "mySect1: {0}", myBV(mySect1))
      Console.WriteLine(ControlChars.Tab + "mySect2: {0}", myBV(mySect2))
      Console.WriteLine(ControlChars.Tab + "mySect3: {0}", myBV(mySect3))
      Console.WriteLine(ControlChars.Tab + "mySect4: {0}", myBV(mySect4))

   End Sub 'Main 

End Class 'SamplesBitVector32


' This code produces the following output.
'
' Initial values:
'        mySect1: 0
'        mySect2: 0
'        mySect3: 0
'        mySect4: 0
' Changing the values of each section:
'        Initial:        BitVector32{00000000000000000000000000000000}
'        mySect1 = 5:    BitVector32{00000000000000000000000000000101}
'        mySect2 = 3:    BitVector32{00000000000000000000000000011101}
'        mySect3 = 1:    BitVector32{00000000000000000000000000111101}
'        mySect4 = 9:    BitVector32{00000000000000000000001001111101}
' New values:
'        mySect1: 5
'        mySect2: 3
'        mySect3: 1
'        mySect4: 9

using System;
using System.Collections.Specialized;


public class SamplesBitVector32  {

   public static void Main()  {

      // Creates and initializes a BitVector32.
      BitVector32 myBV = new BitVector32( 0 );

      // Creates four sections in the BitVector32 with maximum values 6, 3, 1, and 15.
      // mySect3, which uses exactly one bit, can also be used as a bit flag.
      BitVector32.Section mySect1 = BitVector32.CreateSection( 6 );
      BitVector32.Section mySect2 = BitVector32.CreateSection( 3, mySect1 );
      BitVector32.Section mySect3 = BitVector32.CreateSection( 1, mySect2 );
      BitVector32.Section mySect4 = BitVector32.CreateSection( 15, mySect3 );

      // Displays the values of the sections.
      Console.WriteLine( "Initial values:" );
      Console.WriteLine( "\tmySect1: {0}", myBV[mySect1] );
      Console.WriteLine( "\tmySect2: {0}", myBV[mySect2] );
      Console.WriteLine( "\tmySect3: {0}", myBV[mySect3] );
      Console.WriteLine( "\tmySect4: {0}", myBV[mySect4] );

      // Sets each section to a new value and displays the value of the BitVector32 at each step.
      Console.WriteLine( "Changing the values of each section:" );
      Console.WriteLine( "\tInitial:    \t{0}", myBV.ToString() );
      myBV[mySect1] = 5;
      Console.WriteLine( "\tmySect1 = 5:\t{0}", myBV.ToString() );
      myBV[mySect2] = 3;
      Console.WriteLine( "\tmySect2 = 3:\t{0}", myBV.ToString() );
      myBV[mySect3] = 1;
      Console.WriteLine( "\tmySect3 = 1:\t{0}", myBV.ToString() );
      myBV[mySect4] = 9;
      Console.WriteLine( "\tmySect4 = 9:\t{0}", myBV.ToString() );

      // Displays the values of the sections.
      Console.WriteLine( "New values:" );
      Console.WriteLine( "\tmySect1: {0}", myBV[mySect1] );
      Console.WriteLine( "\tmySect2: {0}", myBV[mySect2] );
      Console.WriteLine( "\tmySect3: {0}", myBV[mySect3] );
      Console.WriteLine( "\tmySect4: {0}", myBV[mySect4] );

   }

}

/*
This code produces the following output.

Initial values:
        mySect1: 0
        mySect2: 0
        mySect3: 0
        mySect4: 0
Changing the values of each section:
        Initial:        BitVector32{00000000000000000000000000000000}
        mySect1 = 5:    BitVector32{00000000000000000000000000000101}
        mySect2 = 3:    BitVector32{00000000000000000000000000011101}
        mySect3 = 1:    BitVector32{00000000000000000000000000111101}
        mySect4 = 9:    BitVector32{00000000000000000000001001111101}
New values:
        mySect1: 5
        mySect2: 3
        mySect3: 1
        mySect4: 9

*/

C++

#using <system.dll>

using namespace System;
using namespace System::Collections::Specialized;

int main()
{
   // Creates and initializes a BitVector32.
   BitVector32 myBV(0);

   // Creates four sections in the BitVector32 with maximum values 6, 3, 1, and 15.
   // mySect3, which uses exactly one bit, can also be used as a bit flag.
   BitVector32::Section mySect1 = BitVector32::CreateSection( 6 );
   BitVector32::Section mySect2 = BitVector32::CreateSection( 3, mySect1 );
   BitVector32::Section mySect3 = BitVector32::CreateSection( 1, mySect2 );
   BitVector32::Section mySect4 = BitVector32::CreateSection( 15, mySect3 );

   // Displays the values of the sections.
   Console::WriteLine( "Initial values:" );
   Console::WriteLine( "\tmySect1: {0}", myBV[ mySect1 ] );
   Console::WriteLine( "\tmySect2: {0}", myBV[ mySect2 ] );
   Console::WriteLine( "\tmySect3: {0}", myBV[ mySect3 ] );
   Console::WriteLine( "\tmySect4: {0}", myBV[ mySect4 ] );

   // Sets each section to a new value and displays the value of the BitVector32 at each step.
   Console::WriteLine( "Changing the values of each section:" );
   Console::WriteLine( "\tInitial:    \t {0}", myBV );
   myBV[ mySect1 ] = 5;
   Console::WriteLine( "\tmySect1 = 5:\t {0}", myBV );
   myBV[ mySect2 ] = 3;
   Console::WriteLine( "\tmySect2 = 3:\t {0}", myBV );
   myBV[ mySect3 ] = 1;
   Console::WriteLine( "\tmySect3 = 1:\t {0}", myBV );
   myBV[ mySect4 ] = 9;
   Console::WriteLine( "\tmySect4 = 9:\t {0}", myBV );

   // Displays the values of the sections.
   Console::WriteLine( "New values:" );
   Console::WriteLine( "\tmySect1: {0}", myBV[ mySect1 ] );
   Console::WriteLine( "\tmySect2: {0}", myBV[ mySect2 ] );
   Console::WriteLine( "\tmySect3: {0}", myBV[ mySect3 ] );
   Console::WriteLine( "\tmySect4: {0}", myBV[ mySect4 ] );
}

/*
This code produces the following output.

Initial values:
        mySect1: 0
        mySect2: 0
        mySect3: 0
        mySect4: 0
Changing the values of each section:
        Initial:        BitVector32 {00000000000000000000000000000000}
        mySect1 = 5:    BitVector32 {00000000000000000000000000000101}
        mySect2 = 3:    BitVector32 {00000000000000000000000000011101}
        mySect3 = 1:    BitVector32 {00000000000000000000000000111101}
        mySect4 = 9:    BitVector32 {00000000000000000000001001111101}
New values:
        mySect1: 5
        mySect2: 3
        mySect3: 1
        mySect4: 9

*/

import System.*;
import System.Collections.Specialized.*;

public class SamplesBitVector32
{
    public static void main(String[] args)
    {
        // Creates and initializes a BitVector32.
        BitVector32 myBV = new BitVector32(0);
      
        // Creates four sections in the BitVector32 with maximum values 
        // 6, 3, 1, and 15. mySect3, which uses exactly one bit, 
        // can also be used as a bit flag.
        BitVector32.Section mySect1 = BitVector32.CreateSection((short)6);
        BitVector32.Section mySect2 = 
            BitVector32.CreateSection((short)3, mySect1);
        BitVector32.Section mySect3 = 
            BitVector32.CreateSection((short)1, mySect2);
        BitVector32.Section mySect4 = 
            BitVector32.CreateSection((short)15, mySect3);
          
        // Displays the values of the sections.
        Console.WriteLine("Initial values:");
        Console.WriteLine("\tmySect1: {0}", 
            System.Convert.ToString(myBV .get_Item( mySect1)));
        Console.WriteLine("\tmySect2: {0}", 
            System.Convert.ToString(myBV.get_Item( mySect2)));
        Console.WriteLine("\tmySect3: {0}", 
            System.Convert.ToString(myBV.get_Item(mySect3)));
        Console.WriteLine("\tmySect4: {0}", 
            System.Convert.ToString(myBV.get_Item(mySect4)));
          
        // Sets each section to a new value and displays the value of the
        // BitVector32 at each step.
        Console.WriteLine("Changing the values of each section:");
        Console.WriteLine("\tInitial:    \t{0}", myBV.ToString());
        myBV.set_Item(mySect1 , 5);
        Console.WriteLine("\tmySect1 = 5:\t{0}", myBV.ToString());
        myBV.set_Item(mySect2 , 3);
        Console.WriteLine("\tmySect2 = 3:\t{0}", myBV.ToString());
        myBV.set_Item(mySect3 , 1);
        Console.WriteLine("\tmySect3 = 1:\t{0}", myBV.ToString());
        myBV.set_Item(mySect4 , 9);
        Console.WriteLine("\tmySect4 = 9:\t{0}", myBV.ToString());
          
        // Displays the values of the sections.
        Console.WriteLine("New values:");
        Console.WriteLine("\tmySect1: {0}", 
            System.Convert.ToString(myBV.get_Item( mySect1)));
        Console.WriteLine("\tmySect2: {0}", 
            System.Convert.ToString(myBV.get_Item(mySect2)));
        Console.WriteLine("\tmySect3: {0}", 
            System.Convert.ToString(myBV.get_Item(mySect3)));
        Console.WriteLine("\tmySect4: {0}", 
            System.Convert.ToString(myBV.get_Item(mySect4)));
    } //main
} //SamplesBitVector32

/*
This code produces the following output.

Initial values:
        mySect1: 0
        mySect2: 0
        mySect3: 0
        mySect4: 0
Changing the values of each section:
        Initial:        BitVector32{00000000000000000000000000000000}
        mySect1 = 5:    BitVector32{00000000000000000000000000000101}
        mySect2 = 3:    BitVector32{00000000000000000000000000011101}
        mySect3 = 1:    BitVector32{00000000000000000000000000111101}
        mySect4 = 9:    BitVector32{00000000000000000000001001111101}
New values:
        mySect1: 5
        mySect2: 3
        mySect3: 1
        mySect4: 9

*/

Seguridad para subprocesos

Los miembros estáticos públicos (Shared en Visual Basic) de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Plataformas

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium, Windows Mobile para Pocket PC, Windows Mobile para Smartphone, Windows Server 2003, Windows XP Media Center, Windows XP Professional x64, Windows XP SP2, Windows XP Starter Edition

.NET Framework no admite todas las versiones de cada plataforma. Para obtener una lista de las versiones admitidas, vea Requisitos del sistema.

Información de versión

.NET Framework

Compatible con: 2.0, 1.1, 1.0

.NET Compact Framework

Compatible con: 2.0, 1.0

Vea también

Referencia

BitVector32 (Miembros)
System.Collections.Specialized (Espacio de nombres)
BitArray (Clase)

Etiquetas

: Agregar una etiqueta

Contenido de la comunidad

Agregar contenido nuevo

Anotaciones

Administre su perfil | MSDN Flash en Español | Contacto | Aviso legal