Gestion des éléments multimédias et des entités connexes avec le Kit de développement logiciel (SDK) Media Services .NETManaging Assets and Related Entities with Media Services .NET SDK

Notes

Aucune nouvelle fonctionnalité ni fonction n’est ajoutée à Media Services v2.
Découvrez la dernière version, Media Services v3. Consultez également conseils de migration de v2 vers v3

Cette rubrique montre comment gérer les entités Azure Media Services avec .NET.This topic shows how to manage Azure Media Services entities with .NET.

À compter du 1er avril 2017, les enregistrements de travaux dans votre compte de plus de 90 jours seront automatiquement supprimés, ainsi que leurs enregistrements de tâches associés, même si le nombre total d’enregistrements est inférieur au quota maximum.Starting April 1, 2017, any Job record in your account older than 90 days will be automatically deleted, along with its associated Task records, even if the total number of records is below the maximum quota. Par exemple, le 1er avril 2017, tout enregistrement de travail dans votre compte antérieur au 31 décembre 2016 sera automatiquement supprimé.For example, on April 1, 2017, any Job record in your account older than December 31, 2016, will be automatically deleted. Si vous devez archiver les informations sur le travail/la tâche, vous pouvez utiliser le code décrit dans cette rubrique.If you need to archive the job/task information, you can use the code described in this topic.

Conditions préalablesPrerequisites

Configurez votre environnement de développement et ajoutez des informations de connexion au fichier app.config selon la procédure décrite dans l’article Développement Media Services avec .NET.Set up your development environment and populate the app.config file with connection information, as described in Media Services development with .NET.

Obtenir une référence pointant vers un élément multimédiaGet an Asset Reference

L’obtention d’une référence pointant vers un élément multimédia existant dans Media Services est une tâche fréquente.A frequent task is to get a reference to an existing asset in Media Services. L’exemple de code suivant montre comment vous pouvez obtenir une référence pointant vers un élément multimédia à partir de la collection Assets sur l’objet de contexte du serveur, en fonction d’un ID d’élément multimédia. L’exemple de code suivant utilise une requête Linq pour obtenir une référence pointant vers un objet IAsset existant.The following code example shows how you can get an asset reference from the Assets collection on the server context object, based on an asset Id. The following code example uses a Linq query to get a reference to an existing IAsset object.

    static IAsset GetAsset(string assetId)
    {
        // Use a LINQ Select query to get an asset.
        var assetInstance =
            from a in _context.Assets
            where a.Id == assetId
            select a;
        // Reference the asset as an IAsset.
        IAsset asset = assetInstance.FirstOrDefault();

        return asset;
    }

Répertorier tous les éléments multimédiasList All Assets

Lorsque le nombre d’éléments multimédias de votre stockage augmente, il est utile de les répertorier.As the number of assets you have in storage grows, it is helpful to list your assets. L’exemple de code suivant montre comment parcourir la collection Assets sur l’objet de contexte du serveur.The following code example shows how to iterate through the Assets collection on the server context object. Pour chaque élément multimédia, l’exemple de code écrit également certaines de ses valeurs de propriétés vers la console.With each asset, the code example also writes some of its property values to the console. Par exemple, chaque élément multimédia peut contenir plusieurs fichiers multimédias.For example, each asset can contain many media files. L’exemple de code écrit tous les fichiers associés à chaque élément multimédia.The code example writes out all files associated with each asset.

    static void ListAssets()
    {
        string waitMessage = "Building the list. This may take a few "
            + "seconds to a few minutes depending on how many assets "
            + "you have."
            + Environment.NewLine + Environment.NewLine
            + "Please wait..."
            + Environment.NewLine;
        Console.Write(waitMessage);

        // Create a Stringbuilder to store the list that we build. 
        StringBuilder builder = new StringBuilder();

        foreach (IAsset asset in _context.Assets)
        {
            // Display the collection of assets.
            builder.AppendLine("");
            builder.AppendLine("******ASSET******");
            builder.AppendLine("Asset ID: " + asset.Id);
            builder.AppendLine("Name: " + asset.Name);
            builder.AppendLine("==============");
            builder.AppendLine("******ASSET FILES******");

            // Display the files associated with each asset. 
            foreach (IAssetFile fileItem in asset.AssetFiles)
            {
                builder.AppendLine("Name: " + fileItem.Name);
                builder.AppendLine("Size: " + fileItem.ContentFileSize);
                builder.AppendLine("==============");
            }
        }

        // Display output in console.
        Console.Write(builder.ToString());
    }

