MSDN Magazin > Home > Ausgaben > 2008 > February >  Silverlight: Erstellen eines benutzerdefinierte...
Silverlight
Erstellen eines benutzerdefinierten Expression Encoder-Veröffentlichungs-Plug-Ins
Laurence Moroney

Themen in diesem Artikel:
  • Grundlagen zu Expression Encoder-Plug-Ins
  • Erstellen eines Standard-Plug-Ins
  • Hinzufügen von FTP-Uploadfunktionalität
  • Erstellen, Installieren und Debuggen
In diesem Artikel werden folgende Technologien verwendet:
WPF, Visual Studio, Expression Encoder
Ein vor kurzem veröffentlichtes Tool namens Microsoft® Expression® Encoder hilft Ihnen, umfassende Medienanwendungen zu codieren, zu verbessern und zu veröffentlichen, die mit Microsoft SilverlightTM gerendert werden können. Expression Encoder besitzt eine erweiterbare Plug-In-Architektur, die das Schreiben von Plug-Ins ermöglicht, mit deren Hilfe die Ausgabe von Expression Encoder in verschiedenen Quellen veröffentlicht werden kann.
In diesem Artikel wird der Erstellungsprozess eines Plug-Ins für Expression Encoder mit Microsoft Visual Studio® 2008 Beta 2 schrittweise durchlaufen. Dieses Plug-In lässt sich in den Standardworkflow einer Expression Encoder-Sitzung einpassen und lädt am Ende einer Codierungssitzung die Ausgabe auf einen FTP-Server hoch.

Expression Encoder und Plug-Ins
Abbildung 1 zeigt Expression Encoder. Die linke Seite des Arbeitsbereichs enthält die Videovorschau und eine Steuerleiste, mit der Sie den neu zu codierenden Videobereich einstellen können. Auf der rechten Seite des Bildschirms befinden sich drei Registerkarten: „Settings“ (Einstellungen) zum Konfigurieren der Codierungssitzung, „Metadata“ (Metadaten) zum Anwenden neuer Informationen auf die Medien und „Output“ (Ausgabe) zum Durchführen von Aktionen nach dem Codieren.
Abbildung 1 Expression Encoder (Klicken Sie zum Vergrößern auf das Bild)
Wenn im Verzeichnis „<Installationsverzeichnis>\Plug-Ins“ ein Veröffentlichungs-Plug-In enthalten und dieses Plug-In richtig geladen ist, enthält die Registerkarte „Output“ (Ausgabe) einen Fensterbereich namens „Publish“ (Veröffentlichen), in dem die verfügbaren Veröffentlichungsoptionen aufgelistet werden. Jeder Typ erfordert ein separates Plug-In. Abbildung 2 zeigt, dass das FTP-Plug-In verfügbar ist.
Abbildung 2 Auswählen des FTP-Plug-Ins 
Der oberste Teil des Fensterbereichs „Publish“ ist bei allen Plug-Ins gleich. In die Liste „Publish To“ (Veröffentlichen auf) werden die Namen aller gültigen Plug-Ins aufgenommen, die im Plug-Ins-Verzeichnis gefunden werden. Das Kontrollkästchen „Auto Start Publish“ (Veröffentlichung automatisch starten) ist immer verfügbar. Wenn es markiert wird, wird am Ende einer Codierung die Veröffentlichung automatisch gestartet.
Die Schaltfläche „Publish“ (Veröffentlichen) ist abgeblendet und wird erst nach Abschluss der Codierung verfügbar. Durch Klicken auf diese Schaltfläche können Sie alle mit der Codierung verknüpften Dateien gleichzeitig veröffentlichen. (Dabei kann es sich um eine einzelne Datei handeln, falls keine Vorlage verwendet wird, oder aber alle für den Videoplayer benötigten Dateien, falls eine Vorlage verwendet wird.) Im Bereich „Settings“ (Einstellungen) kann der Benutzer die Details festlegen, die zum Veröffentlichen der Ausgabe erforderlich sind. Bei einer FTP-Ausgabe werden die Serveradresse, der Benutzername und das Kennwort benötigt. Plug-Ins stellen bei Bedarf auch einen Bereich für erweiterte Einstellungen bereit, der zu Beginn nicht sichtbar ist, aber über die Fenstererweiterungsschaltfläche geöffnet werden kann.
Da der Fensterbereich „Settings“ (Einstellungen) nicht an ein bestimmtes Format gebunden ist, können Sie mithilfe von XAML und Windows® Presentation Foundation (WPF) alles flexibel implementieren, was für Ihr Plug-In erforderlich ist.

Erstellen eines Plug-Ins
Der erste Schritt beim Erstellen eines Plug-Ins besteht darin, eine neue Microsoft .NET Framework 3.0-Klassenbibliothek einzurichten. Danach fügen Sie die erforderlichen Verweise hinzu, die es Ihnen ermöglichen, WPF- und Encoder-Anwendungen zu kompilieren und auszuführen. Diese Verweise sind in Abbildung 3 aufgeführt.

Referenz Speicherort
EncoderTypes C:\Program Files\Microsoft Expression\Encoder 1.0\EncoderTypes.dll
PresentationCore C:\Program Files\Reference Assemblies\Microsoft\Framework\v3.0\PresentationCore.dll
PresentationFramework C:\Program Files\Reference Assemblies\Microsoft\Framework\v3.0\PresentationFramework.dll
WindowsBase C:\Program Files\Reference Assemblies\Microsoft\Framework\v3.0\WindowsBase.dll
Ein Plug-In ist lediglich eine .NET-Standardklasse, die aus der PublishPlugin-Basisklasse abgeleitet und durch das EncoderPluginAttribute-Attribut ergänzt wird. Hierdurch werden die Metadaten hinzugefügt, die das Plug-In beschreiben. Der Konstruktor akzeptiert zwei Zeichenfolgen: den Plug-In-Namen und eine etwas längere Beschreibung.
Hier ist der dazu erforderliche Code:
using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Expression.Encoder.Plugins.
  Publishing;

namespace TestPlugin
{
    [EncoderPlugin("Boiler Plate", 
      "Boiler Plate App")]
    public class Class1 : PublishPlugin
    {
    }
}
Um das Plug-In erfolgreich zu kompilieren, müssen Sie die drei Memberfunktionen der PublishPlugin-Klasse implementieren. CreateStandardSettingsEditor erstellt ein Dialogfeld für Standardeinstellungen und gibt ein Objekt zurück, das die Benutzeroberfläche dafür beschreibt. CreateAdvancedSettingsEditor erstellt ein Dialogfeld für erweiterte Einstellungen und gibt ein Objekt zurück, das die Benutzeroberfläche für dieses Dialogfeld beschreibt. PerformPublish wird aufgerufen, wenn die Schaltfläche „Publish“ aktiviert wird. Diese Memberfunktion akzeptiert zwei Parameter: „root“ und „filesToPublish“. „root“ enthält das Verzeichnis der Dateien, die veröffentlicht werden sollen. „filesToPublish“ besteht aus einem Array von Pfaden zu den Dateien, die durch Expression Encoder veröffentlicht werden.
Abbildung 4 zeigt ein Beispiel für eine Standardklasse, die diese drei Funktionen implementiert. Diese Klasse wird in eine DLL-Datei kompiliert. Wenn Sie diese DLL-Datei in das Verzeichnis „Plug-Ins“ kopieren, steht sie danach als Veröffentlichungs-Plug-In zur Verfügung.
using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Expression.Encoder.Plugins.Publishing;

namespace TestPlugin
{
    [EncoderPlugin("Boiler Plate", "Boiler Plate App")]
    public class Class1 : PublishPlugin
    {
        public override void PerformPublish(string root, 
            string[] filesToPublish)
        {
        }
        #region IPublishPlugin Members
        public override object CreateStandardSettingsEditor()
        {
            return "Standard Settings";
        }
        public override object CreateAdvancedSettingsEditor()
        {
            return "Advanced Settings";
        }
        #endregion
    }
}

Die Konstruktorargumente des Attributs definieren den Listeneintrag in der Dropdownliste „Publish To“ (Veröffentlichen auf) und die von den Funktionen „CreateStandardSettingsEditor“ und „CreateAdvancedSettingsEditor“ zurückgegebenen Objekte definieren die Benutzeroberfläche für die Fensterbereiche mit den Einstellungen.

Erstellen des FTP-Upload-Plug-Ins
Beginnen Sie mit dem einfachen Standard-Plug-In, das im Grunde überhaupt nichts tut, und erweitern Sie es zu einem funktionalen FTP-Upload-Plug-In. Die Fensterbereiche für die Standardparameter und die erweiterten Parameter werden in WPF-XAML implementiert, erfordern aber, dass ihre Daten in einer Klasse implementiert werden, die von INotifyPropertyChanged erbt, damit das Plug-In Änderungen erkennt, die der Benutzer an den Einstellungen vornimmt. Eine einzelne Klasse (in diesem Fall PublishData) ist für beide Parameterfensterbereiche ausreichend.
Fünf Eigenschaften werden für das FTP-Upload-Plug-In implementiert. UseProxy bestimmt, ob der Systemproxy verwendet oder umgangen werden soll. ServerAddress liefert die Adresse des FTP-Servers, auf den hochgeladen werden soll. UserName enthält die Anmelde-ID für den Server und UserPassword enthält natürlich das Kennwort für diese Anmelde-ID. ServerDirectory gibt das Verzeichnis auf dem Server an, in dem die hochgeladenen Dateien abgelegt werden. Abbildung 5 zeigt die vollständige Klasse, die diese Eigenschaften implementiert.
using System;
using System.Collections.Generic;
using System.Text;
using System.Windows;
using System.Windows.Threading;
using System.Threading;
using System.ComponentModel;

namespace FTPPublishPlugin
{
    public class PublishData : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        private bool _UseProxy = false;
        public bool UseProxy
        {
            get { return _UseProxy; }
            set
            {
                _UseProxy = value;
                PropertyChanged(this, 
                  new PropertyChangedEventArgs("UseProxy"));
            }
        }

        private string _ServerAddress = "";
        public string ServerAddress
        {
            get { return _ServerAddress; }
            set 
            { 
                _ServerAddress = value; 
                PropertyChanged(this, 
                  new PropertyChangedEventArgs("ServerAddress"));
            }
        }

        private string _UserName = "";
        public string UserName
        {
            get { return _UserName; }
            set
            {
                _UserName = value;
                PropertyChanged(this, 
                  new PropertyChangedEventArgs("UserName"));
            }
        }

        private string _UserPassword = "";
        public string UserPassword
        {
            get { return _UserPassword; }
            set
            {
                _UserPassword = value;
                PropertyChanged(this, 
                  new PropertyChangedEventArgs("UserPassword"));
            }
        }

        private string _ServerDirectory = "";
        public string ServerDirectory
        {
            get { return _ServerDirectory; }
            set
            {
                _ServerDirectory = value;
                PropertyChanged(this, 
                  new PropertyChangedEventArgs("ServerDirectory"));
            }
        }
    }

}

Die Struktur dieser Klasse ist einfach. Zunächst muss die Klasse „INotifyPropertyChanged“ implementieren, um von der Benutzeroberfläche Eigenschaftenbenachrichtigungen zu erhalten. Danach implementiert sie ein standardmäßiges Muster für die Entwicklung von Eigenschaftenhandlern, bei der eine private Membervariable den Wert der Eigenschaft speichert und durch eine Getter- und eine Setter-Accessormethode eingekapselt wird. Wenn die Gettermethode aufgerufen wird, wird der Wert der privaten Membervariable zurückgegeben. Wenn die Settermethode aufgerufen wird, wird der private Member aktualisiert und das Ereignis „PropertyChanged“ ausgelöst. Das Ereignis „PropertyChanged“ wird mit einem Argument initialisiert, das den Namen der zu ändernden Eigenschaft enthält. Die Benutzeroberfläche verwendet XAML-Datenbindung, um eine Verbindung zu diesem Code herzustellen, was zur Folge hat, dass Benutzeraktionen die Getter- und die Settermethode aufrufen. Im Folgenden ist ein Beispiel für die XAML-Datenbindung zu sehen, die im Dialogfeld für die Eigenschaft „ServerAddress“ verwendet wird:
<TextBox Grid.Column="1" Grid.Row="0" Text="{Binding Path=ServerAddress, Mode=TwoWay}" Margin="0,3,0,3" />
Die Steuerelemente der Benutzeroberfläche des Parameterfensterbereichs werden durch standardmäßige WPF-XAML-Benutzersteuerelemente implementiert. Beachten Sie, dass die „x:Class“ für diese Steuerelemente darauf eingestellt werden muss, den Namespace zu verwenden, den Sie bisher in Ihrem Code verwendet haben. So muss beispielsweise für den Fensterbereich für Standardparameter FTPPublishPlugin.StandardParams und für den Fensterbereich für erweiterte Parameter FTPPublishPlugin.AdvancedParams verwendet werden.
Diese sind über Datenbindung mit ihren jeweiligen Eigenschaften innerhalb der Klasse „PublishData“ verknüpft. Dies wird erreicht, indem die Klasse „PublishData“ als Datenkontext für das Benutzersteuerelement eingestellt wird. Wenn das Plug-In das Benutzersteuerelement „StandardParams“ instanziiert, übergibt es dem Steuerelement eine Instanz der Klasse „PublishData“. Das Benutzersteuerelement verwendet anschließend diese Instanz dazu, den Datenkontext einzurichten, wie Sie hier sehen können:
public StandardParams(PublishData data)
{
    this.InitializeComponent();
    this.DataContext = data;

}
Aus diesem Grund verwenden Sie zum Implementieren der Beschriftung und des Textfelds für ServerAddress ganz einfach den folgenden XAML-Code im Benutzersteuerelement:
<Label Grid.Column="0" Grid.Row="0" Margin="0,3,0,3">Server Address
</Label>
<TextBox Grid.Column="1" Grid.Row="0" Text=
"{Binding Path=ServerAddress, Mode=TwoWay}" Margin="0,3,0,3" />
Wie Sie sehen, ist die Eigenschaft „text“ von TextBox an die Eigenschaft „ServerAddress“ gebunden. Diese Bindung ist gegenseitiger Natur und ermöglicht das automatische Einstellen und Abrufen der Eigenschaft durch WPF.
Die Verarbeitung eines Kennworteingabefelds ist etwas schwieriger, da Sie aus Sicherheitsgründen keine Datenbindung an dieses Feld vornehmen können. Darüber hinaus steht die automatische Gestaltung von Beschriftungen und Textfeldern, die der Encoder bereitstellt, beim Kennwortfeld nicht zur Verfügung, weshalb Sie diese Gestaltung selbst festlegen müssen. Daher müssen Sie zum Implementieren eines Kennwortfelds den in Abbildung 6 gezeigten XAML-Code verwenden, um die Benutzeroberfläche zu implementieren.
<PasswordBox PasswordChar="*" Grid.Column="1" Grid.Row="2" 
    x:Name="pass" PasswordChanged="HandlePW" Margin="0,3,0,3">
    <PasswordBox.Style>
        <Style TargetType="{x:Type PasswordBox}" >
            <Setter Property="BorderBrush" 
                Value="{DynamicResource BackgroundBrush}"/>
            <Setter Property="Foreground" 
                Value="{DynamicResource Text1Brush}"/>
            <Setter Property="Background" 
                Value="{DynamicResource BackgroundBrush}"/>
            <Setter Property="FontFamily" 
                Value="{DynamicResource 
                {x:Static SystemFonts.MessageFontFamilyKey}}"/>
            <Setter Property="FontSize" 
                Value="{DynamicResource 
                {x:Static SystemFonts.MessageFontSizeKey}}"/>
            <Setter Property="FontWeight" 
                Value="{DynamicResource 
                {x:Static SystemFonts.MessageFontWeightKey}}"/>
        </Style>
    </PasswordBox.Style>
</PasswordBox>

Dadurch wird als Ereignishandler für die Kennwortänderung HandlePW festgelegt. Diesen Ereignishandler verwenden Sie dazu, das eingegebene Kennwort zu ermitteln und es in der Klasse „PublishData“ zu speichern, die den aktuellen Datenkontext bildet. Hier folgt ein Beispiel für diese Funktion:
public void HandlePW(object sender, RoutedEventArgs e)
{
    PublishData d = (PublishData) this.DataContext;
    d.UserPassword = pass.Password;
}

