For some time now, I was getting very annoyed while copy-pasting content from other software into Microsoft Word 2010. I would press CTRL+C at some other software and then would press ALT+TAB to go into an open Word document and press CTRL+V to paste, but it would not. So I had to move my fingers far away to SHIFT+INSERT to paste.
Today had enough so after some Google search on it, found the best fix by Moshe Eschel at:
To "restore" word to the way you remember, you need to go to, File->Options->Customize Ribbon On the bottom there is a label "Keyboard Shortcuts" and a button "Customize…" – click it
On the Categories box, scroll until you find "All Commands" and select it. Now, from the right box select the following Command: EditCopy Look at the "Current Keys" Box you will see "Ctrl+Insert" which is the NEW mapping now put your cursor in the "Press new shortcut key" and Press Ctrl+C, a button on the bottom named Assign will light up, and you click on it.
Do the same for all the shortcuts you like, such as EditPaste, EditUndo, EditRedo, EditCut, SelectAll etc.
Wonder why Microsoft didn’t add both the old and new shortcuts there, since it seems the dialog does support it. What a huge oversight, having Microsoft Word try to impose a shortcut from Macs (as it seems) to longtime Windows users (especially when other software the user works with use other set of shortcuts for copy-paste).
Moreover, the option to reassign the shortcut keys was very deeply hidden, hard for the average user to find it by themselves (couldn’t find it either and I don’t consider myself an average user).
Even more pathetic was the default shortcut key for Select All (usually Ctrl+A). It was Ctrl+5 and Ctrl+Clear (Numeric keyboard 5). What the heck Microsoft?
If you previously had a new Windows 10 build installed in your computer and then reverted back to an older build, you’ll lose access to the new build and it’ll no longer be offered as an upgrade option. Deleting the number for that build from the list at HKEY_LOCAL_MACHINE\SOFTWARE\
Microsoft\WindowsSelfHost\Applicability\RecoveredFrom key in Registry Editor seems to restore the ability to upgrade. Thanks to our reader "thedicemaster" for this info…
This is useful to know and unfortunately it means that some users may get stuck to an older Windows 10 version. Unless Microsoft has it set like that so that they’ll get automatically the next Windows build (ship the one they were trying to install hoping it fixed the issue they were having). Of course this will work if Microsoft keeps on pushing new builds often, not if they end up updating the OS build once a year or more rare in the future as Windows 10 matures.
To open Registry Editor you can click the Search icon (next to the Windows Start menu icon) at the Windows 10 Taskbar and write RegEdit.exe, then it should offer you a result that says “Run command” that you can click to launch it.
After that, expand the respective tree nodes (that is HKEY_LOCAL_MACHINE, then SOFTWARE, then Microsoft, then Windows, then WindowsSelfHost) from the side pane and right click and delete the “RecoveredFrom” node.
Then try Windows Update again from State menu / Settings / Update & Security and tell it again to check for updates. In case it still doesn’t offer the updates, wait for 1-2 days and try again.
I recently posted a list of the VS2015 extensions I use on my main machine at: https://zoomicon.wordpress.com/2015/11/13/visual-studio-2015-extensions-i-use/
From that list of extensions I use the Productivity Power Tools one, it has a "Power Commands > Remove and Sort Usings" action that one can right click and run on the whole solution. Much easier than opening it for each
There is another nice extension called ResolveUR that is not available for VS2015, but only for VS2013 (think you can edit its .vsix and make it work for it too though, see the process for other similar extension explained at https://devio.wordpress.com/2014/12/03/remove-unused-references-with-visual-studio-2013/). I usually open up the solution in VS2013 too just to run that. Resharper also has such functionality as shown at:
Alternative is to use the Copy References extension and right click a reference under the References subtree of a project, then select "Copy Reference", then Remove the reference and rebuild that project. If rebuild fails, then right click at the References again and select Paste Reference. Then repeat till you remove all references that are not needed
In fact one should FIRST remove all unused using clauses and THEN remove unused references. That is because some files like App.xaml.cs, AssemblyInfo.cs may have using clauses that they don’t really use. So unless those using clauses are removed, the compiler thinks respective references to assemblies those namespaces were at are needed
My comment at:
It would be nice indeed if one could define at the client object’s side a static interface that is a subset of the methods of a server (or serving if you prefer) object (it is only the view of the server that the client has gained knowledge of) that has been passed on to the client
Then there could be a service (a facility I mean) that accepts the server object instance and the interface the client has defined (the duck type) and case the server object to that interface by CHECKING that the duck interface is indeed a subset of the methods the server object implements
the check if our duck interface is indeed covered by what the object to be duck-typed offers can be implemented via reflection already
the implementation could be hacked by spitting out a new object (bytecode generation) that wraps each property/method of the object to be duck-typed and calls into the original object, but it would be much better if there was support in the compiler for that (viewing an object via an interface that is compatible to it in functionality, not in strong typing concept)
…when I say support in the compiler, I mean to avoid the proxying layer (of course security should also be considered carefully when implementing such a thing, in case there are pitfalls)
A very interesting article on the subject showing how to do DuckTyping in .NET is:
Not sure if in the time that has passed (5 years) there have been any DuckTyping-specific additions at C#/.NET
It is rather unfortunate that C# doesn’t support constants in interfaces, whereas Java does.
If IL (intermediate language) that C# usually compiles to (when not using AOT that is like in .NET Native or Xamarin iOS) doesn’t support this, then the compiler could create a special sealed class to carry the constants.
Then, wherever they’re used via the interface it could get them via that class. This would happen internally without the programmer noticing. The programmer should be able to access the constants using:
SomeClass.SomeConstant, where SomeClass implements ISomeInterface
just SomeConstant when the code is inside the body of SomeClass that implements the ISomeInterface
just SomeConstant when there is a “using static” statement (that newer C# has introduced) like “using static ISomeInteface” or “using static ISomeClass”
You can vote up this suggestion at:
It would be nice if one could write in C# (and maybe in other .NET languages too):
s = s.SomeMethodOfS(…)…
s .= SomeMethodOfS(…)…
that is to have a .= operator, similar to += and other shorthand experession operators
see screenshot for an example usecase from the opensource project FoscamController
Ideally, usage of such operators should lead to compiling – whether is is via JIT (Just in Time) or AOT (Ahead of Time) compilation – into more optimized native code, but I’m not sure if C# compilers are exploting that optimization opportunity.
You can vote up this suggestion at: