Porady: bezpośrednie tworzenie wystąpień składników biblioteki WRL

Informacje o sposobach używania Biblioteka szablonów C++ środowiska wykonawczego systemu Windows (WRL) Microsoft::WRL::Make i Microsoft::WRL::Details::MakeAndInitialize funkcje tworzenia wystąpienia składnika z modułu, który definiuje go.

Przez utworzenie wystąpienia składników bezpośrednio, można zmniejszyć obciążenie Jeśli nie ma potrzeby fabryk klas lub innych mechanizmów.Możliwe jest utworzenie instancji składnika w obu Windows Store aplikacji w aplikacji.

Aby dowiedzieć się, jak używać do utworzenia podstawowego Środowisko wykonawcze systemu Windows składnika i utworzenie jej instancji od zewnętrznego Windows Store aplikacji, zobacz Wskazówki: tworzenie podstawowego składnika środowiska wykonawczego systemu Windows za pomocą biblioteki WRL.Aby dowiedzieć się, jak używać WRL do tworzenia składnika klasycznego modelu COM i utworzenie jej instancji z zewnętrznych aplikacji pulpitu, zobacz Porady: tworzenie klasycznego składnika COM za pomocą biblioteki WRL.

Ten dokument zawiera dwa przykłady.W pierwszym przykładzie użyto Make funkcja tworzenia wystąpienia składnika.W drugim przykładzie użyto MakeAndInitialize funkcja tworzenia wystąpienia składnika, który może się nie powieść podczas budowy.(Ponieważ korzysta zwykle COM HRESULT wartości, zamiast wyjątki, aby wskazać błędy, typ COM zwykle nie rzuca z jego konstruktora.MakeAndInitializeWłącza składnik, aby sprawdzić poprawność jej argumentów budowy przez RuntimeClassInitialize metoda.) Zarówno przykłady zdefiniować interfejs podstawowy rejestratora i wdrożenie tego interfejsu poprzez zdefiniowanie klasy, która zapisuje komunikaty konsoli.

Ważne
Nie można użyć new operatora do utworzenia wystąpienia WRL składników.Dlatego firma Microsoft zaleca, aby zawsze używać Make lub MakeAndInitialize bezpośrednio utworzyć wystąpienia składnika.

Aby utworzyć i Utwórz wystąpienie składnika podstawowe rejestratora

1. W programie Visual Studio, tworzenie Win32 Console Application projektu.Nazwa projektu, na przykład, WRLLogger.

2. Dodać Plik regionów (.idl) plik do projektu, pliku o nazwie ILogger.idl, a następnie dodaj ten kod:

   import "ocidl.idl";
   
   // Prints text to the console.
   [uuid(AFDB9683-F18A-4B85-90D1-B6158DAFA46C)]
   interface ILogger : IUnknown
   {
       HRESULT Log([in] BSTR text);
   }
   

3. Użyć następującego kodu, aby zastąpić zawartość WRLLogger.cpp.

   #include "stdafx.h"
   #include <wrl\implements.h>
   #include <comutil.h>
   
   #include "ILogger_h.h"
   
   // comutil.h requires static linkage to comsuppw.lib.
   #pragma comment(lib, "comsuppw")
   
   using namespace Microsoft::WRL;
   
   // Writes logging messages to the console.
   class CConsoleWriter : public RuntimeClass<RuntimeClassFlags<ClassicCom>, ILogger>
   {
   public:
       STDMETHODIMP Log(_In_ BSTR text)
       {
           if (text == nullptr)
           {
               return E_POINTER;
           }
           wprintf_s(L"%s\n", text);
           return S_OK;
       }
   
   private:
       // Make destroyable only through Release.
       ~CConsoleWriter()
       {
       }
   };
   
   int _tmain()
   {
       ComPtr<CConsoleWriter> writer = Make<CConsoleWriter>();
       HRESULT hr = writer->Log(L"Logger ready.");
       return hr;
   }
   
   /* Output:
   Logger ready.
   */
   

Do obsługi awarii budowy dla składnika podstawowe rejestratora

1. Należy użyć następującego kodu, aby zastąpić definicji CConsoleWriter klasy.Ta wersja posiada Członek private string, zmienna i przesłonięcia RuntimeClass::RuntimeClassInitialize metoda.RuntimeClassInitializekończy się niepowodzeniem, jeśli podany parametr jest nullptr.

   // Writes logging messages to the console.
   class CConsoleWriter : public RuntimeClass<RuntimeClassFlags<ClassicCom>, ILogger>
   {
   public:
       // Initializes the CConsoleWriter object.
       // Failure here causes your object to fail construction with the HRESULT you choose.
       HRESULT RuntimeClassInitialize(_In_ BSTR category)
       {
           if (category == nullptr)
           {
               return E_POINTER;
           }
           m_category = category;
           return S_OK;
       }
   
       STDMETHODIMP Log(_In_ BSTR text)
       {
           if (text == nullptr)
           {
               return E_POINTER;
           }
           wprintf_s(L"%s: %s\n", m_category.GetBSTR(), text);
           return S_OK;
       }
   
   private:
       _bstr_t m_category;
   
       // Make destroyable only through Release.
       ~CConsoleWriter()
       {
       }
   };
   

2. Należy użyć następującego kodu, aby zastąpić definicji _tmain.Używa tej wersji MakeAndInitialize do utworzenia wystąpienia dwóch CConsoleWriter obiektów.Demonstracyjne pierwsze wywołanie kończy się powodzeniem, a drugie wywołanie kończy się niepowodzeniem.

   int _tmain()
   {
       BSTR category = L"INFO";
       ComPtr<CConsoleWriter> writer;
       HRESULT hr = MakeAndInitialize<CConsoleWriter>(&writer, category);
       if (FAILED(hr))
       {
           wprintf_s(L"Object creation failed. Result = 0x%x", hr);
           return hr;
       }
       hr = writer->Log(L"Logger ready.");
       if (FAILED(hr))
       {
           return hr;
       }
   
       wprintf_s(L"\n");
   
       category = nullptr;
       hr = MakeAndInitialize<CConsoleWriter>(&writer, category);
       if (FAILED(hr))
       {
           wprintf_s(L"Object creation failed. Result = 0x%x.\n", hr);
           return hr;
       }
       else
       {
           return writer->Log(L"Logger ready.");
       }
   }
   
   /* Output:
   INFO: Logger ready.
   
   Object creation failed. Result = 0x80004003.
   */
   

Zobacz też

Informacje

Microsoft::WRL::Make

Microsoft::WRL::Details::MakeAndInitialize

Koncepcje

Biblioteka szablonów języka C++ środowiska wykonawczego systemu Windows (WRL)