Hızlı Başlangıç: Koruma SDK'ları için istemci uygulaması başlatma (C++)

Bu hızlı başlangıçta, MIP C++ SDK'sının çalışma zamanında kullandığı istemci başlatma desenini nasıl uygulayabileceğiniz gösterilmektedir.

Uyarı

MIP Koruması SDK'larını kullanan tüm istemci uygulamaları bu hızlı başlangıçtaki adımları gerektirir. Uygulama başlatma ve kimlik doğrulama temsilcisi ve onay temsilcisi sınıflarının uygulanmasından sonra bu hızlı başlangıçları seri olarak tamamlayın.

Önkoşullar

Henüz yapmadıysanız şunları yaptığınızdan emin olun:

Microsoft Information Protection (MIP) SDK kurulumu ve yapılandırmasındaki adımları tamamlayın. Bu "İstemci uygulaması başlatma" hızlı başlangıcı, doğru SDK kurulumuna ve yapılandırmasına dayanır.
Isteğe bağlı olarak:
- Profil ve altyapı nesnelerini gözden geçirin. Profil ve motor nesneleri, MIP Dosya/Politika/Koruma SDK'larını kullanan istemciler için gerekli olan genel kavramlardır.
- Kimlik doğrulaması ve onayın SDK ve istemci uygulaması tarafından nasıl uygulandığını öğrenmek için Kimlik doğrulama kavramlarını gözden geçirin.
- Gözlemciler ve bunların nasıl uygulandığı hakkında daha fazla bilgi edinmek için Gözlemci kavramlarını gözden geçirin. MIP SDK'sı zaman uyumsuz olay bildirimleri uygulamak için gözlemci desenini kullanır.

Visual Studio çözümü ve projesi oluşturma

İlk olarak, diğer hızlı başlangıçların temel aldığı başlangıç Visual Studio çözümünü ve projesini oluşturun ve yapılandırın.

Visual Studio 2022 veya sonraki bir sürümünü açın, Dosya menüsünü ( Yeni, Proje) seçin. Yeni Proje iletişim kutusunda:
- Sol bölmedeki Yüklü, Diğer Diller'in altında Visual C++ öğesini seçin.
- Orta bölmede Windows Konsol Uygulaması'nı seçin.
- Alt bölmede proje Adı, Konum ve içeren Çözüm adını uygun şekilde güncelleştirin.
- İşiniz bittiğinde sağ alt köşedeki Tamam'ı seçin.
MIP Koruması SDK'sı için NuGet paketini projenize ekleyin:
- Çözüm Gezgini doğrudan üst çözüm düğümünü altındaki proje düğümüne sağ tıklayın ve ardından NuGet paketlerini yönet... öğesini seçin:
- NuGet Paket Yöneticisi sekmesi Düzenleyici Grubu sekmeleri alanında açıldığında:
  - Göz at'ı seçin.
  - Arama kutusuna Microsoft.InformationProtection yazın.
  - Microsoft.InformationProtection.Protection Paketi seçin.
  - Yükle'yi seçin ve ardından Önizleme değişiklikleri onay iletişim kutusu görüntülendiğinde Tamam'ı seçin.

Koruma profilini ve altyapı nesnelerini izlemek için gözlemci sınıfları uygulama

Şimdi SDK'nın mip::ProtectionProfile::Observer sınıfını genişleterek Koruma profili gözlemci sınıfı için temel bir uygulama oluşturun. SDK, gözlemcinin örneğini oluşturur ve daha sonra Protection profil nesnesinin yüklenmesini izlemek ve motor nesnesini profile eklemek için bunu kullanır.

Projenize, sizin için hem üst bilgi (.h) hem de uygulama (.cpp) dosyaları oluşturan yeni bir sınıf ekleyin:
- Çözüm Gezgini proje düğümüne yeniden sağ tıklayın, Ekle'yi ve ardından Sınıf'ı seçin.
- Sınıf Ekle iletişim kutusunda:
  - Sınıf Adı alanına girinprofile_observer. Visual Studio'nun, girdiğiniz ada göre hem .h dosyası hem de .cpp dosyası alanlarını otomatik olarak doldurduğunu unutmayın.
  - İşiniz bittiğinde Tamamseçin.

sınıfı için .h ve .cpp dosyalarını oluşturup Visual Studio her iki dosyayı da Düzenleyici Grubu sekmelerinde açar. Şimdi her dosyayı yeni gözlemci sınıfınızı uygulayacak şekilde güncelleştirin:

profile_observer öğesini, oluşturulan profile_observer.h sınıfını seçip silerek güncelleştirin. Önceki adımın oluşturduğu önişlemci yönergelerini kaldırmayın (#pragma, #include). Ardından aşağıdaki kaynağı kopyalayıp mevcut önişlemci yönergelerinden sonra dosyaya yapıştırın:

#include <memory>
#include "mip/protection/protection_profile.h"
using std::exception_ptr;
using std::shared_ptr;


class ProtectionProfileObserver final : public mip::ProtectionProfile::Observer {
public:
     ProtectionProfileObserver() { }
     void OnLoadSuccess(const std::shared_ptr<mip::ProtectionProfile>& profile, const std::shared_ptr<void>& context) override;
     void OnLoadFailure(const std::exception_ptr& Failure, const std::shared_ptr<void>& context) override;
     void OnAddEngineSuccess(const std::shared_ptr<mip::ProtectionEngine>& engine, const std::shared_ptr<void>& context) override;
     void OnAddEngineFailure(const std::exception_ptr& Failure, const std::shared_ptr<void>& context) override;
};

Oluşturulan profile_observer sınıf uygulamasını seçip silerek güncelleştirinprofile_observer.cpp. Önceki adımın oluşturduğu önişlemci yönergelerini kaldırmayın (#pragma, #include). Ardından aşağıdaki kaynağı kopyalayıp mevcut önişlemci yönergelerinden sonra dosyaya yapıştırın:

#include <future>

using std::promise;
using std::shared_ptr;
using std::static_pointer_cast;
using mip::ProtectionEngine;
using mip::ProtectionProfile;

void ProtectionProfileObserver::OnLoadSuccess(const shared_ptr<ProtectionProfile>& profile, const shared_ptr<void>& context) {
     auto promise = static_pointer_cast<std::promise<shared_ptr<ProtectionProfile>>>(context);
     promise->set_value(profile);
}

void ProtectionProfileObserver::OnLoadFailure(const std::exception_ptr& error, const shared_ptr<void>& context) {
     auto promise = static_pointer_cast<std::promise<shared_ptr<ProtectionProfile>>>(context);
     promise->set_exception(error);
}

void ProtectionProfileObserver::OnAddEngineSuccess(const shared_ptr<ProtectionEngine>& engine, const shared_ptr<void>& context) {
     auto promise = static_pointer_cast<std::promise<shared_ptr<ProtectionEngine>>>(context);
     promise->set_value(engine);
}

void ProtectionProfileObserver::OnAddEngineFailure(const std::exception_ptr& error, const shared_ptr<void>& context) {
     auto promise = static_pointer_cast<std::promise<shared_ptr<ProtectionEngine>>>(context);
     promise->set_exception(error);
}

Projenize Koruma altyapısı gözlemcisi engine_observeriçin yeni bir sınıf eklemek için 1. adımı yineleyin. Bu sınıf sizin için hem üst bilgi (.h) hem de uygulama (.cpp) dosyaları oluşturur.

engine_observer öğesini, oluşturulan engine_observer.h sınıfını seçip silerek güncelleştirin. Önceki adımın oluşturduğu önişlemci yönergelerini kaldırmayın (#pragma, #include). Ardından aşağıdaki kaynağı kopyalayıp mevcut önişlemci yönergelerinden sonra dosyaya yapıştırın:

#include <memory>
#include "mip/protection/protection_engine.h"
using std::vector;
using std::exception_ptr;
using std::shared_ptr;

class ProtectionEngineObserver final : public mip::ProtectionEngine::Observer {
  public:
  ProtectionEngineObserver() {}
  void OnGetTemplatesSuccess(const vector<std::shared_ptr<mip::TemplateDescriptor>>& templateDescriptors, const shared_ptr<void>& context) override;
  void OnGetTemplatesFailure(const exception_ptr& Failure, const shared_ptr<void>& context) override;

};

Oluşturulan engine_observer sınıf uygulamasını seçip silerek güncelleştirinengine_observer.cpp. Önceki adımın oluşturduğu önişlemci yönergelerini kaldırmayın (#pragma, #include). Ardından aşağıdaki kaynağı kopyalayıp mevcut önişlemci yönergelerinden sonra dosyaya yapıştırın:

#include "mip/protection/protection_profile.h"
#include "engine_observer.h"

using std::promise;
void ProtectionEngineObserver::OnGetTemplatesSuccess(const vector<shared_ptr<mip::TemplateDescriptor>>& templateDescriptors,const shared_ptr<void>& context) {
    auto loadPromise = static_cast<promise<vector<shared_ptr<mip::TemplateDescriptor>>>*>(context.get());
    loadPromise->set_value(templateDescriptors);
  };

  void ProtectionEngineObserver::OnGetTemplatesFailure(const exception_ptr& Failure, const shared_ptr<void>& context) {
    auto loadPromise = static_cast<promise<vector<shared_ptr<mip::TemplateDescriptor>>>*>(context.get());
    loadPromise->set_exception(Failure);
  };

İsteğe bağlı olarak, devam etmeden önce başarılı bir şekilde derlendiğini doğrulamak üzere çözümünüzün bir test derlemesini ve bağlantısını çalıştırmak için Ctrl+Shift+B (Derleme Çözümü) tuşlarını kullanın.

MIP SDK'sı, kimlik doğrulaması çalışmasını istemci uygulamasıyla paylaşma mekanizması sağlayan sınıf genişletilebilirliği aracılığıyla kimlik doğrulaması uygular. İstemcinin uygun bir OAuth2 erişim belirteci alması ve çalışma zamanında MIP SDK'sına sağlaması gerekir.

SDK'nın mip::AuthDelegate sınıfını genişleterek ve saf sanal işlevi geçersiz kılarak/uygulayarak mip::AuthDelegate::AcquireOAuth2Token() kimlik doğrulama temsilcisi için bir uygulama oluşturun. Dosya SDK'sı uygulaması başlatma hızlı başlangıcı altında ayrıntılı adımları izleyin. Koruma profili ve Koruma motoru nesneleri, daha sonra kimlik doğrulama temsilcisini örnekler ve kullanır.

Şimdi SDK'nın mip::ConsentDelegate sınıfını genişleterek ve saf sanal işlevi geçersiz kılarak/uygulayarak mip::AuthDelegate::GetUserConsent() onay temsilcisi için bir uygulama oluşturun. Dosya SDK'sı uygulaması başlatma hızlı başlangıcı altında ayrıntılı adımları izleyin. Koruma profili ve Koruma altyapısı nesneleri örneği oluşturur ve onay temsilcisini daha sonra kullanır.

Koruma profili ve altyapısı oluşturma

Belirtildiği gibi, MIP API'lerini kullanan SDK istemcileri için profil ve altyapı nesneleri gerekir. Profil ve altyapı nesnelerinin örneğini oluşturacak kod ekleyerek bu hızlı başlangıcın kodlama bölümünü tamamlayın:

Çözüm Gezgini'nden, projenizde yönteminin uygulanmasını main() içeren .cpp dosyasını açın. Proje oluşturma sırasında belirlediğiniz isim, varsayılan olarak projeyle aynı olup onu içeren yapıdadır.
oluşturulan uygulamasını main()kaldırın. Proje oluşturma sırasında Visual Studio tarafından oluşturulan önişlemci yönergelerini kaldırmayın (#pragma, #include). Önişlemci yönergelerinden sonra aşağıdaki kodu ekleyin:

#include "mip/mip_context.h"  
#include "auth_delegate.h"
#include "consent_delegate.h"
#include "profile_observer.h"
#include"engine_observer.h"

using std::promise;
using std::future;
using std::make_shared;
using std::shared_ptr;
using std::string;
using std::cout;
using mip::ApplicationInfo;
using mip::ProtectionProfile;
using mip::ProtectionEngine;

int main(){

  // Construct/initialize objects required by the application's profile object
  // ApplicationInfo object (App ID, name, version)
  ApplicationInfo appInfo{"<application-id>",                    
                          "<application-name>",
                          "<application-version>"};

  std::shared_ptr<mip::MipConfiguration> mipConfiguration = std::make_shared<mip::MipConfiguration>(appInfo,
				                                                                                               "mip_data",
                                                                                      			         mip::LogLevel::Trace,
                                                                                                     false,
                                                                                                     mip::CacheStorageType::OnDisk);

  std::shared_ptr<mip::MipContext> mMipContext = mip::MipContext::Create(mipConfiguration);

  auto profileObserver = make_shared<ProtectionProfileObserver>(); // Observer object
  auto authDelegateImpl = make_shared<AuthDelegateImpl>("<application-id>"); // Authentication delegate object (App ID)
  auto consentDelegateImpl = make_shared<ConsentDelegateImpl>(); // Consent delegate object

  // Construct/initialize profile object
  ProtectionProfile::Settings profileSettings(
    mMipContext,
    mip::CacheStorageType::OnDisk,      
    consentDelegateImpl,
    profileObserver);

  // Set up promise/future connection for async profile operations; load profile asynchronously
  auto profilePromise = make_shared<promise<shared_ptr<ProtectionProfile>>>();
  auto profileFuture = profilePromise->get_future();
  try
  {
    mip::ProtectionProfile::LoadAsync(profileSettings, profilePromise);
  }
  catch (const std::exception& e)
  {
    cout << "An exception occurred... are the Settings and ApplicationInfo objects populated correctly?\n\n"
          << e.what() << "'\n";
    system("pause");
    return 1;
  }

  auto profile = profileFuture.get();

  // Construct/initialize engine object
  ProtectionEngine::Settings engineSettings(       
     mip::Identity("<engine-account>"),         // Engine identity (account used for authentication)
     authDelegateImpl,                          // Reference to mip::AuthDelegate implementation
     "",                                        // ClientData field
     "en-US");                                  // Locale (default = en-US)

  // Set the engineId so it can be cached and reused. 
  engineSettings.SetEngineId("<engine-account>");

  // Set up promise/future connection for async engine operations; add engine to profile asynchronously
  auto enginePromise = make_shared<promise<shared_ptr<ProtectionEngine>>>();
  auto engineFuture = enginePromise->get_future();
  profile->AddEngineAsync(engineSettings, enginePromise);
  std::shared_ptr<ProtectionEngine> engine;

  try
  {
    engine = engineFuture.get();
  }
  catch (const std::exception& e)
  {
    cout << "An exception occurred... is the access token incorrect/expired?\n\n"
         << e.what() << "'\n";
    system("pause");
    return 1;
  }

  // Application shutdown. Null out profile and engine, call ReleaseAllResources();
  // Application may crash at shutdown if resources aren't properly released.
  engine = nullptr;
  profile = nullptr;
  mMipContext->ShutDown();
  mMipContext = nullptr;

  return 0;
}

Dize sabitlerini kullanarak yapıştırdığınız kaynak koddaki tüm yer tutucu değerleri değiştirin:

Yer tutucu	Değer	Örnek
<uygulama kimliği>	MIP SDK kurulum ve yapılandırma makalesinin 2. adımında kaydettiğiniz uygulamaya atanan Microsoft Entra Uygulama Kimliği (GUID). 2 örneği değiştirin.	`"00001111-aaaa-2222-bbbb-3333cccc4444"`
<uygulama adı>	Uygulamanız için kullanıcı tanımlı anlamlı ad. Geçerli ASCII karakterleri içermelidir ('; hariç) ') ve ideal olarak Microsoft Entra kaydınızda kullandığınız uygulama adıyla eşleşir.	`"AppInitialization"`
<uygulama sürümü>	Uygulamanız için kullanıcı tanımlı sürüm bilgileri. Geçerli ASCII karakterleri içermelidir (';' hariç).	`"1.1.0.0"`
<altyapı hesabı>	Motorun kimliği için kullanılan hesap. Bir kullanıcı hesabıyla kimlik doğrulaması yaparken, elde ettiğiniz jetonun bu değerle eşleşmesi gerekir.	`"user1@tenant.onmicrosoft.com"`
<altyapı durumu>	Motor ile ilişkilendirilen kullanıcı tanımlı durum.	`"My App State"`

Şimdi uygulamanın son derlemesini yapın ve hataları çözün. Kodunuzun başarıyla derlenmesi gerekir, ancak sonraki Quickstart’ı tamamlayana kadar doğru şekilde çalışmaz. Uygulamayı çalıştırırsanız aşağıdakine benzer bir çıkış görürsünüz. Uygulama Koruma profilini ve Koruma altyapısını başarıyla oluşturur, ancak kimlik doğrulama modülünü tetiklemiyor ve bir sonraki hızlı başlangıcı tamamlayana kadar erişim belirteciniz yok.
```
 C:\MIP Sample Apps\ProtectionQS\Debug\ProtectionQS.exe (process 8252) exited with code 0.
 To automatically close the console when debugging stops, enable Tools->Options->Debugging->Automatically close the console when debugging stops.
 Press any key to close this window . . .
```

Sonraki Adımlar

Başlatma kodunuz tamamlandıktan sonra, MIP Koruması SDK'sını deneyimlemek için bir sonraki hızlı başlangıç için hazırsınız demektir.

Koruma şablonlarını listeleme

GitHub'da MIP Koruma SDK'sı C++ örneğini keşfedin.

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Son güncelleştirme: 2026-09-21