Obtenir une référence pointant vers un travailGet a Job Reference

Lorsque vous utilisez des tâches de traitement dans le code de Media Services, vous devez souvent obtenir une référence pointant vers un travail existant basé sur un ID. L’exemple de code suivant montre comment obtenir une référence pointant vers un objet IJob à partir de la collection Jobs.When you work with processing tasks in Media Services code, you often need to get a reference to an existing job based on an Id. The following code example shows how to get a reference to an IJob object from the Jobs collection.

Il est possible que vous deviez obtenir une référence pointant vers un travail lors du démarrage d’un travail d’encodage à long terme et vérifier l’état du travail sur un thread.You may need to get a job reference when starting a long-running encoding job, and need to check the job status on a thread. Dans ce cas, lorsque la méthode est retournée à partir d’un thread, vous devez récupérer une référence actualisée pointant vers le travail.In cases like this, when the method returns from a thread, you need to retrieve a refreshed reference to a job.

    static IJob GetJob(string jobId)
    {
        // Use a Linq select query to get an updated 
        // reference by Id. 
        var jobInstance =
            from j in _context.Jobs
            where j.Id == jobId
            select j;
        // Return the job reference as an Ijob. 
        IJob job = jobInstance.FirstOrDefault();

        return job;
    }

Répertorier les travaux et les éléments multimédiasList Jobs and Assets

Une tâche associée importante consiste à répertorier les éléments multimédias avec leur travail associé dans Media Services.An important related task is to list assets with their associated job in Media Services. L’exemple de code suivant montre comment répertorier chaque objet IJob, puis afficher les propriétés de chaque travail, toutes les tâches associées, ainsi que tous les éléments multimédias d’entrée et de sortie.The following code example shows you how to list each IJob object, and then for each job, it displays properties about the job, all related tasks, all input assets, and all output assets. Cet exemple de code peut être utilise pour bien d’autres tâches.The code in this example can be useful for numerous other tasks. Par exemple, si vous souhaitez répertorier les éléments multimédias de sortie à partir d’un ou plusieurs travaux d’encodage que vous avez exécutés précédemment, ce code montre comment accéder aux éléments multimédias de sortie.For example, if you want to list the output assets from one or more encoding jobs that you ran previously, this code shows how to access the output assets. Lorsque vous avez une référence pointant vers un élément multimédia de sortie, vous pouvez alors livrer le contenu à d’autres utilisateurs ou applications en le téléchargeant ou en fournissant des URL.When you have a reference to an output asset, you can then deliver the content to other users or applications by downloading it, or providing URLs.

Pour plus d’informations sur les options pour la livraison des éléments multimédias, consultez la page Livraison d’éléments multimédias à l’aide du Kit de développement logiciel (SDK) Media Services pour .NET.For more information on options for delivering assets, see Deliver Assets with the Media Services SDK for .NET.

    // List all jobs on the server, and for each job, also list 
    // all tasks, all input assets, all output assets.

    static void ListJobsAndAssets()
    {
        string waitMessage = "Building the list. This may take a few "
            + "seconds to a few minutes depending on how many assets "
            + "you have."
            + Environment.NewLine + Environment.NewLine
            + "Please wait..."
            + Environment.NewLine;
        Console.Write(waitMessage);

        // Create a Stringbuilder to store the list that we build. 
        StringBuilder builder = new StringBuilder();

        foreach (IJob job in _context.Jobs)
        {
            // Display the collection of jobs on the server.
            builder.AppendLine("");
            builder.AppendLine("******JOB*******");
            builder.AppendLine("Job ID: " + job.Id);
            builder.AppendLine("Name: " + job.Name);
            builder.AppendLine("State: " + job.State);
            builder.AppendLine("Order: " + job.Priority);
            builder.AppendLine("==============");


            // For each job, display the associated tasks (a job  
            // has one or more tasks). 
            builder.AppendLine("******TASKS*******");
            foreach (ITask task in job.Tasks)
            {
                builder.AppendLine("Task Id: " + task.Id);
                builder.AppendLine("Name: " + task.Name);
                builder.AppendLine("Progress: " + task.Progress);
                builder.AppendLine("Configuration: " + task.Configuration);
                if (task.ErrorDetails != null)
                {
                    builder.AppendLine("Error: " + task.ErrorDetails);
                }
                builder.AppendLine("==============");
            }

            // For each job, display the list of input media assets.
            builder.AppendLine("******JOB INPUT MEDIA ASSETS*******");
            foreach (IAsset inputAsset in job.InputMediaAssets)
            {

                if (inputAsset != null)
                {
                    builder.AppendLine("Input Asset Id: " + inputAsset.Id);
                    builder.AppendLine("Name: " + inputAsset.Name);
                    builder.AppendLine("==============");
                }
            }

            // For each job, display the list of output media assets.
            builder.AppendLine("******JOB OUTPUT MEDIA ASSETS*******");
            foreach (IAsset theAsset in job.OutputMediaAssets)
            {
                if (theAsset != null)
                {
                    builder.AppendLine("Output Asset Id: " + theAsset.Id);
                    builder.AppendLine("Name: " + theAsset.Name);
                    builder.AppendLine("==============");
                }
            }

        }

        // Display output in console.
        Console.Write(builder.ToString());
    }

Répertorier toutes les stratégies d’accèsList all Access Policies

Dans Media Services, vous pouvez définir une stratégie d’accès sur un élément multimédia ou ses fichiers.In Media Services, you can define an access policy on an asset or its files. Une stratégie d’accès définit les autorisations pour un fichier ou un élément multimédia (le type d’accès et la durée).An access policy defines the permissions for a file or an asset (what type of access, and the duration). Dans votre code Media Services, vous définissez généralement une stratégie d’accès en créant un objet IAccessPolicy et en l’associant à un élément multimédia existant.In your Media Services code, you typically define an access policy by creating an IAccessPolicy object and then associating it with an existing asset. Ensuite, vous créez un objet ILocator, qui vous permet de fournir un accès direct aux éléments multimédias dans Media Services.Then you create an ILocator object, which lets you provide direct access to assets in Media Services. Le projet Visual Studio qui accompagne cette documentation contient plusieurs exemples de code qui montrent comment créer et attribuer des localisateurs et les stratégies d’accès aux éléments multimédias.The Visual Studio project that accompanies this documentation series contains several code examples that show how to create and assign access policies and locators to assets.

L’exemple de code suivant montre comment répertorier toutes les stratégies d’accès sur le serveur et quel type d’autorisations leur est associé.The following code example shows how to list all access policies on the server, and shows the type of permissions associated with each. Une autre méthode d’affichage des stratégies d’accès consiste à répertorier tous les objets ILocator sur le serveur, puis répertorier les stratégies d’accès associées à chaque localisateur à l’aide de leur propriété AccessPolicy.Another useful way to view access policies is to list all ILocator objects on the server, and then for each locator, you can list its associated access policy by using its AccessPolicy property.

    static void ListAllPolicies()
    {
        foreach (IAccessPolicy policy in _context.AccessPolicies)
        {
            Console.WriteLine("");
            Console.WriteLine("Name:  " + policy.Name);
            Console.WriteLine("ID:  " + policy.Id);
            Console.WriteLine("Permissions: " + policy.Permissions);
            Console.WriteLine("==============");

        }
    }

Limiter les stratégies d’accèsLimit Access Policies

Notes

Un nombre limite de 1 000 000 a été défini pour les différentes stratégies AMS (par exemple, pour la stratégie de localisateur ou pour ContentKeyAuthorizationPolicy). Vous devez utiliser le même ID de stratégie si vous utilisez toujours les mêmes jours / autorisations d’accès, par exemple, les stratégies pour les localisateurs destinées à demeurer en place pendant une longue période (stratégies sans chargement).

Par exemple, vous pouvez créer un ensemble générique de stratégies avec le code suivant qui ne s’exécute qu’une seule fois dans votre application.For example, you can create a generic set of policies with the following code that would only run one time in your application. Vous pouvez enregistrer les ID dans un fichier journal pour une utilisation ultérieure :You can log IDs to a log file for later use:

    double year = 365.25;
    double week = 7;
    IAccessPolicy policyYear = _context.AccessPolicies.Create("One Year", TimeSpan.FromDays(year), AccessPermissions.Read);
    IAccessPolicy policy100Year = _context.AccessPolicies.Create("Hundred Years", TimeSpan.FromDays(year * 100), AccessPermissions.Read);
    IAccessPolicy policyWeek = _context.AccessPolicies.Create("One Week", TimeSpan.FromDays(week), AccessPermissions.Read);

    Console.WriteLine("One year policy ID is: " + policyYear.Id);
    Console.WriteLine("100 year policy ID is: " + policy100Year.Id);
    Console.WriteLine("One week policy ID is: " + policyWeek.Id);

