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

Zestaw SDK plików obsługuje operacje etykietowania dla plików .msg w taki sam sposób, jak w przypadku dowolnego innego typu pliku, z wyjątkiem tego, że zestaw SDK wymaga aplikacji włączenia flagi funkcji MSG. Ten przewodnik szybkiego startu pokazuje, jak ustawić tę flagę.

Jak wspomniano wcześniej, utworzenie instancji IFileEngine wymaga obiektu ustawień FileEngineSettings. Aplikacja korzysta z FileEngineSettings do przekazywania ustawień niestandardowych dla konkretnej instancji. Właściwość CustomSettingsFileEngineSettings ustawia flagę enable_msg_file_type , aby umożliwić przetwarzanie plików .msg.

Wymagania wstępne

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

Najpierw wykonaj Przewodnik Szybki start: inicjowanie aplikacji zestawu SDK plików (C#), w ramach którego utworzysz początkowe rozwiązanie programu Visual Studio. Ten przewodnik „Szybki start” „Jak przetwarzać pliki wiadomości e-mail .msg (C#)” opiera się na poprzednim.
Zapoznaj się z pojęciami dotyczącymi MIP SDK dla plików e-mail.
Opcjonalnie: Zapoznaj się z pojęciami dotyczącymi silników plików w zestawie MIP SDK.
Opcjonalnie: Zapoznaj się z koncepcjami obsługi plików w zestawie MIP SDK.

Ustaw enable_msg_file_type i użyj zestawu File SDK do etykietowania plików .msg

Kontynuując przewodnik Szybki start: inicjowanie aplikacji interfejsu File API, zmodyfikuj kod tworzenia mechanizmu plików, aby ustawić enable_msg_file_type flag, a następnie użyj mechanizmu plików do oznaczenia pliku .msg.

Otwórz rozwiązanie programu Visual Studio utworzone w poprzednim przewodniku „Szybki start: inicjowanie aplikacji File SDK (C#)”.
W Eksplorator rozwiązań otwórz plik .cs w projekcie zawierający implementację Main() metody . Domyślnie ma taką samą nazwę jak projekt zawierający go, który został określony podczas tworzenia projektu.

Usuń implementację funkcji Main() z poprzedniego przewodnika Szybki start. Main() Wewnątrz treści wstaw następujący kod. W poniższym bloku kodu tworzenie silnika plików ustawia flagę enable_msg_file_type. IFileHandler obiekty utworzone przy użyciu silnika plików mogą następnie przetwarzać plik .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;
}

Aby uzyskać więcej informacji na temat operacji na plikach, zobacz Pojęcia dotyczące obsługi plików.

Zastąp wartości symboli zastępczych w kodzie źródłowym następującymi wartościami:

Placeholder	Wartość
<ścieżka pliku wejściowego>	Pełna ścieżka do pliku komunikatu wejściowego testu, na przykład: `c:\\Test\\message.msg`.
<ścieżka pliku wyjściowego>	Pełna ścieżka do pliku wyjściowego, który jest kopią pliku wejściowego z etykietami, na przykład: `c:\\Test\\message_labeled.msg`.
<label-id>	Identyfikator etykiety pobrany za pomocą silnika plików, na przykład: `667466bf-a01b-4b0a-8bbf-a79a3d96f720`.

Kompilowanie i testowanie aplikacji

Skompiluj aplikację kliencą przy użyciu F6 (rozwiązanie kompilacji). Jeśli nie masz błędów 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.

Opinia

Czy ta strona była pomocna?

Ostatnia aktualizacja o 2026-09-21