Introduzione a Microsoft Interface Definition Language 3.0Introduction to Microsoft Interface Definition Language 3.0

Microsoft Interface Definition Language (MIDL) 3,0 è una sintassi semplificata e moderna per la definizione di tipi di Windows Runtime all'interno di file IDL (Interface Definition Language) .idl .Microsoft Interface Definition Language (MIDL) 3.0 is a simplified, modern syntax for defining Windows Runtime types inside Interface Definition Language (IDL) files (.idl files). Questa nuova sintassi risulterà familiare a chiunque abbia sperimentato C, C++, C# e/o Java.This new syntax will feel familiar to anyone experienced with C, C++, C#, and/or Java. MIDL 3,0 è un modo particolarmente pratico per definire le classi di runtime C++/WinRT , che è notevolmente più conciso rispetto alle versioni precedenti di IDL (riducendo i progetti di due terzi e usando impostazioni predefinite ragionevoli per ridurre la necessità di decorare con gli attributi).MIDL 3.0 is a particularly convenient way to define C++/WinRT runtime classes, being dramatically more concise than previous versions of IDL (reducing designs by two thirds in length, and using reasonable defaults to reduce the need for decorating with attributes).

Ecco il modo in cui MIDL 3,0 sembra. in questo esempio viene illustrata la maggior parte degli elementi della sintassi del linguaggio che probabilmente verranno utilizzati.Here's how MIDL 3.0 looks; this example demonstrates most of the language syntax elements that you'll likely use.

// Photo.idl
namespace PhotoEditor
{
    delegate void RecognitionHandler(Boolean arg); // delegate type, for an event.

    runtimeclass Photo : Windows.UI.Xaml.Data.INotifyPropertyChanged // interface.
    {
        Photo(); // constructors.
        Photo(Windows.Storage.StorageFile imageFile);

        String ImageName{ get; }; // read-only property.
        Single SepiaIntensity; // read-write property.

        Windows.Foundation.IAsyncAction StartRecognitionAsync(); // (asynchronous) method.

        event RecognitionHandler ImageRecognized; // event.
    }
}

Si noti che la sintassi di MIDL 3,0 è specificamente progettata per la definizione dei tipi.Note that the syntax of MIDL 3.0 is specifically and solely designed for defining types. Per implementare tali tipi verrà usato un linguaggio di programmazione diverso.You'll use a different programming language to implement those types. Per usare MIDL 3,0, è necessario Windows SDK versione 10.0.17134.0 (Windows 10, versione 1803) ( midl.exe versione 8.01.0622 o successiva, usato con il /winrt Commuter).To use MIDL 3.0, you'll need Windows SDK version 10.0.17134.0 (Windows 10, version 1803) (midl.exe version 8.01.0622 or later, used with the /winrt switch).

Nota

Vedere anche Windows Runtime riferimento consolidato (il sistema di tipi di Windows Runtimee i file di metadati di Windows).Also see the Windows Runtime consolidated reference (The Windows Runtime type system, and Windows Metadata files).

MIDL 1,0, 2,0 e 3,0MIDL 1.0, 2.0, and 3.0

Il linguaggio di definizione dell'interfaccia (IDL) inizia con il sistema Distributed Computing Environment/Remote Procedure Calls (DCE/RPC).Interface Definition Language (IDL) began with the Distributed Computing Environment/Remote Procedure Calls (DCE/RPC) system. Il MIDL 1,0 originale è DCE/RPC IDL con miglioramenti per la definizione di interfacce com e coclassi.The original MIDL 1.0 is DCE/RPC IDL with enhancements for defining COM interfaces and coclasses.

Un aggiornamento della sintassi MIDL 2,0 (noto anche come MIDLRT) è stato quindi sviluppato in Microsoft per dichiarare Windows Runtime API per la piattaforma Windows.An updated MIDL 2.0 syntax (also known as MIDLRT) was then developed within Microsoft to declare Windows Runtime APIs for the Windows platform. Se si osserva la cartella Windows SDK %WindowsSdkDir%Include<WindowsTargetPlatformVersion>\winrt , verranno visualizzati esempi di .idl file scritti con la sintassi MIDL 2,0.If you look in the Windows SDK folder %WindowsSdkDir%Include<WindowsTargetPlatformVersion>\winrt then you'll see examples of .idl files that are written with the MIDL 2.0 syntax. Si tratta di API Windows Runtime predefinite, dichiarate nel formato ABI (Application Binary Interface).These are built-in Windows Runtime APIs, declared in their application binary interface (ABI) form. Questi file esistono principalmente per gli strumenti per l'uso di — queste API in questo formato, a meno che non si stia scrivendo codice di basso livello.These files exist primarily for tooling to use—you won't author nor consume these APIs in this form (unless you're writing very low-level code).

Vedere anche la pagina relativa alla transizione a MIDL 3,0 da MIDLRT classici.Also see Transition to MIDL 3.0 from classic MIDLRT.

MIDL 3,0 è una sintassi molto più semplice e moderna, il cui scopo è dichiarare Windows Runtime API.MIDL 3.0 is a much simpler and more modern syntax, whose purpose is to declare Windows Runtime APIs. Ed è possibile usarlo nei progetti, in particolare per definire classi di runtime C++/WinRT .And you can use it in your projects, particularly to define C++/WinRT runtime classes. Le intestazioni, per l'uso da C++/WinRT, per le API Windows Runtime predefinite fanno parte dell'SDK, all'interno della cartella %WindowsSdkDir%Include<WindowsTargetPlatformVersion>\cppwinrt\winrt .The headers, for use from C++/WinRT, for the built-in Windows Runtime APIs are part of the SDK, inside the folder %WindowsSdkDir%Include<WindowsTargetPlatformVersion>\cppwinrt\winrt.

Casi d'uso per MIDL 3,0Use cases for MIDL 3.0

In generale, tutte le API Windows Runtime sono progettate per essere disponibili per tutte le proiezioni di Windows Runtime linguaggio.In general, all Windows Runtime APIs are designed to be available to all Windows Runtime language projections. Questa operazione viene eseguita, in parte, scegliendo di passare in modo esclusivo i tipi di Windows Runtime da e verso Windows Runtime API.This is done, in part, by choosing to exclusively pass Windows Runtime types to and from Windows Runtime APIs. Sebbene si tratta di una decisione di progettazione valida per passare un'interfaccia COM non elaborata da e verso un'API Windows Runtime, questa operazione consente di limitare gli utenti di tale particolare Windows Runtime API alle applicazioni C++.While it is a valid design decision to pass a raw COM interface to and from a Windows Runtime API, doing so limits the consumers of that particular Windows Runtime API to C++ applications. È possibile osservare la tecnica negli scenari di interoperatività — , ad esempio, quando si interagiscono tra Direct3D e XAML.The technique can be seen in interoperation scenarios—for example, when interoperating between Direct3D and XAML. Poiché Direct3D è nell'immagine, lo scenario è necessariamente limitato alle applicazioni C++.Since Direct3D is in the picture, the scenario is necessarily narrowed to C++ applications. Quindi, un'API che richiede un'interfaccia COM non impone alcuna limitazione aggiuntiva oltre a ciò che è intrinseco.So, an API that requires a COM interface doesn't impose any additional limitation over and above what's inherent. Ad esempio, un'applicazione C++ può ottenere un puntatore a interfaccia IDXGISwapChain e quindi passarlo al Metodo ISwapChainPanelNative:: SetSwapChain.For example, a C++ application can obtain an IDXGISwapChain interface pointer, and then pass that to the ISwapChainPanelNative::SetSwapChain method. Un'applicazione C#, ad esempio, non sarebbe in grado di ottenere un IDXGISwapChain per iniziare, quindi non sarebbe in grado di usare tale metodo per questo motivo.A C# application, for example, wouldn't be able to obtain an IDXGISwapChain to begin with, so it wouldn't be able to use that method for that reason. Queste eccezioni correlate all'interoperabilità si trovano in intestazioni di interoperabilità, ad esempio windows.ui.xaml.media.dxinterop.h .These interop-related exceptions live in interop headers, such as windows.ui.xaml.media.dxinterop.h.

Se sono presenti caratteristiche o funzionalità di un componente COM che si desidera esporre per Windows Runtime proiezioni di linguaggio oltre a C++, è quindi possibile creare un componente Windows Runtime C++ (WRC) che crea e usa direttamente il componente COM (ad esempio, DirectX) ed espone una replica di alcune funzionalità e funzionalità sotto forma di una superficie API Windows Runtime che accetta e restituisce solo Windows Runtime tipi.If there are features or functionality of a COM component that you wish to expose to Windows Runtime language projections beyond C++, then you can create a C++ Windows Runtime component (WRC) that directly creates and uses the COM component (such as DirectX, for example), and exposes a replication of some subset of its features and functionality in the form of a Windows Runtime API surface that takes and returns Windows Runtime types only. È quindi possibile utilizzare tale WRC da un'applicazione scritta in qualsiasi proiezione del linguaggio Windows Runtime.You could then consume that WRC from an application written in any Windows Runtime language projection.

Struttura di definizione e chiamata di midl.exe dalla riga di comandoDefinition structure, and calling midl.exe from the command line

I concetti aziendali chiave in una definizione MIDL 3,0 sono gli spazi dei nomi, i tipi e i membri.The key organizational concepts in a MIDL 3.0 definition are namespaces, types, and members. Un file di origine MIDL 3,0 (un .idl file) contiene almeno uno spazio dei nomi, all'interno di tipi e/o spazi dei nomi subordinati.A MIDL 3.0 source file (an .idl file) contains at least one namespace, inside which are types and/or subordinate namespaces. Ogni tipo contiene zero o più membri.Each type contains zero or more members.

  • Classi, interfacce, strutture ed enumerazioni sono tipi.Classes, interfaces, structures, and enumerations are types.
  • I campi, i metodi, le proprietà e gli eventi sono esempi di membri.Fields, methods, properties, and events are examples of members.

Quando si compila un file di origine MIDL 3,0, il compilatore ( midl.exe ) genera un file di metadati di Windows Runtime (in genere un .winmd file).When you compile a MIDL 3.0 source file, the compiler (midl.exe) emits a Windows Runtime metadata file (typically a .winmd file).

// Bookstore.idl
namespace Bookstore
{
    runtimeclass BookSku : Windows.UI.Xaml.Data.INotifyPropertyChanged
    {
        BookSku();
        BookSku(Single price, String authorName, String coverImagePath, String title);

        Single Price;

        String AuthorName{ get; };
        Windows.UI.Xaml.Media.ImageSource CoverImage{ get; };
        String CoverImagePath{ get; };
        String Title{ get; };

        Boolean Equals(BookSku other);
        void ApplyDiscount(Single percentOff);
    }
}

Poiché lo spazio dei nomi di un tipo di Windows Runtime diventa parte del nome del tipo, nell'esempio precedente viene definita una classe di runtime denominata Bookstore. BookSku.Since the namespace of a Windows Runtime type becomes part of the type name, the example above defines a runtime class named Bookstore.BookSku. Non esiste alcun modo indipendente dalla lingua per esprimere BookSku senza esprimere lo spazio dei nomi.There's no language-independent way of expressing BookSku without also expressing the namespace.

Questa classe implementa l'interfaccia Windows. UI. XAML. Data. INotifyPropertyChanged .This class implements the Windows.UI.Xaml.Data.INotifyPropertyChanged interface. E la classe contiene diversi membri: due costruttori, una proprietà di lettura/scrittura (Price), alcune proprietà di sola lettura (AuthorName through title) e due metodi, denominati Equals e ApplyDiscount.And the class contains several members: two constructors, a read-write property (Price), some read-only properties (AuthorName through Title), and two methods, named Equals and ApplyDiscount. Si noti l'uso del tipo Single anziché float.Note the use of the type Single rather than float. E la stringa ha una "S" maiuscola.And that String has an upper-case "S".

Suggerimento

Visual Studio offre la migliore esperienza per la compilazione di MIDL 3,0, mediante l'estensione di Visual Studio (VSIX) C++/WinRT.Visual Studio provides the best experience for compiling MIDL 3.0, by means of the C++/WinRT Visual Studio Extension (VSIX). Vedere supporto di Visual Studio per C++/WinRT e VSIX.See Visual Studio support for C++/WinRT, and the VSIX.

Tuttavia, è anche possibile compilare MIDL 3,0 dalla riga di comando.But you can also compile MIDL 3.0 from the command line. Se il codice sorgente per questo esempio è archiviato in un file denominato Bookstore.idl , è possibile eseguire il comando seguente.If the source code for this example is stored in a file named Bookstore.idl, then you can issue the command below. Se necessario, è possibile aggiornare il numero di versione dell'SDK usato nel comando (10.0.17134.0).If necessary for your case, you can update the SDK version number used in the command (which is 10.0.17134.0).

midl /winrt /metadata_dir "%WindowsSdkDir%References\10.0.17134.0\windows.foundation.foundationcontract\3.0.0.0" /h "nul" /nomidl /reference "%WindowsSdkDir%References\10.0.17134.0\Windows.Foundation.FoundationContract\3.0.0.0\Windows.Foundation.FoundationContract.winmd" /reference "%WindowsSdkDir%References\10.0.17134.0\Windows.Foundation.UniversalApiContract\6.0.0.0\Windows.Foundation.UniversalApiContract.winmd" /reference "%WindowsSdkDir%\References\10.0.17134.0\Windows.Networking.Connectivity.WwanContract\2.0.0.0\Windows.Networking.Connectivity.WwanContract.winmd" Bookstore.idl

Lo midl.exe strumento compila l'esempio e produce un file di metadati denominato Bookstore.winmd (per impostazione predefinita, viene usato il nome del .idl file).The midl.exe tool compiles the example and produces a metadata file named Bookstore.winmd (by default, the name of the .idl file is used).

Suggerimento

Se si usa più di un file IDL (per consigli, vedere factoring di classi di runtime in file MIDL (IDL)), quindi unire tutti i file risultanti .winmd in un singolo file con lo stesso nome dello spazio dei nomi radice.If you use more than one IDL file (for advice about that, see Factoring runtime classes into Midl files (.idl)), then merge all of the resulting .winmd files into a single file with the same name as the root namespace. Il file finale sarà quello .winmd che verrà usato dagli utenti delle API.That final .winmd file will be the one that the consumers of your APIs will reference.

In questo caso, BookSku è l'unica classe di runtime nello spazio dei nomi Bookstore , quindi è stato salvato un passaggio e il nome del .idl file per lo spazio dei nomi.In this case, BookSku is the only runtime class in the Bookstore namespace, so we saved a step and just named the .idl file for the namespace.

È possibile utilizzare il where comando per individuare la posizione in cui midl.exe è installato.Incidentally, you can use the where command to find out where midl.exe is installed.

where midl

Se si desidera utilizzare i tipi definiti in un .idl file da un file diverso .idl , utilizzare la import direttiva.If you want to use the types defined in one .idl file from a different .idl file, then you use the import directive. Per altri dettagli e un esempio di codice, vedere controlli XAML; eseguire il binding a una proprietà C++/WinRT.For more details, and a code example, see XAML controls; bind to a C++/WinRT property. Naturalmente, se si utilizza un componente incorporato o di terze parti, non sarà possibile accedere al .idl file.Of course, if you're consuming a built-in or third-party component, then you won't have access to the .idl file. Ad esempio, potrebbe essere necessario utilizzare l'API Windows Runtime Win2D per il rendering di grafica 2D in modalità immediata.For example, you might want to consume the Win2D Windows Runtime API for immediate-mode 2D graphics rendering. Il comando precedente usava l' /reference opzione per fare riferimento a un file di metadati di Windows Runtime ( .winmd ).The command above used the /reference switch to reference a Windows Runtime metadata (.winmd) file. In questo esempio si userà di nuovo il cambio, immaginando lo scenario in cui è presente Bookstore.winmd , ma non Bookstore.idl .In this next example, we'll use that switch again, imagining the scenario where we have Bookstore.winmd, but not Bookstore.idl.

// MVVMApp.idl
namespace MVVMApp
{
    runtimeclass ViewModel
    {
        ViewModel();
        Bookstore.BookSku BookSku{ get; };
    }
}

Se il codice sorgente per l'esempio precedente viene archiviato in un file denominato MVVMApp.idl , è possibile eseguire il comando seguente per fare riferimento a Bookstore.winmd .If the source code for the example above is stored in a file named MVVMApp.idl, then you can issue the command below to reference Bookstore.winmd.

midl /winrt /metadata_dir "%WindowsSdkDir%References\10.0.17134.0\windows.foundation.foundationcontract\3.0.0.0" /h "nul" /nomidl /reference "%WindowsSdkDir%References\10.0.17134.0\Windows.Foundation.FoundationContract\3.0.0.0\Windows.Foundation.FoundationContract.winmd" /reference "%WindowsSdkDir%References\10.0.17134.0\Windows.Foundation.UniversalApiContract\6.0.0.0\Windows.Foundation.UniversalApiContract.winmd" /reference "%WindowsSdkDir%\References\10.0.17134.0\Windows.Networking.Connectivity.WwanContract\2.0.0.0\Windows.Networking.Connectivity.WwanContract.winmd" /reference Bookstore.winmd MVVMApp.idl

Spazi dei nomiNamespaces

È necessario uno spazio dei nomi.A namespace is required. Viene anteposto il nome di tutti i tipi definiti nell'ambito del blocco dello spazio dei nomi con il nome dello spazio dei nomi.It prefixes the name of all types defined in the scope of the namespace block with the namespace name. Uno spazio dei nomi può inoltre contenere dichiarazioni dello spazio dei nomi subordinate.A namespace can also contain subordinate namespace declarations. Il nome dei tipi definiti in un ambito dello spazio dei nomi subordinato ha un prefisso di tutti i nomi di spazio dei nomi che lo contengono.The name of types defined in a subordinate namespace scope have a prefix of all the containing namespace names.

Gli esempi seguenti sono due modi per dichiarare la stessa classe Windows. Foundation. Uri (come si può notare, i punti che separano i livelli degli spazi dei nomi annidati).The examples below are two ways of declaring the same Windows.Foundation.Uri class (as you can see, periods separate the levels of nested namespaces).

namespace Windows.Foundation
{
    runtimeclass Uri : IStringable
    {
        ...
    }
}
namespace Windows
{
    namespace Foundation
    {
        runtimeclass Uri : IStringable
        {
            ...
        }
    }
}

Ecco un altro esempio che mostra che è lecito dichiarare gli spazi dei nomi e i relativi tipi in modo annidato.Here's another example showing that it's legal to declare namespaces and their types in a nested fashion.

namespace RootNs.SubNs1
{
    runtimeclass MySubNs1Class
    {
        void DoWork();
    }

    namespace SubNs2
    {
        runtimeclass MySubNs2Class
        {
            void DoWork();
        }
    }
}

Tuttavia, è pratica più comune chiudere lo spazio dei nomi precedente e aprirne uno nuovo, come questo.But it's more common practice to close the previous namespace, and open a new one, like this.

namespace RootNs.SubNs1
{
    runtimeclass MySubNs1Class
    {
        void DoWork();
    }
}

namespace RootNs.SubNs1.SubNs2
{
    runtimeclass MySubNs2Class
    {
        void DoWork();
    }
}

TipiTypes

Esistono due tipi di tipi di dati in MIDL 3,0: tipi valore e tipi di riferimento.There are two kinds of data types in MIDL 3.0: value types, and reference types. Una variabile di un tipo di valore contiene direttamente i relativi dati.A variable of a value type directly contains its data. Una variabile di un tipo riferimento archivia un riferimento ai relativi dati (tale variabile è nota anche come oggetto).A variable of a reference type stores a reference to its data (such a variable is also known as an object).

È possibile che due variabili di tipo riferimento facciano riferimento allo stesso oggetto.It's possible for two reference type variables to reference the same object. Pertanto, un'operazione su una variabile influiscono sull'oggetto a cui fa riferimento l'altra variabile.Thus, an operation on one variable affects the object referenced by the other variable. Con i tipi di valore, ogni variabile ha una propria copia dei dati e non è possibile che un'operazione in uno possa influire sull'altra.With value types, the variables each have their own copy of the data, and it's not possible for an operation on one to affect the other.

I tipi di valore di MIDL 3.0 sono ulteriormente divisi in tipi semplici, tipi enum, tipi struct e tipi nullable.MIDL 3.0's value types are further divided into simple types, enum types, struct types, and nullable types.

I tipi di riferimento di MIDL 3.0 sono ulteriormente divisi in tipi di classe, tipi di interfaccia e tipi di delegati.MIDL 3.0's reference types are further divided into class types, interface types, and delegate types.

Ecco una panoramica del sistema di tipi di MIDL 3.0.Here's an overview of MIDL 3.0's type system. Diversamente dalle versioni precedenti di MIDL, non è possibile usare alias per questi tipi.Unlike previous versions of MIDL, you can't use aliases for these types.

CategoryCategory DescrizioneDescription
Tipi valoreValue types Tipi sempliciSimple types Integrale con segno: Int16, Int32, Int64Signed integral: Int16, Int32, Int64
Integrale senza segno: Uint8, UInt16, UInt32, UInt64Unsigned integral: UInt8, UInt16, UInt32, UInt64
Caratteri Unicode: char (rappresenta un UTF-16LE; un'unità di codice Unicode a 16 bit)Unicode characters: Char (represents a UTF-16LE; a 16-bit Unicode code unit)
Stringhe Unicode: stringaUnicode strings: String
Virgola mobile IEEE: singola, doppiaIEEE floating point: Single, Double
Booleano: booleanoBoolean: Boolean
UUID bit 128: GUID128 bit UUID: Guid
Tipi enumEnum types Tipi definiti dall'utente nel formato enum E {...}User-defined types of the form enum E {...}
Tipi structStruct types Tipi definiti dall'utente dello struct di form S {...}User-defined types of the form struct S {...}
Tipi nullableNullable types Estensioni di tutti gli altri tipi di valore con un valore nullExtensions of all other value types with a null value
Tipi riferimentoReference types Tipi di classeClass types Classe base finale di tutti gli altri tipi: ObjectUltimate base class of all other types: Object
Tipi definiti dall'utente nel formato RuntimeClass C {. ..}User-defined types of the form runtimeclass C {...}
Tipi interfacciaInterface types Tipi definiti dall'utente con interfaccia di form i {. ..}User-defined types of the form interface I {...}
Tipi delegatoDelegate types Tipi definiti dall'utente del modulo delegano < returnType > D (...)User-defined types of the form delegate <returnType> D(...)

I sette tipi integrali forniscono supporto per i dati senza segno a 8 bit; e i valori a 16 bit, a 32 bit e a 64 bit in formato signed o unsigned.The seven integral types provide support for 8-bit unsigned data; and 16-bit, 32-bit, and 64-bit values in signed or unsigned form.

I due tipi a virgola mobile, Single e Double, rappresentano i dati usando rispettivamente i formati IEEE 754 a precisione singola a 32 bit e 64 bit.The two floating point types, Single and Double, represent data using the 32-bit single-precision and 64-bit Double-precision IEEE 754 formats, respectively.

Il tipo booleano di MIDL 3.0 rappresenta i valori booleani. true o false .MIDL 3.0's Boolean type represents boolean values; either true or false.

I caratteri e le stringhe in MIDL 3,0 contengono caratteri Unicode.Characters and strings in MIDL 3.0 contain Unicode characters. Il tipo char rappresenta un'unità di codice UTF-16LE; e il tipo stringa rappresenta una sequenza di unità di codice UTF-16LE.The Char type represents a UTF-16LE code unit; and the String type represents a sequence of UTF-16LE code units.

La tabella seguente riepiloga i tipi numerici di MIDL 3.0.The following table summarizes MIDL 3.0's numeric types.

CategoryCategory BITSBits TipoType Intervallo/precisioneRange/Precision
Integrale con segnoSigned integral 1616 Int16Int16 – 32768... 32, 767–32,768...32,767
3232 Int32Int32 – 2147483648... 2, 147, 483, 647–2,147,483,648...2,147,483,647
6464 Int64Int64 – 9.223.372.036.854.775.808... 9, 223, 372, 036, 854, 775, 807–9,223,372,036,854,775,808...9,223,372,036,854,775,807
Unsigned IntegerUnsigned integral 88 UInt8UInt8 0... 2550...255
1616 UInt16UInt16 0... 65, 5350...65,535
3232 UInt32UInt32 0... 4, 294, 967, 2950...4,294,967,295
6464 UInt64UInt64 0... 18, 446, 744, 073, 709, 551, 6150...18,446,744,073,709,551,615
Virgola mobileFloating point 3232 SingoloSingle 1,5 × 10− 45 a 3,4 × 1038, precisione a 7 cifre1.5 × 10−45 to 3.4 × 1038, 7-digit precision
6464 DoubleDouble 5,0 × 10− 324 a 1,7 × 10308, precisione di 15 cifre5.0 × 10−324 to 1.7 × 10308, 15-digit precision

I file di origine MIDL 3,0 usano le definizioni dei tipi per creare nuovi tipi.MIDL 3.0 source files use type definitions to create new types. Una definizione di tipo specifica il nome e i membri del nuovo tipo.A type definition specifies the name and the members of the new type. Queste categorie di tipo MIDL 3,0 sono definibili dall'utente.These MIDL 3.0 type categories are user-definable.

  • tipi di attributo,attribute types,
  • tipi struct,struct types,
  • tipi di interfaccia,interface types,
  • tipi RuntimeClass,runtimeclass types,
  • tipi delegati edelegate types, and
  • tipi enum.enum types.

Un tipo di attributo definisce un Windows Runtime attributo che può essere applicato ad altre definizioni di tipi.An attribute type defines a Windows Runtime attribute that can be applied to other type definitions. Un attributo fornisce metadati sul tipo a cui viene applicato l'attributo.An attribute provides metadata about the type to which the attribute is applied.

Un tipo struct definisce una struttura Windows Runtime che contiene membri dati.A struct type defines a Windows Runtime structure that contains data members. Gli struct sono tipi valore e non richiedono l'allocazione dell'heap.Structs are value types, and they do not require heap allocation. Un membro dati di un tipo struct deve essere un tipo valore o un tipo Nullable.A data member of a struct type must either be a value type or a nullable type. I tipi struct non supportano l'ereditarietà.Struct types do not support inheritance.

Un tipo di interfaccia definisce un'interfaccia Windows Runtime, ovvero un set denominato di membri di funzione.An interface type defines a Windows Runtime interface, which is a named set of function members. Un'interfaccia può specificare che un'implementazione dell'interfaccia deve implementare anche una o più interfacce aggiuntive (obbligatorie) specificate.An interface may specify that an implementation of the interface must also implement of one or more specified additional (required) interfaces. Ogni tipo di interfaccia deriva direttamente dalla Windows Runtime interfaccia IInspectable .Every interface type directly derives from the Windows Runtime IInspectable interface.

Un tipo RuntimeClass definisce una classe Windows Runtime (classe Runtime).A runtimeclass type defines a Windows Runtime class (runtime class). Una classe di runtime contiene membri che possono essere proprietà, metodi ed eventi.A runtime class contains members that can be properties, methods, and events.

Un tipo delegato definisce un delegato Windows Runtime, che rappresenta un riferimento a un metodo con un elenco di parametri e un tipo restituito specifici.A delegate type defines a Windows Runtime delegate, which represents a reference to a method with a particular parameter list and return type. I delegati consentono di trattare un metodo come un'entità che può essere passata come parametro.Delegates make it possible to treat a method as an entity that can be passed as a parameter. Un delegato è simile al concetto di puntatore a funzione trovato in altri linguaggi.A delegate is similar to the concept of a function pointer found in some other languages. A differenza dei puntatori a funzione, i delegati sono orientati agli oggetti e indipendenti dai tipi.Unlike function pointers, delegates are object-oriented, and type-safe.

Un tipo enum è un tipo distinto con costanti denominate.An enum type is a distinct type with named constants. Ogni tipo di enumerazione ha un tipo sottostante implicito; Int32 o UInt32.Every enum type has an implicit underlying type; either Int32 or UInt32. Il set di valori di un tipo enum corrisponde al set di valori del tipo sottostante.The set of values of an enum type is the same as the set of values of the underlying type.

MIDL 3,0 supporta tre categorie di tipi aggiuntive.MIDL 3.0 supports three additional type categories.

  • tipi di matrici unidimensionali,single-dimensional array types,
  • tipi di valore nullable enullable value types, and
  • tipo di oggetto .the Object type.

Non è necessario dichiarare una matrice unidimensionale prima di poterla usare.You don't need to declare a single-dimensional array before you can use it. Al contrario, i tipi matrice vengono costruiti facendo seguire a un nome di tipo delle parentesi quadre.Instead, array types are constructed by following a type name with square brackets. Ad esempio, Int32 [] è una matrice unidimensionale di Int32.For example, Int32[] is a single-dimensional array of Int32.

Analogamente, non è necessario definire anche i tipi di valore Nullable prima che possano essere utilizzati.Similarly, nullable value types also do not have to be defined before they can be used. Per ogni tipo di valore non Nullable t (ad eccezione di String), esiste un tipo nullable corrispondente Windows. Foundation. < IReference > T, che può conservare il valore aggiuntivo null .For each non-nullable value type T (except String), there's a corresponding nullable type Windows.Foundation.IReference<T>, which can hold the additional value null. Ad esempio, Windows. Foundation. IReference < Int32 > è un tipo in grado di ospitare qualsiasi intero a 32 bit o il valore null .For instance, Windows.Foundation.IReference<Int32> is a type that can hold any 32-bit integer, or the value null. Vedere anche IReference < T >.Also see IReference<T>.

Infine, MIDL 3,0 supporta il tipo di oggetto , che esegue il mapping all'interfaccia Windows Runtime IInspectable .Finally, MIDL 3.0 supports the Object type, which maps to the Windows Runtime IInspectable interface. I tipi di riferimento Interface e RuntimeClass derivano concettualmente dal tipo di oggetto ; il delegato non lo è.The interface and runtimeclass reference types conceptually derive from the Object type; delegate does not.

Espressioni in un valore enumeratoExpressions in an enumerated value

Con MIDL 3,0, è possibile usare solo un' espressione nella definizione del valore delle costanti denominate di un tipo enumerato; in altre parole, in un inizializzatore di enumerazione.With MIDL 3.0, you can only use an expression in the definition of the value of an enumerated type's named constants; in other words, in an enumeration initializer.

Un'espressione viene costruita da operandi e operatori.An expression is constructed from operands and operators. Gli operatori in un'espressione indicano quali operazioni applicare agli operandi.The operators in an expression indicate which operations to apply to the operands. Esempi di operatori includono +,-, *,/e new .Examples of operators include +, -, *, /, and new. mentre i valori effettivi, i campi, le variabili locali e le espressioni sono esempi di operandi.Examples of operands include literals, fields, local variables, and expressions.

Quando un'espressione contiene più operatori, la precedenza degli operatori controlla l'ordine in cui vengono valutati i singoli operatori.When an expression contains multiple operators, the precedence of the operators controls the order in which the individual operators are evaluated. Ad esempio, l'espressione x + y * z viene valutata come x + (y * z) perché l'operatore * ha precedenza più alta rispetto all'operatore +.For example, the expression x + y * z is evaluated as x + (y * z) because the * operator has higher precedence than the + operator. Le operazioni logiche sono con precedenza inferiore rispetto alle operazioni bit per bit.Logical operations are lower precedence than bitwise operations.

Nella tabella seguente sono riepilogati gli operatori di MIDL 3.0, che elencano le categorie di operatori in ordine di precedenza dal più alto al più basso.The following table summarizes MIDL 3.0's operators, listing the operator categories in order of precedence from highest to lowest. Gli operatori nella stessa categoria hanno la stessa precedenza.Operators in the same category have equal precedence.

CategoriaCategory EspressioneExpression DescrizioneDescription
PrimariaPrimary x++x++ Post-incrementoPost-increment
x--x-- Post-decrementoPost-decrement
UnariaUnary +x+x IdentitàIdentity
-X-x NegazioneNegation
!x!x Negazione logicaLogical negation
~x~x Negazione bit per bitBitwise negation
++x++x Pre-incrementoPre-increment
--x--x Pre-decrementoPre-decrement
MoltiplicazioneMultiplicative x \* yx \* y MoltiplicazioneMultiplication
x / yx / y DivisioneDivision
x% yx % y RestoRemainder
AdditiveAdditive x + yx + y Aggiunta, concatenazione di stringhe, combinazione di delegatiAddition, String concatenation, delegate combination
x – yx – y Sottrazione, rimozione di delegatiSubtraction, delegate removal
MAIUSCShift x < < yx << y Spostamento a sinistraShift left
x >> yx >> y Spostamento a destraShift right
AND bit per bitBitwise AND x & yx & y AND bit per bit IntegerInteger bitwise AND
XOR bit per bitBitwise XOR x ^ yx ^ y XOR bit per bit IntegerInteger bitwise XOR
OR bit per bitBitwise OR x | yx | y Or integer bit per bitInteger bitwise OR
AND logicoLogical AND x && yx && y AND logico booleanoBoolean logical AND
OR logicoLogical OR x || yx || y OR logico booleanoBoolean logical OR

ClassiClasses

Le classi (o classi di Runtime) sono le più importanti dei tipi di MIDL 3.0.Classes (or runtime classes) are the most fundamental of MIDL 3.0's types. Una classe è una definizione di un'aggregazione di metodi, proprietà ed eventi in una singola unità.A class is a definition of an aggregation of methods, properties, and events in a single unit. Le classi supportano i meccanismi di ereditarietà e polimorfismo, in — cui le classi derivate possono estendere e specializzare le classi baseClasses support inheritance and polymorphism—mechanisms whereby derived classes can extend and specialize base classes.

Si definisce un nuovo tipo di classe usando una definizione di classe.You define a new class type using a class definition. Una definizione di classe inizia con un'intestazione che specifica la runtimeclass parola chiave, il nome della classe, la classe base (se specificata) e le interfacce implementate dalla classe.A class definition starts with a header that specifies the runtimeclass keyword, the name of the class, the base class (if given), and the interfaces implemented by the class. L'intestazione è seguita dal corpo della classe, che è costituito da un elenco di dichiarazioni di membri scritte tra i delimitatori {e}.The header is followed by the class body, which consists of a list of member declarations written between the delimiters { and }.

Ecco una definizione di una classe semplice denominata area.Here's a definition of a simple class named Area.

runtimeclass Area
{
    Area(Int32 width, Int32 height);

    Int32 Height;
    Int32 Width;

    static Int32 NumberOfAreas { get; };
}

Definisce una nuova classe Windows Runtime denominata area, che dispone di un costruttore che accetta due parametri Int32 , due proprietà Int32 di lettura/scrittura denominate altezza e larghezza e una proprietà statica di sola lettura denominata NumberOfAreas.This defines a new Windows Runtime class named Area, which has a constructor that take two Int32 parameters, two Int32 read-write properties named Height and Width, and a static read-only property named NumberOfAreas.

Per impostazione predefinita, un RuntimeClass è sealed e la derivazione non è consentita.By default, a runtimeclass is sealed, and derivation from it is disallowed. Vedere classi di base.See Base classes.

Per associare XAML a un modello di visualizzazione, è necessario definire la classe di runtime del modello di visualizzazione in MIDL.In order to bind XAML to a view model, the view model runtime class needs to be defined in MIDL. Per altri dettagli, vedi Controlli XAML, binding a una proprietà C++/WinRT.See XAML controls; bind to a C++/WinRT property for more details.

È possibile dichiarare che una classe non supporta alcuna istanza (e di conseguenza deve contenere solo membri statici) anteponendo la definizione della classe runtime con la static parola chiave.You can declare that a class supports no instances (and consequently must contain only static members) by prefixing the runtime class definition with the static keyword. Se si aggiunge un membro non statico alla classe, viene generato un errore di compilazione.Adding a non-static member to the class then causes a compilation error.

static runtimeclass Area
{
    static Int32 NumberOfAreas { get; };
}

Una classe statica è diversa da una classe vuota.A static class is different from an empty class. Vedere anche classi vuote.Also see Empty classes.

È possibile indicare che una definizione di classe è incompleta anteponendo la definizione della classe runtime con la partial parola chiave.You can indicate that a class definition is incomplete by prefixing the runtime class definition with the partial keyword. Tutte le definizioni di classe parziali rilevate dal compilatore vengono combinate in una singola classe di Runtime.All of the partial class definitions encountered by the compiler are combined into a single runtime class. Questa funzionalità è principalmente per gli scenari di creazione di XAML, in cui alcune classi parziali sono generate dal computer.This feature is primarily for XAML authoring scenarios, where some of the partial classes are machine-generated.

ModificatoreModifier SignificatoMeaning
staticstatic La classe non dispone di istanze.Class has no instances. Di conseguenza, sono consentiti solo i membri statici.Consequently, only static members are permitted.
partialpartial La definizione della classe non è completa.Class definition is incomplete.

Per i modificatori avanzati, vedere composizione e attivazione .See Composition and activation for advanced modifiers.

Modificatori di accesso ai membriMember access modifiers

Poiché MIDL 3,0 è un linguaggio di definizione per la descrizione della superficie pubblica dei tipi di Windows Runtime, non è necessaria la sintassi esplicita per dichiarare l'accessibilità pubblica di un membro.As MIDL 3.0 is a definition language for describing the public surface of Windows Runtime types, there's no need for explicit syntax to declare the public accessibility of a member. Tutti i membri sono implicitamente pubblici.All members are implicitly public. Questo è il motivo per cui MIDL 3,0 non richiede né consente la parola chiave (effettivamente ridondante) public .That's why MIDL 3.0 doesn't require nor allow the (effectively redundant) public keyword.

Classi di baseBase classes

Una definizione di classe può specificare una classe di base seguendo il nome della classe e i parametri di tipo con i due punti e il nome della classe di base.A class definition may specify a base class by following the class name and type parameters with a colon and the name of the base class. L'omissione di una specifica della classe base equivale alla derivazione da un oggetto di tipo (in altre parole, da IInspectable).Omitting a base class specification is the same as deriving from type Object (in other words, from IInspectable).

Nota

Le classi del modello — di visualizzazione in realtà, qualsiasi classe di runtime definita nell'applicazione — non deve derivare da una classe base.Your view model classes—in fact, any runtime class that you define in your application—need not derive from a base class.

Tutte le classi di runtime definite nell'applicazione che derivano da una classe di base sono note come classi componibili .Any runtime class that you define in the application that does derive from a base class is known as a composable class. Le classi componibili sono soggette a limitazioni.And there are constraints around composable classes. Affinché un'applicazione superi i test del Kit di certificazione app Windows utilizzato da Visual Studio e da Microsoft Store per convalidare gli invii, e possa essere inserita correttamente nel sistema di Microsoft Store, una classe componibile in ultima analisi deve derivare da una classe di base di Windows.For an application to pass the Windows App Certification Kit tests used by Visual Studio and by the Microsoft Store to validate submissions (and therefore for the application to be successfully ingested into the Microsoft Store), a composable class must ultimately derive from a Windows base class. Vale a dire che la classe radice della gerarchia di ereditarietà deve essere un tipo che ha origine in uno spazio dei nomi Windows.*.Meaning that the class at the very root of the inheritance hierarchy must be a type originating in a Windows.* namespace.

Per altri dettagli, vedi Controlli XAML, binding a una proprietà C++/WinRT.See XAML controls; bind to a C++/WinRT property for more details.

Nell'esempio seguente la classe di base di volume è area e la classe di base di area è Windows. UI. XAML. DependencyObject.In the next example, the base class of Volume is Area, and the base class of Area is Windows.UI.Xaml.DependencyObject.

unsealed runtimeclass Area : Windows.UI.Xaml.DependencyObject
{
    Area(Int32 width, Int32 height);
    Int32 Height;
    Int32 Width;
}

runtimeclass Volume : Area
{
    Volume(Int32 width, Int32 height, Int32 depth);
    Int32 Depth;
}

Nota

Qui, area e volume sono definiti nello stesso file di origine.Here, Area and Volume are defined in the same source file. Per una descrizione dei vantaggi e degli svantaggi, vedere factoring di classi di runtime in file MIDL (IDL).For a discussion of the pros and cons, see Factoring runtime classes into Midl files (.idl).

Una classe eredita i membri della relativa classe di base.A class inherits the members of its base class. L'ereditarietà indica che una classe contiene in modo implicito tutti i membri della relativa classe di base, ad eccezione dei costruttori della classe di base.Inheritance means that a class implicitly contains all members of its base class, except for the constructor(s) of the base class. Una classe derivata può aggiungere nuovi membri a quelli ereditati, ma non può rimuovere la definizione di un membro ereditato.A derived class can add new members to those it inherits, but it cannot remove the definition of an inherited member.

Nell'esempio precedente il volume eredita le proprietà Height e Width dall' area.In the previous example, Volume inherits the Height and Width properties from Area. Ogni istanza del volume contiene quindi tre proprietà: Altezza, larghezza e profondità.So, every Volume instance contains three properties: Height, Width, and Depth.

In generale, le regole di risoluzione dei tipi richiedono che il nome di un tipo sia completo quando vi si fa riferimento.In general, type resolution rules require that a type name is fully qualified when referenced. Un'eccezione si verifica quando il tipo è stato definito nello stesso spazio dei nomi del tipo corrente.An exception is when the type has been defined in the same namespace as the current type. L'esempio precedente funziona come scritto se area e volume sono entrambi nello stesso spazio dei nomi.The example above works as written if Area and Volume are both in the same namespace.

Interfacce implementateImplemented interfaces

Una definizione di classe può inoltre specificare un elenco di interfacce implementate dalla classe.A class definition may also specify a list of interfaces that the class implements. Le interfacce vengono specificate come un elenco delimitato da virgole di interfacce che seguono la classe di base (facoltativo).You specify the interfaces as a comma-separated list of interfaces following the (optional) base class.

Nell'esempio riportato di seguito, la classe area implementa l'interfaccia che consente di: e la classe del volume implementa sia l' interfaccia che l'ipotetica interfaccia IEquatable .In the example below, the Area class implements the IStringable interface; and the Volume class implements both IStringable and the hypothetical IEquatable interface.

unsealed runtimeclass Area : Windows.Foundation.IStringable
{
    Area(Int32 width, Int32 height);
    Int32 Height;
    Int32 Width;
}

runtimeclass Volume : Area, Windows.Foundation.IStringable, IEquatable
{
    Volume(Int32 width, Int32 height, Int32 depth);
    Int32 Depth;
}

In MIDL i membri dell'interfaccia non vengono dichiarati nella classe.In the MIDL, you don't declare the interface's members on the class. Naturalmente, è necessario dichiararli e definirli nell'implementazione effettiva.You do, of course, have to declare and define them on the actual implementation.

MembriMembers

I membri di una classe sono membri statici o membri di istanza.The members of a class are either static members or instance members. Un membro statico appartiene a una classe.A static member belongs to a class. Un membro di istanza appartiene a un oggetto, ovvero un'istanza di una classe.An instance member belongs to an object (that is, an instance of a class).

Questa tabella mostra i tipi di membro che una classe può contenere.This table shows the kinds of member that a class can contain.

Tipo di membroMember kind DescrizioneDescription
CostruttoriConstructors Azioni necessarie per inizializzare un'istanza della classe oppure per inizializzare la classe stessaActions required to initialize an instance of the class, or to initialize the class itself
ProprietàProperties Azioni associate alla lettura e alla scrittura di proprietà denominate di un'istanza della classe o della classe stessaActions associated with reading and writing named properties of an instance of the class, or of the class itself
MetodiMethods Calcoli e azioni che possono essere eseguiti da un'istanza della classe o dalla classe stessaComputations and actions that can be performed by an instance of the class, or by the class itself
EventiEvents Notifiche che possono essere generate da un'istanza della classeNotifications that can be raised by an instance of the class

CostruttoriConstructors

MIDL 3,0 supporta la dichiarazione di costruttori di istanza.MIDL 3.0 supports the declaration of instance constructors. Un costruttore di istanza è un metodo che implementa le azioni necessarie per inizializzare un'istanza di una classe.An instance constructor is a method that implements the actions required to initialize an instance of a class. I costruttori non possono essere statici.Constructors may not be static.

Un costruttore viene dichiarato come un metodo di istanza (ma senza tipo restituito) e con lo stesso nome della classe che lo contiene.A constructor is declared like an instance method (but with no return type), and with the same name as the containing class.

È possibile eseguire l'overload di costruttori di istanze.Instance constructors can be overloaded. La classe di test seguente, ad esempio, dichiara tre costruttori di istanza; uno senza parametri (il costruttore predefinito ), uno che accetta un parametro Int32 e uno che accetta due parametri doppi (costruttori con parametri ).For example, the Test class below declares three instance constructors; one with no parameters (the default constructor), one that takes an Int32 parameter, and one that takes two Double parameters (parameterized constructors).

runtimeclass Test
{
    Test();
    Test(Int32 x);
    Test(Double x, Double y);
}

Per informazioni dettagliate sulla sintassi per gli elenchi di parametri, vedere i Metodi riportati di seguito.For details on the syntax for parameter lists, see Methods below.

Le proprietà, i metodi e gli eventi dell'istanza vengono ereditati.Instance properties, methods, and events are inherited. I costruttori di istanza non vengono ereditati (con un'eccezione) e una classe non dispone di costruttori di istanza diversi da quelli effettivamente dichiarati nella classe.Instance constructors are not inherited (with one exception), and a class has no instance constructors other than those actually declared in the class. Se non viene fornito alcun costruttore di istanza per una classe, non è possibile creare direttamente un'istanza della classe.If no instance constructor is supplied for a class, then you cannot directly instantiate the class. Per una classe di questo tipo, in genere si ha un metodo factory che restituisce un'istanza della classe.For such a class, you'd typically have a factory method elsewhere that returns an instance of the class.

L'eccezione è rappresentata dalle classi non sealed.The exception is unsealed classes. Una classe non sealed può avere uno o più costruttori protetti.An unsealed class can have one or more protected constructors.

ProprietàProperties

Le Proprietà sono concettualmente simili ai campi.Properties are conceptually similar to fields. Entrambi sono un membro con un nome e un tipo associato.Both are a member with a name and an associated type. A differenza dei campi, tuttavia, le proprietà non denotano posizioni di memoria,However, unlike fields, properties do not denote storage locations. Al contrario, le proprietà dispongono di funzioni di accesso che specificano la funzione da eseguire durante la lettura o la scrittura di una proprietà.Instead, properties have accessors that specify the function to be executed when you read or write a property.

Una proprietà viene dichiarata come un campo, ad eccezione del fatto che la dichiarazione termina con una get parola chiave e/o una set parola chiave scritta tra i delimitatori {e} e termina con un punto e virgola.A property is declared like a field, except that the declaration ends with a get keyword and/or a set keyword written between the delimiters { and }, and ending in a semicolon.

Una proprietà con una get parola chiave e una set parola chiave è una proprietà di lettura/scrittura.A property that has both a get keyword and a set keyword is a read-write property. Una proprietà che dispone solo di una get parola chiave è una proprietà di sola lettura.A property that has only a get keyword is a read-only property. Il Windows Runtime non supporta le proprietà di sola scrittura.The Windows Runtime doesn't support write-only properties.

