Kit de développement logiciel (SDK) de fichier - Traiter les fichiers de messagerie .msg (C#)

Le Kit de développement logiciel (SDK) file prend en charge les opérations d’étiquetage pour les fichiers .msg de la même manière que tout autre type de fichier, sauf que le KIT de développement logiciel (SDK) a besoin de l’application pour activer l’indicateur de fonctionnalité MSG. Ce guide de démarrage rapide montre comment définir cet indicateur.

Comme indiqué précédemment, l’instanciation IFileEngine nécessite l’objet FileEngineSettings settings. L’application utilise FileEngineSettings pour passer des paramètres personnalisés pour une instance particulière. La propriété CustomSettings de FileEngineSettings définit l’indicateur enable_msg_file_type afin de permettre le traitement des fichiers .msg.

Prerequisites

Si ce n’est déjà fait, veillez à remplir les conditions préalables suivantes avant de continuer :

Démarrage rapide complet : Initialisation d’une application sdk de fichiers (C#), qui génère d’abord une solution de démarrage Visual Studio. Ce guide de démarrage rapide « How to - Process email message .msg files (C#) » s’appuie sur le précédent.
Passez en revue les concepts du Kit de développement logiciel (SDK) MIP des fichiers de messagerie .
Si vous le souhaitez, consultez les concepts relatifs aux moteurs de fichiers dans le SDK MIP.
Si vous le souhaitez , passez en revue les gestionnaires de fichiers dans les concepts du Kit de développement logiciel (SDK) MIP .

Définir enable_msg_file_type et utiliser le SDK File pour étiqueter le fichier .msg

Dans la continuation du démarrage rapide de l’initialisation de l’application API file, modifiez le code de construction du moteur de fichiers pour définir enable_msg_file_type flag , puis utilisez le moteur de fichiers pour étiqueter un fichier .msg.

Ouvrez la solution Visual Studio que vous avez créée dans le précédent « Démarrage rapide : Initialisation de l’application sdk de fichiers (C#) ».
Dans Explorateur de solutions, ouvrez le fichier .cs dans votre projet qui contient l’implémentation de la Main() méthode. Il a par défaut le même nom que le projet qui le contient, que vous avez spécifié lors de la création du projet.

Supprimez l’implémentation de la fonction Main() à partir du démarrage rapide précédent. Dans le Main() corps, insérez le code suivant. Dans le bloc de code suivant, la création du moteur de fichiers définit l’indicateur enable_msg_file_type . IFileHandler les objets créés à l’aide du moteur de fichiers peuvent ensuite traiter un fichier .msg.

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

    MipConfiguration mipConfiguration = new MipConfiguration(appInfo, "mip_data", LogLevel.Trace, false, CacheStorageType.OnDiskEncrypted);
    MipContext mipContext = MIP.CreateMipContext(mipConfiguration);

    // 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 = AssignmentMethod.Standard
    };

    Label label = fileEngine.GetLabelById(labelId);
    fileHandler.SetLabel(label, 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.Label.Name));
    Console.WriteLine("Press a key to continue.");
    Console.ReadKey();

    // Application Shutdown
    fileHandler = null;
    handlerModified = null;
    fileEngine = null;
    fileProfile = null;
    mipContext = null;
}

Pour plus d’informations sur les opérations de fichier, consultez les concepts du gestionnaire de fichiers.

Remplacez les valeurs d’espace réservé dans le code source par les valeurs suivantes :

Texte de remplacement	Value
<chemin du fichier d'entrée>	Chemin complet d’un fichier de message d’entrée de test, par exemple : `c:\\Test\\message.msg`.
<output-file-path>	Chemin complet du fichier de sortie, qui est une copie étiquetée du fichier d’entrée, par exemple : `c:\\Test\\message_labeled.msg`.
<label-id>	ID d’étiquette récupéré à l’aide du moteur de fichiers, par exemple : `667466bf-a01b-4b0a-8bbf-a79a3d96f720`.

Concevoir et tester l’application

Utilisez F6 (Build Solution) pour générer votre application cliente. Si vous n’avez pas d’erreurs de build, utilisez F5 (Démarrer le débogage) pour exécuter votre application.

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

Commentaires

Cette page a-t-elle été utile ?

Dernière mise à jour : 2026-09-21