Ensuite, vous pouvez utiliser les ID existants dans votre code comme suit :Then, you can use the existing IDs in your code like this:

    const string policy1YearId = "nb:pid:UUID:2a4f0104-51a9-4078-ae26-c730f88d35cf";


    // Get the standard policy for 1 year read only
    var tempPolicyId = from b in _context.AccessPolicies
                       where b.Id == policy1YearId
                       select b;
    IAccessPolicy policy1Year = tempPolicyId.FirstOrDefault();

    // Get the existing asset
    var tempAsset = from a in _context.Assets
                where a.Id == assetID
                select a;
    IAsset asset = tempAsset.SingleOrDefault();

    ILocator originLocator = _context.Locators.CreateLocator(LocatorType.OnDemandOrigin, asset,
        policy1Year,
        DateTime.UtcNow.AddMinutes(-5));
    Console.WriteLine("The locator base path is " + originLocator.BaseUri.ToString());

Répertorier tous les localisateursList All Locators

Un localisateur est une URL qui fournit un chemin d’accès direct pour accéder à un élément multimédia, ainsi que les autorisations pour accéder à l’élément multimédia, comme défini par la stratégie d’accès associée au localisateur.A locator is a URL that provides a direct path to access an asset, along with permissions to the asset as defined by the locator's associated access policy. Chaque élément multimédia peut avoir une collection d’objets ILocator associée à sa propriété Locators.Each asset can have a collection of ILocator objects associated with it on its Locators property. Le contexte de serveur possède également une collection Locators contenant tous les localisateurs.The server context also has a Locators collection that contains all locators.

L’exemple de code suivant répertorie tous les localisateurs sur le serveur.The following code example lists all locators on the server. Il affiche l’ID des éléments multimédias et les stratégies d’accès associés à chaque localisateur.For each locator, it shows the Id for the related asset and access policy. Il affiche également le type d’autorisation, la date d’expiration et le chemin d’accès complet à l’élément multimédia.It also displays the type of permissions, the expiration date, and the full path to the asset.

Notez qu’un chemin d’accès de localisateur vers un élément multimédia est simplement une URL de base pointant vers l’élément multimédia.Note that a locator path to an asset is only a base URL to the asset. Pour créer un chemin d’accès direct vers les fichiers individuels auxquels peut accéder un utilisateur ou une application, votre code doit ajouter le chemin d’accès de fichier spécifique au chemin d’accès du localisateur.To create a direct path to individual files that a user or application could browse to, your code must add the specific file path to the locator path. Pour plus d’informations sur la procédure à suivre, consultez Livraison d’éléments multimédias à l’aide du Kit de développement logiciel (SDK) Media Services pour .NET.For more information on how to do this, see the topic Deliver Assets with the Media Services SDK for .NET.

    static void ListAllLocators()
    {
        foreach (ILocator locator in _context.Locators)
        {
            Console.WriteLine("***********");
            Console.WriteLine("Locator Id: " + locator.Id);
            Console.WriteLine("Locator asset Id: " + locator.AssetId);
            Console.WriteLine("Locator access policy Id: " + locator.AccessPolicyId);
            Console.WriteLine("Access policy permissions: " + locator.AccessPolicy.Permissions);
            Console.WriteLine("Locator expiration: " + locator.ExpirationDateTime);
            // The locator path is the base or parent path (with included permissions) to access  
            // the media content of an asset. To create a full URL to a specific media file, take 
            // the locator path and then append a file name and info as needed.  
            Console.WriteLine("Locator base path: " + locator.Path);
            Console.WriteLine("");
        }
    }

Énumérer les grandes collections d'entitésEnumerating through large collections of entities

Lors de l'interrogation des entités, il existe une limite de 1 000 entités retournées simultanément car l'API REST v2 publique limite les résultats des requêtes à 1 000 résultats.When querying entities, there is a limit of 1000 entities returned at one time because public REST v2 limits query results to 1000 results. Vous devez utiliser Skip et Take lors de l'énumération de grandes collections d'entités.You need to use Skip and Take when enumerating through large collections of entities.

