Zestaw SDK pliku — przetwarzanie plików msg wiadomości e-mail (C#)

Zestaw Sdk pliku obsługuje operacje na etykietach dla plików msg w sposób identyczny z każdym innym typem pliku, z tym że zestaw SDK potrzebuje aplikacji do włączenia flagi funkcji MSG. Tutaj dowiesz się, jak ustawić tę flagę.

Jak wspomniano wcześniej, tworzenie wystąpienia IFileEngine wymaga obiektu ustawień, FileEngineSettings . Za pomocą ustawień FileEngineSettings można przekazać parametry ustawień niestandardowych, które aplikacja musi ustawić dla określonego wystąpienia. CustomSettings służy do ustawienia flagi umożliwiającej FileEngineSettingsenable_msg_file_type przetwarzanie plików msg.

Wymagania wstępne

Jeśli jeszcze tego nie zrobić, przed kontynuowaniem upewnij się, że są spełnione następujące wymagania wstępne:

• Pełny przewodnik Szybki start: najpierw inicjowanie aplikacji zestawu SDK pliku (C#), które tworzy Visual Studio startowe. Ten przewodnik Szybki start "Jak to zrobić — przetwarzanie plików msg wiadomości e-mail (C#)" działa na poprzednim.
• Przejrzyj pojęcia związane z zestawem SDK poczty e-mail.
• Opcjonalnie: Przejrzyj aparaty plików w pojęciach zestawu SDK MIP.
• Opcjonalnie: Przegląd programów obsługi plików w pojęciach zestawu SDK miP.

Konfigurowanie enable_msg_file_type SDK plików do oznaczania pliku msg

W kontynuacji przewodnika Szybki start inicjowania aplikacji interfejsu API pliku zmodyfikuj kod konstrukcyjny aparatu plików, aby ustawić, a następnie za pomocą aparatu plików oznacz enable_msg_file_type flag plik msg etykietą.

1. Otwórz Visual Studio utworzone w poprzedniej wersji "Szybki start: inicjowanie aplikacji zestawu SDK pliku (C#)".

2. Za pomocą Eksploratora rozwiązań otwórz plik cs w projekcie, który zawiera implementację Main() metody. Domyślna nazwa jest taka sama jak nazwa projektu zawierającego projekt, która jest określona podczas tworzenia projektu.

3. Usuń implementację Main() funkcji z poprzedniego szybkiego startu. W treści Main() wstaw następujący kod. W poniższym przykładzie flaga blokowania kodu jest ustawiana podczas tworzenia aparatu plików, plik msg może być następnie przetwarzany przez obiekty utworzone enable_msg_file_typeIFileHandler za pomocą aparatu plików.

   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;
   }
   
   

   Aby uzyskać więcej szczegółowych informacji na temat operacji na plikach, zapoznaj się z pojęciami obsługi plików.

4. Zamień wartości zastępcze w kodzie źródłowym na następujące wartości:

   Symbol zastępczy	Wartość
   <input-file-path>	Pełna ścieżka do pliku komunikatu wejściowego testu, na przykład: c:\\Test\\message.msg .
   <output-file-path>	Pełna ścieżka do pliku wyjściowego, który będzie kopią pliku wejściowego oznaczoną etykietą, na przykład: c:\\Test\\message_labeled.msg .
   <label-id>	EtykietaId pobrana za pomocą aparatu plików, na przykład: 667466bf-a01b-4b0a-8bbf-a79a3d96f720 .

Tworzenie i testowanie aplikacji

Skompilowanie aplikacji klienckiej przy użyciu klawisza F6 (build solution). Jeśli nie występują błędy kompilacji, użyj klawisza F5 (rozpocznij debugowanie), aby uruchomić aplikację.

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