Ad esempio, l' area della classe, visualizzata in precedenza, contiene due proprietà di lettura/scrittura denominate Height e Width.For example, the class Area, seen previously, contains two read-write properties named Height and Width.

unsealed runtimeclass Area
{
    Int32 Height { get; set; };
    Int32 Width; // get and set are implied if both are omitted.
}

La dichiarazione di Width omette le parentesi graffe e le get set parole chiave e.The declaration of Width omits the braces and the get and set keywords. L'omissione implica che la proprietà è di lettura/scrittura ed è semanticamente identica a fornire le get set parole chiave e in tale ordine — get , seguito da set .The omission implies that the property is read-write, and is semantically identical to providing the get and set keywords in that order—get, followed by set.

Inoltre, è possibile specificare solo la get parola chiave per indicare che la proprietà è di sola lettura.Additionally, you can specify only the get keyword to indicate that the property is read-only.

// Read-only instance property returning mutable collection.
Windows.Foundation.Collections.IVector<Windows.UI.Color> Colors { get; };

Il Windows Runtime non supporta le proprietà di sola scrittura.The Windows Runtime doesn't support write-only properties. È tuttavia possibile specificare solo la set parola chiave per modificare una proprietà di sola lettura esistente in una proprietà di lettura/scrittura.But you can specify only the set keyword to revise an existing read-only property into a read-write property. Prendere questa versione di area come esempio.Take this version of Area as an example.

unsealed runtimeclass Area
{
    ...
    Color SurfaceColor { get; };
}

Se successivamente si vuole rendere la proprietà SurfaceColor in lettura/scrittura e non è necessario mantenere la compatibilità binaria con le definizioni precedenti dell' area (ad esempio, la classe area è un tipo in un'applicazione che viene ricompilata ogni volta), è possibile aggiungere semplicemente la set parola chiave alla Dichiarazione SurfaceColor esistente come questa.If you want subsequently to make the SurfaceColor property read-write, and you don't need to maintain binary compatibility with prior definitions of Area (for example, the Area class is a type in an application that you recompile each time), then you can simply add the set keyword to the existing SurfaceColor declaration like this.

unsealed runtimeclass Area
{
    ...
    Color SurfaceColor { get; set; };
}

Se invece è necessaria una stabilità binaria (ad esempio, la classe area è un componente di una libreria fornita ai clienti), non è possibile aggiungere la set parola chiave alla dichiarazione di proprietà esistente.If, on the other hand, you do need binary stability (for example, the Area class is a component in a library that you ship to customers), then you cannot add the set keyword to the existing property declaration. In questo modo viene modificata l'interfaccia binaria per la classe.Doing so changes the binary interface to your class.

In tal caso, aggiungere la set parola chiave Property a una definizione aggiuntiva della proprietà alla fine della classe come questa.In that case, add the property set keyword to an additional definition of the property at the end of the class like this.

unsealed runtimeclass Area
{
    ...
    Color SurfaceColor { get; };
    ...
    Color SurfaceColor { set; };
}

Il compilatore genera un errore per una proprietà di sola scrittura.The compiler produces an error for a write-only property. Ma non si tratta di un'operazione eseguita qui.But that's not what's being done here. Dato che la dichiarazione precedente della proprietà è di sola lettura, l'aggiunta della parola chiave set non dichiara una proprietà di sola scrittura, bensì una proprietà di lettura/scrittura.Because of the preceding declaration of the property as read-only, the addition of the set keyword doesn't declare a write-only property, but instead a read-write property.

L'implementazione Windows Runtime di una proprietà è costituita da uno o due metodi della funzione di accesso su un'interfaccia.The Windows Runtime implementation of a property is one or two accessor methods on an interface. L'ordine delle parole chiave Get e set nella dichiarazione di proprietà determina l'ordine dei metodi delle funzioni di accesso get e set nell'interfaccia di supporto.The order of the get and set keywords in the property declaration determine the order of the get and set accessor methods in the backing interface.

La get funzione di accesso corrisponde a un metodo senza parametri con un valore restituito del tipo di proprietà — del Getter della proprietà.The get accessor corresponds to a parameterless method with a return value of the property type—the property getter.

Una set funzione di accesso corrisponde a un metodo con un singolo parametro denominato value e nessun tipo restituito — il setter della proprietà.A set accessor corresponds to a method with a single parameter named value, and no return type—the property setter.

Di conseguenza, queste due dichiarazioni producono interfacce binarie diverse.Consequently, these two declarations produce different binary interfaces.

Color SurfaceColor { get; set; };
Color SurfaceColor { set; get; };
Proprietà statiche e di istanzaStatic and instance properties

Analogamente ai campi e ai metodi, MIDL 3,0 supporta sia le proprietà dell'istanza sia le proprietà statiche.Similar to fields and methods, MIDL 3.0 supports both instance properties and static properties. Le proprietà statiche vengono dichiarate con il static modificatore con prefisso e le proprietà dell'istanza vengono dichiarate senza di essa.Static properties are declared with the static modifier prefixed, and instance properties are declared without it.

MetodiMethods

Un Metodo è un membro che implementa un calcolo o un'azione che può essere eseguita da un'istanza della classe o dalla classe stessa.A method is a member that implements a computation or action that can be performed by an instance of the class, or by the class itself. È possibile accedere A un metodo statico tramite la classe.A static method is accessed through the class. È possibile accedere a un metodo di istanza tramite un'istanza della classe.An instance method is accessed through an instance of the class.

Un metodo dispone di un elenco di parametri(possibilmente vuoto), che rappresentano valori o riferimenti a variabili passati al metodo.A method has a (possibly empty) list of parameters, which represent values or variable references passed to the method. Un metodo dispone anche di un tipo restituito, che specifica il tipo di valore calcolato e restituito dal metodo.A method also has a return type, which specifies the type of the value computed and returned by the method. Il tipo restituito di un metodo è void se non restituisce un valore.A method's return type is void if it doesn't return a value.

// Instance method with no return value.
void AddData(String data);

// Instance method *with* a return value.
Int32 GetDataSize();

// Instance method accepting/returning a runtime class.
// Notice that you don't say "&" nor "*" for reference types.
BasicClass MergeWith(BasicClass other);

// Asynchronous instance methods.
Windows.Foundation.IAsyncAction UpdateAsync();
Windows.Foundation.IAsyncOperation<Boolean> TrySaveAsync();

// Instance method that returns a value through a parameter.
Boolean TryParseInt16(String input, out Int16 value);

// Instance method that receives a reference to a value type.
Double CalculateArea(ref const Windows.Foundation.Rect value);

// Instance method accepting or returning a conformant array.
void SetBytes(UInt8[] bytes);
UInt8[] GetBytes();

// instance method that writes to a caller-provided conformant array
void ReadBytes(ref UInt8[] bytes);

La firma di un metodo deve essere univoca nell'ambito della classe in cui viene dichiarato il metodo.The signature of a method must be unique in the class in which the method is declared. La firma di un metodo è costituita dal nome del metodo, dai tipi dei relativi parametri e/o dal numero di parametri.The signature of a method consists of the name of the method, the types of its parameters, and/or the number of its parameters. La firma di un metodo non include il tipo restituito.The signature of a method doesn't include the return type.

Modificatori di visibilità del metodoMethod visibility modifiers

Un Metodo può avere uno dei due modificatori di visibilità facoltativi quando il metodo è presente in una classe derivata.A method may have one of two optional visibility modifiers when the method is present in a derived class.

Il modificatore Overridable indica che questo metodo esegue l'override di un metodo con lo stesso nome e la stessa firma in una classe base.The overridable modifier states that this method overrides a method with the same name and signature in a base class.

Il modificatore protected indica che questo metodo è accessibile solo ai membri di una classe derivata successivamente.The protected modifier states that this method is only accessible by members in a subsequently derived class.

Overload di un metodoMethod overloading

L' Overload del metodo consente a più metodi nella stessa classe di avere lo stesso nome purché i relativi parametri differiscano da un numero (in altre parole, i metodi hanno un grado diverso).Method overloading permits multiple methods in the same class to have the same name as long as their parameters differ in number (in other words the methods have different arity).

runtimeclass Test
{
    static void F();
    static void F(Double x);
    static void F(Double x, Double y);
}

Nota

Tutti i metodi con lo stesso nome devono avere un grado diverso.All methods with the same name should have differing arity. Questo perché i linguaggi di programmazione con tipizzazione debole non supportano l'overload per tipo.That's because weakly-typed programming languages don't support overloading by type.

ParametriParameters

I parametri vengono usati per passare valori o riferimenti a variabili a un metodo.Parameters are used to pass values or variable references to a method. Un parametro descrive uno slot con un tipo e un nome e, facoltativamente, una parola chiave del modificatore.A parameter describes a slot with a type and a name, and optionally some modifier keyword. Un argomento è un valore effettivo passato da tale slot dal chiamante del metodo al chiamato.An argument is an actual value passed in that slot from the caller of the method to the callee.

I parametri di un metodo ottengono il valore dall' argomento specifico specificato quando viene richiamato il metodo.Parameters of a method get their value from the specific argument that is specified when the method is invoked. Il modo in cui gli argomenti vengono passati tra il chiamante e il chiamato dipende dal tipo di parametro.The way arguments are passed between caller and callee depends on the type of the parameter. Per impostazione predefinita, tutti i parametri sono parametri di input, ovvero vengono sottoposti a marshalling solo dal chiamante al chiamato.By default, all parameters are input parameters, that is they are marshaled from the caller to the callee only. È possibile aggiungere le parole chiave del modificatore ref , ref const , e out per modificare la direzione predefinita del marshalling tra il chiamante e il chiamato e creare i parametri di output.The modifier keywords ref, ref const, and out can be added to modify the default direction of marshaling between caller and callee, and create output parameters. Tuttavia, non tutte le parole chiave sono valide con tutti i tipi di parametro. di seguito sono elencate le combinazioni valide.Not all keywords are valid with all parameter types, though; valid combinations are detailed below.

Importante

Common Language Runtime (CLR) dispone di concetti e parole chiave di modifica che potrebbero sembrare simili a quelli descritti in questa sezione.The Common Language Runtime (CLR) has concepts and modifier keywords that might appear to be similar to the ones described in this section. In pratica, tuttavia, questi modificatori sono specifici per la progettazione e il funzionamento del Windows Runtime.However in practice those are unrelated, and the effect of these modifiers is specific to the design and functioning of the Windows Runtime.

I tipi di valore sono parametri di input impliciti e, per impostazione predefinita, una copia dell'argomento viene passata dal chiamante al chiamato.Value types are implicitly input parameters, and by default a copy of the argument is passed from the caller to the callee. I parametri di valore possono essere trasformati in output Parmeters con la out parola chiave. in tal caso, viene eseguito il marshalling dell'argomento dal chiamato al solo chiamante.Value parameters can be transformed into output parmeters with the out keyword; in that case the argument is marshaled instead from the callee back to the caller only.

runtimeclass Test
{
    static void Divide(Int32 x, Int32 y, out Int32 result, out Int32 remainder);
}

Come speciale ottimizzazione delle prestazioni, i tipi struct (e nessun altro tipo), che in genere vengono passati per valore come copia completa, possono essere passati dal puntatore allo struct non modificabile.As a special performance optimization, struct types (and no other type), which are normally passed by value as a full copy, can be made to be passed by pointer to the immutable struct. Questa operazione viene eseguita con ref const la const ref parola chiave (not), che contrassegna il parametro struct come parametro di input, ma indica al gestore di marshalling di passare un puntatore alla risorsa di archiviazione dello struct, anziché passare una copia completa dello struct.This is achieved with the ref const (not const ref) keyword, which marks the struct parameter as an input parameter, but instructs the marshaler to pass a pointer to the struct's storage, instead of passing a full copy of the struct. Si noti tuttavia che lo struct non è modificabile; il puntatore è concettualmente un puntatore const.Note however that the struct is immutable; the pointer is conceptually a const pointer. Non è stato richiesto il Boxing.There is no boxing involved. Si tratta di una scelta pratica quando si accetta un valore di grandi dimensioni come Matrix4x4, ad esempio.This is a practical choice when accepting a value as large as a Matrix4x4, for example.

runtimeclass Test
{
    static Boolean IsIdentity(ref const Windows.Foundation.Numerics.Matrix4x4 m);
}

I tipi di riferimento sono inoltre parametri di input implicitamente, ovvero il chiamante è responsabile dell'allocazione dell'oggetto e del passaggio di un riferimento come argomento; Tuttavia, poiché l'argomento è un riferimento all'oggetto, le modifiche apportate a tale oggetto dal chiamato vengono osservate dal chiamante dopo la chiamata.Reference types are also implicitly input parameters, meaning that the caller is responsible for allocating the object and passing a reference to it as argument; however since the argument is a reference to the object, modifications to that object by the callee are observed by the caller after the call. In alternativa, un tipo riferimento può essere reso un parametro di output con la out parola chiave.Alternatively, a reference type can be made an output parameter with the out keyword. In tal caso, i ruoli vengono invertiti; il chiamato è quello che alloca l'oggetto e lo restituisce al chiamante.In that case the roles are reversed; the callee is the one allocating the object and returning it back to the caller. Anche in questo caso ref non è possibile usare le parole chiave in generale con i tipi di riferimento (vedere l'eccezione riportata di seguito).Again, the ref keywords cannot be used in general with reference types (see exception below).

runtimeclass Test
{
    static void CreateObjectWithConfig(Config config, out MyClass newObject);
}

Nella tabella seguente viene riepilogato il comportamento delle parole chiave di marshalling per i parametri di valore e i parametri di riferimento:The following table summarizes the behavior of the marshaling keywords for value parameters and reference parameters:

ComportamentoBehavior Allocato daAllocated by Parola chiaveKeyword TipiTypes CommentiRemarks
Parametro di inputInput parameter ChiamanteCaller (nessuna)(none) Tutti i tipiAll types Comportamento predefinitoDefault behavior
ref const Solo structStruct only Ottimizzazione delle prestazioniPerformance optimization
Parametro di outputOutput parameter ChiamatoCallee out Tutti i tipiAll types

Windows Runtime supporta i tipi di matrice, il cui comportamento come parametro è leggermente diverso.Windows Runtime supports array types, whose behavior as parameter is somewhat different. Una matrice è una struttura di dati che contiene un numero di variabili archiviate in sequenza e a cui si accede tramite un indice.An array is a data structure that contains a number of variables stored sequentially and accessed via an index. Le variabili contenute in una matrice — , denominate anche elementi della matrice — , sono dello stesso tipo e questo tipo è denominato tipo di elemento della matrice.The variables contained in an array—also called the elements of the array—are all of the same type, and this type is called the element type of the array.

MIDL 3,0 supporta le dichiarazioni di una matrice unidimensionale.MIDL 3.0 supports declarations of a single-dimensional array.

Un parametro di matrice è un tipo di riferimento e come tutti i tipi di riferimento è per impostazione predefinita un parametro di input.An array parameter is a reference type, and like all reference types is by default an input parameter. In tal caso, il chiamante alloca la matrice al chiamato, che può leggere gli elementi ma non può modificarli (sola lettura).In that case, the caller allocates the array to the callee, which can read its elements but cannot modify them (read-only). Si tratta del modello di matrice pass .This is called the pass array pattern. In alternativa, è possibile usare il modello di matrice di riempimento aggiungendo la ref parola chiave al parametro; in tale configurazione, la matrice viene ancora allocata dal chiamante, ma è concettualmente un parametro di output nel senso che il chiamato riempie i valori degli elementi della matrice.Alternatively, the fill array pattern can be used by adding the ref keyword to the parameter; in that setup, the array is still allocated by the caller, but is conceptually an output parameter in the sense that the callee will fill the values of the array elements. Infine, l'ultimo modello è la matrice di ricezione in cui, come tutti i parametri di riferimento di output, il chiamato sta allocando e inizializzando l'argomento prima che venga restituito al chiamante.Finally, the last pattern is the receive array where (like all output reference parameters) the callee is both allocating and initializing the argument before it is returned to the caller.

runtimeclass Test
{
    // Pass array pattern: read-only array from caller to callee
    void PassArray(Int32[] values);

    // Fill array pattern: caller allocates array for callee to fill
    void FillArray(ref Int32[] values);

    // Receive array pattern: callee allocates and fill an array returned to caller
    void ReceiveArray(out Int32[] values);
}

Nella tabella seguente viene riepilogato il comportamento per le matrici e i relativi elementi:The following table summarizes the behavior for arrays and their elements:

Modello di matriceArray pattern Parola chiaveKeyword Allocato daAllocated by Accesso agli elementi per chiamataElements access by callee
"Pass array""Pass array" (nessuna)(none) ChiamanteCaller Sola letturaRead-only
"Riempimento matrice""Fill array" ref ChiamanteCaller Sola scritturaWrite-only
"Receive Array""Receive array" out ChiamatoCallee Lettura/scritturaRead-write
Metodi statici e di istanzaStatic and instance methods

Un metodo dichiarato con un static modificatore preceduto è un metodo statico.A method declared with a static modifier prefixed is a static method. Un metodo statico non ha accesso a un'istanza specifica e pertanto può accedere direttamente ad altri membri statici della classe.A static method has no access to a specific instance, and therefore can only directly access other static members of the class.

Un metodo dichiarato senza un static modificatore è un metodo di istanza.A method declared without a static modifier is an instance method. Un metodo di istanza ha accesso a un'istanza specifica e può accedere ai membri statici e di istanza della classe.An instance method has access to a specific instance, and can access both static and instance members of the class.

La classe di entità seguente contiene membri statici e di istanza.The following Entity class has both static and instance members.

runtimeclass Entity
{
    Int32 SerialNo { get; };
    static Int32 GetNextSerialNo();
    static void SetNextSerialNo(Int32 value);
}

Ogni istanza dell' entità contiene il proprio numero di serie (e presumibilmente alcune altre informazioni non illustrate qui).Each Entity instance contains its own serial number (and presumably some other information that is not shown here). Internamente, il costruttore di entità , che è simile a un metodo di istanza, Inizializza la nuova istanza con il numero di serie successivo disponibile.Internally, the Entity constructor (which is like an instance method) initializes the new instance with the next available serial number.

La proprietà SerialNo consente di accedere al numero di serie per l'istanza sulla quale viene richiamato il metodo Get della proprietà .The SerialNo property provides access to the serial number for the instance on which you invoke the property get method.

I metodi statici GetNextSerialNo e SetNextSerialNo possono accedere al membro statico successivo disponibile del numero di serie interno della classe di entità .The GetNextSerialNo and SetNextSerialNo static methods can access the internal next available serial number static member of the Entity class.

Metodi protetti ed overrideProtected and override methods

Tutti i metodi in un tipo di Windows Runtime sono effettivamente virtuali.All methods in a Windows Runtime type are effectively virtual. Quando viene richiamato un metodo virtuale, il tipo in fase di esecuzione dell'istanza per cui viene eseguita la chiamata determina l'implementazione effettiva del metodo da richiamare.When a virtual method is invoked, the run-time type of the instance for which that invocation takes place determines the actual method implementation to invoke.

Un metodo può essere sottoposto a override in una classe derivata.A method can be overridden in a derived class. Quando una dichiarazione di metodo di istanza include un override modificatore, il metodo esegue l'override di un metodo virtuale ereditato con la stessa firma.When an instance method declaration includes an override modifier, the method overrides an inherited virtual method with the same signature. Mentre una dichiarazione di metodo in genere introduce un nuovo metodo, una override dichiarazione di metodo specializza un metodo virtuale ereditato esistente fornendo una nuova implementazione del metodo.Whereas a method declaration ordinarily introduces a new method, an override method declaration specializes an existing inherited virtual method by providing a new implementation of that method.

Quando una dichiarazione di metodo di istanza include un protected modificatore, il metodo è visibile solo alle classi derivate.When an instance method declaration includes a protected modifier, the method is only visible to derived classes.

EventiEvents

Una dichiarazione di evento è un membro che specifica che una classe è un'origine evento.An event declaration is a member that specifies that a class is an event source. Tale origine evento fornisce notifiche a qualsiasi destinatario che implementa un delegato (un metodo con una firma specifica).Such an event source provides notifications to any recipient that implements a delegate (a method with a specific signature).

Si dichiara un evento usando la event parola chiave, seguita dal nome del tipo delegato, che descrive la firma del metodo richiesta, seguito dal nome dell'evento.You declare an event using the event keyword, followed by the delegate type name (which describes the required method signature), followed by the name of the event. Di seguito è riportato un evento di esempio che usa un tipo delegato esistente dalla piattaforma.Here's an example event that uses an existing delegate type from the platform.

runtimeclass Area
{
    ...
    event Windows.UI.Xaml.WindowSizeChangedEventHandler SizeChanged;
    ...
}

Una dichiarazione di evento aggiunge in modo implicito due metodi alla classe: un metodo Add , che viene chiamato da un client per aggiungere un gestore eventi all'origine, e un metodo Remove , che un client chiama per rimuovere un gestore eventi aggiunto in precedenza.An event declaration implicitly adds two methods to the class: an add method, which a client calls to add an event handler to the source, and a remove method, which a client calls to remove a previously added event handler. Di seguito sono riportati altri esempi.Here are more examples.

// Instance event with no meaningful payload.
event Windows.Foundation.TypedEventHandler<BasicClass, Object> Changed;

// Instance event with event parameters.
event Windows.Foundation.TypedEventHandler<BasicClass, BasicClassSaveCompletedEventArgs> SaveCompleted;

// Static event with no meaningful payload.
static event Windows.Foundation.EventHandler<Object> ResetOccurred;

// Static event with event parameters.
static event Windows.Foundation.EventHandler<BasicClassDeviceAddedEventArgs> DeviceAdded;

Per convenzione, due parametri vengono sempre passati a un gestore eventi Windows Runtime: l'identità del mittente e un oggetto arguments dell'evento.By convention, two parameters are always passed to a Windows Runtime event handler: the identity of the sender, and an event arguments object. Il mittente è l'oggetto che ha generato l'evento o null per gli eventi statici.The sender is the object that raised the event, or null for static events. Se l'evento non ha un payload significativo, gli argomenti dell'evento sono un oggetto il cui valore è null.If the event has no meaningful payload, then the event arguments is an Object whose value is null.

DelegatiDelegates

Un tipo delegato specifica un metodo con un elenco di parametri e un tipo restituito specifici.A delegate type specifies a method with a particular parameter list and return type. Una singola istanza di un evento può contenere un numero qualsiasi di riferimenti a istanze del tipo delegato.A single instance of an event can contain any number of references to instances of its delegate type. La dichiarazione è simile a quella di un normale metodo membro, ad eccezione del fatto che esiste al di fuori di una classe di runtime ed è preceduta dalla delegate parola chiave.The declaration is similar to that of a regular member method, except that it exists outside of a runtime class, and it's prefixed with the delegate keyword.

Un delegato consente di trattare metodi come entità che possono essere assegnati a variabili e passati come parametri.A delegate makes it possible to treat methods as entities that can be assigned to variables and passed as parameters. I delegati sono simili al concetto di puntatori a funzione disponibili in altri linguaggi.Delegates are similar to the concept of function pointers found in some other languages. Tuttavia, a differenza dei puntatori a funzione, i delegati sono orientati agli oggetti e indipendenti dai tipi.But, unlike function pointers, delegates are object-oriented and type-safe.

Se non si vuole usare il tipo delegato WindowSizeChangedEventHandler dalla piattaforma, è possibile definire un tipo delegato personalizzato.If we don't want to use the WindowSizeChangedEventHandler delegate type from the platform, then we can define our own delegate type.

delegate void SizeChangedHandler(Object sender, Windows.UI.Core.WindowSizeChangedEventArgs args);

Un'istanza del tipo delegato SizeChangedHandler può fare riferimento a qualsiasi metodo che accetta due argomenti (un oggetto e un WindowSizeChangedEventArgs) e restituisce void.An instance of our SizeChangedHandler delegate type can reference any method that takes two arguments (an Object, and a WindowSizeChangedEventArgs), and returns void. Dopo aver esaminato gli struct, sarà anche possibile sostituire il parametro WindowSizeChangedEventArgs con un tipo di argomenti dell' evento personalizzato.After we've discussed structs, you'll also be able to replace the WindowSizeChangedEventArgs parameter with an event args type of your own.

Una proprietà interessante e utile di un delegato è che non è in grado di conoscere o preoccuparsi della classe del metodo a cui fa riferimento. è importante che il metodo a cui si fa riferimento abbia gli stessi parametri e il tipo restituito del delegato.An interesting and useful property of a delegate is that it doesn't know or care about the class of the method it references; all that matters is that the referenced method has the same parameters and return type as the delegate.

Facoltativamente, è possibile attribuire una dichiarazione di delegato a [uuid(...)] .You can optionally attribute a delegate declaration with [uuid(...)].

Vedere anche delegati che restituiscono HRESULT.Also see Delegates returning HRESULT.

StructStructs

Uno struct è una struttura di dati che può contenere membri dati.A struct is a data structure that can contain data members. Tuttavia, a differenza di una classe, uno struct è un tipo valore.But, unlike a class, a struct is a value type.

I tipi struct sono particolarmente utili per strutture dati di piccole dimensioni che hanno una semantica di valori.Structs are particularly useful for small data structures that have value semantics. I numeri complessi o i punti in un sistema di coordinate sono ottimi esempi di struct.Complex numbers, or points in a coordinate system, are good examples of structs. L'uso di struct anziché classi per strutture di dati di piccole dimensioni può fare una grande differenza nel numero di allocazioni di memoria eseguite da un'applicazione.The use of structs rather than classes for small data structures can make a large difference in the number of memory allocations that an application performs.

Viene ora usato un esempio per contrastare classi e struct.Let's use an example to contrast classes and structs. Ecco una versione di Point First come classe.Here's a version of Point first as a class.

runtimeclass Point
{
    Point(Int32 x, Int32 y);
    Int32 x;
    Int32 y;
}

Questo programma C# crea e Inizializza una matrice di istanze di 100 di Point.This C# program creates and initializes an array of 100 instances of Point. Con il punto implementato come una classe, vengono create istanze di 101 oggetti distinti: uno per l'oggetto matrice. e uno per ogni elemento di 100 punti .With Point implemented as a class, 101 separate objects are instantiated: one for the array object itself; and one for each of the 100 Point elements.

class Test
{
    static Test()
    {
        Point[] points = new Point[100];
        for (Int32 i = 0; i < 100; ++i) points[i] = new Point(i, i);
    }
}

Un'alternativa più efficiente consiste nel creare il punto di uno struct, anziché una classe.A more performant alternative is to make Point a struct, instead of a class.

struct Point
{
    Int32 x;
    Int32 y;
}

A questo punto, viene creata solo un'istanza — dell'oggetto Array.Now, only one object is instantiated—the array object itself. Gli elementi punto vengono archiviati in linea all'interno della matrice; una disposizione di memoria che le cache del processore possono usare per un effetto potente.The Point elements are stored in line inside the array; a memory arrangement that processor caches are able to use to powerful effect.

La modifica di uno struct è una modifica di rilievo binaria.Changing a struct is a binary breaking change. Gli struct implementati come parte di Windows non vengono quindi modificati una volta introdotti.Therefore, structs implemented as part of Windows itself are not altered once introduced.

InterfacceInterfaces

Un' interfaccia definisce un contratto che può essere implementato dalle classi.An interface defines a contract that can be implemented by classes. Un'interfaccia può contenere metodi, proprietà ed eventi — esattamente come le classi.An interface can contain methods, properties, and events—just like classes.

A differenza di una classe, un'interfaccia non fornisce implementazioni dei membri che definisce.Unlike a class, an interface doesn't provide implementations of the members it defines. Specifica semplicemente i membri che devono essere forniti da qualsiasi classe che implementa l'interfaccia.It merely specifies the members that must be supplied by any class that implements the interface.