La fonction suivante effectue une itération sur toutes les tâches dans le compte Media Services fourni.The following function loops through all the jobs in the provided Media Services Account. Media Services renvoie 1 000 tâches dans Collection de tâches.Media Services returns 1000 jobs in Jobs Collection. La fonction utilise Skip et Take pour s'assurer que toutes les tâches sont énumérées (au cas où vous avez plus de 1 000 tâches dans votre compte).The function makes use of Skip and Take to make sure that all jobs are enumerated (in case you have more than 1000 jobs in your account).

    static void ProcessJobs()
    {
        try
        {

            int skipSize = 0;
            int batchSize = 1000;
            int currentBatch = 0;

            while (true)
            {
                // Loop through all Jobs (1000 at a time) in the Media Services account
                IQueryable _jobsCollectionQuery = _context.Jobs.Skip(skipSize).Take(batchSize);
                foreach (IJob job in _jobsCollectionQuery)
                {
                    currentBatch++;
                    Console.WriteLine("Processing Job Id:" + job.Id);
                }

                if (currentBatch == batchSize)
                {
                    skipSize += batchSize;
                    currentBatch = 0;
                }
                else
                {
                    break;
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
    }

Supprimer un élément multimédiaDelete an Asset

L’exemple suivant montre la suppression d’un élément multimédia.The following example deletes an asset.

    static void DeleteAsset( IAsset asset)
    {
        // delete the asset
        asset.Delete();

        // Verify asset deletion
        if (GetAsset(asset.Id) == null)
            Console.WriteLine("Deleted the Asset");

    }

Supprimer un travailDelete a Job

Pour supprimer un travail, vous devez vérifier l’état associé, comme indiqué dans la propriété State.To delete a job, you must check the state of the job as indicated in the State property. Les travaux terminés ou annulés peuvent être supprimés, tandis que pour les travaux dans d’autres états, par exemple en file d’attente, planifiés ou en cours de traitement, il faut d’abord procéder à une annulation, puis supprimer le travail.Jobs that are finished or canceled can be deleted, while jobs that are in certain other states, such as queued, scheduled, or processing, must be canceled first, and then they can be deleted.

L’exemple de code suivant montre une méthode de suppression de travail qui vérifie l’état des travaux, puis supprime ceux terminés ou annulés.The following code example shows a method for deleting a job by checking job states and then deleting when the state is finished or canceled. Ce code est basé sur la section précédente de cette rubrique pour obtenir une référence pointant vers un travail : Obtenir une référence pointant vers un travail.This code depends on the previous section in this topic for getting a reference to a job: Get a job reference.

    static void DeleteJob(string jobId)
    {
        bool jobDeleted = false;

        while (!jobDeleted)
        {
            // Get an updated job reference.  
            IJob job = GetJob(jobId);

            // Check and handle various possible job states. You can 
            // only delete a job whose state is Finished, Error, or Canceled.   
            // You can cancel jobs that are Queued, Scheduled, or Processing,  
            // and then delete after they are canceled.
            switch (job.State)
            {
                case JobState.Finished:
                case JobState.Canceled:
                case JobState.Error:
                    // Job errors should already be logged by polling or event 
                    // handling methods such as CheckJobProgress or StateChanged.
                    // You can also call job.DeleteAsync to do async deletes.
                    job.Delete();
                    Console.WriteLine("Job has been deleted.");
                    jobDeleted = true;
                    break;
                case JobState.Canceling:
                    Console.WriteLine("Job is cancelling and will be deleted "
                        + "when finished.");
                    Console.WriteLine("Wait while job finishes canceling...");
                    Thread.Sleep(5000);
                    break;
                case JobState.Queued:
                case JobState.Scheduled:
                case JobState.Processing:
                    job.Cancel();
                    Console.WriteLine("Job is scheduled or processing and will "
                        + "be deleted.");
                    break;
                default:
                    break;
            }

        }
    }

Supprimer une stratégie d’accèsDelete an Access Policy

L’exemple de code suivant montre comment obtenir une référence pointant vers une stratégie d’accès en fonction d’un ID de stratégie, puis comment supprimer cette stratégie.The following code example shows how to get a reference to an access policy based on a policy Id, and then to delete the policy.

    static void DeleteAccessPolicy(string existingPolicyId)
    {
        // To delete a specific access policy, get a reference to the policy.  
        // based on the policy Id passed to the method.
        var policyInstance =
                from p in _context.AccessPolicies
                where p.Id == existingPolicyId
                select p;
        IAccessPolicy policy = policyInstance.FirstOrDefault();

        policy.Delete();

    }

Parcours d’apprentissage de Media ServicesMedia Services learning paths

Media Services v3 (dernière version)Media Services v3 (latest)

Découvrez la dernière version d’Azure Media Services.Check out the latest version of Azure Media Services!

Media Services v2 (hérité)Media Services v2 (legacy)

Fournir des commentairesProvide feedback

Utilisez le forum User Voice pour fournir des commentaires et des suggestions sur la façon d’améliorer Azure Media Services.Use the User Voice forum to provide feedback and make suggestions on how to improve Azure Media Services. Vous pouvez également accéder directement à l’une des catégories suivantes :You also can go directly to one of the following categories: