Quelqu'un at-il une liste complète des LINQPad extension modes et méthodes, telles que
Très apprécié !
Réponses
Trop de publicités?
LINQPad définit deux méthodes d'extension (en LINQPad.Extensions), à savoir l' Dump() et Disassemble(). Dump() écrit à la fenêtre de sortie à l'aide de LINQPad de sortie du module de formatage et est surchargé pour vous permettre de spécifier un en-tête:
typeof (int).Assembly.Dump ();
typeof (int).Assembly.Dump ("mscorlib");
Vous pouvez également spécifier un maximum de profondeur de récursion pour remplacer la valeur par défaut de 5 niveaux:
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
Démonter() démonte une méthode pour l' IL, de retourner le résultat dans une chaîne de caractères:
typeof (Uri).GetMethod ("GetHashCode").Disassemble().Dump();
En plus de ces deux méthodes d'extension, il existe quelques méthodes statiques dans LINQPad.Util. Ceux-ci sont documentés dans l'auto-complétion, et comprennent:
- Cmd - exécute une commande shell ou un programme externe
- CreateXhtmlWriter - crée un texte de l'écrivain qui utilise LINQPad du Dump() formateur
- SqlOutputWriter - renvoie le texte de l'écrivain qui écrit pour le SQL de la fenêtre de sortie
- GetMyQueries, GetSamples - retourne une collection d'objets représentant vos requêtes enregistrées / échantillons (par exemple, exécuter une recherche à l'aide de la commande Modifier | Recherche de Toutes les)
- Mettez en surbrillance - enveloppe un objet de sorte qu'il sera surligné en jaune lorsque l'objet de Dumping
- HorizontalRun - vous permet de vider une série d'objets sur la même ligne
LINQPad fournit également la HyperLinq classe. Cela a deux objectifs: le premier est à l'affichage ordinaire des liens hypertexte:
new Hyperlinq ("www.linqpad.net").Dump();
new Hyperlinq ("www.linqpad.net", "Web site").Dump();
new Hyperlinq ("mailto:user@domain.com", "Email").Dump();
Vous pouvez combiner cela avec Util.HorizontalRun:
Util.HorizontalRun (true,
"Check out",
new Hyperlinq ("http://stackoverflow.com", "this site"),
"for answers to programming questions.").Dump();
Résultat:
Découvrez ce site pour des réponses à des questions de programmation.
Le deuxième but de HyperLinq est de créer dynamiquement des requêtes:
// 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();
Vous pouvez également écrire vos propres méthodes d'extension dans LINQPad. Allez à "Mes Requêtes" et cliquez sur la requête "Mes Extensions". Tous les types méthodes qui définissent ici sont accessibles à toutes les requêtes:
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) nouvelles classes et de nouvelles méthodes ont été introduites:
- DumpContainer (classe)
- OnDemand (méthode d'extension)
- Util.ProgressBar (classe)
En outre, la Hyperlinq classe prend désormais en charge d'une Action de délégué qui sera appelée lorsque vous cliquez sur le lien, vous permettant de réagir dans le code et pas juste un lien externe des pages web.
DumpContainer est une classe qui ajoute un bloc dans la fenêtre de sortie qui peut avoir son contenu remplacé.
REMARQUE! N'oubliez pas de .Dump() le DumpContainer lui-même dans l'endroit approprié.
Pour l'utiliser:
var dc = new DumpContainer();
dc.Content = "Test";
// further down in the code
dc.Content = "Another test";
OnDemand est une méthode d'extension qui n'aura pas de sortie le contenu de son paramètre de la fenêtre de sortie, mais au lieu d'ajouter un lien cliquable, qui lorsqu'il est cliqué remplacera le lien avec l' .Dump()ed contenu du paramètre. Ce qui est excellent pour parfois besoin de structures de données qui est coûteux et prend beaucoup d'espace.
REMARQUE! N'oubliez pas de .Dump() les résultats de l'appel d' OnDemand dans l'endroit approprié.
Pour l'utiliser:
Customers.OnDemand("Customers").Dump(); // description is optional
Util.ProgressBar est une classe qui peut afficher un graphique de la barre de progression à l'intérieur de la fenêtre de sortie, qui peut être changé que le code se déplace sur.
REMARQUE! N'oubliez pas de .Dump() l'Util.ProgressBar objet à l'endroit approprié.
Pour l'utiliser:
var pb = new Util.ProgressBar("Analyzing data");
for (int index = 0; index <= 100; index++)
{
pb.Percent = index;
Thread.Sleep(100);
}
Matt
Points
3445
Outre le bien-connu, myQuery.Dump("Query result:"), une autre fonctionnalité cachée de mentionner, c'est l' Util classe: Il contient de nombreuses très pratique méthodes (que je viens de mentionner certains d'entre eux que j'ai trouvé utile, mais il y a de plus).
Aussi intéressant est que vous pouvez facilement modifier la façon dont Dump() travaux.
Enfin, je vais vous montrer comment vous pouvez faire des changements permanents (c'est à dire insérer, mettre à jour, supprimer des requêtes LINQ) à l'aide d' SubmitChanges() ainsi que la façon dont vous pouvez accéder à la connexion interne de l'objet de LinqPad.
Alors, voici la liste des fonctionnalités:
Util.WriteCsv
(nouveau: disponible depuis LinqPad version v4.45.05 (beta))
Util.WriteCsv (Customers, @"c:\temp\customers.csv");
Cela permettra d'écrire le contenu de la table Customers le fichier CSV c:\temp\customers.csv. Vous pouvez également trouver un bel exemple, comment utiliser Util.WriteCsv puis afficher les données au format CSV, en Linqpad de la fenêtre de résultat ici.
Conseils:
Si la table est grande, utilisez
ObjectTrackingEnabled = false;avant d'écrire le CSV afin d'éviter la mise en cache en mémoire.Si vous voulez sortir un tableau en format XML plutôt que comme un fichier délimité par des virgules, consultez ce lien pour des exemples de code.
Util.GetPassword
var pwd = Util.GetPassword("UserXY");
Cela permettra de récupérer le mot de passe de LinqPad intégré dans le gestionnaire de mot de passe. 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.
Les avantages sont que vous pouvez stocker le mot de passe dans le LinqScripts vous créez en toute sécurité, séparément et chiffré dans Windows profil de l'utilisateur. LinqPad utilise Windows DPAPI pour protéger le mot de passe.
Aussi, le mot de passe sont stockées 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éé.
Util.Cmd
Cette méthode fonctionne comme un processeur de commande. Vous pouvez appeler toutes les commandes que vous connaissez de la console Windows, comme dir:
Util.Cmd(@"dir C:\");
Ceci affichera le résultat de l'annuaire sans la nécessité d' .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 permettra de vider tous les fichiers avec les extensions de fichier ".exe" ou ".dll" figurant dans l' C:\windows\system32. L' /s commutateur est utilisé de manière récursive tous les sous-répertoires et /b est utilisé pour les nus format de sortie. Notez que le deuxième paramètre de la Cmd méthode est spécifiée pour supprimer la sortie de la console pour afficher uniquement les résultats filtré à l'aide de la méthode de Vidage.
Vous pouvez voir que c'est plus souple que les jokers que vous avez avec dir car vous pouvez l'utiliser toute la flexibilité de Linq du moteur de recherche.
Util.Image
Affiche les 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.Progrès
À l'aide de Util.ProgressBar vous permet d'afficher une barre de progression. Vous pouvez utiliser les méthodes suivantes de la classe 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;
}
}
}
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);
}
Alternativement, vous pouvez utiliser Util.Progress de la mise à jour LinqPads intégrée de la barre de progression, par exemple:
Util.Progress = 25; // 25 percent complete
La différence est qu'elle ne s'affiche pas dans la fenêtre de résultats, et vous ne pouvez pas affecter un message.
Util.RawHtml
Affiche le code HTML dans la fenêtre de sortie. Exemple:
Util.RawHtml (new XElement ("h1", "This is a big heading")).Dump();
Hyperlinq, Util.HorizontalRun
Vous pouvez utiliser cet exemple de fonction
public void ShowUrl(string strURL, string Title)
{
Action showURL = delegate() { Process.Start("iexplore.exe", strURL); };
var url = new Hyperlinq(showURL, "this link", true);
Util.HorizontalRun (true, "Click ", url, " for details.").Dump(Title);
}
pour afficher les liens hypertexte dans la fenêtre de résultat - ou toutes les actions comme ouvrir votre éditeur préféré. Utilisation:
ShowUrl("http://stackoverflow.com", "Check out StackOverflow");
Notez que cette fonction fonctionne toujours, alors que new Hyperlinq ("http://myURL", "Web site").Dump(); ne fonctionne pas pour certains type d'Url (en particulier, si vous devez passer le port des noms comme ":1234" comme partie de l'URL).
Util.ReadLine
Lit d'entrée de la console. Exemple:
int age = Util.ReadLine<int> ("Enter your age");
Comme un synonyme d' Util.ReadLine<string>(), vous pouvez utiliser Console.ReadLine() .
Mais il n'y est plus! Vous pouvez créer un simple parser JSON avec l'extrait suivant - très utile, par exemple si vous souhaitez analyser et de tester une chaîne JSON à la volée. Enregistrer l'extrait de code suivant comme JSONAnalyzer.linq à l'aide d'un éditeur de texte , puis l'ouvrir dans LinqPad (c'est d'ajouter les références facilement à la volée):
<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");
}
Maintenant, vous pouvez l'exécuter et il suffit de coller une chaîne JSON à partir du presse-papiers dans la console il va utiliser l' Dump pour l'afficher comme un objet bien - et vous obtenez également les messages d'erreur de l'analyseur sur l'écran pour résoudre les problèmes. Très utile pour le débogage AJAX.
Util.ClearResults
Si vous avez besoin d'effacer la fenêtre de résultats à l'intérieur de votre script, utilisez:
Util.ClearResults();
Le choix de l'utiliser au début de votre script, ou - si vous êtes en cours d'exécution de plusieurs requêtes dans un script, vous devez attendre que la saisie de l'utilisateur avant de masquage de l'écran (par exemple, en le faisant précéder d' Util.ReadLine).
La coutume .Dump() - ICustomMemberProvider
Il est également intéressant, que vous pouvez influencer la sortie de l' .Dump() méthode. Simplement implémenter l'interface ICustomMemberProvider, par exemple
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");
puis elle sortie de l' Hint, constMember1, constMember2, et myprop, mais pas la propriété xyz:
Afficher une MessageBox dans LinqPad
Si vous avez besoin d'afficher une messagebox, regardez ici comment le faire.
Util.Exécuter
(nouveau: disponible depuis LinqPad version v4.52.1 (beta))
Vous permet d'exécuter un autre LINQPad script à partir de l'intérieur de votre script ou au sein de votre propre .NET programme ou d'un service Windows (en référence à la LINQPad4-AnyCPU version de LINQPad.exe). Il exécute le script tout comme l'outil de ligne de commande lprun.exe le ferait.
Exemples:
const string path=@"C:\myScripts\LinqPad\";
var dummy=new LINQPad.QueryResultFormat(); // needed to call Util.Run
Util.Run(path+"foo.linq", dummy);
Cet exemple exécute le script foo.linq, qui contient l'exemple de code suivant:
void Main(string[] args)
{
#if CMD
"I'm been called from lprun! (command line)".Dump();
#else
"I'm running in the LINQPad GUI!".Dump();
args = new[] { "testhost", "test@foo.com", "test@foo.com", "Test Subject" };
#endif
args.Dump("Args");
}
Il permet de distinguer si le script a été exécuté à partir de l'intérieur de la LinqPad GUI ou via lprun.exe ou avec Util.Run.
Remarque: 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()
Si vous utilisez LinqToSQL, vous voudrez peut-être faire des changements permanents ( insert/update/delete).
Depuis le contexte de base de données est implicitement faite par LinqPad, vous devez appeler SubmitChanges() après chaque modification comme indiqué ci-dessous.
Exemples de (LinqPad-)les Comptoirs de la base de données:
Insérer
var newP = new Products() { ProductID=pID, CategoryID=cID,
ProductName="Salmon#"+pID.ToString() };
Products.InsertOnSubmit(newP);
SubmitChanges();
Mise à jour
var prod=(from p in Products
where p.ProductName.Contains("Salmon")
select p).FirstOrDefault();
prod.ProductName="Trout#"+prod.ProductID.ToString();
SubmitChanges();
Supprimer
var itemsToDelete=Products.Where(p=> p.ProductName.Contains("Salmon") ||
p.ProductName.Contains("Trout"));
foreach(var item in itemsToDelete) { Products.DeleteOnSubmit(item); }
SubmitChanges();
Remarque: afin d'obtenir valide Id pour les exemples précédents, vous pouvez utiliser:
var cID = (from c in Categories
where c.CategoryName.Contains("Seafood")
select c).FirstOrDefault().CategoryID;
var pID = Products.Count()+1;
avant de vous appeler.
c'.Connexion
À l'aide de LinqPad avec OleDb, la conversion d'une datatable pour objet Linq
L'extrait de code suivant vous permet d'utiliser LinqPad avec OleDb. Ajouter System.Data.OleDb de la System.Data de l'assemblée à l'propriétés de la requête, puis collez le code suivant dans Main():
var connStr="Provider=SQLOLEDB.1;"+this.Connection.ConnectionString;
OleDbConnection connection = new OleDbConnection(connStr);
DataSet myDataSet = new DataSet();
connection.Open();
string sql = @"SELECT * from Customers";
OleDbDataAdapter DBAdapter = new OleDbDataAdapter();
DBAdapter.SelectCommand = new OleDbCommand(sql, connection);
DBAdapter.Fill(myDataSet);
myDataSet.Dump();
Maintenant, ajoutez un SqlServer connexion à LinqPad et ajouter la base de données Northwind pour exécuter cet exemple.
Vous pouvez même convertir myDataSet dans Linq, les réponses à la question suivante montrer comment le faire: Nice exemples d'utilisation .NET 4 dynamique de mots clés avec Linq
Pour en savoir plus: Joe site web pour LinqPad est toujours une excellente source. À l'intérieur de LinqPad, Help -> What's New vous donne des conseils sur de nouvelles fonctions et de méthodes. Le LinqPad Forum contient également des conseils utiles.
John
Points
904
Dump est une méthode d’extension mondiale et SubmitChanges provient de l’objet DataContext qui est un objet de System.Data.Linq.DataContext.
LP ajoute uniquement Dump et démonter autant que je sache. Bien que je recommande fortement ouvrant dans le réflecteur pour voir quoi d’autre est là qui peut être utilisé. Une des choses plus intéressantes est l’espace de noms LINQPad.Util qui a quelques goodies utilisés en interne par LINQPad.
