PhoneExperienceHost Provides application-specific behavior to supplement the default Application class. InitializeComponent() GetXamlType(Type) GetXamlType(String) GetXmlnsDefinitions() An empty window that can be used on its own or navigated to within a Frame. InitializeComponent() Connect() GetBindingConnector(int connectionId, object target) Bootstrapper is where we build the dependency injection container. We support three types of registrations: - Singleton: Only a single instance exists for the duration of the app - Scoped: Every window get's its own instance and the class can't be instantiated without a window scope. - Transient: Every time the object is resolved it will get a new instance. These registrations are the cheapest as there is no bookkeeping needed. NOTE: Any UI object, view and viewmodel needs to be registered as scoped or transient. Scoped registrations can only be resolved in the context of a window and are disposed once the window scope is disposed (generally when the window closes). Singleton registrations cannot depend on scoped registrations. InitializeComponent() Connect() GetBindingConnector(int connectionId, object target) InitializeComponent() Connect() GetBindingConnector(int connectionId, object target) InitializeComponent() Connect() GetBindingConnector(int connectionId, object target) InitializeComponent() Connect() GetBindingConnector(int connectionId, object target) InitializeComponent() Connect() GetBindingConnector(int connectionId, object target) InitializeComponent() Connect() GetBindingConnector(int connectionId, object target) InitializeComponent() Connect() GetBindingConnector(int connectionId, object target) This protocol parser handles the com server protocol. This protocol parser handles the app protocol, as well as a null protocol if we have a device. Fired when the app was launched after previously being suspended and closed by the OS. Raises the Restarting event. The activated event args. InitializeComponent() UnloadObject(DependencyObject) Connect() DisconnectUnloadedObject(int connectionId) GetBindingConnector(int connectionId, object target) InitializeComponent() Connect() GetBindingConnector(int connectionId, object target) NOTE: This activity doesn't include linked device info or ring info as this is not yet initialized when the event happens. This class writes the DelegateExecute value to the registry for the ms-phone protocol. By default the packaging stack writes its own server that will get activate when a protocol launch happens. It will then use the activation stack to activate the app in a new process. Because we are single instance, we then have to redirect that activation to the main instance. Instead this class writes our own DelegateExecute server to the registry so we bypass the appx stack handling of protocol launch to speed up protocol launch. This function generates a ProgId for the given packageFamilyName, packageRelativeApplicationId, category and subcategory, using the same algorithm as StateRepository::DataType::ProgId::GenerateProgId in onecore\base\appmodel\StateRepository\DataAccessLayer\DataType-ProgId.cpp DispatcherQueueSyncContext allows developers to await calls and get back onto the UI thread. Needs to be installed on the UI thread through DispatcherQueueSyncContext.SetForCurrentThread This class has been modified from the one shipping in the WindowsAppSDK by adding support for Send, see https://github.com/microsoft/CsWinRT/pull/1078 Handles the Application Lifecycle. Main class for providing metadata for the app or library GetXamlType(Type) GetXamlType(String) GetXmlnsDefinitions() Contains extern methods from "api-ms-win-core-winrt-l1-1-0.dll". Contains extern methods from "api-ms-win-core-winrt-string-l1-1-0.dll". Contains extern methods from "KERNEL32.dll". Contains extern methods from "OLE32.dll". Contains extern methods from "USER32.dll". Removes an array of registered activation factories from the Windows Runtime. Type: RO_REGISTRATION_COOKIE Call the RoRevokeActivationFactories function remove the activation factories represented in the cookie array from the Windows Runtime. Gets the activation factory for the specified runtime class. (RoGetActivationFactory) Type: HSTRING The ID of the activatable class. Read more on docs.microsoft.com. Type: REFIID The reference ID of the interface. Read more on docs.microsoft.com. Type: void** The activation factory. Read more on docs.microsoft.com. Type: HRESULT If this function succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. Learn more about this API from docs.microsoft.com. Decrements the reference count of a string buffer. Type: HRESULT This function always returns S_OK. Use the WindowsDeleteString function to de-allocate an [**HSTRING**](/windows/win32/winrt/hstring). Calling WindowsDeleteString decrements the reference count of the backing buffer, and if the reference count reaches 0, the Windows Runtime de-allocates the buffer. Creates a new HSTRING based on the specified source string. Type: [in, optional] LPCWSTR A null-terminated string to use as the source for the new [**HSTRING**](/windows/win32/winrt/hstring). To create a new, empty, or NULL string, pass NULL for sourceString and 0 for length. Read more on docs.microsoft.com. Type: [in] UINT32 The length of sourceString, in Unicode characters. Must be 0 if sourceString is NULL. Read more on docs.microsoft.com. Type: HRESULT This function can return one of these values. This doc was truncated. Use the WindowsCreateString function to allocate a new [**HSTRING**](/windows/win32/winrt/hstring). The Windows Runtime copies string to the backing buffer of the new HSTRING and manages the buffer lifetime by using a reference count. Call the WindowsCreateStringReference function to create a fast-pass string, which uses an existing string without copying it. Call the WindowsDeleteString function to de-allocate the [**HSTRING**](/windows/win32/winrt/hstring). Each call to the WindowsCreateString function must be matched by a call to WindowsDeleteString. To create a new, empty, or NULL string, pass NULL for sourceString and 0 for length. If sourceString has embedded null characters, the WindowsCreateString function copies all characters to the terminating null character. Read more on docs.microsoft.com. Registers the active instance of an application for restart. A pointer to a Unicode string that specifies the command-line arguments for the application when it is restarted. The maximum size of the command line that you can specify is RESTART_MAX_CMD_LINE characters. Do not include the name of the executable in the command line; this function adds it for you. If this parameter is NULL or an empty string, the previously registered command line is removed. If the argument contains spaces, use quotes around the argument. Read more on docs.microsoft.com. This function returns S_OK on success or one of the following error codes. This doc was truncated. Your initial registration for restart must occur before the application encounters an unhandled exception or becomes unresponsive. You could then call this function from inside your recovery callback to update the command line. For a Windows application that is being updated, the last opportunity to call this function is while processing the WM_QUERYENDSESSION message. For a console application that is being updated, the registration must occur before the installer tries to shutdown the application (you need to keep the registration current; you cannot call this function when handling the CTRL_C_EVENT notification). If you register for restart and the application encounters an unhandled exception or is not responsive, the user is offered the opportunity to restart the application; the application is not automatically restarted without the user's consent. However, if the application is being updated and requires a restart, the application is restarted automatically. To prevent cyclical restarts, the system will only restart the application if it has been running for a minimum of 60 seconds. Note that for an application to be restarted when the update requires a computer restart, the installer must call the ExitWindowsEx function with the EWX_RESTARTAPPS flag set or the InitiateShutdown function with the SHUTDOWN_RESTARTAPPS flag set. Read more on docs.microsoft.com. Registers an EXE class object with OLE so other applications can connect to it. The CLSID to be registered. A pointer to the IUnknown interface on the class object whose availability is being published. The context in which the executable code is to be run. For information on these context values, see the CLSCTX enumeration. Indicates how connections are made to the class object. For information on these flags, see the REGCLS enumeration. A pointer to a value that identifies the class object registered; later used by the CoRevokeClassObject function to revoke the registration. This function can return the standard return values E_INVALIDARG, E_OUTOFMEMORY, and E_UNEXPECTED, as well as the following values. This doc was truncated. EXE object applications should call CoRegisterClassObject on startup. It can also be used to register internal objects for use by the same EXE or other code (such as DLLs) that the EXE uses. Only EXE object applications call CoRegisterClassObject. Object handlers or DLL object applications do not call this function — instead, they must implement and export the DllGetClassObject function. At startup, a multiple-use EXE object application must create a class object (with the IClassFactory interface on it), and call CoRegisterClassObject to register the class object. Object applications that support several different classes (such as multiple types of embeddable objects) must allocate and register a different class object for each. Multiple registrations of the same class object are independent and do not produce an error. Each subsequent registration yields a unique key in lpdwRegister. Multiple document interface (MDI) applications must register their class objects. Single document interface (SDI) applications must register their class objects only if they can be started by means of the /Embedding switch. The server for a class object should call CoRevokeClassObject to revoke the class object (remove its registration) when all of the following are true: This doc was truncated. Read more on docs.microsoft.com. Informs OLE that a class object, previously registered with the CoRegisterClassObject function, is no longer available for use. A token previously returned from the CoRegisterClassObject function. This function can return the standard return values E_INVALIDARG, E_OUTOFMEMORY, and E_UNEXPECTED, as well as the following values. This doc was truncated. A successful call to CoRevokeClassObject means that the class object has been removed from the global class object table (although it does not release the class object). If other clients still have pointers to the class object and have caused the reference count to be incremented by calls to IUnknown::AddRef, the reference count will not be zero. When this occurs, applications may benefit if subsequent calls (with the obvious exceptions of AddRef and IUnknown::Release) to the class object fail. Note that CoRegisterClassObject calls AddRef and CoRevokeClassObject calls Release, so the two functions form an AddRef/Release pair. An object application must call CoRevokeClassObject to revoke registered class objects before exiting the program. Class object implementers should call CoRevokeClassObject as part of the release sequence. You must specifically revoke the class object even when you have specified the flags value REGCLS_SINGLEUSE in a call to CoRegisterClassObject, indicating that only one application can connect to the class object. Read more on docs.microsoft.com. Called by a server that can register multiple class objects to inform the SCM about all registered classes, and permits activation requests for those class objects. This function returns S_OK to indicate that the CLSID was retrieved successfully. Servers that can register multiple class objects call CoResumeClassObjects once, after having first called CoRegisterClassObject, specifying REGCLS_LOCAL_SERVER | REGCLS_SUSPENDED for each CLSID the server supports. This function causes OLE to inform the SCM about all the registered classes, and begins letting activation requests into the server process. This reduces the overall registration time, and thus the server application startup time, by making a single call to the SCM, no matter how many CLSIDs are registered for the server. Another advantage is that if the server has multiple apartments with different CLSIDs registered in different apartments, or is a free-threaded server, no activation requests will come in until the server calls CoResumeClassObjects. This gives the server a chance to register all of its CLSIDs and get properly set up before having to deal with activation requests, and possibly shutdown requests. Read more on docs.microsoft.com. Indicates to the system that a thread has made a request to terminate (quit). It is typically used in response to a WM_DESTROY message. Type: int The application exit code. This value is used as the wParam parameter of the WM_QUIT message. Read more on docs.microsoft.com. The PostQuitMessage function posts a WM_QUIT message to the thread's message queue and returns immediately; the function simply indicates to the system that the thread is requesting to quit at some time in the future. When the thread retrieves the WM_QUIT message from its message queue, it should exit its message loop and return control to the system. The exit value returned to the system must be the wParam parameter of the WM_QUIT message. Read more on docs.microsoft.com. Values that are used in activation calls to indicate the execution contexts in which an object is to be run. Values from the CLSCTX enumeration are used in activation calls (CoCreateInstance, CoCreateInstanceEx, CoGetClassObject, and so on) to indicate the preferred execution contexts (in-process, local, or remote) in which an object is to be run. They are also used in calls to CoRegisterClassObject to indicate the set of execution contexts in which a class object is to be made available for requests to construct instances (IClassFactory::CreateInstance). To indicate that more than one context is acceptable, you can combine multiple values with Boolean ORs. The contexts are tried in the order in which they are listed. Given a set of CLSCTX flags, the execution context to be used depends on the availability of registered class codes and other parameters according to the following algorithm. This doc was truncated. Read more on docs.microsoft.com. The code that creates and manages objects of this class is a DLL that runs in the same process as the caller of the function specifying the class context. The code that manages objects of this class is an in-process handler. This is a DLL that runs in the client process and implements client-side structures of this class when instances of the class are accessed remotely. The EXE code that creates and manages objects of this class runs on same machine but is loaded in a separate process space. Obsolete. A remote context. The LocalServer32 or LocalService code that creates and manages objects of this class is run on a different computer. Obsolete. Reserved. Reserved. Reserved. Reserved. Disables the downloading of code from the directory service or the Internet. This flag cannot be set at the same time as CLSCTX_ENABLE_CODE_DOWNLOAD. Reserved. Specify if you want the activation to fail if it uses custom marshalling. Enables the downloading of code from the directory service or the Internet. This flag cannot be set at the same time as CLSCTX_NO_CODE_DOWNLOAD. The CLSCTX_NO_FAILURE_LOG can be used to override the logging of failures in CoCreateInstanceEx. If the ActivationFailureLoggingLevel is created, the following values can determine the status of event logging: This doc was truncated. Read more on docs.microsoft.com. Disables activate-as-activator (AAA) activations for this activation only. This flag overrides the setting of the EOAC_DISABLE_AAA flag from the EOLE_AUTHENTICATION_CAPABILITIES enumeration. This flag cannot be set at the same time as CLSCTX_ENABLE_AAA. Any activation where a server process would be launched under the caller's identity is known as an activate-as-activator (AAA) activation. Disabling AAA activations allows an application that runs under a privileged account (such as LocalSystem) to help prevent its identity from being used to launch untrusted components. Library applications that use activation calls should always set this flag during those calls. This helps prevent the library application from being used in an escalation-of-privilege security attack. This is the only way to disable AAA activations in a library application because the EOAC_DISABLE_AAA flag from the EOLE_AUTHENTICATION_CAPABILITIES enumeration is applied only to the server process and not to the library application. Windows 2000:  This flag is not supported. Read more on docs.microsoft.com. Enables activate-as-activator (AAA) activations for this activation only. This flag overrides the setting of the EOAC_DISABLE_AAA flag from the EOLE_AUTHENTICATION_CAPABILITIES enumeration. This flag cannot be set at the same time as CLSCTX_DISABLE_AAA. Any activation where a server process would be launched under the caller's identity is known as an activate-as-activator (AAA) activation. Enabling this flag allows an application to transfer its identity to an activated component. Windows 2000:  This flag is not supported. Read more on docs.microsoft.com. Begin this activation from the default context of the current apartment. Activate or connect to a 32-bit version of the server; fail if one is not registered. Activate or connect to a 64 bit version of the server; fail if one is not registered. When this flag is specified, COM uses the impersonation token of the thread, if one is present, for the activation request made by the thread. When this flag is not specified or if the thread does not have an impersonation token, COM uses the process token of the thread's process for the activation request made by the thread. Windows Vista or later:  This flag is supported. Read more on docs.microsoft.com. Indicates activation is for an app container.
Note  This flag is reserved for internal use and is not intended to be used directly from your code.
 
 Read more on docs.microsoft.com. Specify this flag for Interactive User activation behavior for As-Activator servers. A strongly named Medium IL Windows Store app can use this flag to launch an "As Activator" COM server without a strong name. Also, you can use this flag to bind to a running instance of the COM server that's launched by a desktop application. The client must be Medium IL, it must be strongly named, which means that it has a SysAppID in the client token, it can't be in session 0, and it must have the same user as the session ID's user in the client token. If the server is out-of-process and "As Activator", it launches the server with the token of the client token's session user. This token won't be strongly named. If the server is out-of-process and RunAs "Interactive User", this flag has no effect. If the server is out-of-process and is any other RunAs type, the activation fails. This flag has no effect for in-process servers. Off-machine activations fail when they use this flag. Read more on docs.microsoft.com. Used for loading Proxy/Stub DLLs.
Note  This flag is reserved for internal use and is not intended to be used directly from your code.
 
 Read more on docs.microsoft.com. Increments the reference count for an interface pointer to a COM object. You should call this method whenever you make a copy of an interface pointer. The method returns the new reference count. This value is intended to be used only for test purposes. A COM object uses a per-interface reference-counting mechanism to ensure that the object doesn't outlive references to it. You use **AddRef** to stabilize a copy of an interface pointer. It can also be called when the life of a cloned pointer must extend beyond the lifetime of the original pointer. The cloned pointer must be released by calling [IUnknown::Release](/windows/desktop/api/unknwn/nf-unknwn-iunknown-queryinterface(refiid_void)) on it. The internal reference counter that **AddRef** maintains should be a 32-bit unsigned integer. Read more on docs.microsoft.com. Decrements the reference count for an interface on a COM object. The method returns the new reference count. This value is intended to be used only for test purposes. When the reference count on an object reaches zero, **Release** must cause the interface pointer to free itself. When the released pointer is the only (formerly) outstanding reference to an object (whether the object supports single or multiple interfaces), the implementation must free the object. Note that aggregation of objects restricts the ability to recover interface pointers. Read more on docs.microsoft.com. The IID guid for this interface. {00000000-0000-0000-c000-000000000046} Controls the type of connections to a class object. In CoRegisterClassObject, members of both the REGCLS and the CLSCTX enumerations, taken together, determine how the class object is registered. An EXE surrogate (in which DLL servers are run) calls CoRegisterClassObject to register a class factory using a new REGCLS value, REGCLS_SURROGATE. All class factories for DLL surrogates should be registered with REGCLS_SURROGATE set. Do not set REGCLS_SINGLUSE or REGCLS_MULTIPLEUSE when you register a surrogate for DLL servers. The following table summarizes the allowable REGCLS value combinations and the object registrations affected by the combinations. This doc was truncated. Read more on docs.microsoft.com. After an application is connected to a class object with CoGetClassObject, the class object is removed from public view so that no other applications can connect to it. This value is commonly used for single document interface (SDI) applications. Specifying this value does not affect the responsibility of the object application to call CoRevokeClassObject; it must always call CoRevokeClassObject when it is finished with an object class. Multiple applications can connect to the class object through calls to CoGetClassObject. If both the REGCLS_MULTIPLEUSE and CLSCTX_LOCAL_SERVER are set in a call to CoRegisterClassObject, the class object is also automatically registered as an in-process server, whether CLSCTX_INPROC_SERVER is explicitly set. Useful for registering separate CLSCTX_LOCAL_SERVER and CLSCTX_INPROC_SERVER class factories through calls to CoGetClassObject. If REGCLS_MULTI_SEPARATE is set, each execution context must be set separately; CoRegisterClassObject does not automatically register an out-of-process server (for which CLSCTX_LOCAL_SERVER is set) as an in-process server. This allows the EXE to create multiple instances of the object for in-process needs, such as self embeddings, without disturbing its CLSCTX_LOCAL_SERVER registration. If an EXE registers a REGCLS_MULTI_SEPARATE class factory and a CLSCTX_INPROC_SERVER class factory, instance creation calls that specify CLSCTX_INPROC_SERVER in the CLSCTX parameter executed by the EXE would be satisfied locally without approaching the SCM. This mechanism is useful when the EXE uses functions such as OleCreate and OleLoad to create embeddings, but at the same does not wish to launch a new instance of itself for the self-embedding case. The distinction is important for embeddings because the default handler aggregates the proxy manager by default and the application should override this default behavior by calling OleCreateEmbeddingHelper for the self-embedding case. If your application need not distinguish between the local and inproc case, you need not register your class factory using REGCLS_MULTI_SEPARATE. In fact, the application incurs an extra network round trip to the SCM when it registers its MULTIPLEUSE class factory as MULTI_SEPARATE and does not register another class factory as INPROC_SERVER. Read more on docs.microsoft.com. Suspends registration and activation requests for the specified CLSID until there is a call to CoResumeClassObjects. This is used typically to register the CLSIDs for servers that can register multiple class objects to reduce the overall registration time, and thus the server application startup time, by making a single call to the SCM, no matter how many CLSIDs are registered for the server.
