本主题基于 Windows 运行时组件和其使用的应用程序，而 C++/WinRT 主题将指导你如何构建这些 Windows 运行时组件。
下面是本主题添加的新功能。
- 更新温度计的运行时类，以便在温度低于冰点时触发事件。
- 更新使用温度计运行时类的核心应用，以便处理该事件。
注释
有关安装和使用 C++/WinRT Visual Studio 扩展 （VSIX） 和 NuGet 包（它们共同提供项目模板和生成支持）的信息，请参阅 Visual Studio 对 C++/WinRT 的支持。
重要
有关支持您理解如何使用 C++/WinRT 来消费和编写运行时类的基本概念和术语，请参阅 使用 C++/WinRT 消费 API，以及 使用 C++/WinRT 编写 API。
创建 温度计WRC 和 温度计核心应用程序
如果要遵循本主题中所示的更新，以便可以生成和运行代码，则第一步是按照 Windows 运行时组件中的演练操作，其中包含 C++/WinRT 主题。 通过执行此操作，你将拥有 温度计WRC Windows 运行时组件，以及使用它的 温度计CoreApp 核心应用。
更新 温度计WRC 以触发事件
更新 Thermometer.idl，如下所示。 这是如何使用单精度浮点数的参数声明委托类型 EventHandler 的事件。
// Thermometer.idl
namespace ThermometerWRC
{
runtimeclass Thermometer
{
Thermometer();
void AdjustTemperature(Single deltaFahrenheit);
event Windows.Foundation.EventHandler<Single> TemperatureIsBelowFreezing;
};
}
保存文件。 项目在当前状态下无法完成构建，但无论如何，请现在执行构建以生成 \ThermometerWRC\ThermometerWRC\Generated Files\sources\Thermometer.h 和 Thermometer.cpp 存根文件的更新版本。 在这些文件中，你现在可以看到 TemperatureIsBelowFreezing 事件的存根实现。 在 C++/WinRT 中，IDL 声明的事件作为一组重载函数实现（类似于属性作为一对重载 get 和 set 函数实现的方式）。 一个重载函数接受一个用于注册的委托，并返回一个令牌（winrt::event_token）。 另一个采用令牌，并撤销关联委托的注册。
现在打开 Thermometer.h 并 Thermometer.cpp更新 温度计 运行时类的实现。 在 Thermometer.h中，添加两个重载 TemperatureIsBelowFreezing 函数，以及用于实现这些函数的私有事件数据成员。
// Thermometer.h
...
namespace winrt::ThermometerWRC::implementation
{
struct Thermometer : ThermometerT<Thermometer>
{
...
winrt::event_token TemperatureIsBelowFreezing(Windows::Foundation::EventHandler<float> const& handler);
void TemperatureIsBelowFreezing(winrt::event_token const& token) noexcept;
private:
winrt::event<Windows::Foundation::EventHandler<float>> m_temperatureIsBelowFreezingEvent;
...
};
}
...
如上所示，事件由 winrt：：event 结构模板表示，由特定委托类型参数化（该委托类型本身可由 args 类型参数化）。
在 Thermometer.cpp中，实现两个重载的 TemperatureIsBelowFreezing 函数。
// Thermometer.cpp
...
namespace winrt::ThermometerWRC::implementation
{
winrt::event_token Thermometer::TemperatureIsBelowFreezing(Windows::Foundation::EventHandler<float> const& handler)
{
return m_temperatureIsBelowFreezingEvent.add(handler);
}
void Thermometer::TemperatureIsBelowFreezing(winrt::event_token const& token) noexcept
{
m_temperatureIsBelowFreezingEvent.remove(token);
}
void Thermometer::AdjustTemperature(float deltaFahrenheit)
{
m_temperatureFahrenheit += deltaFahrenheit;
if (m_temperatureFahrenheit < 32.f) m_temperatureIsBelowFreezingEvent(*this, m_temperatureFahrenheit);
}
}
注释
有关自动事件撤销程序是什么的详细信息，请参阅 撤销已注册的委托。 你可以免费获得事件自动撤销机制的实现。 换句话说，无需为事件撤销程序实现重载，C++/WinRT 投影为你提供了该重载。
其他重载（注册和手动吊销重载）没有 内置到投影中。 这能让您在具体情境下灵活地以最佳方式实施它们。 调用 event：：add 和 event：：remove ，如这些实现中所示，这是一个高效且并发/线程安全的默认值。 但是，如果你有大量的事件，则你可能不希望为每个事件设置字段，而是选择某种稀疏存储方式。
你还可以在上面看到，如果温度低于冰点，则 AdjustTemperature 函数的实现已被更新，以引发 TemperatureIsBelowFreezing 事件。
更新 温度计核心应用 以处理该事件
在 温度计CoreApp 项目中，在 App.cpp中，对代码进行以下更改以注册事件处理程序，然后使温度降至冰点以下。
WINRT_ASSERT 是宏定义，它扩展到 _ASSERTE。
struct App : implements<App, IFrameworkViewSource, IFrameworkView>
{
winrt::event_token m_eventToken;
...
void Initialize(CoreApplicationView const &)
{
m_eventToken = m_thermometer.TemperatureIsBelowFreezing([](const auto &, float temperatureFahrenheit)
{
WINRT_ASSERT(temperatureFahrenheit < 32.f); // Put a breakpoint here.
});
}
...
void Uninitialize()
{
m_thermometer.TemperatureIsBelowFreezing(m_eventToken);
}
...
void OnPointerPressed(IInspectable const &, PointerEventArgs const & args)
{
m_thermometer.AdjustTemperature(-1.f);
...
}
...
};
请注意对 OnPointerPressed 方法所做的更改。 现在，每次单击窗口时，你将从温度计的温度减去 华氏度。 现在，应用正在处理当温度低于冰点时引发的事件。 若要证明事件按预期引发，请在处理 TemperatureIsBelowFreezing 事件的 lambda 表达式中放置一个断点，运行应用程序，然后在窗口中单击。
跨 ABI 的参数化委托
如果事件必须跨应用程序二进制接口（例如组件与其使用的应用程序之间）进行访问，则事件必须使用 Windows 运行时委托类型。 上面的示例使用 Windows：：Foundation：：EventHandler<T> Windows 运行时委托类型。 TypedEventHandler<TSender，TResult> 是 Windows 运行时委托类型的另一个示例。
这两种委托类型的类型参数必须跨越 ABI，因此类型参数也必须是 Windows 运行时类型。 这包括 Windows 运行时类、第三方运行时类和基元类型，例如数字和字符串。 如果忘记了该约束，编译器会通过错误“T 必须是 WinRT 类型”来帮助你。
下面是代码列表形式的示例。 从本主题前面创建的 ThermometerWRC 和 ThermometerCoreApp 项目开始，将这些项目中的代码编辑为与这些列表中的代码相似。
第一个列表适用于 温度计WRC 项目。 在按如下所示编辑 ThermometerWRC.idl 后，生成项目，然后将 MyEventArgs.h 和 .cpp 从 Generated Files 文件夹中复制到项目中，就像之前对 Thermometer.h 和 .cpp所做的那样。 请记得从这两个文件中删除代码 static_assert。
// ThermometerWRC.idl
namespace ThermometerWRC
{
[default_interface]
runtimeclass MyEventArgs
{
Single TemperatureFahrenheit{ get; };
}
[default_interface]
runtimeclass Thermometer
{
...
event Windows.Foundation.EventHandler<ThermometerWRC.MyEventArgs> TemperatureIsBelowFreezing;
...
};
}
// MyEventArgs.h
#pragma once
#include "MyEventArgs.g.h"
namespace winrt::ThermometerWRC::implementation
{
struct MyEventArgs : MyEventArgsT<MyEventArgs>
{
MyEventArgs() = default;
MyEventArgs(float temperatureFahrenheit);
float TemperatureFahrenheit();
private:
float m_temperatureFahrenheit{ 0.f };
};
}
// MyEventArgs.cpp
#include "pch.h"
#include "MyEventArgs.h"
#include "MyEventArgs.g.cpp"
namespace winrt::ThermometerWRC::implementation
{
MyEventArgs::MyEventArgs(float temperatureFahrenheit) : m_temperatureFahrenheit(temperatureFahrenheit)
{
}
float MyEventArgs::TemperatureFahrenheit()
{
return m_temperatureFahrenheit;
}
}
// Thermometer.h
...
struct Thermometer : ThermometerT<Thermometer>
{
...
winrt::event_token TemperatureIsBelowFreezing(Windows::Foundation::EventHandler<ThermometerWRC::MyEventArgs> const& handler);
...
private:
winrt::event<Windows::Foundation::EventHandler<ThermometerWRC::MyEventArgs>> m_temperatureIsBelowFreezingEvent;
...
}
...
// Thermometer.cpp
#include "MyEventArgs.h"
...
winrt::event_token Thermometer::TemperatureIsBelowFreezing(Windows::Foundation::EventHandler<ThermometerWRC::MyEventArgs> const& handler) { ... }
...
void Thermometer::AdjustTemperature(float deltaFahrenheit)
{
m_temperatureFahrenheit += deltaFahrenheit;
if (m_temperatureFahrenheit < 32.f)
{
auto args = winrt::make_self<winrt::ThermometerWRC::implementation::MyEventArgs>(m_temperatureFahrenheit);
m_temperatureIsBelowFreezingEvent(*this, *args);
}
}
...
此清单适用于 温度计核心应用程序 项目。
// App.cpp
...
void Initialize(CoreApplicationView const&)
{
m_eventToken = m_thermometer.TemperatureIsBelowFreezing([](const auto&, ThermometerWRC::MyEventArgs args)
{
float degrees = args.TemperatureFahrenheit();
WINRT_ASSERT(degrees < 32.f); // Put a breakpoint here.
});
}
...
ABI 中的简单信号
如果你不需要使用事件传递任何参数或参数，则可以定义自己的简单的 Windows 运行时委托类型。 下面的示例显示了温度 计 运行时类的更简单版本。 它声明了一个名为 SignalDelegate 的委托类型，然后使用该类型来引发信号类型事件，而不是带有参数的事件。
// ThermometerWRC.idl
namespace ThermometerWRC
{
delegate void SignalDelegate();
runtimeclass Thermometer
{
Thermometer();
event ThermometerWRC.SignalDelegate SignalTemperatureIsBelowFreezing;
void AdjustTemperature(Single value);
};
}
// Thermometer.h
...
namespace winrt::ThermometerWRC::implementation
{
struct Thermometer : ThermometerT<Thermometer>
{
...
winrt::event_token SignalTemperatureIsBelowFreezing(ThermometerWRC::SignalDelegate const& handler);
void SignalTemperatureIsBelowFreezing(winrt::event_token const& token);
void AdjustTemperature(float deltaFahrenheit);
private:
winrt::event<ThermometerWRC::SignalDelegate> m_signal;
float m_temperatureFahrenheit{ 0.f };
};
}
// Thermometer.cpp
...
namespace winrt::ThermometerWRC::implementation
{
winrt::event_token Thermometer::SignalTemperatureIsBelowFreezing(ThermometerWRC::SignalDelegate const& handler)
{
return m_signal.add(handler);
}
void Thermometer::SignalTemperatureIsBelowFreezing(winrt::event_token const& token)
{
m_signal.remove(token);
}
void Thermometer::AdjustTemperature(float deltaFahrenheit)
{
m_temperatureFahrenheit += deltaFahrenheit;
if (m_temperatureFahrenheit < 32.f)
{
m_signal();
}
}
}
// App.cpp
struct App : implements<App, IFrameworkViewSource, IFrameworkView>
{
ThermometerWRC::Thermometer m_thermometer;
winrt::event_token m_eventToken;
...
void Initialize(CoreApplicationView const &)
{
m_eventToken = m_thermometer.SignalTemperatureIsBelowFreezing([] { /* ... */ });
}
...
void Uninitialize()
{
m_thermometer.SignalTemperatureIsBelowFreezing(m_eventToken);
}
...
void OnPointerPressed(IInspectable const &, PointerEventArgs const & args)
{
m_thermometer.AdjustTemperature(-1.f);
...
}
...
};
项目中的参数化委托、简单信号和回调
如果需要 Visual Studio 项目内部的事件（而不是跨二进制文件），其中这些事件不限于 Windows 运行时类型，则仍然可以使用 winrt：：event<Delegate> 类模板。 只需使用 winrt：:d elegate 而不是实际的 Windows 运行时委托类型，因为 winrt：:d elegate 还支持非 Windows 运行时参数。
下面的示例首先显示了不采用任何参数（实质上是简单信号）的委托签名，然后显示一个采用字符串的委托签名。
winrt::event<winrt::delegate<>> signal;
signal.add([] { std::wcout << L"Hello, "; });
signal.add([] { std::wcout << L"World!" << std::endl; });
signal();
winrt::event<winrt::delegate<std::wstring>> log;
log.add([](std::wstring const& message) { std::wcout << message.c_str() << std::endl; });
log.add([](std::wstring const& message) { Persist(message); });
log(L"Hello, World!");
留心你如何根据需要向活动添加任意数量的订阅委托。 但是，与某些事件相关联时会有一些开销。 如果您只需要一个简单的回调，并且只有一个订阅委托，那么您可以单独使用 winrt::delegate<... T> 本身。
winrt::delegate<> signalCallback;
signalCallback = [] { std::wcout << L"Hello, World!" << std::endl; };
signalCallback();
winrt::delegate<std::wstring> logCallback;
logCallback = [](std::wstring const& message) { std::wcout << message.c_str() << std::endl; }f;
logCallback(L"Hello, World!");
如果从项目中内部使用事件和委托的 C++/CX 代码库进行移植，winrt::delegate 将帮助你在 C++/WinRT 中复制该模式。
可延迟事件
Windows 运行时中的常见模式是可延迟的事件。 事件处理程序通过调用事件参数的 GetDeferral 方法获取延迟。 这样做会向事件来源指示，活动后的工作应推迟，直到延迟过程完成为止。 这样，事件处理程序就可以执行异步作来响应事件。
winrt::deferrable_event_args 结构模板是用于实现 Windows 运行时延迟模式的辅助类。 下面是一个示例。
// Widget.idl
namespace Sample
{
runtimeclass WidgetStartingEventArgs
{
Windows.Foundation.Deferral GetDeferral();
Boolean Cancel;
};
runtimeclass Widget
{
event Windows.Foundation.TypedEventHandler<
Widget, WidgetStartingEventArgs> Starting;
};
}
// Widget.h
namespace winrt::Sample::implementation
{
struct Widget : WidgetT<Widget>
{
Widget() = default;
event_token Starting(Windows::Foundation::TypedEventHandler<
Sample::Widget, Sample::WidgetStartingEventArgs> const& handler)
{
return m_starting.add(handler);
}
void Starting(event_token const& token) noexcept
{
m_starting.remove(token);
}
private:
event<Windows::Foundation::TypedEventHandler<
Sample::Widget, Sample::WidgetStartingEventArgs>> m_starting;
};
struct WidgetStartingEventArgs : WidgetStartingEventArgsT<WidgetStartingEventArgs>,
deferrable_event_args<WidgetStartingEventArgs>
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
{
bool Cancel() const noexcept { return m_cancel; }
void Cancel(bool value) noexcept { m_cancel = value; }
bool m_cancel = false;
};
}
下面是事件收件人如何使用可延迟的事件模式。
// EventRecipient.h
widget.Starting([](auto sender, auto args) -> fire_and_forget
{
auto deferral = args.GetDeferral();
if (!co_await CanWidgetStartAsync(sender))
{
// Do not allow the widget to start.
args.Cancel(true);
}
deferral.Complete();
});
作为事件源（生成者）的实现者，您可以从 winrt::deferrable_event_args 派生您的事件参数类。 deferrable_event_args<T> 为你实现 T：：GetDeferral。 它还公开了一个新的辅助方法 deferrable_event_args::wait_for_deferrals，该方法在所有未完成的延迟完成时完成（如果没有延迟，则会立即完成）。
// Widget.h
IAsyncOperation<bool> TryStartWidget(Widget const& widget)
{
auto args = make_self<WidgetStartingEventArgs>();
// Raise the event to let people know that the widget is starting
// and give them a chance to prevent it.
m_starting(widget, *args);
// Wait for deferrals to complete.
co_await args->wait_for_deferrals();
// Use the results.
bool started = false;
if (!args->Cancel())
{
widget.InsertBattery();
widget.FlipPowerSwitch();
started = true;
}
co_return started;
}
设计指南
我们建议将事件而不是委托作为函数参数传递。 添加 函数的 winrt::event 是一个例外，因为在这种情况下必须传递委托。 本准则的理由是，由于在不同的 Windows 运行时语言中，委托可能会不同，这取决于它们是支持单一还是多个客户端注册。 事件及其多个订阅者模型构成了更可预测和一致的选项。
事件处理程序委托的签名应包含两个参数：发送者（IInspectable），以及 事件参数（例如 RoutedEventArgs）。
请注意，在设计内部 API 时，这些准则不一定适用。 随着时间的推移，内部 API 通常会变为公共 API。