Exemplarische Vorgehensweise: Erstellen und Verwenden von dynamischen Objekten (C# und Visual Basic)Walkthrough: Creating and Using Dynamic Objects (C# and Visual Basic)

Dynamische Objekte machen Member wie etwa Eigenschaften und Methoden zur Laufzeit anstatt zur Kompilierzeit verfügbar.Dynamic objects expose members such as properties and methods at run time, instead of in at compile time. Dadurch können Sie Objekte erstellen, mit denen Sie mit Strukturen arbeiten können, die keinem statischen Typ oder Format entsprechen.This enables you to create objects to work with structures that do not match a static type or format. Sie können z.B. ein dynamisches Objekt verwenden, um auf das HTML-DOM (Document Object Model) zu verweisen, das eine Kombination aus gültigen HTML-Markupelementen und Attributen enthalten kann.For example, you can use a dynamic object to reference the HTML Document Object Model (DOM), which can contain any combination of valid HTML markup elements and attributes. Da jedes HTML-Dokument eindeutig ist, werden die Elemente für ein bestimmtes HTML-Dokument zur Laufzeit bestimmt.Because each HTML document is unique, the members for a particular HTML document are determined at run time. Eine gängige Methode zum Verweisen eines Attributes auf ein HTML-Element ist, den Namen des Attributs an die GetProperty-Methode des Elements weiterzugeben.A common method to reference an attribute of an HTML element is to pass the name of the attribute to the GetProperty method of the element. Rufen Sie zum Verweisen des id-Attributs auf das HTML-Element <div id="Div1"> zuerst einen Verweis auf das <div>-Element ab, und verwenden Sie anschließend divElement.GetProperty("id").To reference the id attribute of the HTML element <div id="Div1">, you first obtain a reference to the <div> element, and then use divElement.GetProperty("id"). Wenn Sie ein dynamisches Objekt verwenden, können Sie auf das id-Attribut als divElement.id verweisen.If you use a dynamic object, you can reference the id attribute as divElement.id.

Dynamische Objekte bieten außerdem einfachen Zugriff auf dynamische Sprachen wie IronPython und IronRuby.Dynamic objects also provide convenient access to dynamic languages such as IronPython and IronRuby. Sie können ein dynamisches Objekt verwenden, um sich auf ein dynamisches Skript zu beziehen, das zur Laufzeit ausgeführt wird.You can use a dynamic object to refer to a dynamic script that is interpreted at run time.

Sie verweisen auf ein dynamisches Objekt mithilfe der späten Bindung.You reference a dynamic object by using late binding. Geben Sie in C# den Typ eines spät gebundenen Objekts als dynamic an.In C#, you specify the type of a late-bound object as dynamic. Geben Sie in Visual Basic den Typ eines spät gebundenen Objekts als Object an.In Visual Basic, you specify the type of a late-bound object as Object. Weitere Informationen finden Sie unter dynamic und Frühes und spätes Binden.For more information, see dynamic and Early and Late Binding.

Sie können benutzerdefinierte dynamische Objekte erstellen, indem Sie die Klassen im System.Dynamic-Namespace verwenden.You can create custom dynamic objects by using the classes in the System.Dynamic namespace. Sie können z.B. ein ExpandoObject erstellen und die Member dieses Objekts zur Laufzeit angeben.For example, you can create an ExpandoObject and specify the members of that object at run time. Sie können auch einen eigenen Typ erstellen, der die DynamicObject-Klasse erbt.You can also create your own type that inherits the DynamicObject class. Sie können die Member dieser DynamicObject-Klasse anschließend außer Kraft setzen, um dynamische Funktionen zur Laufzeit bereitzustellen.You can then override the members of the DynamicObject class to provide run-time dynamic functionality.

Im Verlauf dieser exemplarischen Vorgehensweise führen Sie folgende Aufgaben aus:In this walkthrough you will perform the following tasks:

  • Erstellen Sie ein benutzerdefiniertes Objekt, das die Inhalte einer Textdatei als Eigenschaften eines Objekts weitergibt.Create a custom object that dynamically exposes the contents of a text file as properties of an object.

  • Erstellen Sie ein Objekt, das die IronPython-Bibliothek verwendet.Create a project that uses an IronPython library.

Erforderliche KomponentenPrerequisites

Sie benötigen IronPython für .NET für diese exemplarische Vorgehensweise.You need IronPython for .NET to complete this walkthrough. Wechseln Sie zur Downloadseite, um die neueste Version zu erhalten.Go to their Download page to obtain the latest version.

Hinweis

Auf Ihrem Computer werden möglicherweise andere Namen oder Speicherorte für die Benutzeroberflächenelemente von Visual Studio angezeigt als die in den folgenden Anweisungen aufgeführten.Your computer might show different names or locations for some of the Visual Studio user interface elements in the following instructions. Diese Elemente sind von der jeweiligen Visual Studio-Version und den verwendeten Einstellungen abhängig.The Visual Studio edition that you have and the settings that you use determine these elements. Weitere Informationen finden Sie unter Personalisieren der IDE.For more information, see Personalizing the IDE.

Erstellen eines benutzerdefinierten dynamischen ObjektsCreating a Custom Dynamic Object

Das erste Projekt, das Sie in dieser exemplarischen Vorgehensweise erstellen definiert ein benutzerdefiniertes dynamisches Objekt, das die Inhalte einer Textdatei durchsucht.The first project that you create in this walkthrough defines a custom dynamic object that searches the contents of a text file. Der Text, nach dem gesucht werden soll, wird vom Namen einer dynamischen Eigenschaft angegeben.Text to search for is specified by the name of a dynamic property. Wenn aufrufender Code z.B. dynamicFile.Sample angibt, gibt die dynamische Klasse eine generische Liste von Zeichenfolgen zurück, die alle Zeilen aus der Datei enthält, die mit „Sample“ anfangen.For example, if calling code specifies dynamicFile.Sample, the dynamic class returns a generic list of strings that contains all of the lines from the file that begin with "Sample". Die Groß- und Kleinschreibung wird bei der Suche nicht berücksichtigt.The search is case-insensitive. Die dynamische Klasse unterstützt auch zwei optionale Argumente.The dynamic class also supports two optional arguments. Das erste Argument ist ein Enumerationswert einer Suchoption, der angibt, dass die dynamische Klasse am Beginn, am Ende oder an einer beliebigen Stelle der Zeile nach Übereinstimmungen suchen soll.The first argument is a search option enum value that specifies that the dynamic class should search for matches at the start of the line, the end of the line, or anywhere in the line. Das zweite Argument gibt an, dass die dynamische Klasse führende und nachfolgende Leerzeichen vor dem Suchvorgang aus jeder Zeile entfernen soll.The second argument specifies that the dynamic class should trim leading and trailing spaces from each line before searching. Wenn aufrufender Code z.B. dynamicFile.Sample(StringSearchOption.Contains) angibt, sucht die dynamische Klasse an einer beliebigen Stelle in der Zeile nach „Sample“.For example, if calling code specifies dynamicFile.Sample(StringSearchOption.Contains), the dynamic class searches for "Sample" anywhere in a line. Wenn der aufrufende Code dynamicFile.Sample(StringSearchOption.StartsWith, false) angibt, sucht die dynamische Klasse am Beginn jeder Zeile nach „Sample“ und entfernt keine führenden oder nachfolgenden Leerzeichen.If calling code specifies dynamicFile.Sample(StringSearchOption.StartsWith, false), the dynamic class searches for "Sample" at the start of each line, and does not remove leading and trailing spaces. Standardmäßig sucht die dynamische Klasse nach Übereinstimmungen am Beginn jeder Zeile und entfernt führende oder nachfolgende Leerzeichen.The default behavior of the dynamic class is to search for a match at the start of each line and to remove leading and trailing spaces.

So erstellen Sie eine benutzerdefinierte dynamische KlasseTo create a custom dynamic class

  1. Starten Sie Visual Studio.Start Visual Studio.

  2. Zeigen Sie im Menü Datei auf Neu , und klicken Sie dann auf Projekt.On the File menu, point to New and then click Project.

  3. Überprüfen Sie, ob im Dialogfeld Neues Projekt im Bereich Projekttypen der Eintrag Windows ausgewählt ist.In the New Project dialog box, in the Project Types pane, make sure that Windows is selected. Wählen Sie im Bereich Vorlagen die Option Konsolenanwendung aus.Select Console Application in the Templates pane. Geben Sie im Feld Name die Bezeichnung DynamicSample ein, und klicken Sie dann auf OK.In the Name box, type DynamicSample, and then click OK. Das neue Projekt wird erstellt.The new project is created.

  4. Klicken Sie mit der rechten Maustaste auf das Projekt „DynamicSample“ und halten Sie den Mauszeiger auf Hinzufügen. Klicken Sie anschließend auf Klasse.Right-click the DynamicSample project and point to Add, and then click Class. Geben Sie im Feld Name die Bezeichnung ReadOnlyFile ein, und klicken Sie dann auf OK.In the Name box, type ReadOnlyFile, and then click OK. Eine neue Datei wird hinzugefügt, die die Klasse „ReadOnlyFile“ enthält.A new file is added that contains the ReadOnlyFile class.

  5. Fügen Sie am Anfang der Dateien „ReadOnlyFile.cs“ oder „ReadOnlyFile.vb“ den folgenden Code zum Importieren der System.IO- und System.Dynamic-Namespaces hinzu.At the top of the ReadOnlyFile.cs or ReadOnlyFile.vb file, add the following code to import the System.IO and System.Dynamic namespaces.

    using System.IO;
    using System.Dynamic;
    
    Imports System.IO
    Imports System.Dynamic
    
  6. Das benutzerdefinierte dynamische Objekt verwendet einen Enumerationswert, um die Suchkriterien zu bestimmen.The custom dynamic object uses an enum to determine the search criteria. Fügen Sie vor der class-Anweisung die folgende Enumerationsdefinition ein.Before the class statement, add the following enum definition.

    public enum StringSearchOption
    {
        StartsWith,
        Contains,
        EndsWith
    }
    
    Public Enum StringSearchOption
        StartsWith
        Contains
        EndsWith
    End Enum
    
  7. Aktualisieren Sie die class-Anweisung wie im folgenden Beispiel, um die DynamicObject-Klasse zu erben.Update the class statement to inherit the DynamicObject class, as shown in the following code example.

    class ReadOnlyFile : DynamicObject
    
    Public Class ReadOnlyFile
        Inherits DynamicObject
    
  8. Fügen Sie den folgenden Code zur ReadOnlyFile-Klasse hinzu, um ein privates Feld für den Dateipfad und einen Konstruktor für die ReadOnlyFile-Klasse zu definieren.Add the following code to the ReadOnlyFile class to define a private field for the file path and a constructor for the ReadOnlyFile class.

    // Store the path to the file and the initial line count value.
    private string p_filePath;
    
    // Public constructor. Verify that file exists and store the path in 
    // the private variable.
    public ReadOnlyFile(string filePath)
    {
        if (!File.Exists(filePath))
        {
            throw new Exception("File path does not exist.");
        }
    
        p_filePath = filePath;
    }
    
    ' Store the path to the file and the initial line count value.
    Private p_filePath As String
    
    ' Public constructor. Verify that file exists and store the path in 
    ' the private variable.
    Public Sub New(ByVal filePath As String)
        If Not File.Exists(filePath) Then
            Throw New Exception("File path does not exist.")
        End If
    
        p_filePath = filePath
    End Sub
    
  9. Fügen Sie die folgende GetPropertyValue-Methode zu der ReadOnlyFile-Klasse hinzu.Add the following GetPropertyValue method to the ReadOnlyFile class. Die GetPropertyValue-Methode akzeptiert Suchkriterien als Eingabe und gibt die Zeilen aus einer Textdatei zurück, die den Suchkriterien entsprechen.The GetPropertyValue method takes, as input, search criteria and returns the lines from a text file that match that search criteria. Die von der ReadOnlyFile-Klasse bereitgestellten Methoden rufen die GetPropertyValue-Methode auf, um ihre entsprechenden Ergebnisse abzurufen.The dynamic methods provided by the ReadOnlyFile class call the GetPropertyValue method to retrieve their respective results.

    public List<string> GetPropertyValue(string propertyName,
                                         StringSearchOption StringSearchOption = StringSearchOption.StartsWith,
                                         bool trimSpaces = true) 
    {
        StreamReader sr = null;
        List<string> results = new List<string>();
        string line = "";
        string testLine = "";
    
        try
        {
            sr = new StreamReader(p_filePath);
    
            while (!sr.EndOfStream)
            {
                line = sr.ReadLine();
    
                // Perform a case-insensitive search by using the specified search options.
                testLine = line.ToUpper();
                if (trimSpaces) { testLine = testLine.Trim(); }
    
                switch (StringSearchOption)
                {
                    case StringSearchOption.StartsWith:
                        if (testLine.StartsWith(propertyName.ToUpper())) { results.Add(line); }
                        break;
                    case StringSearchOption.Contains:
                        if (testLine.Contains(propertyName.ToUpper())) { results.Add(line); }
                        break;
                    case StringSearchOption.EndsWith:
                        if (testLine.EndsWith(propertyName.ToUpper())) { results.Add(line); }
                        break;
                }
            }
        }
        catch
        {
            // Trap any exception that occurs in reading the file and return null.
            results = null;
        }
        finally
        {
            if (sr != null) {sr.Close();}
        }
    
        return results;
    }
    
    Public Function GetPropertyValue(ByVal propertyName As String,
                                     Optional ByVal StringSearchOption As StringSearchOption = StringSearchOption.StartsWith,
                                     Optional ByVal trimSpaces As Boolean = True) As List(Of String)
    
        Dim sr As StreamReader = Nothing
        Dim results As New List(Of String)
        Dim line = ""
        Dim testLine = ""
    
        Try
            sr = New StreamReader(p_filePath)
    
            While Not sr.EndOfStream
                line = sr.ReadLine()
    
                ' Perform a case-insensitive search by using the specified search options.
                testLine = UCase(line)
                If trimSpaces Then testLine = Trim(testLine)
    
                Select Case StringSearchOption
                    Case StringSearchOption.StartsWith
                        If testLine.StartsWith(UCase(propertyName)) Then results.Add(line)
                    Case StringSearchOption.Contains
                        If testLine.Contains(UCase(propertyName)) Then results.Add(line)
                    Case StringSearchOption.EndsWith
                        If testLine.EndsWith(UCase(propertyName)) Then results.Add(line)
                End Select
            End While
        Catch
            ' Trap any exception that occurs in reading the file and return Nothing.
            results = Nothing
        Finally
            If sr IsNot Nothing Then sr.Close()
        End Try
    
        Return results
    End Function
    
  10. Fügen Sie nach der GetPropertyValue-Methode den folgenden Code hinzu, um die TryGetMember-Methode der DynamicObject-Klasse zu überschreiben.After the GetPropertyValue method, add the following code to override the TryGetMember method of the DynamicObject class. Die Methode TryGetMember wird aufgerufen, wenn ein Member einer dynamischen Klasse angefordert wird und keine Argumente angegeben werden.The TryGetMember method is called when a member of a dynamic class is requested and no arguments are specified. Das Argument binder enthält Informationen über den Member, auf den verwiesen wurde. Das Argument result verweist auf das Ergebnis, das für den angegebenen Member zurückgegeben wird.The binder argument contains information about the referenced member, and the result argument references the result returned for the specified member. Die Methode TryGetMember gibt einen booleschen Wert zurück, der true zurückgibt, wenn der angeforderte Member vorhanden ist; andernfalls wird false zurückgegeben.The TryGetMember method returns a Boolean value that returns true if the requested member exists; otherwise it returns false.

    // Implement the TryGetMember method of the DynamicObject class for dynamic member calls.
    public override bool TryGetMember(GetMemberBinder binder,
                                      out object result) 
    {
        result = GetPropertyValue(binder.Name);
        return result == null ? false : true;
    }
    
    ' Implement the TryGetMember method of the DynamicObject class for dynamic member calls.
    Public Overrides Function TryGetMember(ByVal binder As GetMemberBinder,
                                           ByRef result As Object) As Boolean
        result = GetPropertyValue(binder.Name)
        Return If(result Is Nothing, False, True)
    End Function
    
  11. Fügen Sie nach der TryGetMember-Methode den folgenden Code hinzu, um die TryInvokeMember-Methode der DynamicObject-Klasse zu überschreiben.After the TryGetMember method, add the following code to override the TryInvokeMember method of the DynamicObject class. Die TryInvokeMember-Methode wird aufgerufen, wenn ein Mitglied einer dynamischen Klasse mit Argumenten angefordert wird.The TryInvokeMember method is called when a member of a dynamic class is requested with arguments. Das Argument binder enthält Informationen über den Member, auf den verwiesen wurde. Das Argument result verweist auf das Ergebnis, das für den angegebenen Member zurückgegeben wird.The binder argument contains information about the referenced member, and the result argument references the result returned for the specified member. Das Argument args enthält ein Array von Argumenten, die an den Member weitergegeben werden.The args argument contains an array of the arguments that are passed to the member. Die Methode TryInvokeMember gibt einen booleschen Wert zurück, der true zurückgibt, wenn der angeforderte Member vorhanden ist; andernfalls wird false zurückgegeben.The TryInvokeMember method returns a Boolean value that returns true if the requested member exists; otherwise it returns false.

    Die benutzerdefinierte Version der Methode TryInvokeMember erwartet, dass es sich beim ersten Argument um einen Wert der StringSearchOption-Enumeration handelt, die Sie in einem vorherigen Schritt definiert haben.The custom version of the TryInvokeMember method expects the first argument to be a value from the StringSearchOption enum that you defined in a previous step. Die Methode TryInvokeMember erwartet, dass es sich beim zweiten Argument um einen booleschen Wert handelt.The TryInvokeMember method expects the second argument to be a Boolean value. Wenn es sich bei einem oder beiden Argumenten um gültige Werte handelt, werden sie an die Methode GetPropertyValue zum Abrufen der Werte weitergegeben.If one or both arguments are valid values, they are passed to the GetPropertyValue method to retrieve the results.

    // Implement the TryInvokeMember method of the DynamicObject class for 
    // dynamic member calls that have arguments.
    public override bool TryInvokeMember(InvokeMemberBinder binder,
                                         object[] args,
                                         out object result)
    {
        StringSearchOption StringSearchOption = StringSearchOption.StartsWith;
        bool trimSpaces = true;
    
        try
        {
            if (args.Length > 0) { StringSearchOption = (StringSearchOption)args[0]; }
        }
        catch
        {
            throw new ArgumentException("StringSearchOption argument must be a StringSearchOption enum value.");
        }
    
        try
        {
            if (args.Length > 1) { trimSpaces = (bool)args[1]; }
        }
        catch
        {
            throw new ArgumentException("trimSpaces argument must be a Boolean value.");
        }
    
        result = GetPropertyValue(binder.Name, StringSearchOption, trimSpaces);
    
        return result == null ? false : true;
    }
    
    ' Implement the TryInvokeMember method of the DynamicObject class for 
    ' dynamic member calls that have arguments.
    Public Overrides Function TryInvokeMember(ByVal binder As InvokeMemberBinder,
                                              ByVal args() As Object,
                                              ByRef result As Object) As Boolean
    
        Dim StringSearchOption As StringSearchOption = StringSearchOption.StartsWith
        Dim trimSpaces = True
    
        Try
            If args.Length > 0 Then StringSearchOption = CType(args(0), StringSearchOption)
        Catch
            Throw New ArgumentException("StringSearchOption argument must be a StringSearchOption enum value.")
        End Try
    
        Try
            If args.Length > 1 Then trimSpaces = CType(args(1), Boolean)
        Catch
            Throw New ArgumentException("trimSpaces argument must be a Boolean value.")
        End Try
    
        result = GetPropertyValue(binder.Name, StringSearchOption, trimSpaces)
    
        Return If(result Is Nothing, False, True)
    End Function
    
  12. Speichern und schließen Sie die Datei.Save and close the file.

So erstellen Sie eine BeispieltextdateiTo create a sample text file

  1. Klicken Sie mit der rechten Maustaste auf das Projekt „DynamicSample“ und halten Sie den Mauszeiger auf Hinzufügen. Klicken Sie anschließend auf Neues Element.Right-click the DynamicSample project and point to Add, and then click New Item. Wählen Sie im Bereich Installierte Vorlagen Allgemein aus, und wählen Sie anschließend die Vorlage Textdatei aus.In the Installed Templates pane, select General, and then select the Text File template. Übernehmen Sie den Standardnamen der Datei „TextFile1.txt“ im Feld Name, und klicken Sie auf Hinzufügen.Leave the default name of TextFile1.txt in the Name box, and then click Add. Eine neue Textdatei wird zum Projekt hinzugefügt.A new text file is added to the project.

  2. Kopieren Sie den folgenden Text in die Datei „TextFile1.txt“.Copy the following text to the TextFile1.txt file.

    List of customers and suppliers  
    
    Supplier: Lucerne Publishing (http://www.lucernepublishing.com/)  
    Customer: Preston, Chris  
    Customer: Hines, Patrick  
    Customer: Cameron, Maria  
    Supplier: Graphic Design Institute (http://www.graphicdesigninstitute.com/)   
    Supplier: Fabrikam, Inc. (http://www.fabrikam.com/)   
    Customer: Seubert, Roxanne  
    Supplier: Proseware, Inc. (http://www.proseware.com/)   
    Customer: Adolphi, Stephan  
    Customer: Koch, Paul  
    
  3. Speichern und schließen Sie die Datei.Save and close the file.

So erstellen Sie eine Beispielanwendung, die das benutzerdefinierte dynamische Objekt enthältTo create a sample application that uses the custom dynamic object

  1. Doppelklicken Sie im Projektmappen-Explorer auf die Datei „Module1.vb“, wenn Sie Visual Basic verwenden, oder auf die Datei „Program.cs“, wenn Sie Visual C# verwenden.In Solution Explorer, double-click the Module1.vb file if you are using Visual Basic or the Program.cs file if you are using Visual C#.

  2. Fügen Sie den folgenden Code zur Main-Prozedur hinzu, um eine Instanz der Klasse ReadOnlyFile für die Datei „TextFile1.txt“ zu erstellen.Add the following code to the Main procedure to create an instance of the ReadOnlyFile class for the TextFile1.txt file. Der Code verwendet spätes Binden, um dynamische Member aufzurufen und die Textzeilen abzurufen, die die Zeichenfolge „Customer“ (Kunde) enthalten.The code uses late binding to call dynamic members and retrieve lines of text that contain the string "Customer".

    dynamic rFile = new ReadOnlyFile(@"..\..\TextFile1.txt");
    foreach (string line in rFile.Customer)
    {
        Console.WriteLine(line);
    }
    Console.WriteLine("----------------------------");
    foreach (string line in rFile.Customer(StringSearchOption.Contains, true))
    {
        Console.WriteLine(line);
    }
    
    Dim rFile As Object = New ReadOnlyFile("..\..\TextFile1.txt")
    For Each line In rFile.Customer
        Console.WriteLine(line)
    Next
    Console.WriteLine("----------------------------")
    For Each line In rFile.Customer(StringSearchOption.Contains, True)
        Console.WriteLine(line)
    Next
    
  3. Speichern Sie die Datei und drücken Sie STRG+F5, um die Anwendung zu erstellen und auszuführen.Save the file and press CTRL+F5 to build and run the application.

Aufrufen einer Bibliothek in einer dynamischen SpracheCalling a Dynamic Language Library

Das nächste Projekt, das Sie in dieser exemplarischen Vorgehensweise erstellen, greift auf eine Bibliothek zu, die in der dynamischen Sprache IronPython geschrieben ist.The next project that you create in this walkthrough accesses a library that is written in the dynamic language IronPython.

So erstellen Sie eine benutzerdefinierte dynamische KlasseTo create a custom dynamic class

  1. Zeigen Sie in Visual Studio im Menü Datei auf Neu, und klicken Sie auf Projekt.In Visual Studio, on the File menu, point to New and then click Project.

  2. Überprüfen Sie, ob im Dialogfeld Neues Projekt im Bereich Projekttypen der Eintrag Windows ausgewählt ist.In the New Project dialog box, in the Project Types pane, make sure that Windows is selected. Wählen Sie im Bereich Vorlagen die Option Konsolenanwendung aus.Select Console Application in the Templates pane. Geben Sie im Feld Name die Bezeichnung DynamicIronPythonSample ein, und klicken Sie dann auf OK.In the Name box, type DynamicIronPythonSample, and then click OK. Das neue Projekt wird erstellt.The new project is created.

  3. Klicken Sie mit der rechten Maustaste auf das Projekt „DynamicIronPythonSample“ und klicken Sie dann auf Eigenschaften, wenn Sie Visual Basic verwenden.If you are using Visual Basic, right-click the DynamicIronPythonSample project and then click Properties. Klicken Sie auf die Registerkarte Verweise. Klicken Sie auf die Schaltfläche Hinzufügen.Click the References tab. Click the Add button. Klicken Sie wenn Sie Visual C# verwenden im Projektmappen-Explorer mit der rechten Maustaste auf den Ordner Verweise und klicken Sie dann auf Verweis hinzufügen.If you are using Visual C#, in Solution Explorer, right-click the References folder and then click Add Reference.

  4. Navigieren Sie auf der Registerkarte Durchsuchen zum Ordner, in dem die IronPython-Bibliotheken installiert sind.On the Browse tab, browse to the folder where the IronPython libraries are installed. Z.B. C:\Programme\IronPython 2.6 für .NET 4.0.For example, C:\Program Files\IronPython 2.6 for .NET 4.0. Wählen Sie die Bibliotheken IronPython.dll, IronPython.Modules.dll, Microsoft.Scripting.dll und Microsoft.Dynamic.dll.Select the IronPython.dll, IronPython.Modules.dll, Microsoft.Scripting.dll, and Microsoft.Dynamic.dll libraries. Klicken Sie auf OK.Click OK.

  5. Wenn Sie Visual Basic verwenden, bearbeiten Sie die Datei „Module1.vb“.If you are using Visual Basic, edit the Module1.vb file. Wenn Sie Visual C# verwenden, bearbeiten Sie die Datei „Program.cs“.If you are using Visual C#, edit the Program.cs file.

  6. Fügen Sie am Anfang der Datei den folgenden Code zum Importieren der Microsoft.Scripting.Hosting- und IronPython.Hosting-Namespaces aus den IronPython-Bibliotheken ein.At the top of the file, add the following code to import the Microsoft.Scripting.Hosting and IronPython.Hosting namespaces from the IronPython libraries.

    using Microsoft.Scripting.Hosting;
    using IronPython.Hosting;
    
    Imports Microsoft.Scripting.Hosting
    Imports IronPython.Hosting
    
  7. Fügen Sie in der Main-Methode den folgenden Code zum Erstellen eines neuen Microsoft.Scripting.Hosting.ScriptRuntime-Objekts zum Hosten der IronPython-Bibliotheken hinzu.In the Main method, add the following code to create a new Microsoft.Scripting.Hosting.ScriptRuntime object to host the IronPython libraries. Das ScriptRuntime-Objekt lädt das IronPython-Bibliotheksmodul „random.py“.The ScriptRuntime object loads the IronPython library module random.py.

    // Set the current directory to the IronPython libraries.
    System.IO.Directory.SetCurrentDirectory(
       Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles) + 
       @"\IronPython 2.6 for .NET 4.0\Lib");
    
    // Create an instance of the random.py IronPython library.
    Console.WriteLine("Loading random.py");
    ScriptRuntime py = Python.CreateRuntime();
    dynamic random = py.UseFile("random.py");
    Console.WriteLine("random.py loaded.");
    
    ' Set the current directory to the IronPython libraries.
    My.Computer.FileSystem.CurrentDirectory = 
       My.Computer.FileSystem.SpecialDirectories.ProgramFiles &
       "\IronPython 2.6 for .NET 4.0\Lib"
    
    ' Create an instance of the random.py IronPython library.
    Console.WriteLine("Loading random.py")
    Dim py = Python.CreateRuntime()
    Dim random As Object = py.UseFile("random.py")
    Console.WriteLine("random.py loaded.")
    
  8. Fügen Sie nach dem Code zum Laden des Moduls „random.py“ den folgenden Code zum Erstellen eines Arrays von ganzen Zahlen hinzu.After the code to load the random.py module, add the following code to create an array of integers. Das Array wird an die shuffle-Methode des Moduls „random.py“ übergeben, das die Werte im Array per Zufall sortiert.The array is passed to the shuffle method of the random.py module, which randomly sorts the values in the array.

    // Initialize an enumerable set of integers.
    int[] items = Enumerable.Range(1, 7).ToArray();
    
    // Randomly shuffle the array of integers by using IronPython.
    for (int i = 0; i < 5; i++)
    {
        random.shuffle(items);
        foreach (int item in items)
        {
            Console.WriteLine(item);
        }
        Console.WriteLine("-------------------");
    }
    
    ' Initialize an enumerable set of integers.
    Dim items = Enumerable.Range(1, 7).ToArray()
    
    ' Randomly shuffle the array of integers by using IronPython.
    For i = 0 To 4
        random.shuffle(items)
        For Each item In items
            Console.WriteLine(item)
        Next
        Console.WriteLine("-------------------")
    Next
    
  9. Speichern Sie die Datei und drücken Sie STRG+F5, um die Anwendung zu erstellen und auszuführen.Save the file and press CTRL+F5 to build and run the application.

Siehe auchSee Also

System.Dynamic
System.Dynamic.DynamicObject
Verwenden von dynamischen TypenUsing Type dynamic
Frühes und spätes BindenEarly and Late Binding
dynamicdynamic
Implementing Dynamic Interfaces (downloadable PDF from Microsoft TechNet) (Implementieren von dynamischen Schnittstellen (PDF von Microsoft TechNet zum Download))Implementing Dynamic Interfaces (downloadable PDF from Microsoft TechNet)