Le interfacce possono richiedere una classe che implementa l'interfaccia per implementare anche altre interfacce.Interfaces may require a class that implements the interface to also implement other interfaces. Nell'esempio seguente l'interfaccia IComboBox richiede che tutte le classi che implementano IComboBox, implementino anche ITextBox e IListBox.In the following example, the interface IComboBox requires that any class implementing IComboBox, also implement both ITextBox and IListBox. Inoltre, una classe che implementa IComboBox deve implementare IControl.Additionally, a class implementing IComboBox must also implement IControl. Questo perché sia ITextBox che IListBox lo richiedono.That's because both ITextBox and IListBox require it.

interface IControl
{
    void Paint();
}

interface ITextBox requires IControl
{
    void SetText(String text);
}

interface IListBox requires IControl
{
    void SetItems(String[] items);
}

interface IComboBox requires ITextBox, IListBox
{
    ...
}

Una classe può implementare zero o più interfacce.A class can implement zero or more interfaces. Nell'esempio seguente la classe casella implementa sia IControl che IDataBound.In the next example, the class EditBox implements both IControl and IDataBound.

interface IDataBound
{
    void Bind(Binder b);
}

runtimeclass EditBox : IControl, IDataBound
{
}

Per Windows Runtime tipi nella piattaforma Windows, viene definita un'interfaccia se gli sviluppatori che utilizzano tali tipi si prevede di implementare l'interfaccia.For Windows Runtime types in the Windows platform, an interface is defined if developers who consume those types are expected to implement the interface. Un altro caso d'uso per la definizione di un'interfaccia è quando più classi di Runtime implementano l'interfaccia e gli sviluppatori che utilizzano tali classi di runtime accederanno a diversi tipi di oggetto in modo generico (e quindi in modo polimorfico) tramite tale interfaccia comune.Another use case for defining an interface is when multiple runtime classes implement the interface, and developers consuming those runtime classes will access different types of object generically (and thus polymorphically) via that common interface.

Nota

Considerare due volte l'uso della requires parola chiave in MIDL 3,0.Think twice about using the requires keyword in MIDL 3.0. Questo può comportare progettazioni confuse, soprattutto quando viene presa in considerazione il controllo delle versioni.It can lead to messy designs, especially when versioning is taken into account.

EnumerazioniEnums

Un tipo enum (o un tipo enumerato, o enumerazione) è un tipo di valore distinct con un set di costanti denominate.An enum type (or enumerated type, or enumeration) is a distinct value type with a set of named constants. Nell'esempio seguente viene definito e utilizzato un tipo enum denominato color con tre valori costanti: rosso, verde e blu.The following example defines and uses an enum type named Color with three constant values: Red, Green, and Blue.

enum Color
{
    Red,
    Green,
    Blue, // Trailing comma is optional, but recommended to make future changes easier.
};

Ogni tipo di enumerazione ha un tipo integrale corrispondente denominato tipo sottostante del tipo enum.Each enum type has a corresponding integral type called the underlying type of the enum type. Il tipo sottostante di un'enumerazione è Int32 o UInt32.The underlying type of an enum is either Int32 or UInt32.

Il Windows Runtime supporta due tipi di enumerazioni: enum normali e enumerazioni di flag .The Windows Runtime supports two kinds of enums: normal enums, and flags enums. Un'enumerazione del tipo normale esprime un set di valori esclusivi. mentre uno dei flag Kind rappresenta un set di valori booleani.An enum of the normal kind expresses a set of exclusive values; while one of the flags kind represents a set of Boolean values. Per abilitare gli operatori bit per bit per un'enumerazione Flags, il compilatore MIDL 3,0 genera overload degli operatori C++.To enable bitwise operators for a flags enum, the MIDL 3.0 compiler generates C++ operator overloads.

All'enumerazione Flags è [flags] applicato l'attributo.A flags enum has the [flags] attribute applied. In tal caso, il tipo sottostante dell'enumerazione è UInt32.In that case, the underlying type of the enum is UInt32. Quando l' [flags] attributo non è presente (enumerazione normale), il tipo sottostante dell'enumerazione è Int32.When the [flags] attribute is not present (a normal enum), the underlying type of the enum is Int32. Non è possibile dichiarare un'enumerazione come qualsiasi altro tipo.It's not possible to declare an enum as any other type.

[flags]
enum SetOfBooleanValues
{
    None   = 0x00000000,
    Value1 = 0x00000001,
    Value2 = 0x00000002,
    Value3 = 0x00000004,
};

Il formato di archiviazione e l'intervallo di valori possibili di un tipo enum sono determinati dal tipo sottostante.An enum type's storage format and range of possible values are determined by its underlying type. Il set di valori che un tipo enum può assumere non è limitato dai membri enum dichiarati.The set of values that an enum type can take on is not limited by its declared enum members.

Nell'esempio seguente viene definito un tipo enum denominato Alignment, con un tipo sottostante Int32.The following example defines an enum type named Alignment, with an underlying type of Int32.

enum Alignment
{
    Left = -1,
    Center = 0,
    Right = 1
};

Come accade anche per C e C++, un'enum MIDL 3,0 può includere un'espressione costante che specifica il valore del membro, come illustrato in precedenza.As is also true for C and C++, a MIDL 3.0 enum can include a constant expression that specifies the value of the member (as seen above). Il valore costante per ogni membro enum deve essere compreso nell'intervallo del tipo sottostante dell'enumerazione.The constant value for each enum member must be in the range of the underlying type of the enum. Quando una dichiarazione di un membro enum non specifica in modo esplicito un valore, al membro viene assegnato il valore zero (se è il primo membro nel tipo enum) o il valore del membro enum testuale precedente, più uno.When an enum member declaration doesn't explicitly specify a value, the member is given the value zero (if it is the first member in the enum type), or the value of the textually preceding enum member plus one.

Nell'esempio seguente viene definito un tipo enum denominato Permissions, con un tipo sottostante UInt32.The following example defines an enum type named Permissions, with an underlying type of UInt32.

[flags]
enum Permissions
{
    None = 0x0000,
    Camera = 0x0001,
    Microphone = 0x0002
};

AttributiAttributes

I tipi, i membri e altre entità nel codice sorgente MIDL 3,0 supportano i modificatori che controllano alcuni aspetti del comportamento.Types, members, and other entities in MIDL 3.0 source code support modifiers that control certain aspects of their behavior. L'accessibilità di un metodo, ad esempio, viene controllata usando il protected modificatore di accesso.For example, the accessibility of a method is controlled using the protected access modifier. MIDL 3,0 generalizza questa funzionalità in modo che i tipi definiti dall'utente di informazioni dichiarative possano essere collegati alle entità del programma e recuperati in fase di esecuzione dai metadati.MIDL 3.0 generalizes this capability such that user-defined types of declarative information can be attached to program entities, and retrieved at run-time from the metadata.

I programmi specificano queste informazioni dichiarative aggiuntive definendo e usando attributi.Programs specify this additional declarative information by defining and using attributes.

Nell'esempio successivo viene definito un attributo HelpAttribute , che può essere inserito in entità Program per fornire collegamenti alla relativa documentazione associata.The next example defines a HelpAttribute attribute, which can be placed on program entities to provide links to their associated documentation. Come si può notare, un attributo è essenzialmente un tipo struct, quindi non dispone di un costruttore e contiene solo membri dati.As you can see, an attribute is essentially a struct type, so it doesn't have a constructor, and contains only data members.

[attributeusage(target_runtimeclass, target_event, target_method, target_property)]
attribute HelpAttribute
{
    String ClassUri;
    String MemberTopic;
}

Un attributo può essere applicato assegnando il nome, insieme a qualsiasi argomento, all'interno di parentesi quadre immediatamente prima della dichiarazione associata.An attribute can be applied by giving its name, along with any arguments, inside square brackets just before the associated declaration. Se il nome di un attributo termina con Attribute, la parte del nome può essere omessa quando si fa riferimento all'attributo.If an attribute's name ends in Attribute, then that part of the name can be omitted when the attribute is referenced. Ad esempio, l'attributo HelpAttribute può essere usato come questo.For example, the HelpAttribute attribute can be used like this.

[Help("https://docs.contoso.com/.../BookSku", "BookSku class")]
runtimeclass BookSku : Windows.UI.Xaml.Data.INotifyPropertyChanged
{
    [Help("https://docs.contoso.com/.../BookSku_Title", "Title method")]
    String Title;
}

È possibile applicare lo stesso attributo a più dichiarazioni utilizzando un blocco di ambito che segue l'attributo.You can apply the same attribute to multiple declarations by using a scope block following the attribute. Ovvero un attributo seguito immediatamente da parentesi graffe che racchiudono le dichiarazioni a cui si applica l'attributo.That is, an attribute immediately followed by braces surrounding the declarations to which the attribute applies.

runtimeclass Widget
{
    [Help("https://docs.contoso.com/.../Widget", "Widget members")]
    {
        void Display(String text);
        void Print();
        Single Rate;
    }
}

Gli attributi implementati come parte di Windows sono in genere nello spazio dei nomi Windows. Foundation .Attributes implemented as part of Windows itself are usually in the Windows.Foundation namespace.

Come illustrato nel primo esempio, si usa l' [attributeusage(<target>)] attributo nella definizione dell'attributo.As shown in the first example, you use the [attributeusage(<target>)] attribute on your attribute definition. I valori di destinazione validi sono target_all ,, target_delegate target_enum , target_event , target_field , target_interface , target_method , target_parameter , target_property , target_runtimeclass e target_struct .Valid target values are target_all, target_delegate, target_enum, target_event, target_field, target_interface, target_method, target_parameter, target_property, target_runtimeclass, and target_struct. È possibile includere più destinazioni tra parentesi, separate da virgole.You can include multiple targets within the parentheses, separated by commas.

Altri attributi che è possibile applicare a un attributo sono [allowmultiple] e [attributename("<name>")] .Other attributes you can apply to an attribute are [allowmultiple] and [attributename("<name>")].

Tipi con parametriParameterized types

Nell'esempio seguente viene generato l' errore MIDL2025: [msg] sintassi Error [Context]: expecting > o, near ">>".The example below produces error MIDL2025: [msg]syntax error [context]: expecting > or, near ">>".

Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<String>> RetrieveCollectionAsync();

Inserire invece uno spazio tra i due > caratteri in modo che la coppia di caratteri di chiusura del modello non venga interpretata erroneamente come operatore di spostamento a destra.Instead, insert a space between the two > characters so that the pair of template-closing characters is not misinterpreted as a right-shift operator.

Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<String> > RetrieveCollectionAsync();

Nell'esempio seguente viene generato l' errore MIDL2025: [msg] sintassi Error [Context]: expecting > o, near "[".The example below produces error MIDL2025: [msg]syntax error [context]: expecting > or, near "[". Questo perché non è valido utilizzare una matrice come argomento di tipo di parametro per un'interfaccia con parametri.This is because it's invalid to use an array as a parameter type argument to a parameterized interface.

Windows.Foundation.IAsyncOperation<Int32[]> RetrieveArrayAsync();

Per la soluzione, vedere restituzione di una matrice in modo asincrono.For the solution, see Returning an array asynchronously.