Gestione di asset ed entità correlate con Media Services .NET SDKManaging Assets and Related Entities with Media Services .NET SDK

Questo argomento illustra come gestire le entità dei Servizi multimediali di Azure con .NET.This topic shows how to manage Azure Media Services entities with .NET.

Nota

A partire dal 1° aprile 2017, tutti i record di processo presenti nell'account e più vecchi di 90 giorni verranno eliminati automaticamente, insieme ai record attività associati, anche se il numero totale di record è inferiore alla quota massima. Ad esempio, il 1° aprile 2017 qualsiasi record di processo nell'account precedente il 31 dicembre 2016 verrà automaticamente eliminato. Se è necessario archiviare le informazioni sul processo o sull'attività, è possibile usare il codice descritto in questo argomento.

PrerequisitiPrerequisites

Configurare l'ambiente di sviluppo e popolare il file app.config con le informazioni di connessione, come descritto in Sviluppo di applicazioni di Servizi multimediali con .NET.Set up your development environment and populate the app.config file with connection information, as described in Media Services development with .NET.

Ottenere un riferimento a un assetGet an Asset Reference

Un'attività comune consiste nell'ottenere un riferimento a un asset esistente in Servizi multimediali.A frequent task is to get a reference to an existing asset in Media Services. L'esempio di codice seguente mostra come ottenere un riferimento a un asset dalla raccolta Assets sull'oggetto contesto del server, in base all'ID dell'asset. L'esempio di codice seguente usa una query Linq per ottenere un riferimento a un oggetto IAsset.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;
}

Elencare tutti gli assetList All Assets

Man mano che aumenta il numero degli asset archiviati, è utile elencarli tutti.As the number of assets you have in storage grows, it is helpful to list your assets. L'esempio di codice seguente mostra come scorrere la raccolta Assets nell'oggetto contesto del server.The following code example shows how to iterate through the Assets collection on the server context object. Con ogni asset, l'esempio di codice scrive anche alcuni valori delle relative proprietà nella console.With each asset, the code example also writes some of its property values to the console. Ogni asset, ad esempio, può includere numerosi file multimediali.For example, each asset can contain many media files. L'esempio di codice elenca tutti i file associati a ogni asset.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());
}

Ottenere un riferimento a un processoGet a Job Reference

Quando si usano attività di elaborazione nel codice di Servizi multimediali, è spesso necessario ottenere un riferimento a un processo esistente in base a un ID. L'esempio di codice seguente mostra come ottenere un riferimento a un oggetto IJob dalla raccolta 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.

Può essere necessario ottenere un riferimento a un processo quando si avvia un processo di codifica di lunga esecuzione e si vuole verificare lo stato del processo su 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. In casi come questo, quando il metodo è restituito da un thread, è necessario recuperare un riferimento aggiornato a un processo.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;
}

Elencare i processi e gli assetList Jobs and Assets

Un'importante attività correlata consiste nell'elencare gli asset con il relativo processo associato in Servizi multimediali.An important related task is to list assets with their associated job in Media Services. L'esempio di codice seguente mostra come elencare ogni oggetto IJob e quindi, per ogni processo, visualizzare le proprietà relative al processo, tutte le attività correlate, tutti gli asset di input e tutti gli asset di output.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. Il codice di questo esempio può essere utile per molte altre attività.The code in this example can be useful for numerous other tasks. Se ad esempio si vuole elencare gli asset di output di uno o più processi di codifica eseguiti in precedenza, questo codice mostra come accedere agli asset di output.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. Quando è disponibile un riferimento a un asset di output, è quindi possibile distribuire il contenuto ad altri utenti o applicazioni scaricandolo o specificando gli 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.

Per altre informazioni sulle opzioni per la distribuzione degli asset, vedere Distribuire asset con Media Services SDK for .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());
}

Elencare tutti i criteri di accessoList all Access Policies

In Servizi multimediali è possibile definire un criterio di accesso per un asset o i relativi file.In Media Services, you can define an access policy on an asset or its files. Un criterio di accesso definisce le autorizzazioni per un file o un asset, ovvero il tipo di accesso e la durata.An access policy defines the permissions for a file or an asset (what type of access, and the duration). Nel codice di Servizi multimediali, in genere si definisce un criterio di accesso creando un oggetto IAccessPolicy e associandolo a un asset esistente.In your Media Services code, you typically define an access policy by creating an IAccessPolicy object and then associating it with an existing asset. È quindi necessario creare un oggetto ILocator, che permette di fornire l'accesso diretto agli asset in Servizi multimediali.Then you create a ILocator object, which lets you provide direct access to assets in Media Services. Il progetto di Visual Studio fornito con questa serie di argomenti include diversi esempi di codice in cui è illustrato come creare e assegnare criteri di accesso e localizzatori agli asset.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'esempio di codice seguente illustra come elencare tutti i criteri di accesso nel server e mostra il tipo di autorizzazioni associato a ognuno.The following code example shows how to list all access policies on the server, and shows the type of permissions associated with each. Un altro modo utile per visualizzare i criteri di accesso consiste nell'elencare tutti gli oggetti ILocator nel server e quindi, per ogni localizzatore, elencare il relativo criterio di accesso associato usando la relativa proprietà 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("==============");

    }
}

Limitare i criteri di accessoLimit Access Policies

Nota

È previsto un limite di 1.000.000 di criteri per i diversi criteri AMS (ad esempio per i criteri Locator o ContentKeyAuthorizationPolicy). Usare lo stesso ID criterio se si usano sempre gli stessi giorni/autorizzazioni di accesso, come nel cado di criteri per i localizzatori che devono rimanere attivi per molto tempo (criteri di non caricamento).

Ad esempio è possibile creare un insieme generico di criteri con il codice seguente che vengono eseguiti una sola volta nell'applicazione.For example, you can create a generic set of policies with the following code that would only run one time in your application. È possibile registrare gli ID in un file di log per usarli in seguito: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);

Quindi sarà possibile usare gli ID esistenti nel codice come segue: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());

Elencare tutti i localizzatoriList All Locators

Un localizzatore è un URL che fornisce un percorso diretto per accedere a un asset, insieme alle autorizzazioni per l'asset definite dal criterio di accesso associato del localizzatore.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. A ogni asset può essere associata una raccolta di oggetti ILocator per la relativa proprietà Locators.Each asset can have a collection of ILocator objects associated with it on its Locators property. Anche nel contesto del server è disponibile una raccolta Locators contenente tutti i localizzatori.The server context also has a Locators collection that contains all locators.

Nell'esempio di codice seguente sono elencati tutti i localizzatori nel server.The following code example lists all locators on the server. Per ogni localizzatore, sono mostrati l'ID per l'asset e il criterio di accesso correlati.For each locator, it shows the Id for the related asset and access policy. Sono anche visualizzati il tipo di autorizzazioni, la data di scadenza e il percorso completo dell'asset.It also displays the type of permissions, the expiration date, and the full path to the asset.

Si noti che il percorso localizzatore per un asset è solo un URL di base per l'accesso all'asset.Note that a locator path to an asset is only a base URL to the asset. Per creare un percorso diretto per i singoli file a cui un utente o un'applicazione potrebbe accedere, il codice deve aggiungere il percorso del file specifico al percorso localizzatore.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. Per altre informazioni su come eseguire questa operazione, vedere l'argomento Distribuire asset con Media Services SDK for .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("");
    }
}

Enumerazione di grandi raccolte di entitàEnumerating through large collections of entities

Quando si esegue una query di entità, è previsto un limite di 1000 entità restituite in una sola volta perché la versione 2 pubblica di REST limita i risultati della query a 1000 risultati.When querying entities, there is a limit of 1000 entities returned at one time because public REST v2 limits query results to 1000 results. Quando si esegue l'enumerazione di grandi raccolte di entità, è necessario usare la proprietà Skip and Take.You need to use Skip and Take when enumerating through large collections of entities.

La funzione seguente consente di scorrere tutti i processi nell'account di Servizi multimediali specificato.The following function loops through all the jobs in the provided Media Services Account. Servizi multimediali restituisce 1000 processi nella raccolta di processi.Media Services returns 1000 jobs in Jobs Collection. La funzione usa la proprietà Skip and Take per assicurarsi che tutti i processi vengano enumerati (se si dispone di più di 1000 processi nell'account).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);
    }
}

Eliminare un assetDelete an Asset

Nell'esempio seguente sarà eliminato un asset.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");

}

Eliminare un processoDelete a Job

Per eliminare un processo, è necessario verificarne lo stato indicato nella proprietà State.To delete a job, you must check the state of the job as indicated in the State property. I processi completati o annullati possono essere eliminati direttamente, mentre i processi che hanno altri stati, ad esempio che sono accodati, pianificati o in elaborazione, devono essere annullati prima di poter essere eliminati.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'esempio di codice seguente illustra un metodo per eliminare un processo verificandone lo stato e procedendo con l'eliminazione quando lo stato è completato o annullato.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. Questo codice dipende dalla sezione precedente di questo argomento per ottenere un riferimento a un processo: Ottenere un riferimento a un processo.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;
        }

    }
}

Eliminare un criterio di accessoDelete an Access Policy

L'esempio di codice seguente illustra come ottenere un riferimento a un criterio di accesso in base all'ID del criterio e quindi come eliminare il criterio.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();

}

Percorsi di apprendimento di Servizi multimedialiMedia Services learning paths

Altre informazioni sui percorsi di apprendimento di Servizi multimediali di Azure:Read about the Azure Media Services learning paths:

Fornire commenti e suggerimentiProvide feedback

Usare il forum di suggerimenti degli utenti per fornire commenti e suggerimenti su come migliorare Servizi multimediali di Azure.Use the User Voice forum to provide feedback and make suggestions on how to improve Azure Media Services. È anche possibile passare direttamente a una delle categorie seguenti:You also can go directly to one of the following categories: