Tutorial: Crear y usar objetos dinámicos (C# y Visual Basic)Walkthrough: Creating and Using Dynamic Objects (C# and Visual Basic)

Los objetos dinámicos exponen miembros como propiedades y métodos en tiempo de ejecución, en lugar de en tiempo de compilación.Dynamic objects expose members such as properties and methods at run time, instead of at compile time. Esto le permite crear objetos para trabajar con estructuras que no coinciden con un formato o tipo estático.This enables you to create objects to work with structures that do not match a static type or format. Por ejemplo, puede usar un objeto dinámico para hacer referencia a Document Object Model (DOM) HTML, que puede contener cualquier combinación de atributos y elementos de marcado HTML válidos.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. Dado que cada documento HTML es único, los miembros de un documento HTML específico se determinan en tiempo de ejecución.Because each HTML document is unique, the members for a particular HTML document are determined at run time. Un método común para hacer referencia a un atributo de un elemento HTML consiste en pasar el nombre del atributo al método GetProperty del elemento.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. Para hacer referencia al atributo id del elemento HTML <div id="Div1">, primero debe obtener una referencia al elemento <div> y, después, usar 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"). Si usa un objeto dinámico, puede hacer referencia al atributo id como divElement.id.If you use a dynamic object, you can reference the id attribute as divElement.id.

Los objetos dinámicos también proporcionan un acceso cómodo a lenguajes dinámicos como IronPython e IronRuby.Dynamic objects also provide convenient access to dynamic languages such as IronPython and IronRuby. Puede usar un objeto dinámico para hacer referencia a un script dinámico que se interpreta en tiempo de ejecución.You can use a dynamic object to refer to a dynamic script that is interpreted at run time.

Para hacer referencia a un objeto dinámico, use un enlace en tiempo de ejecución.You reference a dynamic object by using late binding. En C#, el tipo de un objeto enlazado en tiempo de ejecución se especifica como dynamic.In C#, you specify the type of a late-bound object as dynamic. En Visual Basic, el tipo de un objeto enlazado en tiempo de ejecución se especifica como Object.In Visual Basic, you specify the type of a late-bound object as Object. Para obtener más información, vea dynamic y Enlace en tiempo de compilación y en tiempo de ejecución.For more information, see dynamic and Early and Late Binding.

Puede crear objetos dinámicos personalizados con las clases del espacio de nombres System.Dynamic.You can create custom dynamic objects by using the classes in the System.Dynamic namespace. Por ejemplo, puede crear un objeto ExpandoObject y especificar los miembros de ese objeto en tiempo de ejecución.For example, you can create an ExpandoObject and specify the members of that object at run time. También puede crear su propio tipo que hereda la clase DynamicObject.You can also create your own type that inherits the DynamicObject class. Después, puede invalidar los miembros de la clase DynamicObject para proporcionar funciones dinámicas en tiempo de ejecución.You can then override the members of the DynamicObject class to provide run-time dynamic functionality.

En este tutorial realizará las tareas siguientes:In this walkthrough you will perform the following tasks:

  • Crear un objeto personalizado que expone dinámicamente el contenido de un archivo de texto como propiedades de un objeto.Create a custom object that dynamically exposes the contents of a text file as properties of an object.

  • Crear un proyecto que usa una biblioteca IronPython.Create a project that uses an IronPython library.

Requisitos previosPrerequisites

Necesita IronPython para .NET para poder seguir este tutorial.You need IronPython for .NET to complete this walkthrough. Vaya a su página de descarga para obtener la versión más reciente.Go to their Download page to obtain the latest version.

Nota

Es posible que tu equipo muestre nombres o ubicaciones diferentes para algunos de los elementos de la interfaz de usuario de Visual Studio en las siguientes instrucciones.Your computer might show different names or locations for some of the Visual Studio user interface elements in the following instructions. La edición de Visual Studio que se tenga y la configuración que se utilice determinan estos elementos.The Visual Studio edition that you have and the settings that you use determine these elements. Para obtener más información, vea Personalizar el IDE.For more information, see Personalizing the IDE.

Crear un objeto dinámico personalizadoCreating a Custom Dynamic Object

El primer proyecto que se crea en este tutorial define un objeto dinámico personalizado que busca en el contenido de un archivo de texto.The first project that you create in this walkthrough defines a custom dynamic object that searches the contents of a text file. El texto que se va a buscar se especifica mediante el nombre de una propiedad dinámica.Text to search for is specified by the name of a dynamic property. Por ejemplo, si el código de llamada especifica dynamicFile.Sample, la clase dinámica devuelve una lista genérica de cadenas que contiene todas las líneas del archivo que comienzan con "Sample".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". La búsqueda no distingue entre mayúsculas y minúsculas.The search is case-insensitive. La clase dinámica también admite dos argumentos opcionales.The dynamic class also supports two optional arguments. El primer argumento es un valor de enumeración de opción de búsqueda que especifica que la clase dinámica debe buscar coincidencias al principio de la línea, al final de la línea o en cualquier parte de la línea.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. El segundo argumento especifica que la clase dinámica debe recortar los espacios iniciales y finales de cada línea antes de buscar.The second argument specifies that the dynamic class should trim leading and trailing spaces from each line before searching. Por ejemplo, si el código de llamada especifica dynamicFile.Sample(StringSearchOption.Contains), la clase dinámica busca "Sample" en cualquier parte de una línea.For example, if calling code specifies dynamicFile.Sample(StringSearchOption.Contains), the dynamic class searches for "Sample" anywhere in a line. Si el código de llamada especifica dynamicFile.Sample(StringSearchOption.StartsWith, false), la clase dinámica busca "Sample" al principio de cada línea y no quita los espacios iniciales y finales.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. El comportamiento predeterminado de la clase dinámica es buscar una coincidencia al principio de cada línea y quitar los espacios iniciales y finales.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.

Para crear una clase dinámica personalizadaTo create a custom dynamic class

  1. Inicie Visual Studio.Start Visual Studio.

  2. En el menú Archivo , elija Nuevo y haga clic en Proyecto.On the File menu, point to New and then click Project.

  3. En el panel Tipos de proyecto del cuadro de diálogo Nuevo proyecto, asegúrese de que esté seleccionado Windows.In the New Project dialog box, in the Project Types pane, make sure that Windows is selected. Seleccione Aplicación de consola en el panel Plantillas.Select Console Application in the Templates pane. En el cuadro Nombre, escriba DynamicSample y haga clic en Aceptar.In the Name box, type DynamicSample, and then click OK. Se crea el proyecto.The new project is created.

  4. Haga clic con el botón derecho en el proyecto DynamicSample, seleccione Agregar y, después, haga clic en Clase.Right-click the DynamicSample project and point to Add, and then click Class. En el cuadro Nombre, escriba ReadOnlyFile y haga clic en Aceptar.In the Name box, type ReadOnlyFile, and then click OK. Se agrega un nuevo archivo que contiene la clase ReadOnlyFile.A new file is added that contains the ReadOnlyFile class.

  5. En la parte superior del archivo ReadOnlyFile.cs o ReadOnlyFile.vb, agregue el código siguiente para importar los espacios de nombres System.IO y System.Dynamic.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. El objeto dinámico personalizado usa una enumeración para determinar los criterios de búsqueda.The custom dynamic object uses an enum to determine the search criteria. Antes de la instrucción de clase, agregue la siguiente definición de enumeración.Before the class statement, add the following enum definition.

    public enum StringSearchOption
    {
        StartsWith,
        Contains,
        EndsWith
    }
    
    Public Enum StringSearchOption
        StartsWith
        Contains
        EndsWith
    End Enum
    
  7. Actualice la instrucción de clase para heredar la clase DynamicObject, como se muestra en el ejemplo de código siguiente.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. Agregue el código siguiente a la clase ReadOnlyFile para definir un campo privado para la ruta de acceso y un constructor para la clase ReadOnlyFile.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. Agregue el método GetPropertyValue siguiente a la clase ReadOnlyFile.Add the following GetPropertyValue method to the ReadOnlyFile class. El método GetPropertyValue toma como entrada criterios de búsqueda y devuelve las líneas de un archivo de texto que coinciden con los criterios de búsqueda.The GetPropertyValue method takes, as input, search criteria and returns the lines from a text file that match that search criteria. Los métodos dinámicos proporcionados por la clase ReadOnlyFile llaman al método GetPropertyValue para recuperar los resultados correspondientes.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. Después del método GetPropertyValue, agregue el código siguiente para invalidar el método TryGetMember de la clase DynamicObject.After the GetPropertyValue method, add the following code to override the TryGetMember method of the DynamicObject class. Se llama al método TryGetMember cuando se solicita un miembro de una clase dinámica y no se especifican argumentos.The TryGetMember method is called when a member of a dynamic class is requested and no arguments are specified. El argumento binder contiene información sobre el miembro al que se hace referencia y el argumento result hace referencia al resultado devuelto para el miembro especificado.The binder argument contains information about the referenced member, and the result argument references the result returned for the specified member. El método TryGetMember devuelve un valor booleano que devuelve true si el miembro solicitado existe. En caso contrario, devuelve false.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. Después del método TryGetMember, agregue el código siguiente para invalidar el método TryInvokeMember de la clase DynamicObject.After the TryGetMember method, add the following code to override the TryInvokeMember method of the DynamicObject class. Se llama al método TryInvokeMember cuando se solicita un miembro de una clase dinámica con argumentos.The TryInvokeMember method is called when a member of a dynamic class is requested with arguments. El argumento binder contiene información sobre el miembro al que se hace referencia y el argumento result hace referencia al resultado devuelto para el miembro especificado.The binder argument contains information about the referenced member, and the result argument references the result returned for the specified member. El argumento args contiene una matriz de los argumentos que se pasan al miembro.The args argument contains an array of the arguments that are passed to the member. El método TryInvokeMember devuelve un valor booleano que devuelve true si el miembro solicitado existe. En caso contrario, devuelve false.The TryInvokeMember method returns a Boolean value that returns true if the requested member exists; otherwise it returns false.

    La versión personalizada del método TryInvokeMember espera que el primer argumento sea un valor del enumerador StringSearchOption que se ha definido en un paso anterior.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. El método TryInvokeMember espera que el segundo argumento sea un valor booleano.The TryInvokeMember method expects the second argument to be a Boolean value. Si uno o ambos argumentos son valores válidos, se pasan al método GetPropertyValue para recuperar los resultados.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. Guarde y cierre el archivo.Save and close the file.

Para crear un archivo de texto de ejemploTo create a sample text file

  1. Haga clic con el botón derecho en el proyecto DynamicSample, seleccione Agregar y, después, haga clic en Nuevo elemento.Right-click the DynamicSample project and point to Add, and then click New Item. En el panel Plantillas instaladas seleccione General y, luego, la plantilla Archivo de texto.In the Installed Templates pane, select General, and then select the Text File template. Deje el nombre predeterminado TextFile1.txt en el cuadro Nombre y haga clic en Agregar.Leave the default name of TextFile1.txt in the Name box, and then click Add. Se agregará un archivo de texto nuevo al proyecto.A new text file is added to the project.

  2. Copie el texto siguiente en el archivo TextFile1.txt.Copy the following text to the TextFile1.txt file.

    List of customers and suppliers  
    
    Supplier: Lucerne Publishing (https://www.lucernepublishing.com/)  
    Customer: Preston, Chris  
    Customer: Hines, Patrick  
    Customer: Cameron, Maria  
    Supplier: Graphic Design Institute (https://www.graphicdesigninstitute.com/)   
    Supplier: Fabrikam, Inc. (https://www.fabrikam.com/)   
    Customer: Seubert, Roxanne  
    Supplier: Proseware, Inc. (http://www.proseware.com/)   
    Customer: Adolphi, Stephan  
    Customer: Koch, Paul  
    
  3. Guarde y cierre el archivo.Save and close the file.

Para crear una aplicación de ejemplo que usa el objeto dinámico personalizadoTo create a sample application that uses the custom dynamic object

  1. En el Explorador de soluciones, haga doble clic en el archivo Module1.vb si usa Visual Basic o en el archivo Program.cs si usa Visual C#.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. Agregue el código siguiente al procedimiento Main para crear una instancia de la clase ReadOnlyFile para el archivo TextFile1.txt.Add the following code to the Main procedure to create an instance of the ReadOnlyFile class for the TextFile1.txt file. El código usa el enlace en tiempo de ejecución para llamar a miembros dinámicos y recuperar líneas de texto que contienen la cadena "Customer".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. Guarde el archivo y presione CTRL+F5 para compilar y ejecutar la aplicación.Save the file and press CTRL+F5 to build and run the application.

Llamar a una biblioteca de lenguaje dinámicoCalling a Dynamic Language Library

El siguiente proyecto que cree en este tutorial tendrá acceso a una biblioteca escrita en el lenguaje dinámico IronPython.The next project that you create in this walkthrough accesses a library that is written in the dynamic language IronPython.

Para crear una clase dinámica personalizadaTo create a custom dynamic class

  1. En el menú Archivo de Visual Studio, apunte a Nuevo y haga clic en Proyecto.In Visual Studio, on the File menu, point to New and then click Project.

  2. En el panel Tipos de proyecto del cuadro de diálogo Nuevo proyecto, asegúrese de que esté seleccionado Windows.In the New Project dialog box, in the Project Types pane, make sure that Windows is selected. Seleccione Aplicación de consola en el panel Plantillas.Select Console Application in the Templates pane. En el cuadro Nombre, escriba DynamicIronPythonSample y haga clic en Aceptar.In the Name box, type DynamicIronPythonSample, and then click OK. Se crea el proyecto.The new project is created.

  3. Si usa Visual Basic, haga clic con el botón derecho en el proyecto DynamicIronPythonSample y luego haga clic en Propiedades.If you are using Visual Basic, right-click the DynamicIronPythonSample project and then click Properties. Haga clic en la pestaña Referencias. Haga clic en el botón Agregar.Click the References tab. Click the Add button. Si usa Visual C#, en el Explorador de soluciones, haga clic con el botón derecho en la carpeta Referencias y, después, haga clic en Agregar referencia.If you are using Visual C#, in Solution Explorer, right-click the References folder and then click Add Reference.

  4. En la pestaña Examinar, vaya a la carpeta donde están instaladas las bibliotecas de IronPython.On the Browse tab, browse to the folder where the IronPython libraries are installed. Por ejemplo, C:\Program Files\IronPython 2.6 para .NET 4.0.For example, C:\Program Files\IronPython 2.6 for .NET 4.0. Seleccione las bibliotecas IronPython.dll, IronPython.Modules.dll, Microsoft.Scripting.dll y Microsoft.Dynamic.dll.Select the IronPython.dll, IronPython.Modules.dll, Microsoft.Scripting.dll, and Microsoft.Dynamic.dll libraries. Haga clic en Aceptar.Click OK.

  5. Si usa Visual Basic, edite el archivo Module1.vb.If you are using Visual Basic, edit the Module1.vb file. Si usa Visual C#, edite el archivo Program.cs.If you are using Visual C#, edit the Program.cs file.

  6. En la parte superior del archivo, agregue el código siguiente para importar los espacios de nombres Microsoft.Scripting.Hosting y IronPython.Hosting de las bibliotecas de IronPython.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. En el método Main, agregue el código siguiente para crear un objeto Microsoft.Scripting.Hosting.ScriptRuntime que hospede las bibliotecas de IronPython.In the Main method, add the following code to create a new Microsoft.Scripting.Hosting.ScriptRuntime object to host the IronPython libraries. El objeto ScriptRuntime carga el módulo de biblioteca de IronPython 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. Una vez que el código haya cargado el módulo random.py, agregue el código siguiente para crear una matriz de enteros.After the code to load the random.py module, add the following code to create an array of integers. La matriz se pasa al método shuffle del módulo random.py, que ordena aleatoriamente los valores de la matriz.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. Guarde el archivo y presione CTRL+F5 para compilar y ejecutar la aplicación.Save the file and press CTRL+F5 to build and run the application.

Vea tambiénSee also