Méthodes LINQPad [extension]

outre le célèbre myQuery.Dump("Query result:") , une autre caractéristique à mentionner est la classe Util : elle contient beaucoup de méthodes assez pratiques (certains d'entre eux que j'ai mentionnés, mais il ya beaucoup plus).

également intéressant est que vous pouvez facilement modifier la façon Dump() fonctionne .

enfin je vais vous montrer comment vous pouvez faire des changements permanents (i.e. insert, update, delete LINQ queries) en utilisant SubmitChanges() ou SaveChanges() ainsi que la façon dont vous pouvez accéder à L'objet de connexion interne de LinqPad.

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

donc, voici une collection de construite à LinqPad les fonctionnalités (à partir de ma propre expérience avec l'outil):

---

.Dump ()

(paramètres disponibles dans LinqPad v5.03.08 et plus)

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

mais saviez-vous qu'il y a quelques paramètres disponible? Regardez 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 seulement les variables a et c et Cache b et d , le 2ème 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 cachées individuellement, car elles ne sont pas au niveau supérieur.

les paramètres suivants sont disponibles ( Tous sont optionnels ):

• description [string] - fournit une description pour l'objet de dump
• depth [int?]- limite la profondeur à laquelle les objets sont inspectés de façon récursive
• toDataGrid [bool] - si elle est vraie, la sortie est formatée en datagrid plutôt qu'en RichText
• exclude [chaîne de caractères] - 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 cachés)
• exclude [string] avec le préfixe " + " - le préfixe inverse la logique du paramètre exclude. Cela signifie que, si vous fournissez une liste de variables séparées par des virgules, toutes les variables sauf celles spécifiées sont cachées (dans les exemples "+b, d": b et d sont affichés, tous les autres cachés)
• biens inclus et exclus 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 seconde chaîne une liste à exclure
• étendre sur le clic: si vous utilisez .OnDemand("click me").Dump(); au lieu de .Dump() , il affichera un lien que vous pouvez cliquez sur pour élargir. Utile si vous voulez inspecter les valeurs, par exemple Util.OnDemand("Customer-ID: " + customerObject.ID.ToString(), ()=>customerObject, false).Dump(); pour toujours montrer L'ID par défaut mais révéler les détails de customerObject seulement si vous êtes intéressé par.

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

---

environnement

il ne s'agit pas D'une extension LinqPad, mais plutôt d'une classe .NET, car elle est utile, Je vais vous parler de toute façon. Vous pouvez obtenir beaucoup d'informations utiles que vous pouvez utiliser dans vos scripts tels que :

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

N. B. Pour l'obtention d'un Domain\UserName je voudrais utiliser System.Security.Principal.WindowsIdentity.GetCurrent().Name

plutôt que Environment.UserDomainName+@"\"+Environment.UserName .

---

Util.Ordonnance n ° 15191710920"

( nouveau: disponible depuis LinqPad version v4.45.05. (bêta) )

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

cela écrira le contenu du tableau Customers dans le fichier CSV c:\temp\customers.csv . Vous pouvez également trouver un bel exemple d'utilisation de Util.WriteCsv et ensuite afficher les données CSV dans la fenêtre de résultat de Linqpad ici .

conseils:

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

• si la table est grande, utilisez ObjectTrackingEnabled = false; avant d'écrire le CSV pour éviter de le cacher dans la mémoire.

• si vous voulez sortir un tableau dans format XML plutôt que comme fichier séparé par des virgules, Vous pouvez le faire comme:

  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 a le même nom que la requête et qui est contenu dans le même chemin. Consultez le lien ce lien pour d'autres exemples de codes.

---

Util.GetPassword

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

ceci récupérera le mot de passe du gestionnaire de mot de passe intégré à LinqPad. Pour créer et modifier le mot de passe, ouvrez le "gestionnaire de Mot de passe" dans le menu dans le menu "Fichier" de LinqPad. S'il n'y a pas de mot de passe enregistré lorsque vous lancez le code C#, une boîte de dialogue de mot de passe s'ouvrira vous demandant le mot de passe et vous aurez le choix de le créer et de l'enregistrer à la volée en cochant la case enregistrer le mot de passe (dans l'exemple, le mot de passe pour "UserXY" serait enregistré, et plus tard vous pouvez trouver cette entrée dans le Gestionnaire de mot de passe ).

avantages sont que vous pouvez stocker le mot de passe dans les scripts Linq que vous créez en toute sécurité, séparément et crypté dans le profil D'utilisateur de Windows (il est stocké dans %localappdata%\LINQPad\Passwords comme un fichier). LinqPad utilise Windows DPAPI pour protéger le mot de passe.

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

Notes:

• :
  
  var pwd = Util.GetPassword("UserXY", true);
  
  Cela décochera la case enregistrer mot de passe dans la boîte de dialogue Mot de passe (cependant, l'utilisateur est toujours en mesure de vérifier et de choisir de sauvegarder de toute façon).

• si vous avez besoin que le mot de passe soit stocké dans un SecureString , vous pouvez utiliser cette fonction d'aide (n. B.: pour obtenir la méthode d'extension .ToSecureString() utilisé, s'il vous plaît suivre ce lien à Stackoverflow - il vous permet également de le convertir en arrière 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 commande. Vous pouvez invoquer toutes les commandes que vous connaissez depuis la console Windows.

exemple 1-dir:

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

cela affichera le résultat du répertoire sans le besoin .Dump . Stocker dans une variable a l'avantage que vous pouvez utiliser d'autres requêtes Linq. 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 va vider tous les fichiers avec des extensions de fichier ".exe" ou ".dll "contenue 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 second paramètre de la méthode Cmd est spécifié pour supprimer la sortie de la console afin de n'afficher que le résultat filtré en utilisant la méthode Dump.

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

exemple 2-éditeur de texte:

vous pouvez ouvrir un fichier dans Notepad comme ceci:

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

---

Util.Image

Affiche des images à partir 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 helper 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;
        }
    }
}

il suffit de l'utiliser 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 aussi utiliser Util.Progress pour mettre à jour les LinqPads integrated progress barre, 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 assigner un message.

---

Util.RawHtml

affiche 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 cette fonction d'exemple

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ésultat - ou toute action comme ouvrir votre éditeur préféré. Utilisation:

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

Note que cette fonction fonctionne toujours, alors que new Hyperlinq ("http://myURL", "Web site").Dump(); ne fonctionne pas pour une sorte d'URL (surtout si vous devez passer des noms de port comme": 1234 " comme partie de L'URL).

---

Util.ReadLine

lit les entrées de la console. Exemple:

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

Comme synonyme de Util.ReadLine<string>() , vous pouvez utiliser Console.ReadLine() .

mais il y a plus! Vous pouvez créer un simple JSON parser avec l'extrait suivant - très utile, par exemple si vous voulez Parser et tester une chaîne JSON à la volée. Enregistrer l'extrait de code suivant en tant que JSONAnalyzer.linq en utilisant un éditeur de texte puis l'ouvrir dans LinqPad (ceci 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");
}

Maintenant, vous pouvez l'exécuter et simplement coller une chaîne JSON du presse - papiers dans la console - il utilisera la fonction Dump pour l'afficher comme un objet joliment-et vous obtenez également les messages d'erreur de l'analyseur sur l'écran pour corriger les problèmes. Très utile pour déboguer AJAX.

---

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 devriez attendre l'entrée de l'utilisateur avant de supprimer l'écran (par exemple en le précédant par Util.ReadLine ).

---

Personnalisé .Dump() - Icustommember Provider

est également intéressant, que vous pouvez influencer la sortie de la méthode .Dump() . Il suffit de mettre en œuvre l'interface ICustomMemberProvider , p.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 sortira seulement Hint , constMember1 , constMember2 , et myprop , mais pas de biens xyz :

---

affichage D'une boîte à MessageBox ou InputBox dans LinqPad

Si vous avez besoin d'afficher une messagebox, 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
    }
}

(ne pas oubliez D'appuyer sur F4 et D'ajouter Microsoft.VisualBasic.dll et ses espaces de noms pour faire ce travail)

---

Util.Run

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

vous permet d'exécuter un autre script LINQPad depuis votre script ou depuis votre propre programme. net ou service Windows (en vous référant à la version LINQPad4-AnyCPU de LINQPad.exe ). Il exécute le script comme le ferait l'outil en 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 le code échantillon 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", "test@foo.com", "test@foo.com", "Test Subject" };
    #endif
    args.Dump("Args");
}

il permet de distinguer si le script a été exécuté depuis L'intérieur de la GUI LinqPad ou via lprun.exe ou avec Util.Run .

Note: les variantes suivantes de l'invocation pourrait être utile:

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 effectuer des changements permanents (pour les opérations insérer/mettre à jour/supprimer ). Puisque le contexte de la base de données est implicitement fait par LinqPad, vous devez appeler SubmitChanges() après chaque changement 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();

Note: pour obtenir des identifiants 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 que vous les invoquiez.

---

SaveChanges () - Entity Framework

si vous utilisez Entity Framework , vous pourriez vouloir rendre les changements permanents aussi bien (pour insérer/mettre à jour/supprimer opérations). Comme le contexte de la base de données est implicitement fait par LinqPad, vous devez appeler SaveChanges() après chaque changement comme indiqué ci-dessous.

les exemples sont essentiellement les mêmes qu'avant pour LinqToSQL , mais vous devez utiliser SaveChanges() à la place, et pour insérer et supprimer les méthodes ont changé aussi.

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();

