Cet article a fait l'objet d'une traduction automatique.

Interopérabilité .NET

Mise en route de IronRuby et RSpec, partie 1

Ben Hall

Cet article est basé sur une version préliminaire de IronRuby.Toutes les informations sont sujets à modification.

Téléchargement de code disponible de la bibliothèque de code MSDN
Parcourir le code en ligne

Contenu

Définition de configuration et des exemples dans code
Rubis et colvert entrée
Ruby et MetaProgramming
Rubis et le .NET Framework
Rubis et le CLR
IronRuby intérieur
Test d'une application en c# avec IronRuby
Déplacement en suivant

« Ce n'est pas ce que nous avons demandé pour! » Je suis sûr que la plupart des développeurs ont entendu ce cry à partir d'un client peu après la livraison de la dernière version.Le client peut être yelling au développeur médiocre pour diverses raisons, peut-être les exigences ont été correctement comprises ou partie du système simplement n'a pas fonctionner.

Clients étant souvent confuses à leurs propres exigences, ils sont opter pour la sécurité du document technique 100 pages qui tente de définir tout ce que le système devrez peut-être faire.En outre, les développeur struggles avec du code hérité non documentée, tentez de comprendre comment l'application est destinée à utiliser lors de la tentative implémenter les nouvelles exigences sans casser rien.

Modifiez les heures.Nouvelles approches au développement de logiciels sont destinées à résoudre les ces problèmes, qui vous répondre aux besoins client à la première tentative sans entraîner des échecs dans le processus.Ces approches sont tire parti de langages tels que Ruby, permet de créer facilement lisible et plus facile à gérer le code avec beaucoup plus courtes itérations de développement.

Dans cet article, J'AI va vous présenter Ruby et IronRuby et illustrent certains principes fondamentaux de Ruby interopérabilité avec du code basées sur .NET Framework de Microsoft.J'AI également explique comment infrastructures comme RSpec peuvent être utilisées pour générer des exemples de comment les objets sont destinés à se comporter, fournissant documentation et vérifier que le système est bâti correctement.L'étape pour un article futur dans lequel je s'expliquer acceptation test dans détail et illustrent la création des tests d'acceptation avec IronRuby va devenir.

Définition de configuration et des exemples dans code

Pour écrire des exemples et définir les exigences, vous devez une infrastructure.Il existe plusieurs approches différentes pour écrire automatisée des tests d'acceptation ou exécutables spécifications.Certaines personnes utilisent infrastructures de test xUnit standard avec succès, tandis que d'autres personnes utilisent ajuster et adéquation infrastructures.J'ai trouvé que l'approche meilleure consiste à utiliser Behavior-Driven développement (BDD).Dan Nord ont trouvé comment unEnvironnement BDD appelé JBehavecomme un moyen de définir des scénarios qui décrivent le comportement de l'application d'une manière qui peut être communiquée à l'équipe entière, indépendamment de capacité technique.

JBehave était le résultat de problèmes Nord confronté avec Test-Driven Development (TDD) et a été implémenté pour la langue de Java.Plus tard, Nord créé RBehave qui a depuis été intégré dans RSpec, une infrastructure populaire pour Ruby.RSpec adapte deux approches différentes pour BDD : approche du Nord Dan, basée sur articles et des scénarios pour décrire le comportement de l'application, etApproche de Dave Astels, qui se concentre plus sur la création d'exemples au niveau de l'objet.

EN c# possède certaines infrastructures BDD, tels que NSpec et NBehave.Le problème principal à écrire des tests dans C# est que l'intention du test de cette propriété a la valeur true est souvent masquée en raison fait que vous disposez éléments structurels supplémentaires et des métadonnées telles qu'accolades, publiques et privées.Globalement, je ne pense que ce qui se trouve sur offre via C# et NSpec/NBehave peut correspondre ce qui est disponible via IronRuby et RSpec.Auparavant, cela aurait été un problème majeur pour les développeurs C#, tel que vous ne pourriez pas avoir utilisé la RSpec en fonction de Ruby pour tester des applications Visual c#.Avec IronRuby, ce n'est plus un problème.

Encore plus tôt en développement, IronRuby est tire parti de la dynamique Language Runtime (DLR) à une implémentation de la langue Ruby en haut du CLR.Avec IronRuby, vous pouvez utiliser applications Ruby existantes et infrastructures avec les langages .NET Framework et compatible .NET.Le résultat est que vous pouvez utiliser la langue Ruby et la RSpec pour tester des applications C# !

Comme une langue, Ruby est concise, qui vous permet écrire moins de code et express de manière beaucoup plus naturelle, facilite votre code gérer.Par exemple, pour lire toutes les lignes de texte à partir d'un fichier et écrire les à la console, vous devez écrire ceci :

File.readlines('AboutMicrosoft.txt').map {|line| puts line}

Le code ouvre le fichier AboutMicrosoft.txt et lit toutes les lignes, passant chaque ligne dans le bloc, avec la ligne en tant que paramètre écrit à la console.Dans Ruby, un bloc est la collection d'instructions entre les accolades et est similaire à invoquant une méthode en C#, qui utilise l'instruction rendement pour renvoyer le contrôle à la méthode d'appel.

Son approche de langage naturel est un des raisons pour lesquelles Ruby est idéal à utiliser lors de tests.Les tests ou scénarios sont dans ce cas, beaucoup plus lisible.

Rubis et colvert entrée

Une des raisons pourquoi Ruby et dynamique est faciles à lire est due à comment ils gèrent taper.Au lieu de développeur définition d'un type, lorsque le code Ruby est interrompu, le type de la variable est déduit.La langue est toujours fortement typée, mais il détermine dynamiquement la variable type.

Avec C#, interfaces permettent découplage des objets lors de toujours définir un contrat de l'implémentation.Avec Ruby, il est inutile des contrats et des interfaces.En revanche, si l'objet a une implémentation de la méthode que vous appelez, il est agit.Si ce n'est pas le cas, une erreur est renvoyée.Par conséquent, le contrat pour l'objet est défini par son implémentation, pas la relation à d'autres parties du code.

Pour illustrer cela, J'AI créé une méthode qui accepte une valeur, le type qui va être déduit au moment de l'exécution.Il est ensuite sortie Hello plus la valeur :

   def SayHello(val)
     puts "Hello #{val}"
   end

En raison de la manière types sont gérés, vous pouvez réutiliser la même méthode pour les chaînes et les entiers sans modifier aucun de code :

   SayHello("Test") => "Hello Test"
   SayHello(5) => "Hello 5"

J'AI peut avoir également avoir appelé la méthode sans crochets, car ces sont facultatifs dans Ruby et peuvent rendre la syntaxe beaucoup plus lisible :

   SayHello "Test" => "Hello Test"

Cela peut être obtenue en LANGAGE c# à l'aide objet, mais Voyons comment cela fonctionne avec les objets plus complexes. J'AI défini une nouvelle méthode pour copier le résultat d'un appel à GetName. Tant que la valeur de paramètre n implémente une méthode appelée GetName, le code fonctionnera :

def outputName(n)
  puts n.GetName()
end 

Voici deux classes non liées :

class Person
  attr_accessor :name
  def GetName()
    @name
  end
end
class Product
  def GetName()
    "The product with no name"
  end
end

Personne possède un accès autorisant la variable Nom pour définir, alors que le produit renvoie une valeur codée en dur. Dans Ruby, il n'est pas nécessaire d'écrire l'instruction de retour, que le dernier résultat de la dernière ligne de code d'une méthode est retourné par défaut.

Si vous appelez la outputName méthode, la méthode GetName est appelée, illustrant comment en tapant Ruby peut améliorer réutilisabilité code étant donné que nous n'est pas fixe un seul type :

