LINQPad metodi

Qualcuno ha una lista completa di metodi e metodi di estensione LINQPad, come

.Dump() SubmitChanges() 

LINQPad definisce due metodi di estensione (in LINQPad.Extensions), ovvero Dump() e Disassemble() . Dump() scrive nella finestra di output utilizzando il formattatore di output di LINQPad e viene sovraccaricato per consentire di specificare un’intestazione:

 typeof (int).Assembly.Dump (); typeof (int).Assembly.Dump ("mscorlib"); 

Puoi anche specificare una profondità di ricorsione massima per sovrascrivere il valore predefinito di 5 livelli:

 typeof (int).Assembly.Dump (1); // Dump just one level deep typeof (int).Assembly.Dump (7); // Dump 7 levels deep typeof (int).Assembly.Dump ("mscorlib", 7); // Dump 7 levels deep with heading 

Disassemble () disassembla qualsiasi metodo in IL , restituendo l’output in una stringa:

 typeof (Uri).GetMethod ("GetHashCode").Disassemble().Dump(); 

Oltre a questi due metodi di estensione, ci sono alcuni metodi statici utili in LINQPad.Util. Questi sono documentati in completamento automatico e includono:

  • Cmd – esegue un comando di shell o un programma esterno
  • CreateXhtmlWriter : crea un writer di testo che utilizza il formattatore Dump () di LINQPad
  • SqlOutputWriter – restituisce il writer di testo che scrive nella finestra di output SQL
  • GetMyQueries , GetSamples : restituisce una raccolta di oggetti che rappresentano le query / campioni salvati (per un esempio, eseguire una ricerca utilizzando Modifica | Cerca tutto)
  • Evidenzia : avvolge un object in modo che risulti in giallo quando viene eseguito il dump
  • HorizontalRun : consente di eseguire il dump di una serie di oggetti sulla stessa riga

LINQPad fornisce anche la class HyperLinq. Questo ha due scopi: il primo è quello di visualizzare i collegamenti ipertestuali ordinari:

 new Hyperlinq ("www.linqpad.net").Dump(); new Hyperlinq ("www.linqpad.net", "Web site").Dump(); new Hyperlinq ("mailto:[email protected]", "Email").Dump(); 

Puoi combinarlo con Util.HorizontalRun :

 Util.HorizontalRun (true, "Check out", new Hyperlinq ("http://stackoverflow.com", "this site"), "for answers to programming questions.").Dump(); 

Risultato:

Dai un’occhiata a questo sito per le risposte alle domande di programmazione.

Il secondo scopo di HyperLinq è di creare dynamicmente le query:

 // Dynamically build simple expression: new Hyperlinq (QueryLanguage.Expression, "123 * 234").Dump(); // Dynamically build query: new Hyperlinq (QueryLanguage.Expression, @"from c in Customers where c.Name.Length > 3 select c.Name", "Click to run!").Dump(); 

Puoi anche scrivere i tuoi metodi di estensione in LINQPad. Vai su “Le mie query” e fai clic sulla query chiamata “Le mie estensioni”. Tutti i tipi / metodi che definiscono qui sono accessibili a tutte le query:

 void Main() { "hello".Pascal().Dump(); } public static class MyExtensions { public static string Pascal (this string s) { return char.ToLower (s[0]) + s.Substring(1); } } 

In 4.46 (.02) sono state introdotte nuove classi e metodi :

  • DumpContainer (class)
  • OnDemand (metodo di estensione)
  • Util.ProgressBar (class)

Inoltre, la class Hyperlinq ora supporta un delegato di azione che verrà chiamato quando si fa clic sul collegamento, consentendo di reactjs ad esso nel codice e non solo il collegamento a pagine Web esterne.

DumpContainer è una class che aggiunge un blocco alla finestra di output che può avere il suo contenuto sostituito.

NOTA! Ricordati di .Dump() DumpContainer stesso nel punto appropriato.

Usare:

 var dc = new DumpContainer(); dc.Content = "Test"; // further down in the code dc.Content = "Another test"; 

OnDemand è un metodo di estensione che non produrrà il contenuto del suo parametro nella finestra di output, ma aggiungerà invece un link cliccabile, che quando cliccato sostituirà il collegamento con il contenuto di .Dump() del parametro. Questo è ottimo per strutture dati a volte necessarie che sono costose o occupano molto spazio.

NOTA! Ricordati di .Dump() i risultati della chiamata di OnDemand nel punto appropriato.

Per usarlo:

 Customers.OnDemand("Customers").Dump(); // description is optional 

Util.ProgressBar è una class che può mostrare una Util.ProgressBar avanzamento grafica all’interno della finestra di output, che può essere modificata mentre il codice si sposta.

NOTA! Ricordati di .Dump() l’object Util.ProgressBar nel punto appropriato.

Per usarlo:

 var pb = new Util.ProgressBar("Analyzing data"); pb.Dump(); for (int index = 0; index <= 100; index++) { pb.Percent = index; Thread.Sleep(100); } 

Oltre al noto myQuery.Dump("Query result:") , un’altra caratteristica da citare è la class Util : contiene molti metodi molto utili (alcuni dei quali ho menzionato, ma ce ne sono molti altri).

È interessante anche che puoi facilmente modificare il modo in cui funziona Dump() .

Infine, ti mostrerò come è ansible rendere permanenti le modifiche (ad esempio , inserire, aggiornare, eliminare query LINQ) utilizzando SubmitChanges() o SaveChanges() , nonché il modo in cui è ansible accedere all’object connessione interna di LinqPad.

E per accorgerlo, ti mostrerò come è ansible creare una semplice grafica 2D all’interno di LinqPad ( linee di disegno , bitmap o funzioni ).

Quindi, ecco una raccolta di funzionalità incorporate di LinqPad (dalla mia esperienza con lo strumento):


.dump ()

(parametri disponibili in LinqPad v5.03.08 e versioni successive)

Tutti gli utenti LinqPad conoscono e amano il sofisticato metodo di estensione .Dump() , che consuma e stampa (quasi) tutto.

Ma lo sapevi che ci sono un paio di parametri disponibili? Dai un’occhiata a questo snippet di codice:

 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 

Il primo esempio stampa solo le variabili a e c e nasconde b e d , il secondo esempio fa il contrario (si noti che specifica solo 2 dei parametri disponibili). Le variabili y e z non possono essere nascoste singolarmente, perché non sono al livello più alto.

Sono disponibili i seguenti parametri ( tutti sono opzionali ):

  • description [string] – fornisce una descrizione dell’object da scaricare
  • depth [int?] – limita la profondità di ispezione degli oggetti in modo ricorsivo
  • toDataGrid [bool] – se vero, l’output è formattato come un datagrid piuttosto che come RichText
  • exclude [string] – se fornite un elenco di variabili separate da virgole, saranno escluse dall’output (nell’esempio “a, c”: vengono mostrati b d , a e c sono nascosti)
  • exclude [string] con prefisso “+” – il prefisso inverte la logica del parametro exclude. Ciò significa che se si fornisce un elenco di variabili separate da virgole, tutte tranne quelle specificate sono nascoste (nell’esempio “+ b, d”: vengono mostrati b, d, tutti gli altri nascosti)
  • archivio incluso ed escluso proprietà in una variabile (nuovo da LinqPad V5.09.04):
    var x=Util.ToExpando(obj, "a, c", "b, d"); x.Dump();
    La prima stringa contiene un elenco di proprietà da includere, la seconda stringa un elenco da escludere
  • expand on click: Se usi .OnDemand("click me").Dump(); Invece di .Dump() , verrà visualizzato un collegamento su cui è ansible fare clic per espandere. Utile se si desidera esaminare i valori, ad esempio Util.OnDemand("Customer-ID: " + customerObject.ID.ToString(), ()=>customerObject, false).Dump(); per mostrare sempre l’ID per impostazione predefinita ma rivelare i dettagli di customerObject solo se sei interessato.

Gli argomenti più avanzati su Dump possono essere trovati qui .


Ambiente

Questa non è un’estensione LinqPad, ma piuttosto una class .NET, ma poiché è utile, lo menzionerò comunque. Puoi ottenere molte informazioni utili che puoi usare negli script come:

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

NB Per ottenere Domain\UserName vorrei usare System.Security.Principal.WindowsIdentity.GetCurrent().Name
piuttosto che [email protected]"\"+Environment.UserName .


Util.WriteCsv

( nuovo: disponibile dalla versione di LinqPad v4.45.05 (beta) )

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

Questo scriverà il contenuto della tabella Customers nel file CSV c:\temp\customers.csv . Puoi anche trovare un buon esempio su come utilizzare Util.WriteCsv e quindi visualizzare i dati CSV nella finestra dei risultati di Linqpad qui .

suggerimenti:

  • Per ottenere / creare un file CSV che si trova nella stessa directory della query, puoi utilizzare:
    var csvFile=Util.CurrentQueryPath.Replace(".linq", ".csv");

  • Se la tabella è grande, utilizzare ObjectTrackingEnabled = false; prima di scrivere il CSV per evitare di memorizzarlo nella cache.

  • Se vuoi generare una tabella in formato XML piuttosto che come file separati da virgole, puoi farlo come:

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

    Questo esempio restituisce tutti gli elementi che hanno l’attributo attr1 che contiene il valore "a" da un file XML che ha lo stesso nome della query ed è contenuto nello stesso percorso. Dai un’occhiata a questo link per ulteriori esempi di codice.


Util.GetPassword

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

Questo recupererà la password dal gestore di password incorporato di LinqPad. Per creare e modificare la password, aprire la voce di menu “Gestione password” nel menu “File” di LinqPad. Se non viene salvata alcuna password quando si esegue il codice C #, verrà visualizzata una finestra di dialogo con la password che richiede la password e si ha la possibilità di crearlo e salvarlo al volo selezionando la casella di controllo Salva password (nell’esempio, la password per “UserXY” verrebbe salvata e in seguito sarà ansible trovare questa voce in Gestione password ).

I vantaggi sono che è ansible memorizzare la password nei LinqScripts creati in modo sicuro, separatamente e crittografati nel profilo utente di Windows (è memorizzato in %localappdata%\LINQPad\Passwords come file). LinqPad utilizza Windows DPAPI per proteggere la password.

Inoltre, la password viene memorizzata centralmente, quindi se devi cambiarla, puoi farlo nel menu e si applica immediatamente a tutti gli script che hai creato.

Gli appunti:

  • Se non vuoi salvare la password e fai apparire una finestra di dialogo con password, puoi usare il 2 ° parametro come segue:
    var pwd = Util.GetPassword("UserXY", true);
    Questo deselezionerà la casella di controllo della password di salvataggio nella finestra di dialogo della password (tuttavia, l’utente è ancora in grado di controllarlo e scegliere di salvare comunque).

  • Se si richiede la memorizzazione della password in SecureString , è ansible utilizzare questa funzione di supporto (nb: per utilizzare il metodo di estensione .ToSecureString() , seguire questo link su Stackoverflow – consente anche di riconvertirlo se necessario) :
    System.Security.SecureString GetPasswordSecure(string Name, bool noDefaultSave=true)
    {
    return Util.GetPassword(Name, noDefaultSave) .ToSecureString();
    }


Util.Cmd

Questo metodo funziona come un processore di comandi. Puoi richiamare tutti i comandi che conosci dalla console di Windows.

Esempio 1: dir:

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

Questo produrrà il risultato della directory senza la necessità di eseguire il .Dump . Archiviandolo in una variabile ha il vantaggio che è ansible utilizzare ulteriori query Linq su di essa. Per esempio:

 var [email protected]"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(); 

Questo scaricherà tutti i file con estensioni di file “.exe” o “.dll” contenute in C:\windows\system32 . L’opzione /s viene utilizzata per richiamare tutte le sottodirectory e /b è utilizzato per il formato di output nullo. Si noti che il secondo parametro del metodo Cmd viene specificato per sopprimere l’output della console al fine di mostrare solo il risultato filtrato utilizzando il metodo Dump.

Puoi vedere che questo è più flessibile dei caratteri jolly che hai con dir dato che puoi usare la massima flessibilità del motore di query di Linq.

Esempio 2 – editor di testo:

Puoi aprire un file in Blocco note come questo:

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

Util.Image

Visualizza le immagini da un URL. Esempio:

 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’utilizzo di Util.ProgressBar consente di visualizzare una barra di avanzamento. Puoi utilizzare la seguente class helper:

 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; } } } 

Usalo semplicemente come mostra il seguente esempio:

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

In alternativa, è ansible utilizzare Util.Progress per aggiornare la barra di avanzamento integrata di LinqPads, ad esempio:

 Util.Progress = 25; // 25 percent complete 

La differenza è che non verrà visualizzata nella finestra dei risultati e non è ansible assegnarvi un messaggio.


Util.RawHtml

Visualizza HTML nella finestra di output. Esempio:

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

Hyperlinq, Util.HorizontalRun

Puoi usare questa funzione di esempio

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

per mostrare i collegamenti ipertestuali nella finestra dei risultati – o qualsiasi azione come aprire il tuo editor preferito. Uso:

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

Si noti che questa funzione funziona sempre, mentre il new Hyperlinq ("http://myURL", "Web site").Dump(); non funziona per alcuni tipi di URL (specialmente se devi passare nomi di porte come “: 1234” come parte dell’URL).


Util.ReadLine

Legge l’input dalla console. Esempio:

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

Come sinonimo di Util.ReadLine() , puoi anche usare Console.ReadLine() .

Ma c’è di più! Puoi creare un semplice parser JSON con il seguente frammento: molto utile, ad esempio se vuoi analizzare e testare una stringa JSON al volo. Salva il seguente frammento come JSONAnalyzer.linq usando un editor di testo e aprilo in LinqPad (questo per aggiungere facilmente i riferimenti al volo):

  <RuntimeDirectory>\System.Web.Extensions.dll System.Web.Script.Serialization;  void Main() { var jsonData=Util.ReadLine("Enter JSON string:"); var jsonAsObject = new JavaScriptSerializer().Deserialize(jsonData); jsonAsObject.Dump("Deserialized JSON"); } 

Ora puoi eseguirlo e incollare semplicemente una stringa JSON dagli Appunti nella console – userà la funzione Dump per visualizzarla come un object con piacere – e avrai anche i messaggi di errore del parser sullo schermo per risolvere i problemi. Molto utile per il debug di AJAX.

JSON


Util.ClearResults

Se hai bisogno di cancellare la finestra dei risultati all’interno del tuo script, usa:

 Util.ClearResults(); 

O lo usi all’inizio dello script o, se stai eseguendo più query in uno script, dovresti attendere l’input dell’utente prima di cancellare lo schermo (ad esempio, precedendolo con Util.ReadLine ).


Custom .Dump () – ICustomMemberProvider

È anche interessante che tu possa influenzare l’output del metodo .Dump() . Basta implementare l’interfaccia ICustomMemberProvider , ad es

 public class test : ICustomMemberProvider { IEnumerable ICustomMemberProvider.GetNames() { return new List{"Hint", "constMember1", "constMember2", "myprop"}; } IEnumerable ICustomMemberProvider.GetTypes() { return new List{typeof(string), typeof(string[]), typeof(string), typeof(string)}; } IEnumerable ICustomMemberProvider.GetValues() { return new List{ "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 } 

Se crei un’istanza di questa class, ad esempio

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

quindi produrrà solo Hint , constMember1 , constMember2 e myprop , ma non la proprietà xyz :

Discarica Linqpad


Visualizzazione di un MessageBox o InputBox in LinqPad

Se è necessario visualizzare una finestra di messaggio, guarda qui come farlo.

Ad esempio, è ansible visualizzare un InputBox utilizzando il seguente codice

 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 } } 

(non dimenticare di premere F4 e aggiungere Microsoft.VisualBasic.dll e i suoi spazi dei nomi per farlo funzionare)


Util.Run

( nuovo: disponibile dalla versione di LinqPad v4.52.1 (beta) )

Consente di eseguire un altro script LINQPad dallo script o dal proprio programma .NET o dal servizio Windows (facendo riferimento alla versione LINQPad.exe di LINQPad4- LINQPad.exe ). lprun.exe lo script proprio come lo sarebbe lo strumento a riga di comando lprun.exe .

Esempi:

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

Questo esempio esegue lo script foo.linq , che contiene il seguente codice di esempio:

 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"); } 

Permette di distinguere se lo script è stato eseguito dalla GUI di LinqPad o tramite lprun.exe o con Util.Run .

Nota: le seguenti varianti di invocazione potrebbero essere utili:

 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 To SQL

Se stai usando LinqToSQL , potresti voler rendere le modifiche permanenti (per operazioni di inserimento / aggiornamento / cancellazione ). Poiché il contesto del database è implicitamente eseguito da LinqPad, è necessario chiamare SubmitChanges() dopo ogni modifica, come mostrato di seguito.

Esempi per il database (LinqPad-) Northwind :

Inserire

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

Aggiornare

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

Elimina

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

Nota: per ottenere ID validi per gli esempi precedenti, puoi utilizzare:

 var cID = (from c in Categories where c.CategoryName.Contains("Seafood") select c).FirstOrDefault().CategoryID; var pID = Products.Count()+1; 

prima di invocarli.


SaveChanges () – Entity Framework

Se si utilizza Entity Framework , è ansible che si desideri rendere anche le modifiche permanenti (per operazioni di inserimento / aggiornamento / eliminazione ). Poiché il contesto del database è implicitamente creato da LinqPad, è necessario chiamare SaveChanges() dopo ogni modifica come mostrato di seguito.

Gli esempi sono fondamentalmente gli stessi di prima per LinqToSQL , ma è necessario utilizzare SaveChanges() e, per l’inserimento e l’eliminazione, anche i metodi sono cambiati.

Inserire

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

Aggiornare

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

Elimina

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

Nota: per ottenere ID validi per gli esempi precedenti, puoi utilizzare:

 var cID = (from c in Categories where c.CategoryName.Contains("Seafood") select c).FirstOrDefault().CategoryID; var pID = Products.Count()+1; 

prima di invocarli.


questo – contesto del database

In LinqPad , il contesto del database viene stabilito automaticamente utilizzando la casella combinata nella parte superiore e selezionando il database corretto per la query. Ma a volte, è utile fare riferimento in modo esplicito, ad esempio se copi del codice dal tuo progetto da Visual Studio e lo incolli in LinqPad.

Lo snippet di codice preso dal progetto Visual Studio molto probabilmente assomiglia a questo:

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

Ora cosa fare con dc ? Naturalmente, è ansible rimuovere ogni occorrenza di dc. nella tua domanda, ma è molto più facile. Basta aggiungere

 var dc=this; // UserQuery 

in cima allo snippet in questo modo:

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

e il codice funzionerà all’istante!


this.Connection

Utilizzo di LinqPad con OleDb, conversione di un datatable in object Linq, query SQL in Linq

Il seguente frammento di codice ti aiuta a usare LinqPad con OleDb. Aggiungere System.Data.OleDb dall’assembly System.Data alle proprietà della query, quindi incollare il seguente codice in 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(); 

Ora aggiungi una connessione SqlServer a LinqPad e aggiungi il database Northwind per eseguire questo esempio.

NB: se desideri semplicemente ottenere il database e il server della connessione attualmente selezionata, puoi utilizzare questo snippet di codice:

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

Puoi persino convertire myDS in Linq, le risposte alla seguente domanda mostrano come farlo: esempi myDS di utilizzo della parola chiave dynamic .NET 4 con Linq

Un altro esempio: supponiamo che il tuo DBA ti dia una query SQL e che tu voglia analizzare i risultati in LinqPad – ovviamente in Linq, non in SQL. Quindi puoi fare quanto segue:

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

In questo esempio la query SELECT del DBA è semplicemente “gettato” nel testo del comando, ei risultati vengono filtrati e ordinati per città.
Ovviamente, questo è un esempio semplificato, il tuo DBA probabilmente ti supporterà con uno script più complesso, ma ti viene l’idea: basta aggiungere una class di risultati di supporto che contenga tutti i campi dalla clausola SELECT e quindi puoi direttamente usare esso.
Puoi anche prendere il risultato da una stored procedure in questo modo e usarlo in Linq. Come puoi vedere, in questo esempio non mi interessa il tipo di dati e uso dynamic per esprimerlo.
Quindi si tratta di una programmazione rapida per poter analizzare rapidamente i dati. Non dovresti farlo nella tua vera applicazione per vari motivi (SQL injection, perché puoi usare EF dall’inizio, ecc.).


PanelManager

Disegna la grafica in LinqPad, parte 1

Per utilizzare gli esempi seguenti, premere F4 e aggiungere System.Windows.dll , System.Windows.Forms.dll , WindowsFormsIntegration.dll , PresentationCore.dll e PresentationFramework.dll nel programma LinqPad e aggiungere anche lo spazio dei nomi System.Windows.Shapes .

Il primo esempio disegna semplicemente una linea:

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

Il secondo esempio mostra come è ansible visualizzare grafici in LinqPad usando PanelManager. Normalmente LinqPad supporta solo oggetti Wpf. Questo esempio utilizza System.Windows.Forms.Integration.WindowsFormsHost per rendere disponibile Windows.Forms.PictureBox (è stato ispirato da questo ):

 // 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 classs 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); } 

Questo creerà il seguente grafico (le voci del pannello “Grafica” e “Immagine” sono aggiunte dagli esempi sopra):

Showing_Graphic_in_LinqPad

Se si desidera visualizzare le immagini dal database Northwind, è ansible effettuare le seguenti operazioni:
Cambia il nome del file immagine in “NorthwindPics.jpg”, quindi aggiungi il codice seguente all’inizio del secondo metodo 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(); } 

