c# - transact - Métodos LINQPad
test linq query (3)
¿Alguien tiene una lista completa de métodos y métodos de extensión LINQPad, como
.Dump()
SubmitChanges()
Además del conocido myQuery.Dump("Query result:") , otra característica para mencionar es la clase Util : contiene muchos métodos muy útiles (algunos de ellos he mencionado, pero hay muchos más).
También es interesante que puedes modificar fácilmente la forma en que funciona Dump() .
Finalmente, le mostraré cómo puede hacer cambios permanentes (es decir , insertar, actualizar, eliminar consultas LINQ) utilizando SubmitChanges() o SaveChanges() así como también cómo puede acceder al objeto de conexión interno de LinqPad.
Y para redondearlo, le mostraré cómo puede crear un gráfico 2d simple dentro de LinqPad ( líneas de dibujo , mapas de bits o funciones ).
Entonces, aquí hay una colección de características integradas de LinqPad (según mi propia experiencia con la herramienta):
.Tugurio()
(parámetros disponibles en LinqPad v5.03.08 y superior)
Todos los usuarios de LinqPad conocen y aman el sofisticado método de extensión .Dump() , que consume e imprime (casi) todo.
¿Pero sabías que hay un par de parámetros disponibles? Eche un vistazo a este fragmento de código:
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
El primer ejemplo imprime solo las variables a y c y oculta b y d , el segundo ejemplo hace lo contrario (tenga en cuenta que especifica solo 2 de los parámetros disponibles). Las variables y y z no pueden ocultarse individualmente, porque no están en el nivel superior.
Los siguientes parámetros están disponibles ( todos son opcionales ):
-
description[string] - proporciona una descripción del objeto a volcar -
depth[int?] - limita la profundidad con la que los objetos son inspeccionados recursivamente -
toDataGrid[bool]: si es verdadero, el resultado se formatea como una cuadrícula de datos en lugar de como RichText -
exclude[cadena] - si proporciona una lista de variables separadas por comas, se excluirán de la salida (en el ejemplo "a, c":bydse muestran,aycestán ocultos) -
exclude[cadena] con el prefijo "+" - el prefijo invierte la lógica del parámetro de exclusión. Esto significa que si proporciona una lista de variables separadas por comas, todas las opciones, excepto las especificadas, están ocultas (en el ejemplo "+ b, d":bydse muestran, todas las demás ocultas) - almacenar propiedades incluidas y excluidas en una variable (nuevo desde LinqPad V5.09.04):
var x=Util.ToExpando(obj, "a, c", "b, d"); x.Dump();
La primera cadena contiene una lista de propiedades para incluir, la segunda cadena una lista para excluir - expandir al hacer clic: si usa
.OnDemand("click me").Dump();en lugar de.Dump(), mostrará un enlace en el que puede hacer clic para expandir. Es útil si desea inspeccionar valores, por ejemplo,Util.OnDemand("Customer-ID: " + customerObject.ID.ToString(), ()=>customerObject, false).Dump();para mostrar siempre la ID por defecto, pero revele los detalles decustomerObjectsolo si le interesa.
Se pueden encontrar temas más avanzados sobre Dump here .
Ambiente
Esta no es una extensión LinqPad, sino más bien una clase .NET, pero dado que es útil, lo mencionaré de todos modos. Puede obtener mucha información útil que puede usar en sus secuencias de comandos, como por ejemplo:
Environment.UserDomainName.Dump();
Environment.MachineName.Dump();
Environment.UserName.Dump();
Environment.CurrentDirectory.Dump();
Environment.SystemDirectory.Dump();
NB Para obtener Domain/UserName usaría System.Security.Principal.WindowsIdentity.GetCurrent().Name
en lugar de Environment.UserDomainName+@"/"+Environment.UserName .
Util.WriteCsv
( nuevo: disponible desde la versión de LinqPad v4.45.05 (beta) )
Util.WriteCsv (Customers, @"c:/temp/customers.csv");
Esto escribirá el contenido de la tabla Customers en el archivo CSV c:/temp/customers.csv . También puede encontrar un buen ejemplo de cómo usar Util.WriteCsv y luego mostrar los datos CSV en la ventana de resultados de Linqpad here .
Sugerencias:
Para obtener / crear un archivo CSV que se encuentre en el mismo directorio que la consulta, puede usar:
var csvFile=Util.CurrentQueryPath.Replace(".linq", ".csv");Si la tabla es grande, use
ObjectTrackingEnabled = false;antes de escribir el CSV para evitar almacenarlo en la memoria caché.Si desea generar una tabla en formato XML en lugar de como un archivo separado por comas, puede hacerlo de la siguiente manera:
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();Este ejemplo devuelve todos los elementos que tienen el atributo
attr1que contiene el valor"a"de un archivo XML que tiene el mismo nombre que la consulta y está contenido en la misma ruta. Consulte this enlace para obtener más ejemplos de código.
Util.GetPassword
var pwd = Util.GetPassword("UserXY");
Esto recuperará la contraseña del administrador de contraseñas integrado de LinqPad. Para crear y cambiar la contraseña, abra el elemento de menú "Administrador de contraseñas" en el menú "Archivo" de LinqPad. Si no se guarda esa contraseña al ejecutar el código C #, se abrirá un cuadro de diálogo de contraseña que le solicitará la contraseña y usted tiene la opción de crearla y guardarla sobre la marcha marcando la casilla Guardar contraseña (en el ejemplo, la contraseña para "UserXY" se guardará, y más adelante puede encontrar esta entrada en el administrador de contraseñas ).
Las ventajas son que puede almacenar la contraseña en los LinqScripts que crea de forma segura, por separado y encriptada en el perfil de usuario de Windows (se almacena en %localappdata%/LINQPad/Passwords como un archivo). LinqPad usa Windows DPAPI para proteger la contraseña.
Además, la contraseña se almacena de forma centralizada, por lo que si necesita cambiarla, puede hacerlo en el menú e inmediatamente se aplica a todas las secuencias de comandos que haya creado.
Notas:
Si no desea guardar la contraseña y solo abrir un cuadro de diálogo de contraseña, puede usar el 2do parámetro de la siguiente manera:
var pwd = Util.GetPassword("UserXY", true);
Esto desmarca la casilla de verificación guardar contraseña en el cuadro de diálogo de contraseña (sin embargo, el usuario aún puede verificarlo y elegir guardar de todos modos).Si necesita que la contraseña se almacene en un
SecureString, puede usar esta función auxiliar (nb: para.ToSecureString()método de extensión.ToSecureString(), siga este enlace en ; también le permite convertirlo si es necesario) :
System.Security.SecureString GetPasswordSecure(string Name, bool noDefaultSave=true)
{
return Util.GetPassword(Name, noDefaultSave).ToSecureString();
}
Util.Cmd
Este método funciona como un procesador de comandos. Puede invocar todos los comandos que conoce desde la consola de Windows.
Ejemplo 1 - dir:
Util.Cmd(@"dir C:/");
Esto generará el resultado del directorio sin la necesidad de .Dump . Almacenarlo en una variable tiene la ventaja de que puede utilizar otras consultas de Linq en él. Por ejemplo:
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();
Esto arrojará todos los archivos con extensiones de archivo ".exe" o ".dll" contenidos en C:/windows/system32 . El modificador /s se usa para recursar todos los subdirectorios y /b se usa para el formato de salida simple. Tenga en cuenta que el segundo parámetro del método Cmd se especifica para suprimir la salida de la consola a fin de mostrar solo el resultado filtrado mediante el método de volcado.
Puede ver que esto es más flexible que los comodines que tiene con dir ya que puede usar la flexibilidad total del motor de consultas de Linq.
Ejemplo 2 - editor de texto:
Puede abrir un archivo en el Bloc de notas de esta manera:
var filePath=@"C:/HelloWorld.txt";
Util.Cmd(@"%systemroot%/system32/notepad.exe", filePath);
Util.Image
Muestra imágenes de una URL. Ejemplo:
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
El uso de Util.ProgressBar permite mostrar una barra de progreso. Puedes usar la siguiente clase de ayuda:
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;
}
}
}
Simplemente úsalo como se muestra en el siguiente ejemplo:
void Main()
{
var pb1= new ProgressBar();
Thread.Sleep(50);
pb1.Update(50, "Doing something"); Thread.Sleep(550);
pb1.Update(100); Thread.Sleep(50);
}
Alternativamente, puede utilizar Util.Progress para actualizar la barra de progreso integrada de LinqPads, por ejemplo:
Util.Progress = 25; // 25 percent complete
La diferencia es que no se mostrará en la ventana de resultados y no podrá asignarle un mensaje.
Util.RawHtml
Muestra HTML en la ventana de salida. Ejemplo:
Util.RawHtml (new XElement ("h1", "This is a big heading")).Dump();
Hyperlinq, Util.HorizontalRun
Puedes usar esta función de ejemplo
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);
}
para mostrar hipervínculos en la ventana de resultados, o cualquier acción como abrir su editor favorito. Uso:
ShowUrl("http://.com", "Check out ");
Tenga en cuenta que esta función siempre funciona, mientras que el new Hyperlinq ("http://myURL", "Web site").Dump(); no funciona para algunos tipos de URL (especialmente, si debe pasar nombres de puertos como ": 1234" como parte de la URL).
Util.ReadLine
Lee la entrada desde la consola. Ejemplo:
int age = Util.ReadLine<int> ("Enter your age");
Como sinónimo de Util.ReadLine<string>() , también puede usar Console.ReadLine() .
¡Pero hay más! Puede crear un analizador JSON simple con el siguiente fragmento de código: bastante útil, por ejemplo, si desea analizar y probar una cadena JSON sobre la marcha. Guarde el siguiente fragmento como JSONAnalyzer.linq usando un editor de texto y luego ábralo en LinqPad (esto es para agregar las referencias fácilmente sobre la marcha):
<Query Kind="Program">
<Reference><RuntimeDirectory>/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");
}
Ahora puede ejecutarlo y simplemente pegar una cadena JSON del portapapeles en la consola - usará la función Dump para mostrarlo como un objeto muy bien - y también obtendrá los mensajes de error del analizador en la pantalla para solucionar problemas. Muy útil para depurar AJAX.
Util.ClearResults
Si necesita borrar la ventana de resultados dentro de su script, use:
Util.ClearResults();
Puede usarlo al comienzo de su script o, si está ejecutando varias consultas en un script, debe esperar a que el usuario ingrese antes de borrar la pantalla (por ejemplo, precediéndolo con Util.ReadLine ).
Custom .Dump () - ICustomMemberProvider
También es interesante que puede influir en el resultado del método .Dump() . Simplemente implemente la interfaz ICustomMemberProvider , por ejemplo
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 crea una instancia de esta clase, como
var obj1 = new test();
obj1.Dump("Test");
luego solo mostrará Hint , constMember1 , constMember2 y myprop , pero no la propiedad xyz :
Exhibir un MessageBox o InputBox en LinqPad
Si necesita mostrar un cuadro de mensaje, mire here cómo hacerlo.
Por ejemplo, puede mostrar un InputBox usando el siguiente código
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
}
}
(no olvide presionar F4 y agregar Microsoft.VisualBasic.dll y sus espacios de nombres para que esto funcione)
Util.Run
( nuevo: disponible desde la versión de LinqPad v4.52.1 (beta) )
Le permite ejecutar otro script LINQPad desde su script o dentro de su propio programa .NET o servicio de Windows (haciendo referencia a la versión LINQPad4-AnyCPU de LINQPad.exe ). Ejecuta el script tal como lo haría la herramienta de línea de comando lprun.exe .
Ejemplos:
const string path=@"C:/myScripts/LinqPad/";
var dummy=new LINQPad.QueryResultFormat(); // needed to call Util.Run
Util.Run(path+"foo.linq", dummy);
Este ejemplo ejecuta el script foo.linq , que contiene el siguiente código de ejemplo:
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");
}
Le permite distinguir si el script se ejecutó desde la GUI de LinqPad o mediante lprun.exe o con Util.Run .
Nota: las siguientes variantes de invocación pueden ser útiles:
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 a SQL
Si está utilizando LinqToSQL , es posible que desee hacer cambios permanentes (para operaciones de inserción / actualización / eliminación ). Dado que LinqPad hace implícitamente el contexto de la base de datos, debe llamar a SubmitChanges() después de cada cambio, como se muestra a continuación.
Ejemplos para la base de datos (LinqPad-) Neptuno :
Insertar
var newP = new Products() { ProductID=pID, CategoryID=cID,
ProductName="Salmon#"+pID.ToString() };
Products.InsertOnSubmit(newP);
SubmitChanges();
Actualizar
var prod=(from p in Products
where p.ProductName.Contains("Salmon")
select p).FirstOrDefault();
prod.ProductName="Trout#"+prod.ProductID.ToString();
SubmitChanges();
Borrar
var itemsToDelete=Products.Where(p=> p.ProductName.Contains("Salmon") ||
p.ProductName.Contains("Trout"));
foreach(var item in itemsToDelete) { Products.DeleteOnSubmit(item); }
SubmitChanges();
Nota: Para obtener ID válidos para los ejemplos anteriores, puede usar:
var cID = (from c in Categories
where c.CategoryName.Contains("Seafood")
select c).FirstOrDefault().CategoryID;
var pID = Products.Count()+1;
antes de invocarlos.
SaveChanges () - Entity Framework
Si está utilizando Entity Framework , es posible que desee hacer cambios permanentes también (para operaciones de inserción / actualización / eliminación ). Como LinqPad hace el contexto de la base de datos de forma implícita, debe llamar a SaveChanges() después de cada cambio, como se muestra a continuación.
Los ejemplos son básicamente los mismos que antes para LinqToSQL , pero necesita usar SaveChanges() lugar, y para insertar y eliminar los métodos también han cambiado.
Insertar
var newP = new Products() { ProductID=pID, CategoryID=cID,
ProductName="Salmon#"+pID.ToString() };
Products.Add(newP);
SaveChanges();
Actualizar
var prod=(from p in Products
where p.ProductName.Contains("Salmon")
select p).FirstOrDefault();
prod.ProductName="Trout#"+prod.ProductID.ToString();
SaveChanges();
Borrar
var itemsToDelete=Products.Where(p=> p.ProductName.Contains("Salmon") ||
p.ProductName.Contains("Trout"));
foreach(var item in itemsToDelete) { Products.Remove(item); }
SaveChanges();
Nota: Para obtener ID válidos para los ejemplos anteriores, puede usar:
var cID = (from c in Categories
where c.CategoryName.Contains("Seafood")
select c).FirstOrDefault().CategoryID;
var pID = Products.Count()+1;
antes de invocarlos.
esto - contexto de la base de datos
En LinqPad , el contexto de la base de datos se establece automáticamente utilizando el cuadro combinado en la parte superior y seleccionando la base de datos correcta para su consulta. Pero a veces, es útil hacer referencia explícita, por ejemplo, si copia algún código de su proyecto de Visual Studio y lo pega en LinqPad.
Es muy probable que el fragmento de código tomado del proyecto de Visual Studio tenga este aspecto:
var prod=(from p in dc.Products
where p.ProductName.Contains("Salmon")
select p).FirstOrDefault();
prod.ProductName="Trout#"+prod.ProductID.ToString();
dc.SaveChanges();
Ahora que hacer con dc ? Por supuesto, puedes eliminar cada aparición de dc. en su consulta, pero es mucho más fácil. Solo agrega
var dc=this;
al principio de tu fragmento como ese:
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();
}
¡y el código funcionará instantáneamente!
esto.conexión
Usando LinqPad con OleDb, convirtiendo una tabla de datos a un objeto Linq, consultas SQL en Linq
El siguiente fragmento de código te ayuda a usar LinqPad con OleDb. Agregue System.Data.OleDb del ensamblado System.Data a las propiedades de la consulta, luego pegue el siguiente código en 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();
Ahora agregue una conexión SqlServer a LinqPad y agregue la base de datos de Northwind para ejecutar este ejemplo.
NB: si solo quiere obtener la base de datos y el servidor de la conexión actualmente seleccionada, puede usar este fragmento de código:
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();
}
Incluso puede convertir myDS en Linq, las respuestas a la siguiente pregunta muestran cómo hacerlo: Buenos ejemplos de uso de la palabra clave dinámica .NET 4 con Linq
Un ejemplo más: supongamos que su DBA le da una consulta SQL y desea analizar los resultados en LinqPad, por supuesto en Linq, no en SQL. Entonces puedes hacer lo siguiente:
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;
}
En este ejemplo, la consulta SELECT del DBA simplemente se "arroja" al texto del comando, y City filtra y ordena los resultados.
Por supuesto, este es un ejemplo simplificado, su DBA probablemente lo respalde con un script más complejo, pero se entiende la idea: simplemente agregue una clase de resultados de soporte que contenga todos los campos de la cláusula SELECT y luego puede usar directamente eso.
Incluso puede tomar el resultado de un procedimiento almacenado de esta manera y usarlo en Linq. Como puede ver, en este ejemplo no me importa el tipo de datos y uso la dynamic para expresarlo.
Entonces, esto realmente se trata de una programación rápida para poder analizar datos rápidamente. No debe hacer esto en su aplicación real por varias razones (inyección SQL, porque puede usar EF desde el principio, etc.).
PanelManager
Dibujar gráfico en LinqPad, parte 1
Para utilizar los ejemplos a continuación, presione F4 y agregue System.Windows.dll , System.Windows.Forms.dll , WindowsFormsIntegration.dll , PresentationCore.dll y PresentationFramework.dll a su programa LinqPad y también agregue el espacio de nombres System.Windows.Shapes .
El primer ejemplo simplemente dibuja una línea:
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");
El segundo ejemplo muestra cómo puede visualizar gráficos en LinqPad utilizando el PanelManager. Normalmente LinqPad solo admite objetos Wpf. Este ejemplo usa System.Windows.Forms.Integration.WindowsFormsHost para hacer que Windows.Forms.PictureBox esté disponible (se inspiró en 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://.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);
}
Esto creará el siguiente gráfico (los elementos del panel "Gráfico" e "Imagen" se agregan mediante los ejemplos anteriores):
Si desea visualizar las imágenes de la base de datos de Northwind, puede hacer lo siguiente:
Cambie el nombre del archivo de imagen a "NorthwindPics.jpg", luego agregue el siguiente código al comienzo del método Main () del segundo ejemplo :
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();
}
Leerá el primer registro de la tabla Empleados y mostrará la imagen.
Consulte los siguientes enlaces para obtener más información:
Formas y dibujo básico en WPF
Visualizadores personalizados LinqPad
Nota: Puede lograr lo mismo sin el PanelManager también, como en el siguiente ejemplo, que vi here muestra:
// 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();
}
Está utilizando el .Dump() para mostrarlo. Puede invocar image.Dump() varias veces y agregará la imagen.
Formularios de Windows
Dibujar gráfico en LinqPad, parte 2
El siguiente ejemplo, inspirado en this publicación, muestra cómo implementar un trazador de funciones simple en Linqpad 5 usando 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;
}
Está utilizando la capacidad de LinqPad para mostrar formularios de Windows en el panel de resultados.
Agregar referencias (presione F4 ) :
System.Drawing.dll , System.Windows.Forms.dll , System.Windows.Forms.DataVisualization.dll
y agregue todos los espacios de nombres de estos ensamblajes.
Consejos adicionales / lectura adicional:
¿Quieres usar LinqPad en Visual Studio ? Así es como puedes hacer eso .
¿Necesita tener LinqPad como una "aplicación portátil" ? Lea aquí cómo hacer eso.
El sitio web de Joe para LinqPad siempre es una excelente fuente. Dentro de LinqPad,
Help -> What''s Newda pistas sobre nuevas funciones y métodos. El foro de LinqPad también contiene consejos útiles.También es muy útil: This artículo sobre la depuración de Linq (Pad).
Use
lprun.exepara ejecutar consultas LINQ en sus scripts por lotes. Lee este artículo para más detalles. Por ejemplo:
echo Customers.Take(100) > script.txt
lprun -lang=e -cxname=CompanyServer.CustomerDb script.txt
En este ejemplo, la consulta es una expresión LINQ simple. Por supuesto, también puede preparar consultas complejas utilizando el-lang=programpara activar el modo de programa.Puede escribir sus propios métodos de extensión y almacenarlos en la pestaña Mis consultas en el lado izquierdo de LinqPad: el último elemento del árbol se llama Mis extensiones ; Haga doble clic en él para abrir un archivo donde puede escribir extensiones que están disponibles para todas sus consultas. Simplemente colóquelos en la clase estática pública
MyExtensions, y use el métodoMain()para incluir pruebas para sus extensiones.
Dump es un método de extensión global y SubmitChanges proviene del objeto DataContext, que es un objeto System.Data.Linq.DataContext.
LP agrega solo Volcar y Desarmar hasta donde yo sé. Aunque recomiendo abrirlo en Reflector para ver qué más se puede usar. Una de las cosas más interesantes es el espacio de nombres LINQPad.Util, que tiene algunas ventajas que LINQPad utiliza internamente.
LINQPad define dos métodos de extensión (en LINQPad.Extensions), a saber, Dump() y Disassemble() . Dump() escribe en la ventana de salida utilizando el formateador de salida de LINQPad y está sobrecargado para permitirte especificar un encabezado:
typeof (int).Assembly.Dump ();
typeof (int).Assembly.Dump ("mscorlib");
También puede especificar una profundidad de recursión máxima para anular el valor predeterminado de 5 niveles:
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
Desensamblar () desensambla cualquier método en IL , devolviendo la salida en una cadena:
typeof (Uri).GetMethod ("GetHashCode").Disassemble().Dump();
Además de esos dos métodos de extensión, hay algunos métodos estáticos útiles en LINQPad.Util. Estos están documentados en autocompletado e incluyen:
- Cmd : ejecuta un comando de shell o un programa externo
- CreateXhtmlWriter : crea una grabadora de texto que usa el formateador Dump () de LINQPad
- SqlOutputWriter - devuelve el escritor de texto que escribe en la ventana de salida de SQL
- GetMyQueries , GetSamples : devuelve una colección de objetos que representa sus consultas / muestras guardadas (por ejemplo, ejecute una búsqueda usando Editar | Buscar todo)
- Resaltado : envuelve un objeto para que se resalte en amarillo cuando se lo deshace
- HorizontalRun : te permite volcar una serie de objetos en la misma línea
LINQPad también proporciona la clase HyperLinq. Esto tiene dos propósitos: el primero es mostrar hipervínculos comunes:
new Hyperlinq ("www.linqpad.net").Dump();
new Hyperlinq ("www.linqpad.net", "Web site").Dump();
new Hyperlinq ("mailto:[email protected]", "Email").Dump();
Puedes combinar esto con Util.HorizontalRun :
Util.HorizontalRun (true,
"Check out",
new Hyperlinq ("http://.com", "this site"),
"for answers to programming questions.").Dump();
Resultado:
Consulte este sitio para obtener respuestas a las preguntas de programación.
El segundo objetivo de HyperLinq es generar consultas dinámicamente:
// 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();
También puede escribir sus propios métodos de extensión en LINQPad. Vaya a ''Mis consultas'' y haga clic en la consulta llamada ''Mis extensiones''. Todos los tipos / métodos que se definen aquí son accesibles para todas las consultas:
void Main()
{
"hello".Pascal().Dump();
}
public static class MyExtensions
{
public static string Pascal (this string s)
{
return char.ToLower (s[0]) + s.Substring(1);
}
}
En 4.46 (.02) se han introducido nuevas clases y métodos :
- DumpContainer (clase)
- OnDemand (método de extensión)
- Util.ProgressBar (clase)
Además, la clase Hyperlinq ahora es compatible con un delegado de Action que se llamará cuando haga clic en el enlace, lo que le permite reaccionar en código y no solo vincularlo a páginas web externas.
DumpContainer es una clase que agrega un bloque en la ventana de salida que puede reemplazar sus contenidos.
¡NOTA! Recuerde .Dump() en el lugar apropiado.
Usar:
var dc = new DumpContainer();
dc.Content = "Test";
// further down in the code
dc.Content = "Another test";
OnDemand es un método de extensión que no generará el contenido de su parámetro en la ventana de salida, sino que agregará un enlace en el que se haga clic, que al hacer clic reemplazará el enlace con el contenido del parámetro .Dump() ed. Esto es ideal para estructuras de datos que a veces se necesitan, que son costosas o ocupan mucho espacio.
¡NOTA! Recuerde .Dump() los resultados de llamar a OnDemand en el lugar apropiado.
Para usarlo:
Customers.OnDemand("Customers").Dump(); // description is optional
Util.ProgressBar es una clase que puede mostrar una Util.ProgressBar progreso gráfica dentro de la ventana de salida, que puede modificarse a medida que el código avanza.
¡NOTA! Recuerde .Dump() el objeto Util.ProgressBar en el lugar apropiado.
Para usarlo:
var pb = new Util.ProgressBar("Analyzing data");
pb.Dump();
for (int index = 0; index <= 100; index++)
{
pb.Percent = index;
Thread.Sleep(100);
}