web-dev-qa-db-fra.com

Méthodes LINQPad [extension]

Quelqu'un at-il une liste complète des méthodes d'extension LINQPad et des méthodes, telles que

.Dump()

SubmitChanges()
c#.netentity-frameworklinq-to-sqllinqpad
130
Bent Rasmussen

Outre la fameuse myQuery.Dump("Query result:"), une autre caractéristique à mentionner est la classe Util: elle contient de nombreuses méthodes très pratiques (dont certaines que j'ai mentionnées, mais il y en a beaucoup plus).

Il est également intéressant de noter que vous pouvez facilement modifier le fonctionnement de Dump().

Enfin, je vais vous montrer comment vous pouvez rendre les modifications permanentes (ie insérer, mettre à jour, supprimer requêtes LINQ) en utilisant SubmitChanges() ou SaveChanges() ainsi que la façon dont vous pouvez accéder à l'objet de connexion interne de LinqPad.

Et pour arrondir, je vais vous montrer comment vous pouvez créer un graphique 2D simple à l'intérieur de LinqPad (dessin lignes, bitmaps ou fonctions).

Voici donc une collection de fonctionnalités intégrées de LinqPad (d'après ma propre expérience avec l'outil):

.Déverser()

(paramètres disponibles dans LinqPad v5.03.08 et supérieur)

Tous les utilisateurs de LinqPad connaissent et adorent la méthode d'extension sophistiquée .Dump(), qui consomme et imprime (presque) tout.

Mais saviez-vous que deux paramètres sont disponibles? Jetez un œil à cet extrait de code:

var obj=new { a="Hello", b=5, c="World", d=new { y=5, z=10 } };
obj.Dump(description: "1st example", depth: 5, toDataGrid: false, exclude: "b,d");
obj.Dump("2nd example", exclude: "a,c");
obj.Dump("2nd example", exclude: "+b,d"); // new in V5.06.06 beta

Le 1er exemple imprime uniquement les variables a et c et masque b et d, le 2e exemple fait le contraire (notez qu'il ne spécifie que 2 des paramètres disponibles). Les variables y et z ne peuvent pas être masquées individuellement, car elles ne sont pas au niveau supérieur.

Les paramètres suivants sont disponibles ( tous sont facultatifs ):

  • description [chaîne] - fournit une description de l'objet à vider
  • depth [int?] - limite la profondeur à laquelle les objets sont inspectés récursivement
  • toDataGrid [bool] - si vrai, la sortie est formatée comme une grille de données plutôt que comme RichText
  • exclude [chaîne] - si vous fournissez une liste de variables séparées par des virgules, elles seront exclues de la sortie (dans l'exemple "a, c": b et d sont affichés, a et c sont masqués)
  • exclude [chaîne] avec le préfixe "+" - le préfixe inverse la logique du paramètre d'exclusion. Cela signifie que si vous fournissez une liste de variables séparées par des virgules, toutes sauf celles spécifiées sont masquées (dans l'exemple "+ b, d": b et d sont affichées, toutes les autres caché)
  • stocker les propriétés incluses et exclues dans une variable (nouveau depuis LinqPad V5.09.04):
    var x=Util.ToExpando(obj, "a, c", "b, d"); x.Dump();
    La première chaîne contient une liste de propriétés à inclure, la deuxième chaîne une liste à exclure
  • développer en cliquant: Si vous utilisez .OnDemand("click me").Dump(); au lieu de .Dump(), il affichera un lien sur lequel vous pouvez cliquer pour développer. Utile si vous souhaitez inspecter des valeurs, par ex. Util.OnDemand("Customer-ID: " + customerObject.ID.ToString(), ()=>customerObject, false).Dump(); pour toujours afficher l'ID par défaut mais révéler les détails de customerObject uniquement si cela vous intéresse.

Des sujets plus avancés sur Dump peuvent être trouvés ici .

Environnement

Ce n'est pas une extension LinqPad, mais plutôt une classe .NET, mais comme c'est utile, je le mentionnerai quand même. Vous pouvez obtenir de nombreuses informations utiles que vous pouvez utiliser dans vos scripts, telles que:

Environment.UserDomainName.Dump();
Environment.MachineName.Dump();
Environment.UserName.Dump();
Environment.CurrentDirectory.Dump();
Environment.SystemDirectory.Dump();

N.B. Pour obtenir Domain\UserName, J'utiliserais System.Security.Principal.WindowsIdentity.GetCurrent().Name
plutôt que Environment.UserDomainName+@"\"+Environment.UserName.

Util.WriteCsv

( nouveau: disponible depuis LinqPad version v4.45.05 (beta) )

Util.WriteCsv (Customers, @"c:\temp\customers.csv");

Cela va écrire le contenu de la table Customers dans le fichier CSV c:\temp\customers.csv. Vous pouvez également trouver un bel exemple comment utiliser Util.WriteCsv Puis afficher les données CSV dans la fenêtre de résultat de Linqpad ici .

Astuces:

  • Pour obtenir/créer un fichier CSV qui se trouve dans le même répertoire que la requête, vous pouvez utiliser:
    var csvFile=Util.CurrentQueryPath.Replace(".linq", ".csv");

  • Si le tableau est volumineux, utilisez ObjectTrackingEnabled = false; Avant d'écrire le CSV pour éviter de le mettre en cache en mémoire.

  • Si vous souhaitez générer un tableau au format XML plutôt que sous forme de fichier séparé par des virgules, vous pouvez le faire comme suit:

    var xmlFile=Util.CurrentQueryPath.Replace(".linq", ".xml");
var xml = XElement.Load(xmlFile);
var query =
  from e in xml.Elements()
  where e.Attribute("attr1").Value == "a"
  select e;
query.Dump();

    Cet exemple renvoie tous les éléments ayant l'attribut attr1 Qui contient la valeur "a" D'un fichier XML qui porte le même nom que la requête et est contenu dans le même chemin. Consultez le lien this pour plus d'exemples de code.

Util.GetPassword

var pwd = Util.GetPassword("UserXY");

Cela récupérera le mot de passe du gestionnaire de mots de passe intégré de LinqPad. Pour créer et modifier le mot de passe, ouvrez l'élément de menu "Gestionnaire de mots de passe" dans le menu "Fichier" de LinqPad. Si aucun mot de passe n'est enregistré lorsque vous exécutez le code C #, une boîte de dialogue de mot de passe s'ouvrira pour vous demander le mot de passe et vous avez le choix de le créer et de l'enregistrer à la volée en vérifiant le enregistrer le mot de passe case à cocher (dans l'exemple, le mot de passe pour "UserXY" serait enregistré, et plus tard vous pouvez trouver cette entrée dans le Gestionnaire de mots de passe ).

Les avantages sont que vous pouvez stocker le mot de passe dans les LinqScripts que vous créez en toute sécurité, séparément et chiffrés dans le profil utilisateur de Windows (il est stocké dans %localappdata%\LINQPad\Passwords Sous forme de fichier). LinqPad utilise Windows DPAPI pour protéger le mot de passe.

De plus, le mot de passe est stocké de manière centralisée, donc si vous devez le changer, vous pouvez le faire dans le menu et il s'applique immédiatement à tous les scripts que vous avez créés.

Remarques:

  • Si vous ne souhaitez pas enregistrer le mot de passe et simplement afficher une boîte de dialogue de mot de passe, vous pouvez utiliser le deuxième paramètre comme suit:
    var pwd = Util.GetPassword("UserXY", true);
    Ceci désélectionnera la case à cocher enregistrer le mot de passe dans la boîte de dialogue du mot de passe (cependant, l'utilisateur est toujours en mesure de le vérifier et de choisir d'enregistrer de toute façon).

  • Si vous avez besoin que le mot de passe soit stocké dans un SecureString, vous pouvez utiliser cette fonction d'assistance (nb: pour obtenir la méthode d'extension .ToSecureString() utilisée, veuillez suivre ce lien sur Stackoverflow - il vous permet également de le reconvertir si nécessaire):
    System.Security.SecureString GetPasswordSecure(string Name, bool noDefaultSave=true)
    {
    return Util.GetPassword(Name, noDefaultSave).ToSecureString();
    }

Util.Cmd

Cette méthode fonctionne comme un processeur de commandes. Vous pouvez appeler toutes les commandes que vous connaissez depuis la console Windows.

Exemple 1 - dir: 

Util.Cmd(@"dir C:\");

Cela produira le résultat du répertoire sans avoir besoin de .Dump. Le stockage dans une variable a l'avantage que vous pouvez utiliser d'autres requêtes Linq dessus. Par exemple:

var path=@"C:\windows\system32"; 
var dirSwitch="/s/b";
var x=Util.Cmd(String.Format(@"dir ""{0}"" {1}", path, dirSwitch), true);
var q=from d in x 
        where d.Contains(".exe") || d.Contains(".dll")              
        orderby d
    select d;
q.Dump();

Cela videra tous les fichiers avec les extensions de fichier ".exe" ou ".dll" contenues dans C:\windows\system32. Le commutateur /s Est utilisé pour récupérer tous les sous-répertoires et /b Est utilisé pour le format de sortie nu. Notez que le deuxième paramètre de la méthode Cmd est spécifié pour supprimer la sortie de la console afin d'afficher uniquement le résultat filtré à l'aide de la méthode Dump.

Vous pouvez voir que cela est plus flexible que les caractères génériques que vous avez avec dir puisque vous pouvez utiliser la flexibilité totale du moteur de requête de Linq.

Exemple 2 - éditeur de texte:

Vous pouvez ouvrir un fichier dans le Bloc-notes comme ceci:

var filePath=@"C:\HelloWorld.txt";
Util.Cmd(@"%systemroot%\system32\notepad.exe", filePath);

Util.Image

Affiche les images d'une URL. Exemple:

var url = "http://chart.apis.google.com/chart?cht=p3&chd=s:Uf9a&chs=350x140&chl=January|February|March|April";
Util.Image(url).Dump();

Util.ProgressBar, Util.Progress

L'utilisation de Util.ProgressBar Vous permet d'afficher une barre de progression. Vous pouvez utiliser la classe d'assistance suivante:

public class ProgressBar
{
    Util.ProgressBar prog;

    public ProgressBar() 
    { 
        Init("Processing"); 
    }

    private void Init(string msg)
    {
        prog = new Util.ProgressBar (msg).Dump();
        prog.Percent=0;
    }

    public void Update(int percent)
    {
        Update(percent, null);
    }   

    public void Update(int percent, string msg)
    {
        prog.Percent=percent;
        if (String.IsNullOrEmpty(msg))
        {
            if (percent>99) prog.Caption="Done.";
        }
        else
        {
            prog.Caption=msg;
        }
    }
}

Utilisez-le simplement comme le montre l'exemple suivant:

void Main()
{
    var pb1= new ProgressBar();
    Thread.Sleep(50);
    pb1.Update(50, "Doing something"); Thread.Sleep(550);
    pb1.Update(100); Thread.Sleep(50);
}

Vous pouvez également utiliser Util.Progress Pour mettre à jour la barre de progression intégrée de LinqPads, par exemple:

Util.Progress = 25; // 25 percent complete

La différence est qu'il ne s'affichera pas dans la fenêtre des résultats et vous ne pouvez pas lui attribuer de message.

Util.RawHtml

Affiche le HTML dans la fenêtre de sortie. Exemple:

Util.RawHtml (new XElement ("h1", "This is a big heading")).Dump();

Hyperlinq, Util.HorizontalRun

Vous pouvez utiliser cet exemple de fonction

public void ShowUrl(string strURL, string Title)
{
    Action showURL = delegate() { Process.Start("iexplore.exe", strURL); };
    var url = new Hyperlinq(showURL, "this link", true);
    Util.HorizontalRun (true, "Click ", url, " for details.").Dump(Title);
}

pour afficher des hyperliens dans la fenêtre de résultats - ou toute action comme l'ouverture de votre éditeur préféré. Utilisation: 

ShowUrl("http://stackoverflow.com", "Check out StackOverflow");

Notez que cette fonction fonctionne toujours, tandis que new Hyperlinq ("http://myURL", "Web site").Dump(); ne fonctionne pas pour certains types d'URL (surtout si vous devez passer le port des noms comme ": 1234" dans le cadre de l'URL).

Util.ReadLine

Lit les entrées de la console. Exemple:

int age = Util.ReadLine<int> ("Enter your age");

En tant que synonyme de Util.ReadLine<string>(), vous pouvez également utiliser Console.ReadLine().

Mais il y a plus! Vous pouvez créer un analyseur JSON simple avec l'extrait de code suivant - très utile, par exemple si vous souhaitez analyser et tester une chaîne JSON à la volée. Enregistrez l'extrait de code suivant sous JSONAnalyzer.linq à l'aide d'un éditeur de texte puis ouvrez-le dans LinqPad (c'est pour ajouter les références facilement à la volée):

<Query Kind="Program">
    <Reference>&lt;RuntimeDirectory&gt;\System.Web.Extensions.dll</Reference>
    <Namespace>System.Web.Script.Serialization</Namespace>
</Query>

void Main()
{
    var jsonData=Util.ReadLine<string>("Enter JSON string:");
    var jsonAsObject = new JavaScriptSerializer().Deserialize<object>(jsonData);
    jsonAsObject.Dump("Deserialized JSON");
}

Vous pouvez maintenant l'exécuter et coller simplement une chaîne JSON du presse-papiers dans la console - il utilisera la fonction Dump pour l'afficher en tant qu'objet - et vous obtiendrez également les messages d'erreur de l'analyseur à l'écran pour résoudre les problèmes. Très utile pour déboguer AJAX.

JSON

Util.ClearResults

Si vous devez effacer la fenêtre de résultats à l'intérieur de votre script, utilisez:

Util.ClearResults();

Utilisez-le au début de votre script ou, si vous exécutez plusieurs requêtes dans un script, vous devez attendre la saisie de l'utilisateur avant de masquer l'écran (par exemple en le précédant de Util.ReadLine).

.Dump () personnalisé - ICustomMemberProvider

Il est également intéressant de noter que vous pouvez influencer la sortie de la méthode .Dump(). Implémentez simplement l'interface ICustomMemberProvider, par ex.

public class test : ICustomMemberProvider 
{

      IEnumerable<string> ICustomMemberProvider.GetNames() {
        return new List<string>{"Hint", "constMember1", "constMember2", "myprop"};
      }

      IEnumerable<Type> ICustomMemberProvider.GetTypes() 
      {
        return new List<Type>{typeof(string), typeof(string[]), 
            typeof(string), typeof(string)};
      }

      IEnumerable<object> ICustomMemberProvider.GetValues() 
      {
        return new List<object>{
        "This class contains custom properties for .Dump()", 
        new string[]{"A", "B", "C"}, "blabla", abc};
      }

      public string abc = "Hello1"; // abc is shown as "myprop"
      public string xyz = "Hello2"; // xyz is entirely hidden
}

Si vous créez une instance de cette classe, comme

var obj1 = new test();
obj1.Dump("Test");

alors il ne sortira que Hint, constMember1, constMember2 et myprop, mais pas la propriété xyz:

Linqpad dump

Affichage d'un MessageBox ou InputBox dans LinqPad

Si vous devez afficher une boîte de message, regardez ici comment le faire.

Par exemple, vous pouvez afficher un InputBox en utilisant le code suivant

void Main()
{
    string inputValue="John Doe"; 
    inputValue=Interaction.InputBox("Enter user name", "Query", inputValue);
    if (!string.IsNullOrEmpty(inputValue)) // not cancelled and value entered
    {
        inputValue.Dump("You have entered;"); // either display it in results window
        Interaction.MsgBox(inputValue, MsgBoxStyle.OkOnly, "Result"); // or as MsgBox
    }
}

(n'oubliez pas d'appuyer sur F4 et d'ajouter Microsoft.VisualBasic.dll et ses espaces de noms pour que cela fonctionne)

Util.Run

( nouveau: disponible depuis LinqPad version v4.52.1 (beta) )

Vous permet d'exécuter un autre script LINQPad à partir de votre script ou de votre propre programme .NET ou service Windows (en référençant la version LINQPad4-AnyCPU de LINQPad.exe). Il exécute le script comme le ferait l'outil de ligne de commande lprun.exe.

Exemples: 

const string path=@"C:\myScripts\LinqPad\";
var dummy=new LINQPad.QueryResultFormat(); // needed to call Util.Run
Util.Run(path+"foo.linq", dummy);

Cet exemple exécute le script foo.linq, Qui contient l'exemple de code suivant:

void Main(string[] args)
{
    #if CMD
       "I'm been called from lprun! (command line)".Dump();
    #else
       "I'm running in the LINQPad GUI!".Dump();
       args = new[] { "testhost", "[email protected]", "[email protected]", "Test Subject" };
    #endif
    args.Dump("Args");
}

Il vous permet de distinguer si le script a été exécuté depuis l'intérieur de l'interface graphique de LinqPad ou via lprun.exe Ou avec Util.Run.

Remarque: Les variantes d'invocation suivantes peuvent être utiles:

Util.Run(path+"foo.linq", dummy).Dump(); // obviously dumps the script output!
Util.Run(path+"foo.linq", dummy).Save(path+"foo.log"); // writes output into log
Util.Run(path+"foo.linq", dummy).SaveAsync(path+"foo1.log");     // async output log

SubmitChanges () - Linq à SQL

Si vous utilisez LinqToSQL , vous voudrez peut-être rendre les modifications permanentes (pour insérer/mettre à jour/supprimer opérations) . Étant donné que le contexte de la base de données est implicitement créé par LinqPad, vous devez appeler SubmitChanges() après chaque modification, comme indiqué ci-dessous.

Exemples pour (LinqPad-) Northwind base de données:

Insérer 

var newP = new Products() { ProductID=pID, CategoryID=cID, 
            ProductName="Salmon#"+pID.ToString() };
Products.InsertOnSubmit(newP);
SubmitChanges();

Mise à jour 

var prod=(from p in Products
            where p.ProductName.Contains("Salmon")
            select p).FirstOrDefault();
prod.ProductName="Trout#"+prod.ProductID.ToString();
SubmitChanges();

Supprimer 

var itemsToDelete=Products.Where(p=> p.ProductName.Contains("Salmon") ||
    p.ProductName.Contains("Trout"));
foreach(var item in itemsToDelete) { Products.DeleteOnSubmit(item); }
SubmitChanges();

Remarque: Afin d'obtenir des ID valides pour les exemples précédents, vous pouvez utiliser:

var cID = (from c in Categories 
            where c.CategoryName.Contains("Seafood") 
            select c).FirstOrDefault().CategoryID;

var pID = Products.Count()+1;

avant de les invoquer.

SaveChanges () - Entity Framework

Si vous utilisez Entity Framework , vous pouvez également vouloir rendre les modifications permanentes (pour insérer/mettre à jour/supprimer = opérations). Étant donné que le contexte de la base de données est implicitement créé par LinqPad, vous devez appeler SaveChanges() après chaque modification, comme indiqué ci-dessous.

Les exemples sont fondamentalement les mêmes que précédemment pour LinqToSQL , mais vous devez utiliser SaveChanges() à la place, et pour insérer et supprimer les méthodes ont également changé.

Insérer 

var newP = new Products() { ProductID=pID, CategoryID=cID, 
            ProductName="Salmon#"+pID.ToString() };
Products.Add(newP);
SaveChanges();

Mise à jour 

var prod=(from p in Products
            where p.ProductName.Contains("Salmon")
            select p).FirstOrDefault();
prod.ProductName="Trout#"+prod.ProductID.ToString();
SaveChanges();

Supprimer 

var itemsToDelete=Products.Where(p=> p.ProductName.Contains("Salmon") ||
    p.ProductName.Contains("Trout"));
foreach(var item in itemsToDelete) { Products.Remove(item); }
SaveChanges();

Remarque: Afin d'obtenir des ID valides pour les exemples précédents, vous pouvez utiliser:

var cID = (from c in Categories 
            where c.CategoryName.Contains("Seafood") 
            select c).FirstOrDefault().CategoryID;

var pID = Products.Count()+1;

avant de les invoquer.

ceci - contexte de la base de données

Dans LinqPad , le contexte de la base de données est établi automatiquement à l'aide de la zone de liste déroulante à en haut et en choisissant la base de données adaptée à votre requête. Mais parfois, il est utile de le référencer explicitement, par exemple si vous copiez du code de votre projet hors de Visual Studio , et collez-le dans LinqPad.

Votre extrait de code extrait du projet Visual Studio ressemble très probablement à ceci:

var prod=(from p in dc.Products
            where p.ProductName.Contains("Salmon")
            select p).FirstOrDefault();
prod.ProductName="Trout#"+prod.ProductID.ToString();
dc.SaveChanges();

Que faire maintenant avec dc? Bien sûr, vous pouvez supprimer chaque occurrence de dc. Dans votre requête, mais c'est beaucoup plus facile. Ajoutez simplement

var dc=this; // UserQuery

en haut de votre extrait comme ceci:

void Main()
{
    var dc=this;
    var prod=(from p in dc.Products
                where p.ProductName.Contains("Salmon")
                select p).FirstOrDefault();
    prod.ProductName="Trout#"+prod.ProductID.ToString();
    dc.SaveChanges(); 
}

et le code fonctionnera instantanément!

this.Connection

Utilisation de LinqPad avec OleDb, conversion d'une table de données en objet Linq, requêtes SQL dans Linq

L'extrait de code suivant vous aide à utiliser LinqPad avec OleDb. Ajoutez System.Data.OleDb De l'assembly System.Data Aux propriétés de la requête, puis collez le code suivant dans Main():

var connStr="Provider=SQLOLEDB.1;"+this.Connection.ConnectionString; 

OleDbConnection conn = new OleDbConnection(connStr);
DataSet myDS = new DataSet();
conn.Open();

string sql = @"SELECT * from Customers";
OleDbDataAdapter adpt = new OleDbDataAdapter();
adpt.SelectCommand = new OleDbCommand(sql, conn); 
adpt.Fill(myDS);

myDS.Dump();

Ajoutez maintenant une connexion SqlServer à LinqPad et ajoutez la base de données Northwind afin d'exécuter cet exemple.

N.B.: Si vous souhaitez simplement obtenir la base de données et le serveur de la connexion actuellement sélectionnée, vous pouvez utiliser cet extrait de code:

void Main()
{
    var dc=this;
    var tgtSrv=dc.Connection.DataSource;
    var tgtDb=dc.Connection.ConnectionString.Split(';').Select(s=>s.Trim())
        .Where(x=>x.StartsWith("initial catalog", StringComparison.InvariantCultureIgnoreCase))
        .ToArray()[0].Split('=')[1];
    tgtSrv.Dump();
    tgtDb.Dump();
}

Vous pouvez même convertir myDS en Linq, les réponses à la question suivante montrent comment le faire: Bons exemples de en utilisant le mot clé dynamique .NET 4 avec Linq

Un autre exemple: supposons que votre DBA vous donne une requête SQL et que vous souhaitiez analyser les résultats dans LinqPad - bien sûr dans Linq, pas dans SQL. Ensuite, vous pouvez effectuer les opérations suivantes:

void Main()
{
    var dc=this;

    // do the SQL query
    var cmd =
        "SELECT Orders.OrderID, Orders.CustomerID, Customers.CompanyName,"
        +"       Customers.Address, Customers.City"
        +" FROM Customers INNER JOIN Orders ON Customers.CustomerID = Orders.CustomerID";
    var results = dc.ExecuteQuery<OrderResult>(cmd);

    // just get the cities back, ordered ascending
    results.Select(x=>x.City).Distinct().OrderBy(x=>x).Dump();
}

class OrderResult
{   // put here all the fields you're returning from the SELECT
    public dynamic OrderID=null; 
    public dynamic CustomerID=null;
    public dynamic CompanyName=null;
    public dynamic Address=null;
    public dynamic City=null;
}

Dans cet exemple, la requête SELECT du DBA est simplement "lancée" dans le texte de la commande et les résultats sont filtrés et classés par ville.
Bien sûr, ceci est un exemple simplifié, votre DBA vous prendrait probablement en charge avec un script plus complexe, mais vous avez l'idée: ajoutez simplement une classe de résultats de support qui contient tous les champs de la clause SELECT et alors vous pouvez l'utiliser directement.
Vous pouvez même prendre le résultat d'une procédure stockée de cette façon et l'utiliser dans Linq. Comme vous pouvez le voir, dans cet exemple, je ne me soucie pas du type de données et j'utilise dynamic pour l'exprimer.
Il s'agit donc vraiment d'une programmation rapide pour pouvoir analyser rapidement les données. Vous ne devriez pas le faire dans votre application réelle pour diverses raisons (injection SQL, car vous pouvez utiliser EF depuis le début, etc.).

PanelManager

Dessiner un graphique dans LinqPad, partie 1

Pour utiliser les exemples ci-dessous, appuyez sur F4 et ajoutez System.Windows.dll, System.Windows.Forms.dll, WindowsFormsIntegration.dll, PresentationCore.dll et PresentationFramework.dll à votre programme LinqPad et ajoutez également l'espace de noms System.Windows.Shapes.

Le 1er exemple trace simplement une ligne:

var myLine = new Line();
myLine.Stroke = System.Windows.Media.Brushes.LightSteelBlue;
myLine.X1 = 1; myLine.X2 = 50;
myLine.Y1 = 1; myLine.Y2 = 50;
myLine.StrokeThickness = 2;
PanelManager.DisplayWpfElement(myLine, "Graphic");

Le 2ème exemple montre comment vous pouvez afficher un graphique dans LinqPad en utilisant le PanelManager. Normalement, LinqPad ne prend en charge que les objets Wpf. Cet exemple utilise System.Windows.Forms.Integration.WindowsFormsHost Pour rendre un Windows.Forms.PictureBox Disponible (il a été inspiré par this ):

// needs (F4): System.Windows.dll, System.Windows.Forms.dll, 
// WindowsFormsIntegration.dll, PresentationCore.dll, PresentationFramework.dll 
void Main()
{       
    var wfHost1 = new System.Windows.Forms.Integration.WindowsFormsHost();
    wfHost1.Height=175; wfHost1.Width=175; wfHost1.Name="Picturebox1";
    wfHost1.HorizontalAlignment=System.Windows.HorizontalAlignment.Left;
    wfHost1.VerticalAlignment=System.Windows.VerticalAlignment.Top;
    System.Windows.Forms.PictureBox pBox1 = new System.Windows.Forms.PictureBox();
    wfHost1.Child = pBox1;
    pBox1.Paint += new System.Windows.Forms.PaintEventHandler(picturebox1_Paint);
    PanelManager.StackWpfElement(wfHost1, "Picture");
} 

public string pathImg
{
    get { return System.IO.Path.Combine(@"C:\Users\Public\Pictures\Sample Pictures\", 
            "Tulips.jpg"); } 
}

// Define other methods and classes here
public void picturebox1_Paint(object sender, System.Windows.Forms.PaintEventArgs e)
{
    // https://stackoverflow.com/a/14143574/1016343
    System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(pathImg);
    System.Drawing.Point ulPoint = new System.Drawing.Point(0, 0);
    e.Graphics.DrawImage(bmp, ulPoint.X, ulPoint.Y, 175, 175);
}

Cela créera le graphique suivant (les éléments du panneau "Graphique" et "Image" sont ajoutés par les exemples ci-dessus):

Showing_Graphic_in_LinqPad

Si vous souhaitez afficher les images de la base de données Northwind, , vous pouvez effectuer les opérations suivantes:
Modifiez le nom du fichier image en "NorthwindPics.jpg", puis ajoutez le code suivant au début du 2ème exemple Main () méthode:

var img = (from e in this.Employees select e).FirstOrDefault().Photo.ToArray();
using (FileStream fs1 = new FileStream(pathImg, FileMode.Create))
{
    const int offset=78;
    fs1.Write(img, offset, img.Length-offset);
    fs1.Close();
}

Il lira le premier enregistrement de la table Employés et affichera l'image.

Consultez les liens suivants pour en savoir plus:
Formes et dessin de base dans WPF
visualiseurs personnalisés LinqPad

Remarque: Vous pouvez également obtenir la même chose sans PanelManager, comme l'exemple suivant, que j'ai vu ici montre:

// using System.Drawing;
using (var image=new Bitmap(100, 100))
using (var gr = Graphics.FromImage(image))
{
    gr.FillRectangle(Brushes.Gold, 0, 0, 100, 100);
    gr.DrawEllipse(Pens.Blue, 5, 5, 90, 90);
    gr.Save();
    image.Dump();
}

Il utilise la commande .Dump() pour l'afficher. Vous pouvez invoquer image.Dump() plusieurs fois et il ajoutera l'image.

Windows Forms

Dessiner un graphique dans LinqPad, partie 2

L'exemple suivant, inspiré par this post, montre comment implémenter un traceur de fonctions simple dans Linqpad 5 en utilisant C # 7 :

void Main()
{
    fnPlotter(x1: -1, x2: 1, fn: (double x) => Math.Pow(x, 3)).Dump();
}

public static Bitmap fnPlotter(double x1=-3, double x2=3, double s=0.05, 
                                   double? ymin=null, double? ymax=null, 
                                   Func<double, double> fn = null, bool enable3D=true)
{
    ymin = ymin ?? x1; ymax = ymax ?? x2;

    dynamic fArrPair(double p_x1 = -3, double p_x2 = 3, double p_s = 0.01, 
                          Func<double, double> p_fn = null)
    {
        if (p_fn == null) p_fn = ((xf) => { return xf; }); // identity as default
        var xl = new List<double>(); var yl = new List<double>();
        for (var x = p_x1; x <= p_x2; x += p_s)
        {
            double? f = null;
            try { f = p_fn(x); }
            finally
            {
                if (f.HasValue) { xl.Add(x); yl.Add(f.Value); }
            }
        }
        return new { Xs = xl.ToArray(), Ys = yl.ToArray() };
    }

    var chrt = new Chart(); var ca = new ChartArea(); chrt.ChartAreas.Add(ca);
    ca.Area3DStyle.Enable3D = enable3D;
    ca.AxisX.Minimum = x1; ca.AxisX.Maximum = x2;   
    ca.AxisY.Minimum = ymin.Value; ca.AxisY.Maximum = ymax.Value;

    var sr = new Series(); chrt.Series.Add(sr);
    sr.ChartType = SeriesChartType.Spline; sr.Color = Color.Red;
    sr.MarkerColor = Color.Blue; sr.MarkerStyle = MarkerStyle.Circle;
    sr.MarkerSize = 2;

    var data = fArrPair(x1, x2, s, fn); sr.Points.DataBindXY(data.Xs, data.Ys); 
    var bm = new Bitmap(width: chrt.Width, height: chrt.Height);
    chrt.DrawToBitmap(bm, chrt.Bounds); return bm;
}

Il utilise la capacité de LinqPad pour afficher les formulaires Windows dans le panneau de résultats.
Example
Ajoutez références (appuyez sur F4) :
System.Drawing.dll, System.Windows.Forms.dll, System.Windows.Forms.DataVisualization.dll
et ajoutez tous les espaces de noms de ces assemblys.

Conseils supplémentaires/lectures complémentaires:

  • Vous souhaitez utiliser LinqPad dans Visual Studio ? Voici comment vous pouvez le faire .

  • Besoin d'avoir LinqPad comme "Application portable" ? Lire ici comment faire cela.

  • Le site Web de Joe pour LinqPad est toujours une excellente source. Dans LinqPad, Help -> What's New Vous donne des conseils sur les nouvelles fonctions et méthodes. Le LinqPad Forum contient également des conseils utiles.

  • Également très utile: This article sur le débogage Linq (Pad).

  • Utilisez lprun.exe pour exécuter des requêtes LINQ dans votre scripts batch. Lisez cet article pour plus de détails. Par exemple:
    echo Customers.Take(100) > script.txt
    lprun -lang=e -cxname=CompanyServer.CustomerDb script.txt
    Dans cet exemple, la requête est une simple expression LINQ. Bien sûr, vous pouvez également préparer des requêtes complexes en utilisant -lang=program Pour activer le mode programme.

  • Vous pouvez écrire vos propres méthodes d'extension et les stocker dans l'onglet Mes requêtes sur le côté gauche de LinqPad: le dernier élément de l'arborescence est nommé Mes extensions ; double-cliquez dessus pour ouvrir un fichier dans lequel vous pouvez écrire des extensions disponibles pour toutes vos requêtes. Placez-les simplement dans la classe statique publique MyExtensions et utilisez la méthode Main() pour inclure des tests pour vos extensions.

123
Matt

Le vidage est une méthode d'extension globale et SubmitChanges provient de l'objet DataContext qui est un objet System.Data.Linq.DataContext.

LP n'ajoute que Dump and Disassemble pour autant que je sache. Bien que je recommande fortement de l'ouvrir dans Reflector pour voir ce qui peut être utilisé. L'un des éléments les plus intéressants est l'espace de noms LINQPad.Util qui contient des goodies utilisés par LINQPad en interne.

2
John