Note  This flag prevents COM activation errors from a possible race condition between an application shutting down and that application attempting to register a COM class.
 
 Read more on docs.microsoft.com. The class object is a surrogate process used to run DLL servers. The class factory registered by the surrogate process is not the actual class factory implemented by the DLL server, but a generic class factory implemented by the surrogate. This generic class factory delegates instance creation and marshaling to the class factory of the DLL server running in the surrogate. For further information on DLL surrogates, see the DllSurrogate registry value. The class object aggregates the free-threaded marshaler and will be made visible to all inproc apartments. Can be used together with other flags. For example, REGCLS_AGILE | REGCLS_MULTIPLEUSE to register a class object that can be used multiple times from different apartments. Without other flags, behavior will retain REGCLS_SINGLEUSE semantics in that only one instance can be generated. Read more on docs.microsoft.com. A handle to a Windows Runtime string. Use **HSTRING** to represent immutable strings in the Windows Runtime. JavaScript and other languages, such as C\#, and Microsoft Visual Basic, can use strings that are represented by using **HSTRING**. The following table shows how an **HSTRING** is represented in other languages. | Programming Language | String Representation | |-----------------------------------------------------------------------------------------|------------------------------------------------------------| | [C++/WinRT](/windows/uwp/cpp-and-winrt-apis/intro-to-using-cpp-with-winrt) | [winrt::hstring](/uwp/cpp-ref-for-winrt/hstring) class | | Visual C++ component extensions ([C++/CX](/cpp/cppcx/visual-c-language-reference-c-cx)) | [Platform::String](/cpp/cppcx/platform-string-class) class | | JavaScript | String object | | .NET Framework | System.String class | The **HSTRING** handle is a standard handle type. Semantically, an **HSTRING** containing the value **NULL** represents the empty string, which consists of zero content characters and a terminating **NULL** character. Creating a string via [**WindowsCreateString**](/windows/win32/api/winstring/nf-winstring-windowscreatestring) with zero characters will produce the handle value **NULL**. When calling [**WindowsGetStringRawBuffer**](/windows/win32/api/winstring/nf-winstring-windowsgetstringrawbuffer) with the value **NULL**, a pointer to an empty string followed only by the **NUL** terminating character will be returned. No distinct value exists to represent an **HSTRING** that is uninitialized. Call the [**WindowsCreateString**](/windows/win32/api/winstring/nf-winstring-windowscreatestring) function to create a new **HSTRING**, and call the [**WindowsDeleteString**](/windows/win32/api/winstring/nf-winstring-windowsdeletestring) function to release the reference to the backing string memory. Call the [**WindowsCreateStringReference**](/windows/win32/api/winstring/nf-winstring-windowscreatestringreference) function to create a string reference, which is also called a *fast-pass string*. Copy an **HSTRING** by calling the [**WindowsDuplicateString**](/windows/win32/api/winstring/nf-winstring-windowsduplicatestring) function. Concatenate two strings by calling the [**WindowsConcatString**](/windows/win32/api/winstring/nf-winstring-windowsconcatstring) function. Access the backing string memory by calling the [**WindowsGetStringRawBuffer**](/windows/win32/api/winstring/nf-winstring-windowsgetstringrawbuffer) function. **HSTRING** can store and use embedded **NUL** characters. Use the [**WindowsStringHasEmbeddedNull**](/windows/win32/api/winstring/nf-winstring-windowsstringhasembeddednull) function to check for embedded **NUL** characters before using any functions which may produce unexpected results. For example, most of the Windows functions use **LPCWSTR** as an input parameter, and they compute the length of the string only until the first **NUL** is encountered. The backing string must remain immutable and null-terminated. When calling code creates a string reference by using the [**WindowsCreateStringReference**](/windows/win32/api/winstring/nf-winstring-windowscreatestringreference) function, the memory containing the backing string representation is owned by the caller. The Windows Runtime relies on the contents of the original string to remain unchanged. When passing a string reference into the Windows Runtime, it is the caller’s responsibility to ensure that the string’s contents are unchanging and **NUL** terminated for the duration of the call. The Windows Runtime releases all references to the string reference when the call returns. When you receive an **HSTRING** as an out parameter, it is good practice to set the handle to **NULL** when you are finished with it. Call the [**WindowsPreallocateStringBuffer**](/windows/win32/api/winstring/nf-winstring-windowspreallocatestringbuffer) function to allocate a mutable string buffer that you can use to create an immutable **HSTRING**. When you have finished populating the buffer, you call the [**WindowsPromoteStringBuffer**](/windows/win32/api/winstring/nf-winstring-windowspromotestringbuffer) function to create the **HSTRING**. This two-phase construction pattern enables functionality that is similar to a "string builder." Read more on docs.microsoft.com. The **HRESULT** data type is the same as the [SCODE](scode.md) data type. An **HRESULT** value consists of the following fields: - A 1-bit code indicating severity, where zero represents success and 1 represents failure. - A 4-bit reserved value. - An 11-bit code indicating responsibility for the error or warning, also known as a facility code. - A 16-bit code describing the error or warning. Most MAPI interface methods and functions return **HRESULT** values to provide detailed cause formation. **HRESULT** values are also used widely in OLE interface methods. OLE provides several macros for converting between **HRESULT** values and **SCODE** values, another common data type for error handling. > [!NOTE] > In 64-bit MAPI, **HRESULT** is still a 32-bit value. For information about the OLE use of **HRESULT** values, see the *OLE Programmer's Reference*. For more information about the use of these values in MAPI, see [Error Handling](error-handling-in-mapi.md) and any of the following interface methods: [IABLogon::GetLastError](iablogon-getlasterror.md) [IMAPISupport::GetLastError](imapisupport-getlasterror.md) [IMAPIControl::GetLastError](imapicontrol-getlasterror.md) [IMAPITable::GetLastError](imapitable-getlasterror.md) [IMAPIProp::GetLastError](imapiprop-getlasterror.md) [IMAPIViewAdviseSink::OnPrint](imapiviewadvisesink-onprint.md) Read more on docs.microsoft.com. A pointer to the IErrorInfo interface that provides more information about the error. You can specify to use the current IErrorInfo interface, or new IntPtr(-1) to ignore the current IErrorInfo interface and construct the exception just from the error code. , if it does not reflect an error. Documentation varies per use. Refer to each: IMbnConnectionContextEvents.OnSetProvisionedContextComplete, IMbnConnectionEvents.OnConnectComplete, IMbnPinEvents.OnChangeComplete, IMbnPinEvents.OnDisableComplete, IMbnPinEvents.OnEnableComplete, IMbnPinEvents.OnEnterComplete, IMbnPinEvents.OnUnblockComplete, IMbnPinManagerEvents.OnGetPinStateComplete, IMbnRadioEvents.OnSetSoftwareRadioStateComplete, IMbnServiceActivationEvents.OnActivationComplete, IMbnSmsEvents.OnSetSmsConfigurationComplete, IMbnSmsEvents.OnSmsDeleteComplete, IMbnSmsEvents.OnSmsReadComplete, IMbnSmsEvents.OnSmsSendComplete. A pointer to a null-terminated, constant character string. A pointer to the first character in the string. The content should be considered readonly, as it was typed as constant in the SDK. Gets the number of characters up to the first null character (exclusive). Returns a with a copy of this character array, up to the first null character (exclusive). A , or if is . Returns a span of the characters in this string, up to the first null character (exclusive). The IID guid for this interface. The reference that is returned comes from a permanent memory address, and is therefore safe to convert to a pointer and pass around or hold long-term. Represents a Win32 handle that can be closed with . Defines a C export. Can be used when updating to use UnmanagedCallersOnlyAttribute would take more time. Creates a new instance. Gets or sets the entry point to use to produce the C export. Provides C code to be defined early in the generated C header file. This attribute is respected on an exported method declaration or on a parameter for the method. The following header files will be included prior to the code being defined. stddef.h stdint.h dnne.h Creates a new instance with the specified parameters. The C code to be defined in the generated C header file. Defines the C type to be used. The level of indirection should be included in the supplied string. Creates a new instance with the specified parameters. The C type to be used.