I suggest you ...

Save/restore queries on close or manually

I'm a multitasker, and I usually have 7 or 8 (or 20) tabs open in LINQPad. When I need to restart my computer, or for whatever reason close LINQPad, I *could* to save each of my queries (coming up with a meaningful name for each), remember which ones I had open, and reopen them one by one when I restart, but I find it's quicker and easier to just kill LINQPad with Task Manager so that it will offer to reload all my tabs for me automatically. I would be nice if LINQPad had the option to save and restore all queries on close/start, and/or the option to save and reload a group of queries at will.

229 votes
Vote
Sign in
Check!
(thinking…)
Reset
or sign in with
  • facebook
  • google
    Password icon
    I agree to the terms of service
    Signed in as (Sign out)
    You have left! (?) (thinking…)
    DaddyDaddy shared this idea  ·   ·  Admin →
    under review  ·  Joe AlbahariAdminJoe Albahari (Admin, LINQPad) responded  · 

    I need some feedback on this feature. First:
    (a) Would you expect it to apply only to untitled queries? Or:
    (b) Would you also expect it to apply to saved queries that were modified?
    (The reason I ask is that option (a) is simple to implement, whereas option (b) creates numerous complications.)

    32 comments

    Sign in
    Check!
    (thinking…)
    Reset
    or sign in with
    • facebook
    • google
      Password icon
      I agree to the terms of service
      Signed in as (Sign out)
      Submitting...
      • Anonymous commented  · 

        Pretty pretty please (b). Having this feature would pretty much mean my whole taskbar works the same way. (Notepad++, all the jetbrains stuff (phpstorm, datagrip, dotpeek etc), and chrome)

      • James CurranJames Curran commented  · 

        I was about to write that I'd be happy with (A), since saving a named file involves just clicking the toolbar icon --- then I realized that LINQPad doesn't have a "Save FIle" icon. GIve me that button, and I'd be happy with option (a).

      • AnonymousAnonymous commented  · 

        I wasn't kidding about buying LINQPad again for this feature. I've pre-emptively kept my word by just now buying a 2nd user license. GO LINQPAD!

      • PhilPhil commented  · 

        Joe: in response to your feedback request, I believe mimicking the behaviour of notepad++ would make the community happy, since then we wouldn't need to remember which application behaves in which manner

      • Carl KelleyCarl Kelley commented  · 

        I usually have many queries open in LINQPAD 5 when I close it. LINQPAD already prompts me whether to save modified queries before closing. What I'd really like it to do is re-open those queries when I restart LINQPAD so that I don't have to hunt around for them.

      • Anonymous commented  · 

        I vote for option (b). However, applying it to saved queries means that next time I open LINQPad, their state is all the same, the edits I made are still there, in the editor, but not in the files. A temporary version should be maintained at all times like in Sublime Text.

      • Drew NoakesDrew Noakes commented  · 

        Best option is to follow the lead of editors such as Notepad++ and Sublime Text:

        When the user closes and reopens the program _NOTHING CHANGES_.

        That is, all buffers are exactly as they were. Any unsaved changes are still unchanged.

        Once you use this feature for a bit, it feels amazing. There's no cognitive barrier to closing the program, because you know it'll be there when you get back. It mightn't be the easiest to implement, but it's not so bad in reality, and it truly is the gold standard in behaviour, IMHO.

      • Adam CAdam C commented  · 

        (b) -> I would expect it to act like other text / code editors, re-opening everything in the same order and same state as before, just like it does if the task is killed.

        It would also be nice sub-feature if we could choose where the session / autosave is stored. Occasionally my restored session is lost and some in-progress queries that I needed were also lost.

        Thanks

      • alopexalopex commented  · 

        but having to choose between a or b, I'd take b so as not to lose anything...
        (sorry I went a bit overboard in my previous answer)

      • alopexalopex commented  · 

        My personal use case is that I usually am in a context, tackling a specific problem (like "building a specific export/tool/whatever for client ABC", usually working at or for client ABC at that precise moment. Then at the end of the day, I close shop, ending up with dozens of opened tabs...

        During the night, the computer could reboot (the dreaded update, or whatever)... or I could have to run to school fetch the kids, or whatever, closing the computer in haste... risking losing all my tabs...

        Or in between work sessions for client ABC, there could a session for client DEF...

        Ideally, for me, I could just close the app, it would save the context of that specific moment, and I could reopen the app afterwards, choose the saved context from a list (by date, if not named, by name like "context client ABC" "work for DEF" or "ABC" and "DEF", If I took premptively the time to name that context, or change the name afterwards... ) and "voila" I would be back to the point I left.

        Optionally, context "ABC" from week04 would coexist with context "ABC" from week07... ;)

      • takeshiktakeshik commented  · 

        I vote for (b).
        Feature (a) is also nice, but, if there are both untitled files and modified saved files in the session, the behavior of (a) may cause some confusion.
        I think the behavior of (b) is easy to understand for users, because all unsaved modifications are kept.

      • DerekDerek commented  · 

        Option (a) is what what I am looking for.

      • Mark HurdMark Hurd commented  · 

        Mostly thinking of (b) here because that does seem to reflect the current functionality: when you kill LP from Task Manager that's the functionality I see.

      • Anonymous commented  · 

        Joe,

        If I had tabs open to saved documents (tabs that refer to specific files) then when I close LinqPad it should ask me if I want to save all documents, and if I say "yes" then it should attempt to save any documents that are open. If I have a bunch of "unsaved" documents then I should be able to cancel out of that "save" so that I can either save the "saved" documents, save all documents, close some documents, etc.

        Basically, the way I was envisioning it working (if I were adding this feature) is that every tab would have a file associated with it. The tabs that I explicitly saved or opened would be associated with the explicit file, the rest would be associated with temp files (somewhere). But they would be tagged as "unsaved" while they only point to a temp file. I would then store somewhere that I had these, for example, seven files loaded, four to "real" files and three to temp files.

        I believe this matches now Notepad++ works (though I've never looked into where NPP stores the "unsaved" files).

      • Michel BretschneiderMichel Bretschneider commented  · 

        Voting for b here.
        b) would be best (and final solution)
        a) still provides a significant improvement, so if b takes more time, going with a first and b after that would "deliver continuous value" here.

      • AnonymousAnonymous commented  · 

        I too am accustomed to Notepad++'s "remember everything" feature (b), but I would be happy to see (a) as a "90% solution" as others have stated.

      • Sean WrightSean Wright commented  · 

        Most of the time I'm creating queries that I need for a couple of sessions (restarts of my laptop or LINQPad) but not after that. So (A) would be awesome.

        (B) would be cool but I feel that if I've already saved a query I probably want to continue saving it, so being forced to save these isn't as necessary of a feature.

      • kjellskikjellski commented  · 

        I think what I would like to have would be best described as the behaviour that I know from Sublime Text:

        If I close the program, it just doesn't bother me. Everything stays the exact same way.

        Examples:
        A saved Query that was opened:
        A Query never saved:
        A Query once saved but modified:

        Get's opened and restored just like before, nothing is written do disk from the users perspective.

        The key point for me is: I never need to bother on closing the program, especially when I shut down my computer in a rush.

      ← Previous 1

      Feedback and Knowledge Base