File SDK: Verarbeiten von E-Mail-MSG-Dateien (C#)

Das File SDK unterstützt Bezeichnungsvorgänge für MSG-Dateien in ähnlicher Weise wie bei jedem anderen Dateityp, mit der Ausnahme, dass das SDK die Anwendung benötigt, um das MSG-Featureflag zu aktivieren. Hier erfahren Sie, wie Sie dieses Flag festlegen.

Wie bereits erwähnt, ist für die Instanziierung von IFileEngine ein Einstellungsobjekt erforderlich: FileEngineSettings. FileEngineSettings kann verwendet werden, um Parameter für benutzerdefinierte Einstellungen zu übergeben, die die Anwendung für eine bestimmte Instanz festlegen muss. Die CustomSettings-Eigenschaft von FileEngineSettings wird verwendet, um das Flag für enable_msg_file_type festzulegen, um die Verarbeitung von MSG-Dateien zu ermöglichen.

Voraussetzungen

Stellen Sie vor dem Fortfahren sicher, dass die folgenden Voraussetzungen erfüllt sind:

• Schließen Sie zuerst den Schnellstart: Initialisieren von File SDK-Anwendungen (C#) ab, in dem eine Starterprojektmappe für Visual Studio erstellt wird. Dieser Schnellstart „Verarbeiten von MSG-Dateien (C#)“ baut auf dem vorherigen auf.
• Lesen Sie die Konzepte für E-Mail-Dateien im MIP SDK.
• Lesen Sie optional die Konzepte zu File-Engines im MIP SDK.
• Lesen Sie optional die Konzepte zu Dateihandlern im MIP SDK.

Festlegen von enable_msg_file_type und Verwenden des File SDK zum Bezeichnen von MSG-Dateien

Ändern Sie in Fortsetzung des Schnellstarts zur Initialisierung der File-API-Anwendung den Konstruktionscode der File-Engine, um enable_msg_file_type flag festzulegen, und verwenden Sie dann die File-Engine, um eine MSG-Datei zu bezeichnen.

1. Öffnen Sie die Visual Studio-Projektmappe, die Sie im vorherigen Schnellstart zur Initialisierung der File SDK-Anwendung (C#) erstellt haben.

2. Öffnen Sie mithilfe des Projektmappen-Explorers die CS-Datei in Ihrem Projekt, die die Implementierung der Main()-Methode enthält. Standardmäßig weist sie denselben Namen wie das Projekt auf, in dem sie enthalten ist. Diesen Namen haben Sie bei der Projekterstellung angegeben.

3. Entfernen Sie die Implementierung der Main()-Funktion aus dem vorherigen Schnellstart. Fügen Sie im Methodenkörper von Main() den folgenden Code ein. Im folgenden Codeblock wird das Flag enable_msg_file_type während der Erstellung der File-Engine festgelegt. Anschließend kann eine MSG-Datei von IFileHandler-Objekten mithilfe der File-Engine verarbeitet werden.

   static void Main(string[] args)
   {
       // Initialize Wrapper for File SDK operations.
       MIP.Initialize(MipComponent.File);
   
       // Create ApplicationInfo, setting the clientID from Azure AD App Registration as the ApplicationId.
       ApplicationInfo appInfo = new ApplicationInfo()
       {
               ApplicationId = clientId,
               ApplicationName = appName,
               ApplicationVersion = "1.0.0"
       };
   
       // Instantiate the AuthDelegateImpl object, passing in AppInfo.
       AuthDelegateImplementation authDelegate = new AuthDelegateImplementation(appInfo);
   
       MipContext mipContext = MIP.CreateMipContext(appInfo,"mip_data",LogLevel.Trace,null,null);
   
       // Initialize and instantiate the File Profile.
       // Create the FileProfileSettings object.
       // Initialize file profile settings to create/use local state.
       var profileSettings = new FileProfileSettings(mipContext, 
                                   CacheStorageType.OnDiskEncrypted, 
                                   new ConsentDelegateImplementation());
   
       // Load the Profile async and wait for the result.
       var fileProfile = Task.Run(async () => await MIP.LoadFileProfileAsync(profileSettings)).Result;
   
       // Create a FileEngineSettings object, then use that to add an engine to the profile.
       var customSettings = new List<KeyValuePair<string, string>>();
       customSettings.Add(new KeyValuePair<string, string>("enable_msg_file_type", "true"));
   
       // Create a FileEngineSettings object, then use that to add an engine to the profile.
       var engineSettings = new FileEngineSettings("user1@tenant.com", authDelegate, "", "en-US");
       engineSettings.Identity = new Identity("user1@tenant.com");
       //set custom settings for the engine
       engineSettings.CustomSettings = customSettings;
   
       //Add fileEngine to profile
       var fileEngine = Task.Run(async () => await fileProfile.AddEngineAsync(engineSettings)).Result;
   
       //Set file paths
       string inputFilePath = "<input-file-path>"; //.msg file to be labeled
       string actualFilePath = inputFilePath;
       string outputFilePath = "<output-file-path>"; //labeled .msg file
       string actualOutputFilePath = outputFilePath;
   
       //Create a file handler for original file
       var fileHandler = Task.Run(async () => await fileEngine.CreateFileHandlerAsync(inputFilePath, 
                                                                   actualFilePath, 
                                                                   true)).Result;
   
       // List labels available to the user and use one of them to label the MSG file.
   
       foreach (var label in fileEngine.SensitivityLabels)
       {
           Console.WriteLine(string.Format("{0} - {1}", label.Name, label.Id));
   
           if (label.Children.Count > 0)
           {
               foreach (Label child in label.Children)
               {
                   Console.WriteLine(string.Format("\t{0} - {1}", child.Name, child.Id));
               }
           }
       }
   
       string labelId = "<label-id>"; //label retrieved using file engine
   
       LabelingOptions labelingOptions = new LabelingOptions()
       {
           AssignmentMethod = options.AssignmentMethod
       };
   
       fileHandler.SetLabel(labelId, labelingOptions, new ProtectionSettings());
   
       // Commit changes, save as outputFilePath
       var result = Task.Run(async () => await fileHandler.CommitAsync(outputFilePath)).Result;
   
       // Create a new handler to read the labeled file metadata
       var handlerModified = Task.Run(async () => await fileEngine.CreateFileHandlerAsync(outputFilePath, 
                                                                       actualOutputFilePath, 
                                                                       true)).Result;
   
       Console.WriteLine(string.Format("Original file: {0}", inputFilePath));
       Console.WriteLine(string.Format("Labeled file: {0}", outputFilePath));
       Console.WriteLine(string.Format("Label applied to file: {0}", 
           handlerModified.Label.Name));
       Console.WriteLine("Press a key to continue.");
       Console.ReadKey();
   
       // Application Shutdown
       fileHandler = null;
       handlerModified = null;
       fileEngine = null;
       fileProfile = null;
       mipContext = null;
   }
   
   

   Weitere Informationen zu Dateivorgängen finden Sie unter den Konzepten zu Dateihandlern.

4. Ersetzen Sie die Platzhalterwerte im Quellcode durch die folgenden Werte:

   Platzhalter	Wert
   <input-file-path>	Der vollständige Pfad zu einer MSG-Testeingabedatei, z. B. c:\\Test\\message.msg
   <output-file-path>	Der vollständige Pfad zur Ausgabedatei, die eine bezeichnete Kopie der Eingabedatei ist, z. B. c:\\Test\\message_labeled.msg
   <label-id>	Die mit der File-Engine abgerufene labelId (Bezeichnungs-ID), z. B. 667466bf-a01b-4b0a-8bbf-a79a3d96f720

Erstellen und Testen der Anwendung

Verwenden Sie F6 (Projektmappe erstellen) zum Erstellen der Clientanwendung. Wenn keine Buildfehler auftreten, verwenden Sie F5 (Debuggen starten), um die Anwendung auszuführen.

    Original file: C:\Test.msg
    Labeled file: C:\Test_Labeled.msg
    Label applied to file: Confidential    
    Press a key to continue.