outputName(Product.new) => "The product with no name"
$x = Person.new
$x.name = "Ben Hall"
outputName($x) => "Ben Hall"

Si vous appelez la méthode utilise un argument qui n'implémente GetName, un NoMethodError est générée :

outputName("MyName") => :1:in 'outputName': \
  undefined method 'GetName' \
  for MyName:String (NoMethodError)

Alors que ce concept concerne certaines personnes, il peut s'avérer utile, mais il permet de testability améliorée et conception de l'application, notamment lors des tests applications de C#, j'aborderai dans la section suivante.

Ruby et MetaProgramming

Met l'accent comme pour les autres langages dynamiques, Ruby sur le concept de meta-programming. Cela permet d'étendre toute classe ou objet au moment de l'exécution, ce qui vous permet de définir méthodes et comportement au moment de l'exécution, ce qui vous donne la possibilité de développer une application self-modifying. Cela est très utile dans les langages dynamiques, en particulier dans de test, car elle vous permet de personnaliser le comportement d'objets et méthodes à vos propres exigences.

De manière similaire, vous pouvez étendre les classes Ruby intégrés pour fournir votre propre point de vue fonctionnel, comme les méthodes d'extension dans C# 3.0. Avec C#, il existe diverses restrictions sur les méthodes que vous pouvez créer. Par exemple, ils doivent être statiques et d'une classe distincte. Tout nuire lisibilité. Avec Ruby, vous créer simplement une méthode normale sur une classe existante. Par exemple, entier est une classe permettant de gérer des nombres entiers. Entier a une série de méthodes, mais il n'a pas une méthode pour dire si le nombre est pair.

Pour créer une telle méthode, vous simplement créez une nouvelle classe portant le même nom (entier) et définissez la nouvelle méthode. Le point d'interrogation à la fin de la méthode indique qu'une valeur de type Boolean est renvoyée avec l'objectif de rendre plus facile à lire :

class Integer
   def even?()
       self.abs % 2 == 0
   end
end
puts 2.even? => true
puts 1.even? => false

Rubis et le .NET Framework

À la place du débat ancien sur si vous souhaitez utiliser un langage statique ou dynamique, IronRuby vous permet d'utiliser la langue de droite pour le travail. Si elle est plus logique d'utiliser Visual c#, vous pouvez utiliser Visual c#. Si vous avez besoin d'une approche plus dynamique, vous pouvez facilement utiliser IronRuby, parti de son interopérabilité avec .NET et la nature dynamique de la langue Ruby. J'AI anticiper les personnes qui utilisent une combinaison de différentes langues et de technologies, telles que C# pour l'application principale et Ruby pour tester.

Le DLR constitue la base pour activer l'interopérabilité .NET. Avec cette en place, vous pouvez profiter de technologie d'interface utilisateur tels que Windows Forms, Windows Presentation Foundation (WPF) et Silverlight lors de l'écriture code d'application en Ruby.

Tirant parti de WPF de IronRuby est simple. Lorsque le code suivant est exécuté, vous pouvez avoir une fenêtre WPF totalement fonctionnelle créée à partir de IronRuby. Vous toujours devez référencer mscorlib et les deux assemblys WPF livrés avec .NET Framework 3.0, comme vous l'avez fait avec C#, à l'aide de la nécessitent des relevés :

require 'mscorlib'
require 'PresentationFramework, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35'
require 'PresentationCore, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35'

Vous pouvez désormais créer et interagir avec les objets WPF. Tout d'abord, créez l'alias pour tous les objets à utiliser. Cela rend le code nettoyage, que n'est pas nécessaire pour accéder à l'objet par son espace de noms :

Window = System::Windows::Window
Application = System::Windows::Application
Button = System::Windows::Controls::Button

Ensuite, créer une fenêtre WPF et lui donner un titre :

win = Window.new
win.title = 'IronRuby and WPF Interop'

Créer un bouton de la même manière :

mainButton = Button.new
mainButton.content = 'I'm a WPF button — press me'

Dans les deux instances j'utilise l'alias pour accéder au nom complet de l'objet. Lorsque vous cliquez sur le bouton, je souhaite afficher un MessageBox à l'utilisateur. Comme vous le feriez dans C#, vous pouvez vous abonner à l'événement et fournir un bloc qui est appelé lorsque l'événement clic est appelé :

mainButton.click do |sender, args|
  System::Windows::MessageBox.Show("Created using IronRuby!")
end

Enfin, définir le contenu de la fenêtre pour être le bouton, créer un nouvel objet application et lancer la fenêtre :

win.content = mainButton
my_app = Application.new
my_app.run win

Figure 1 à l'aide de IronRuby pour créer une application WPF

À ce stade, une fenêtre WPF entièrement interactive s'affiche avec l'événement clic correctement filaire haut comme illustré figure 1 . J'AI interagir avec le .NET Framework de la même manière que je serait interagir avec les bibliothèques Ruby. Parmi les entités de base définie les par John LAM et équipe a pour rester true à la langue Ruby. C'est une entité importante pour l'adoption par actuels développeurs Ruby, qui ne souhaitent modifier la manière dont ils créent des applications Ruby simplement parce que leur vous déplace vers IronRuby. Au lieu de cela ils peuvent accéder tout le code .NET enrichi de la même manière.

Rubis et le CLR

Voici un autre exemple. Si vous essayez d'accéder AddRange sur IEnumerable, en C# le code présenterait :

ArrayList list = new ArrayList();
list.AddRange(new [] { 1,2,3,4 });

Toutefois, Ruby, la convention acceptée est avec des mots dans les noms de méthodes pour être séparées par des traits de soulignement pour améliorer la lisibilité. Création d'une bibliothèque distincte pour suivre cette convention serait trop prend du temps et sujette aux erreurs et il serait prend pas en charge développement tiers supplémentaire.

Au lieu de cela, pour les objets CLR, IronRuby traduit les appels de méthode Ruby dans le nom de méthode équivalente pour le CLR :

   $list = ArrayList.new
   $list.add_range([1,2,3,4])

Ici, je suis accédant à la méthode AddRange approche du Ruby, qui est inférieur cas avec des mots séparés par un trait de soulignement. Si vous préférez, vous pouvez conserver avec la convention d'affectation de noms CLR comme le nom de la méthode existe toujours à partir de Ruby :

$list.AddRange([1,2,3,4])

Les deux fonctionnent de la même ; il s'agit simplement une préférence personnelle pour l'utiliser.

Comme je L'AI déjà mentionné, Ruby déduit le type d'objets au moment de l'exécution, et cela est le même lorsque le traitement d'objets Visual c#. Pensez à une série de méthodes C# que types d'objets différents retour, tandis que le même objet est en cours renvoyé, la signature de la méthode renvoie l'interface ou le type concret. Dans mon exemple, j'ai une interface qui définit une méthode HelloWorld unique :

public interface IHello {
  string HelloWorld();    
}

J'AI créé une classe Hello4Times qui hérite de Hello3Times qui hérite de l'interface, mais a implémenté des trois méthodes Hello­World supplémentaires. Dans la classe que je définir une nouvelle méthode appelée HelloMethodOn4Times qui appelle l'implémentation de base :

public class Hello4Times : Hello3Times {
  public string HelloMethodOn4Times () {
    return base.HelloWorld();
  }
}

J'AI ensuite défini une classe statique et les méthodes qui va renvoyer une nouvelle instance de la classe Hello4Times mais remettre dans le code d'appel comme une interface. Cela signifie que le code appelant doit connaître uniquement HelloWorld, pas une des méthodes supplémentaires définies :

public static class HelloWorld {
  public static IHello ReturnHello4TimesAsInterface() {
    return new Hello4Times();
  }

Dans mon code Ruby, j'ai deux appels de méthode. Le premier appel est de la méthode définie par l'interface qui souhaitez vous envisagez de travailler sans un problème. Toutefois, le second appel est à la méthode de la classe concrète. IronRuby a déterminé le type de l'objet retourné et pouvez distribuer les appels de méthode :

puts InteropSample::HelloWorld.ReturnHello4TimesAsInterface.HelloWorld
puts interopSample::HelloWorld.ReturnHello4TimesAsInterface.HelloMethodOn4Times

Tout ceci se produit sans que vous jamais avoir à soucier de l'objet pour le type approprié pour appeler la méthode de conversion.

Suivant ce thème, vous pouvez étendre les objets .NET de la même manière possible avec les objets Ruby. Lors de l'affichage un MessageBox, je ne souhaite conserver définissant les icônes et boutons à utiliser. Au lieu de cela, je voudrais juste fournir un message.

Vous ne peut-être que la fonctionnalité intégrée et souhaitez étendre la classe MessageBox réelle pour l'interaction transparente. Grâce à Ruby, il est simple. Vous définir une nouvelle classe qui est identique à la MessageBox intégré dans WPF. Vous puis créer une nouvelle méthode de la classe qui simplement appelle la méthode afficher diverses valeurs par défaut :

class System::Windows::MessageBox
  def self.ShowMessage(msg)
    System::Windows::MessageBox.Show(msg, msg, \
      System::Windows::MessageBoxButton.OK, \
      System::Windows::MessageBoxImage.Stop)
  end
end

Après avoir exécuté ce bloc de code

System::Windows::MessageBox.ShowMessage( \
  "I'm going to show you a message") 

Vous pouvez appeler la méthode ShowMessage, le résultat en cours de la boîte de message illustrée dans la La figure 2 .

La figure 2 Affichage un MessageBox personnalisé de Ruby

IronRuby intérieur

Comment est possible d'interopérabilité de base ? La réponse est le DLR. À un niveau élevé, lorsque vous exécutez du code Ruby utilisant IronRuby, beaucoup de travail a lieu en arrière-plan. Tout d'abord, le code que vous écrivez est tokenized et analysé par le moteur IronRuby. Le code analysé est alors converti dans le DLR Abstract syntaxe Organigramme (AST). C'est un AST normalisé que toutes les implémentations de langue, tels que IronPython, doivent fournir à la DLR pour exécuter le code.

Une fois que le DLR a le AST, il convertit l'arborescence dans Intermediate Language (IL). Tout le code .NET est compilé vers le bas dans IL pour fournir une langue générique pour le CLR. Voici comment IronRuby peut interagir avec le .NET Framework, en coulisse, tout le code est exécuté comme IL instructions. Lorsque le DLR a terminé la conversion, il transmet L'IL au CLR pour l'exécution et le résultat est renvoyé à IronRuby.

Pendant ce processus, il existe des étapes pour améliorer les performances et fiabilité, telles que la mise en cache. Pour une explication plue, je recommande lecture colonne CLR Inside Out de nomenclature Chiles » Iron­Python et le runtime de langage dynamique« dans le 2007 octobre émettre de MSDN Magazine .

Dans un assembly distinct, il est une API d'hébergement qui vous permet d'incorporer IronRuby dans vos propres applications, vous permettant d'exécuter du code Ruby de C# ou les utilisateurs à exécuter leur propre code.

Pour en savoir plus sur l'implémentation IronRuby, télécharger le code source entière de RubyForge. IronRuby est un projet open source implémenté dans C# et est un excellent exemple d'une implémentation de langage dynamique. IronPython est disponible que hébergé un projet open source sur CodePlex, et il inclut un langage exemple appelé ToyScript si vous souhaitez une présentation des comment fonctionne la DLR.

Pour garantir la suite de compatibilité avec le noyau plate-forme Ruby, l'équipe IronRuby utilise RubySpecs. Ceci est un ensemble partagé d'exemples basés autour de la façon dont la langue Ruby doit être implémentée. L'objectif de RubySpecs est pour vous assurer différentes implémentations notamment du Matz Ruby interprète (MRI), JRuby, MacRuby et IronRuby possèdent le même comportement. RubySpecs utilise une version compatible de la syntaxe de RSpec appelé MSpec. Ils sont affichés en tant que les tests d'acceptation de l'implémentation IronRuby.

Test d'une application en c# avec IronRuby

Pendant de nombreuses années maintenant, la détection et la pratique consistant à TDD est passée comme un moyen de développement de logiciels, ce qui entraîne le code qualité supérieur, en termes de conception et le facilité de gestion, ainsi que des défauts moins ainsi que la manière. Avec IronRuby, je peux utiliser RSpec spécification framework les runner pour fournir des exemples de comment mes C# objets travail, une approche BDD au lieu de TDD.

Tandis que la structure de scénario, j'aborderai dans un article futur, est plus alignée avec acceptation de test au niveau application l'infrastructure de spécification est plus aligné sur les développeurs à écrire leurs propres caractéristiques sur le code, qu'ils sont simplement à implémenter et son comportement attendu. La structure de la spécification est basée autour de fournir des exemples décrivant le problème au niveau objet. Ces exemples peuvent être exécutés pour vérifier que l'implémentation du système est toujours fonctionne comme prévu dans le développeur tout en offrant la documentation sur la façon dont les objets sont censés se comportent.

Voici une différence importante par rapport aux infrastructures de test d'unités tels que NUnit et MbUnit. Les deux de ces attributs test utilisé pour indiquer une méthode est un test pour le système. RSpec prend une approche différente. RSpec indique que chaque méthode est un exemple de comment le code est conçue pour fonctionner. Lorsque la distinction est subtile, elle modifie la façon vous écrire les exemples, y compris la terminologie que vous utilisez, la façon vous organisez les méthodes et comment facilement le concept peut être compris par rapport aux TDD. Avec BDD et RSpec, avec l'intégration de fermeture de IronRuby et .NET Framework, vous pouvez commencer à utiliser IronRuby pour tester des applications C#. En termes de titre d'exemple, l'exemple RSpec classique est le jeu boule.

Tout d'abord, vous devez accéder implémentation du jeu boule dans un assembly Visual c# :

require File.dirname(__FILE__) + \
  '/InteropSamples/Bowling/Bowling/bin/Debug/bowling.dll'

Vous devez alors accéder RSpec :

require 'rubygems'
require 'spec'

Vous pouvez maintenant commencer à écrire des exemples. Voici un exemple montrant comment bowling implémentation doit fonctionner. RSpec a une langue spécifique de domaine (DSL) que vous devez suivre pour les exemples à l'exécutable. La première partie de la ligne DSL constitue le bloc describe. Ici, vous indiquez simplement l'objet que vous êtes "décrivant » avec une description facultative. Dans ce cas, je définir l'objet boule, qui va être implémentée dans Visual c# :

describe Bowling, " defines the bowling game" do

Pour améliorer la lisibilité, n'importe quel programme d'installation sera effectuée dans un avant de bloc :

