Wie IObjectSafety ein ATL-Steuerelemente sicher für Initialisierung

Veralteter Haftungsausschluss für KB-Inhalte

Dieser Artikel wurde für Produkte geschrieben, für die Microsoft keinen Support mehr anbietet. Deshalb wird dieser Artikel im vorliegenden Zustand bereitgestellt und nicht mehr aktualisiert.

Zusammenfassung

Die standardmäßige Implementierung IObjectSafetyImpl können Sie ein Steuerelement als sicher für Skripting markiert. In vielen Fällen sollten Sie auch das Steuerelement als sicher für die Initialisierung zu markieren.


HINWEIS: Nur markiert das Steuerelement als sicher für scripting oder Initialisierung eigentlich sicher ist. Wenn das Steuerelement möglicherweise nicht sicher ist und als sicher markiert ist, können Sie für Schäden haftbar. Siehe Abschnitt VERWEISE unter Weitere Informationen.

Weitere Informationen

Sie müssen die gewünschte Funktionalität zu Schritte umfassen IObjectSafetyImpl als eine der Klassen, denen das Steuerelement abgeleitet und Überschreiben von GetInterfaceSafetyOptions und SetInterfaceSafetyOptions. Dadurch können Sie in diesem Fall markieren das Steuerelement als sicher für Skripting und Initialisierung die gewünschte Funktionalität implementieren.


Um IObjectSafetyImpl verwenden, müssen Sie die Liste der Klassen hinzufügen, das Steuerelement abgeleitet wird. Im Lernprogramm Polygon sehen Sie beispielsweise die folgenden:
class ATL_NO_VTABLE CPolyCtl :...
public IObjectSafetyImpl<CPolyCtl> // ATL's version of
// IObjectSafety
{
public:
BEGIN_COM_MAP(CPolyCtl)
...
COM_INTERFACE_ENTRY_IMPL(IObjectSafety) // Tie IObjectSafety
// to this COM map
END_COM_MAP()

STDMETHOD(GetInterfaceSafetyOptions)(REFIID riid,
DWORD *pdwSupportedOptions,
DWORD *pdwEnabledOptions)
{
ATLTRACE(_T("CObjectSafetyImpl::GetInterfaceSafetyOptions\n"));
if (!pdwSupportedOptions || !pdwEnabledOptions)
return E_FAIL;
LPUNKNOWN pUnk;
if (_InternalQueryInterface (riid, (void**)&pUnk) == E_NOINTERFACE) {
// Our object doesn't even support this interface.
return E_NOINTERFACE;
}else{
// Cleanup after ourselves.
pUnk->Release();
pUnk = NULL;
}
if (riid == IID_IDispatch) {
// IDispatch is an interface used for scripting. If your
// control supports other IDispatch or Dual interfaces, you
// may decide to add them here as well. Client wants to know
// if object is safe for scripting. Only indicate safe for
// scripting when the interface is safe.
*pdwSupportedOptions = INTERFACESAFE_FOR_UNTRUSTED_CALLER;
*pdwEnabledOptions = m_dwSafety &
INTERFACESAFE_FOR_UNTRUSTED_CALLER;
return S_OK;
}else if ((riid == IID_IPersistStreamInit) ||
(riid == IID_IPersistStorage)) {
// IID_IPersistStreamInit and IID_IPersistStorage are
// interfaces used for Initialization. If your control
// supports other Persistence interfaces, you may decide to
// add them here as well. Client wants to know if object is
// safe for initializing. Only indicate safe for initializing
// when the interface is safe.
*pdwSupportedOptions = INTERFACESAFE_FOR_UNTRUSTED_DATA;
*pdwEnabledOptions = m_dwSafety &
INTERFACESAFE_FOR_UNTRUSTED_DATA;
return S_OK;
}else{
// We are saying that no other interfaces in this control are
// safe for initializing or scripting.
*pdwSupportedOptions = 0;
*pdwEnabledOptions = 0;
return E_FAIL;
}
}

STDMETHOD(SetInterfaceSafetyOptions)(REFIID riid,
DWORD dwOptionSetMask,
DWORD dwEnabledOptions)
{
ATLTRACE(_T("CObjectSafetyImpl::SetInterfaceSafetyOptions\n"));
if (!dwOptionSetMask && !dwEnabledOptions) return E_FAIL;
LPUNKNOWN pUnk;
if (_InternalQueryInterface (riid, (void**)&pUnk) == E_NOINTERFACE) {
// Our object doesn't even support this interface.
return E_NOINTERFACE;
}else{
// Cleanup after ourselves.
pUnk->Release();
pUnk = NULL;
}
// Store our current safety level to return in
// GetInterfaceSafetyOptions
m_dwSafety |= dwEnabledOptions & dwOptionSetMask;
if ((riid == IID_IDispatch) &&
(m_dwSafety & INTERFACESAFE_FOR_UNTRUSTED_CALLER)) {
// Client wants us to disable any functionality that would
// make the control unsafe for scripting. The same applies to
// any other IDispatch or Dual interfaces your control may
// support. Because our control is safe for scripting by
// default we just return S_OK.
return S_OK;
}else if (((riid == IID_IPersistStreamInit) ||
(riid == IID_IPersistStorage)) &&
(m_dwSafety & INTERFACESAFE_FOR_UNTRUSTED_DATA)) {
// Client wants us to make the control safe for initializing
// from persistent data. For these interfaces, this control
// is safe so we return S_OK. For Any interfaces that are not
// safe, we would return E_FAIL.
return S_OK;
}else{
// This control doesn't allow Initialization or Scripting
// from any other interfaces so return E_FAIL.
return E_FAIL;
}
}
...
}


ATL 3.0 wurde die Implementierung IObjectSafetyImpl geändert, damit nun die Sicherheitsoptionen als Vorlagenparameter bereitstellen können. Beispielsweise sieht die Deklaration der obigen Klasse als

class ATL_NO_VTABLE CPolyCtl :...
public IObjectSafetyImpl<CPolyCtl,
INTERFACESAFE_FOR_UNTRUSTED_CALLER |
INTERFACESAFE_FOR_UNTRUSTED_DATA>
{
public:
BEGIN_COM_MAP(CPolyCtl)
...

und Sie würden nicht zwei Methoden überschreiben. Weitere Informationen finden Sie der Microsoft Knowledge Base:

192093 PRB: Compilerfehler beim Portieren IObjectSafetyImpl zu ATL 3.0

Referenzen

Weitere Informationen über ActiveX-Steuerelemente als sicher für Skripting und Initialisierung markieren finden Sie in den folgenden Artikeln der Microsoft Knowledge Base:

161873 MFC-Steuerelemente sicher für Scripting/Initialisierung markieren



164119 BEISPIEL: Implementieren IObjectSafety in einem ActiveX-Steuerelement
Eigenschaften

Artikelnummer: 168371 – Letzte Überarbeitung: 10.01.2017 – Revision: 1

Feedback