SDK de archivos: procesar archivos de .msg de correo electrónico (C#)

El SDK de archivos admite operaciones de etiquetado para .msg archivos de una manera idéntica a cualquier otro tipo de archivo, excepto que el SDK necesita la aplicación para habilitar la marca de características msg. Aquí veremos cómo establecer esta bandera.

Como se ha descrito anteriormente, la creación de instancias de IFileEngine requiere un objeto de configuración, FileEngineSettings. FileEngineSettings se puede usar para pasar parámetros para la configuración personalizada que la aplicación debe establecer para una instancia determinada. CustomSettings propiedad de FileEngineSettings se utiliza para establecer la marca que permite a enable_msg_file_type habilitar el procesamiento de archivos .msg.

Prerrequisitos

Si aún no lo ha hecho, asegúrese de completar los siguientes requisitos previos antes de continuar:

• Complete primero Inicio rápido: Inicialización de aplicaciones cliente del SDK de archivo (C#), que compila una solución de inicio de Visual Studio. Esta guía de inicio rápido sobre "Cómo procesar archivos de mensajes de correo electrónico .msg (C#)" se basa en la guía anterior.
• Revise los conceptos del SDK de MIP de archivos de correo electrónico.
• Opcional: Revise los conceptos sobre motores de archivo en el SDK de MIP.
• Opcional: revise los conceptos de controladores de archivos en el SDK de MIP.

Establecer enable_msg_file_type y usar el SDK de archivos para etiquetar archivos .msg.

En continuación del inicio rápido de inicialización de la aplicación File API, modifique el código de construcción del motor de archivos para establecer enable_msg_file_type flag y, a continuación, use el motor de archivos para etiquetar un archivo .msg.

1. Abra la solución de Visual Studio que creó en el anterior "Inicio rápido: inicialización de la aplicación del SDK de archivos (C#)".

2. Con el Explorador de soluciones, abra el archivo .cs en el proyecto que contiene la implementación del Main() método . El valor predeterminado es el mismo nombre que el proyecto que lo contiene, que especificó durante la creación del proyecto.

3. Elimine la implementación de la función Main() que se quitará del inicio rápido anterior. Dentro del Main() cuerpo, inserte el código siguiente. En el bloque de código siguiente, se establece la marca enable_msg_file_type durante la creación del motor de archivos; un archivo .msg puede entonces ser procesado por los objetos IFileHandler creados usando el motor de archivo.

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

   Para obtener más información sobre las operaciones de archivo, consulte los conceptos del controlador de archivos.

4. Reemplace los valores de marcador de posición en el código fuente con los siguientes valores:

   Marcador de posición	Valor
   <input-file-path>	Ruta de acceso completa a un archivo de mensaje de entrada de prueba, por ejemplo: c:\\Test\\message.msg.
   <output-file-path>	Ruta de acceso completa al archivo de salida, que será una copia etiquetada del archivo de entrada, por ejemplo: c:\\Test\\message_labeled.msg.
   <label-id>	El ID de etiqueta recuperado mediante el motor de archivos, por ejemplo: 667466bf-a01b-4b0a-8bbf-a79a3d96f720.

Crear y probar la aplicación

Presione F6 (Compilar solución) para compilar la aplicación cliente. Si no tiene errores de compilación, use F5 (Iniciar depuración) para ejecutar la aplicación.

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