  before(:each) do  
    @bowling = Bowling.new 
  End

Je suis désormais dans une position pour interagir avec l'objet, créer l'exemple et vérifier qu'il fonctionne correctement. Utiliser le il bloc, fournissant une chaîne indiquant le contexte de l'exemple et il est illustrant. JE écrire ensuite la section de code qui interagit avec le système et vérifie que l'action correcte est survenue :

  it "should score 0 for a gutter game" do
    20.times { @bowling.hit(0) }
    @bowling.score.should == 0
  end
end

L'implémentation C# simplement ressemble à ceci :

public class Bowling {
  public int Score { get; set; }
  public void Hit(int pins)
    { Score += pins; }
}

Enfin, l'exécuter pour vérifier que l'exemple boule fonctionne comme prévu avec RSpec test des objets de Visual c# :

>ir bowling_spec.rb
.
Finished in 1.0458315 seconds
1 example, 0 failures

Si je souhaitais un rapport plus détaillé, J'AI pourrait Sélectionnez le format à specdoc. Cela génère la description d'objet avec tous les exemples, indiquant si leur ont transmis ou non :

>ir bowling_spec.rb --format specdoc
Bowling defines the bowling game
- should score 0 for a gutter game
Finished in 1.43728 seconds
1 example, 0 failures

Au moment de la rédaction, l'équipe IronRuby pas régulièrement livre binaires. L'équipe a dit Qu'est en attente jusqu'à ce qu'elle soit satisfait à la mise en œuvre, la compatibilité et les performances avant de diffuser binaires officiels. Toutefois, la mesure où le code source est disponible gratuitement, vous pouvez télécharger le code et créer vous-même.

Pour télécharger le code source, vous devez avoir un client git source contrôle, tels que msysgit, installé. Le Contrôle de source IronRubyest disponible en ligne. Si vous souhaitez plus d'informations, puis je vous recommande de vous visitez le Site du projet IronRuby ou mon billet de blog » Téléchargement IronRuby depuis GitHub." Une fois vous avez téléchargé le code source, vous pouvez compiler l'assembly d'une avec Visual Studio en utilisant le fichier de solution IronRuby.sln ou, si vous avez MRI installé, vous pouvez utiliser la commande :

rake compile

Après avoir IronRuby compilé, vous devez télécharger plusieurs bibliothèques, telles que RSpec, pour obtenir la fonctionnalité supplémentaire. Rubis a un concept de RubyGems les gems sont des packages vous pouvez télécharger pour obtenir la fonctionnalité et les dépendances supplémentaires. Pour télécharger RSpec, tapez la suivante à partir d'une invite de commandes :

gem install rspec

Vous pouvez pourra maintenant accéder à la bibliothèque de RSpec dans votre code Ruby.Cependant, au moment de la rédaction, RSpec ne fonctionne pas avec IronRuby en raison d'une ou deux bogues.J'espère que cet article est publié par le temps RSpec doit manipuler IronRuby.Pour savoir l'état de la prise en charge RSpec, consultez laSite Web RSpecouListe de publipostage IronRuby.

Si le bogue n'a pas été résolu, J'AI effectuées unebinaire avec le bogue fixée, together with la bibliothèque RSpec en place. (Remarque : n'utilisez pas cette version une fois que l'équipe a résolu le problème.)

Une fois les fichiers binaires corrects en place, ir.exe est l'interpréteur de IronRuby qui peut s'exécuter votre code.Si vous lancez simplement l'application à partir de la ligne de commande, vous pouvez entrer la console interactive.Dans Ruby, code est exécuté sur un ligne par ligne de base, idéal pour la formation et le débogage, mais aussi pour exécuter des commandes court pour résoudre les problèmes quotidiens.Si vous fournissez un nom de fichier en tant que paramètre, le fichier est exécuté avec la sortie de résultats à la console.

Déplacement en suivant

Dans mon prochain article, je présente le concept de test d'acceptation et comment elle peut améliorer la communication entre client et les développeurs.J'explique comment le test d'acceptation peut être automatisée Utilisation IronRuby et RSpec pour vérifier les applications .NET et créer une spécification exécutable pour le système.

Ben Hall est un développeur C# / tester avec une passion fort pour le développement logiciel et loves écrire du code.Ben fonctionne au logiciel de porte rouge dans le Royaume-Unicomme un ingénieur de test et bénéficie d'exploration de différentes façons de tests logiciels, y compris manuel et automatique test, se concentrant sur la meilleure façon de tester des différents types d'applications.Ben est un MVP C# et gère un blog àBlog.BenHall.Me.uk.