Implementieren der Publish-Klasse
Nachdem nun das Fundament gelegt ist, ist das Erstellen der Publish-Klasse für einen FTP-Server ganz einfach. Zuerst müssen Sie sicherstellen, dass mit dem Plug-In eine Instanz der Klasse „PublishData“ erstellt wird. Dies wird am besten im Konstruktor für das Plug-In vorgenommen:
private StandardParams _standardParams;
private PublishData _publishData;
public Publish() : this(new PublishData())
{
}
public Publish(PublishData publishData)
{
    _publishData = publishData;
    _standardParams = new StandardParams(_publishData);
}
Wie Sie sehen, wird dadurch auch das Benutzersteuerelement „StandardParams“ initialisiert, das dann beim Rendern des Plug-Ins angezeigt wird. Es übergibt die Instanz der Klasse „PublishData“ (mit dem Namen „_publishData“) dem Benutzersteuerelement. Dies wird zum Festlegen des Datenkontexts verwendet, wie bereits im vorherigen Schritt erwähnt.
Danach müssen Sie die Funktionen implementieren, die zum Erstellen der Editorfensterbereiche für Standardeinstellungen und erweiterte Einstellungen benötigt werden. Denken Sie an das Standardbeispiel mit den zurückgegebenen Zeichenfolgen zurück, die anschließend gerendert wurden. Jetzt müssen Sie die Benutzersteuerelemente für die jeweiligen Einstellungsfensterbereiche rendern:
public override object CreateStandardSettingsEditor()
{
    return _standardParams;   
}
public override object CreateAdvancedSettingsEditor()
{
    return new AdvancedParams(this, _publishData);  
}
Zum Schluss implementieren Sie die Funktion „Publish“ (Veröffentlichen), die aufgerufen wird, wenn der Benutzer die Veröffentlichung der Ausgabe verlangt, indem er entweder die Schaltfläche „Publish“ betätigt oder die Option „Auto Publish“ auswählt. Da Sie in diesem Fall auf FTP veröffentlichen, wird hier der Code zum Herstellen einer Verbindung zum Server implementiert. Abbildung 7 zeigt ein Beispiel dafür.
public override void PerformPublish(string root, string[] filesToPublish)
{
    try
    {
        int nFileCount = filesToPublish.Length;
        int nFileProgressSize = 100 / nFileCount;
        int nCurrentProgress = 0;
        WebClient wc = new WebClient();
        if (!_publishData.UseProxy)
            wc.Proxy = null;
        wc.BaseAddress = "ftp://" + _publishData.ServerAddress + "/";
        string strURI = "";
        wc.Credentials = 
        new NetworkCredential(_publishData.UserName, 
            _publishData.UserPassword);

        foreach (string theFile in filesToPublish)
        {
            if (!m_Cancelled)
            {
                strURI = theFile.Substring(theFile.LastIndexOf("\\") + 1);
                if (_publishData.ServerDirectory != String.Empty)
                    strURI = _
                        publishData.ServerDirectory + "\\" + strURI;
                nCurrentProgress += nFileProgressSize;
                OnProgress(strURI, nCurrentProgress);
                wc.UploadFile(strURI, theFile);
            }
        }

        if (m_Cancelled)
        {
            PublishingHost.ShowMessageBox("Upload Cancelled",   
                System.Windows.MessageBoxButton.OK, 
                System.Windows.MessageBoxImage.Error);
        } 
    }

    catch (Exception ex)
    {
        string strIE = ex.Message;
        if (ex.InnerException != null)
            strIE += "\n: " + ex.InnerException.Message;
                
        throw new Exception(strIE);
    }

    protected override void CancelPublish()
    {
        m_Cancelled = true;
        base.CancelPublish();
    }
}

Wie Sie sehen, handelt es sich hierbei um einen recht einfachen C#-Code zum Hochladen einer Gruppe von Dateien auf einen FTP-Server. Die erforderlichen Daten für den FTP-Server werden der Klasse „_publishData“ entnommen, die wiederum von den zuvor behandelten Steuerelementen eingestellt wird.
Beachten Sie die Funktion „OnProgress“, die ein Teil der Plug-Ins-API ist und nicht unbedingt implementiert werden muss. Diese Funktion wird ganz einfach mit einer Zeichenfolge und einer Zahl zwischen 0 und 100 aufgerufen. Danach rendert sie die Zeichenfolge und einen Balken, auf dem der Fortschrittswert prozentual dargestellt wird. In diesem Fall wird der Fortschritt durch die Anzahl der hochgeladenen Dateien bestimmt. Wenn es sich beispielsweise um insgesamt 10 Dateien handelt, wird unabhängig von der Dateigröße jede einzelne Datei als 10 Prozent des Fortschritts betrachtet.
Achten Sie auch auf die Funktion „CancelPublish“. Die API stellt Ihnen diese Funktion zum Überschreiben bereit. Sie wird ausgelöst, wenn der Benutzer die Schaltfläche „Cancel“ (Abbrechen) betätigt, die beim Veröffentlichen automatisch von der Benutzeroberfläche generiert wird. In diesem Fall stellt die Funktion die boolesche Variable „m_Cancelled“ einfach auf „True“ ein und bricht die Veröffentlichung ab.
Beachten Sie dabei Folgendes: Da dieser Code lediglich eine Beispielanwendung ist, besitzt er einen einzigen Ausnahmehandler, der alle Ausnahmen erfasst und dem Benutzer meldet. In einer realistischen Anwendung müssten Sie für die verschiedenen Ausnahmen, die in Ihrer Anwendung auftreten könnten, ausführlichere Fehlerinformationen angeben.

Speichern von Konfigurationseinstellungen
Um dem Benutzer die Mühe zu ersparen, ständig Anmeldeinformationen für den FTP-Server eingeben zu müssen, auf dem veröffentlicht werden soll, können Sie die Methoden „SaveJobSettings“ und „LoadJobSettings“ aus der PublishPlugin-Basisklase überschreiben. Diese Methoden werden von Expression Encoder in der Plug-In-Instanz aufgerufen, sobald der Benutzer im Menü „Datei“ die Option „Save Job“ (Auftrag speichern) auswählt, und ermöglichen Ihnen, Ihre Konfigurationseigenschaften zu serialisieren und wiederherzustellen. So würden Sie beispielsweise Folgendes schreiben, um Ihre Konfigurationseigenschaften zu speichern:
public override void SaveJobSettings(XmlWriter writer)
{
  writer.WriteStartElement("FtpSample");
  writer.WriteElementString("UseProxy", 
      _publishData.UseProxy.ToString());
  writer.WriteElementString("ServerAddress", 
      _publishData.ServerAddress);
  writer.WriteElementString("UserName", _publishData.UserName);
  writer.WriteElementString("ServerDirectory", 
      _publishData.ServerDirectory);
  writer.WriteEndElement();
}
Hierbei ist zu beachten, dass Sie die Konfigurationseigenschaften innerhalb eines XML-Elements der obersten Ebene verschachteln müssen. Dies liegt daran, dass die Eigenschaften in die XML-Auftragsdatei Ihres Codierungsauftrags serialisiert werden, in der viele zusätzliche Daten enthalten sind. Sie können die gespeicherten Eigenschaften durch folgenden Code wiederherstellen:
public override void LoadJobSettings(XmlReader reader)
{
  reader.ReadStartElement("FtpSample");
  _publishData.UseProxy = bool.Parse(xr.ReadElementString("UseProxy"));
  _publishData.ServerAddress = xr.ReadElementString("ServerAddress");
  _publishData.UserName = xr.ReadElementString("UserName");
  _publishData.ServerDirectory = xr.ReadElementString("ServerDirectory");
  reader.ReadEndElement();
}

Kompilieren, Bereitstellen und Debuggen
Sollte sich alles problemlos kompilieren lassen, befinden sich anschließend in Ihrem Projektverzeichnis „bin\debug“ drei Dateien: Ihre Plug-In-DLL-Datei, eine .pdb-Datei für Ihre DLL-Datei und eine Datei namens „EncoderTypes.dll“. Kopieren Sie nur die Plug-In-DLL-Datei in den Ordner „Plug-Ins“. Wenn Sie jetzt Expression Encoder starten, müsste das Plug-In korrekt geladen werden.
Kehren Sie nach dem Laden von Expression Encoder zu Visual Studio zurück, und wählen Sie „Debuggen“ | „An den Prozess anhängen“ aus. Dadurch wird das Dialogfeld „An den Prozess anhängen“ angezeigt. Wählen Sie in diesem Dialogfeld „MediaEncoderUI.exe“ aus.
Wenn Sie den Veröffentlichungsprozess überprüfen möchten, können Sie in der Funktion „Veröffentlichen“ einen Haltepunkt festlegen. Wenn Sie anschließend nach Abschluss eines Codierungsauftrags in Expression Encoder die Schaltfläche „Publish“ (Veröffentlichen) betätigen, erreichen Sie den Haltepunkt und können durch den Prozess schalten und beobachten, was in Expression Encoder während der Veröffentlichung Ihrer Dateien geschieht.

Laurence Moroney ist als leitender Technologieexperte mit dem Fachgebiet Silverlight bei Microsoft tätig. Er ist Autor zahlreicher Bücher über Themen aus der Datenverarbeitung, z. B. Silverlight, AJAX, Interoperabilität und Sicherheit. Sein Blog befindet sich unter der Adresse blogs.msdn.com/webnext.

Page view tracker