Note: pour obtenir des identifiants 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 que vous les invoquiez.

---

ce la base de données de contexte

Dans LinqPad , le contexte de base de données s'établit automatiquement en utilisant le combobox en haut et en choisissant la bonne base de données pour votre requête. Mais parfois, il est utile de le référencer explicitement , par exemple si vous copiez un code de votre projet à partir de Visual Studio , et le collez dans LinqPad.

votre extrait de code tiré 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 avec dc ? De bien sûr, vous pouvez supprimer chaque occurrence de dc. dans votre requête, mais c'est beaucoup plus facile. Il suffit d'ajouter

var dc=this; // UserQuery

en haut de votre snippet 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!

---

.Connexion

utilisant LinqPad avec OleDb, conversion d'un datatable en objet Linq, requêtes SQL en Linq

L'extrait de code suivant vous aide à utiliser LinqPad avec OleDb. Ajouter System.Data.OleDb de l'ensemble System.Data aux propriétés de requête, puis coller 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();

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

N.B.: si vous voulez simplement obtenir la base de données et le serveur de la connexion actuellement sélectionnée, vous pouvez utiliser ce code snippet:

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 montrer comment le faire: Nice des exemples d'utilisation .NET 4 dynamique de mots clés avec Linq

un autre exemple: supposons que votre DBA vous donne une requête SQL et que vous voulez analyser les résultats dans LinqPad - bien sûr dans Linq, pas dans SQL. Vous pouvez alors faire ce qui suit:

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 de DBA est simplement" jetée dans " le texte de commande, et les résultats sont filtrés et ordonnés par ville.

Bien sûr, c'est un exemple simplifié, votre DBA vous supporterait probablement avec un script plus complexe, mais vous avez l'idée: il suffit d'ajouter une classe de résultat supportant qui contient tous les champs de la clause SELECT et ensuite 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 utilise dynamic pour l'exprimer.

Donc, c'est vraiment rapide, programmation pour être en mesure d'analyser rapidement les données. Vous ne devriez pas faire cela dans votre application réelle pour diverses raisons (injection SQL, parce que vous pouvez utiliser EF dès le début, etc).

---

PanelManager

dessin 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 aussi l'espace de noms System.Windows.Shapes .

le 1er exemple dessine 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 second exemple montre comment vous pouvez afficher le graphique dans LinqPad en utilisant le PanelManager. Normalement, LinqPad ne supporte que les objets Wpf. Cet exemple utilise System.Windows.Forms.Integration.WindowsFormsHost pour rendre disponible un Windows.Forms.PictureBox (il a été inspiré par ce ):

// 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 (éléments du panneau "graphique" et " image" sont ajoutés par les exemples ci-dessus):

si vous voulez afficher les images de la base de données Northwind, vous pouvez faire ce qui suit:

Changez le nom du fichier image en "NorthwindPics.jpg", puis ajouter le code suivant au début de la méthode du 2e exemple Main ():

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 en WPF

LinqPad visualiseurs personnalisés

Note: vous pouvez obtenir la même chose sans le PanelManager aussi bien, que les suivants exemple, 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

dessin graphique dans LinqPad, partie 2

L'exemple suivant, inspiré par ce post, montre comment implémenter un traceur de fonction 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 formes Windows dans le panneau de résultats.



Ajouter références (appuyer sur F4 ) :

System.Drawing.dll , System.Windows.Forms.dll , System.Windows.Forms.DataVisualization.dll

et ajouter tous les espaces de noms de ces assemblées.

---

conseils supplémentaires / autres lectures:

• vous voulez utiliser LinqPad dans Visual Studio ? Voici comment faire que .

• Nécessité d'avoir des LinqPad comme un "Portable" application ? Lire ici comment le faire.

• Joe le site web de 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.

• aussi très utile: cet article sur le débogage Linq(Pad).

• Utiliser lprun.exe pour exécution de requêtes LINQ dans votre scripts batch. Lire 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 aussi 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'arbre est nommé mes Extensions ; double clic pour ouvrir un fichier dans lequel vous pouvez écrire des extensions qui sont disponibles pour toutes vos questions. Mettez-les simplement dans la classe publique statique MyExtensions , et utilisez la méthode Main() pour inclure des tests pour vos extensions.

Dump est une méthode d'extension globale et SubmitChanges provient de L'objet DataContext qui est un système.Données.Linq.Objet DataContext.

LP ajoute seulement de Vidage et de le Démonter pour autant que je suis au courant. Bien que je recommande fortement l'ouverture dans le réflecteur pour voir ce qui est là-bas qui peut être utilisé. Une des choses les plus intéressantes est le LINQPad.Util namespace qui a quelques goodies utilisés par LINQPad en interne.