Compartir a través de


VarEnum Enumeración

Definición

Precaución

Marshalling VARIANTs may be unavailable in future releases.

Indica cómo calcular las referencias de los elementos de matriz cuando se calculan las referencias de matriz de código administrado a código no administrado como SafeArray.

public enum class VarEnum
[System.Obsolete("Marshalling VARIANTs may be unavailable in future releases.")]
public enum VarEnum
public enum VarEnum
[System.Serializable]
public enum VarEnum
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public enum VarEnum
[<System.Obsolete("Marshalling VARIANTs may be unavailable in future releases.")>]
type VarEnum = 
type VarEnum = 
[<System.Serializable>]
type VarEnum = 
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type VarEnum = 
Public Enum VarEnum
Herencia
Atributos

Campos

VT_ARRAY 8192

Indica un puntero SAFEARRAY.

VT_BLOB 65

Indica la longitud de los bytes con prefijo.

VT_BLOB_OBJECT 70

Indica que un objeto binario contiene un objeto.

VT_BOOL 11

Indica un valor booleano.

VT_BSTR 8

Indica una cadena BSTR.

VT_BYREF 16384

Indica que un valor es una referencia.

VT_CARRAY 28

Indica una matriz de estilo C.

VT_CF 71

Indica el formato del portapapeles.

VT_CLSID 72

Indica un Id. de clase.

VT_CY 6

Indica un valor de moneda.

VT_DATE 7

Indica un valor DATE.

VT_DECIMAL 14

Indica un valor decimal.

VT_DISPATCH 9

Indica un puntero IDispatch.

VT_EMPTY 0

Indica que no se ha especificado un valor.

VT_ERROR 10

Indica un SCODE.

VT_FILETIME 64

Indica un valor de FILETIME.

VT_HRESULT 25

Indica un HRESULT.

VT_I1 16

Indica un valor char.

VT_I2 2

Indica un entero short.

VT_I4 3

Indica un entero long.

VT_I8 20

Indica un entero de 64 bits.

VT_INT 22

Indica un valor entero.

VT_LPSTR 30

Indica una cadena terminada en un carácter null.

VT_LPWSTR 31

Indica una cadena grande terminada en null.

VT_NULL 1

Indica un valor nulo; similar a un valor nulo en SQL.

VT_PTR 26

Indica un tipo de puntero.

VT_R4 4

Indica un valor float.

VT_R8 5

Indica un valor double.

VT_RECORD 36

Indica un tipo definido por el usuario.

VT_SAFEARRAY 27

Indica una SAFEARRAY. No es válida en un tipo VARIANT.

VT_STORAGE 67

Indica que continúa el nombre de un almacenamiento.

VT_STORED_OBJECT 69

Indica que un almacenamiento contiene un objeto.

VT_STREAM 66

Indica que continúa el nombre de una secuencia.

VT_STREAMED_OBJECT 68

Indica que una secuencia contiene un objeto.

VT_UI1 17

Indica un byte.

VT_UI2 18

Indica un unsignedshort.

VT_UI4 19

Indica un unsignedlong.

VT_UI8 21

Indica un entero de 64 bits sin signo.

VT_UINT 23

Indica un valor entero unsigned.

VT_UNKNOWN 13

Indica un puntero IUnknown.

VT_USERDEFINED 29

Indica un tipo definido por el usuario.

VT_VARIANT 12

Indica un puntero far VARIANT.

VT_VECTOR 4096

Indica una matriz simple y contada.

VT_VOID 24

Indica una matriz void de estilo C.

Ejemplos

using namespace System;
using namespace System::Runtime::InteropServices;

// If you do not have a type library for an interface
// you can redeclare it using ComImportAttribute.
// This is how the interface would look in an idl file.
//[
//object,
//uuid("73EB4AF8-BE9C-4b49-B3A4-24F4FF657B26"),
//dual, helpstring("IMyStorage Interface"),
//pointer_default(unique)
//]
//interface IMyStorage : IDispatch
//{
// [id(1)]
// HRESULT GetItem([in] BSTR bstrName, [out, retval] IDispatch ** ppItem);
// [id(2)]
// HRESULT GetItems([in] BSTR bstrLocation, [out] SAFEARRAY(VARIANT)* pItems);
// [id(3)]
// HRESULT GetItemDescriptions([in] BSTR bstrLocation, [out] SAFEARRAY(VARIANT) ** ppItems);
// [id(4), propget]
// HRESULT get_IsEmpty([out, retval] BOOL * pfEmpty);
//};
// This is the managed declaration.

[ComImport]
[Guid("73EB4AF8-BE9C-4b49-B3A4-24F4FF657B26")]
interface class IMyStorage
{
   [DispId(1)]
   Object^ GetItem( [In,MarshalAs(UnmanagedType::BStr)]String^ bstrName );

   //[return : MarshalAs(UnmanagedType::Interface)]

   [DispId(2)]
   void GetItems( [In,MarshalAs(UnmanagedType::BStr)]String^ bstrLocation, [Out,MarshalAs(UnmanagedType::SafeArray,
   SafeArraySubType=VarEnum::VT_VARIANT)]array<Object^>^Items );

   [DispId(3)]
   void GetItemDescriptions( [In]String^ bstrLocation, [In,Out,MarshalAs(UnmanagedType::SafeArray)]array<Object^>^varDescriptions );

   property bool IsEmpty 
   {
      [DispId(4)]
      [returnvalue:MarshalAs(UnmanagedType::VariantBool)]
      bool get();
   }
};
using System;
using System.Runtime.InteropServices;

namespace MyModule
{
    // If you do not have a type library for an interface
    // you can redeclare it using ComImportAttribute.

    // This is how the interface would look in an idl file.

    //[
    //object,
    //uuid("73EB4AF8-BE9C-4b49-B3A4-24F4FF657B26"),
    //dual,	helpstring("IMyStorage Interface"),
    //pointer_default(unique)
    //]
    //interface IMyStorage : IDispatch
    //{
    //	[id(1)]
    //	HRESULT GetItem([in] BSTR bstrName, [out, retval] IDispatch ** ppItem);
    //	[id(2)]
    //	HRESULT GetItems([in] BSTR bstrLocation, [out] SAFEARRAY(VARIANT)* pItems);
    //	[id(3)]
    //	HRESULT GetItemDescriptions([in] BSTR bstrLocation, [out] SAFEARRAY(VARIANT) ** ppItems);
    //	[id(4), propget]
    //	HRESULT get_IsEmpty([out, retval] BOOL * pfEmpty);
    //};

    // This is the managed declaration.

    [ComImport]
    [Guid("73EB4AF8-BE9C-4b49-B3A4-24F4FF657B26")]
    public interface IMyStorage
    {
        [DispId(1)]
        [return: MarshalAs(UnmanagedType.Interface)]
        object GetItem([In, MarshalAs(UnmanagedType.BStr)] String bstrName);

        [DispId(2)]
        void GetItems([In, MarshalAs(UnmanagedType.BStr)] String bstrLocation,
            [Out, MarshalAs( UnmanagedType.SafeArray,
                      SafeArraySubType = VarEnum.VT_VARIANT )] out Object[] Items);

        [DispId(3)]
        void GetItemDescriptions([In] String bstrLocation,
            [In, Out, MarshalAs(UnmanagedType.SafeArray)] ref Object[] varDescriptions);

        bool IsEmpty
        {
            [DispId(4)]
            [return: MarshalAs(UnmanagedType.VariantBool)]
            get;
        }
    }
}
Imports System.Runtime.InteropServices

Module MyModule
    ' If you do not have a type library for an interface
    ' you can redeclare it using ComImportAttribute.

    ' This is how the interface would look in an idl file.

    '[
    'object,
    'uuid("73EB4AF8-BE9C-4b49-B3A4-24F4FF657B26"),
    'dual,	helpstring("IMyStorage Interface"),
    'pointer_default(unique)
    ']
    'interface IMyStorage : IDispatch
    '{
    '	[id(1)]
    '	HRESULT GetItem([in] BSTR bstrName, [out, retval] IDispatch ** ppItem);
    '	[id(2)]
    '	HRESULT GetItems([in] BSTR bstrLocation, [out] SAFEARRAY(VARIANT)* pItems);
    '	[id(3)]
    '	HRESULT GetItemDescriptions([in] BSTR bstrLocation, [out] SAFEARRAY(VARIANT) ** ppItems);
    '	[id(4), propget]
    '	HRESULT get_IsEmpty([out, retval] BOOL * pfEmpty);
    '};

    ' This is the managed declaration.

    <ComImport(), Guid("73EB4AF8-BE9C-4b49-B3A4-24F4FF657B26")> _
    Public Interface IMyStorage
        <DispId(1)> _
        Function GetItem(<InAttribute(), MarshalAs(UnmanagedType.BStr)> ByVal bstrName As String) _
           As <MarshalAs(UnmanagedType.Interface)> Object

        <DispId(2)> _
        Function GetItems(<InAttribute(), MarshalAs(UnmanagedType.BStr)> ByVal bstrLocation As String, _
           <OutAttribute(), MarshalAs(UnmanagedType.SafeArray, SafeArraySubType := VarEnum.VT_VARIANT)> _
                                      ByVal Items() As Object)

        <DispId(3)> _
        Function GetItemDescriptions(<InAttribute()> ByVal bstrLocation As String, _
           <InAttribute(), OutAttribute(), _
                      MarshalAs(UnmanagedType.SafeArray)> ByRef varDescriptions() As Object)

        <DispId(4)> _
        ReadOnly Property IsEmpty(<MarshalAs(UnmanagedType.VariantBool)> ByVal bEmpty As Boolean)

    End Interface
End Module

Comentarios

Se usa con System.Runtime.InteropServices.MarshalAsAttribute para controlar explícitamente el tipo de elemento de SafeArray.

Se aplica a

Consulte también