Leggerà il primo record dalla tabella Impiegati e visualizzerà l’immagine.

Controlla i seguenti link per saperne di più:
Forme e disegni base in WPF
Visualizzatori personalizzati LinqPad

Nota: è ansible ottenere lo stesso risultato anche con PanelManager, come nell’esempio seguente, che ho visto qui :

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

Sta usando il comando .Dump() per visualizzarlo. Puoi invocare image.Dump() più volte e aggiungerà l’immagine.


Windows Form

Disegna la grafica in LinqPad, parte 2

L’esempio seguente, ispirato a questo post, mostra come implementare un semplice plotter di funzione in Linqpad 5 utilizzando 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 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 p_fn = null) { if (p_fn == null) p_fn = ((xf) => { return xf; }); // identity as default var xl = new List(); var yl = new List(); 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; } 

Sta utilizzando la capacità di LinqPad di visualizzare i moduli di Windows nel pannello dei risultati.
Esempio
Aggiungi riferimenti (premi F4 ) :
System.Drawing.dll , System.Windows.Forms.dll , System.Windows.Forms.DataVisualization.dll
e aggiungere tutti gli spazi dei nomi da questi assembly.


Ulteriori suggerimenti / ulteriori letture:

  • Vuoi usare LinqPad in Visual Studio ? Ecco come puoi farlo .

  • Hai bisogno di avere LinqPad come "app portatile" ? Leggi qui come farlo.

  • Il sito web di Joe per LinqPad è sempre un'ottima fonte. In LinqPad, Help -> What's New ti offre suggerimenti su nuove funzioni e metodi. Il forum di LinqPad contiene anche suggerimenti utili.

  • Anche molto utile: questo articolo sul debug di Linq (Pad).

  • Utilizzare lprun.exe per eseguire query LINQ negli script batch. Leggi questo articolo per maggiori dettagli. Per esempio:
    echo Customers.Take(100) > script.txt
    lprun -lang=e -cxname=CompanyServer.CustomerDb script.txt
    In questo esempio, la query è una semplice espressione LINQ. Naturalmente, puoi anche preparare query complesse usando il -lang=program per triggersre la modalità di programmazione.

  • È ansible scrivere i propri metodi di estensione e memorizzarli nella scheda Le mie query sul lato sinistro di LinqPad: L'ultimo elemento dell'albero si chiama My Extensions ; fare doppio clic su di esso per aprire un file in cui è ansible scrivere estensioni disponibili per tutte le query. Basta inserirli nella class statica pubblica MyExtensions e utilizzare il metodo Main() per includere test per le estensioni.

Dump è un metodo di estensione globale e SubmitChanges proviene dall’object DataContext che è un object System.Data.Linq.DataContext.

LP aggiunge solo Dump e Disassemble per quanto ne so. Anche se consiglio vivamente di aprirlo in Reflector per vedere cos’altro può essere usato. Una delle cose più interessanti è lo spazio dei nomi LINQPad.Util che ha alcune chicche utilizzate internamente da LINQPad.