Archive
Suggestion: If and while etc. clauses should accept bool? in C#
At TrackingCam app (http://TrackingCam.codeplex.com) I have the following WPF code, where cbTrackingPresenter is a CheckBox control defined in my MainWindow’s XAML:
private void cbTrackingPresenter_Checked(object sender, RoutedEventArgs e)
{
if (cbTrackingPresenter.IsChecked == true)
StartTrackingPresenter();
else
StopTrackingPresenter();
}
Note the (redundant in my opinion) == true pattern used there. If the == true is omitted, you get the compile-time error "CS0266", with message "Cannot implicitly convert type ‘bool?’ to ‘bool’. An explicit conversion exists (are you missing a cast?)"
Why not make the "if" clause (and "while" and any clause accepts a boolean/condition) more clever and have it accept bool? too? It would only fire the condition if the value is "true" (not if it is false or null) in that case.
You can vote for this suggestion at:
HowTo: show inner exception message if available, else outer one
Sometimes when you catch an exception in .NET, the message it prints out isn’t very informative, since it is wrapping another exception that had been thrown a bit inner in the code. That exception is in that case accessible via InnerException of the Exception instance.
That inner exception is also an Exception, so one would like to use its Message instead of the outer exception’s one, if an inner exception exists and, only if an inner exception doesn’t exist use the caught exception’s message. Here’s a clean-looking pattern I’ve coined up to achieve this while working on the TrackingCam application:
try
{
//…
}
catch (Exception e)
{
MessageBox.Show((e.InnerException ?? e).Message);
}
the ?? operator returns e.InnerException if it is not null, else falls back to returning e. Those two results are both of type Exception, so you can use Message on them, by putting the ?? operator’s expression in parentheses.
Suggestion: C# static extension methods invokable on class type too
it would be nice if C# supported syntax like:
public static DependencyProperty Register(static DependencyProperty x, string name, Type propertyType, Type ownerType, FrameworkPropertyMetadata typeMetadata)
that is static extension methods for classes, that can be invoked without a class instance (just with the class type), apart from normal extension methods that can be invoked on a class instance.
Then for example I could use it in Silverlight to add to its DependencyProperty class some extra WPF syntax that it currently misses, in order to increase code portability. It would wrap Dr.WPF’s implementation of value coercion for Silverlight’s DependencyProperty. I have the related code at my Compatibility library (http://Compatibility.codeplex.com) and respective NuGet package (http://nuget.org/packages/Compatibility), but the syntactic sugar is missing to achieve source code portability (via WPF and Silverlight projects that include common files via file links) without changes.
Note the "static DependencyProperty" parameter instead of the "this DependencyProperty" one that is used in C# extension methods (or else instead of static maybe they could use other keyword like type or typeof there, but I feel static is more appropriate).
Related discussion:
http://stackoverflow.com/questions/866921/static-extension-methods
http://stackoverflow.com/questions/249222/can-i-add-extension-methods-to-an-existing-static-class
Also see https://visualstudio.uservoice.com/forums/121579-visual-studio-2015/suggestions/2060313-c-support-static-extension-methods-like-f where somebody mentions "static extension properties" apart from "extension properties". Indeed it is natural that if static extension methods are to be allowed in the future, static extension properties should be added too (to extend a type with [attached] static properties)
You can vote for a related suggestion here:
HowTo: Pause and Resume Speech Recognition with Microsoft engines
At SpeechTurtle application, I’ve just added speech feedback (voicing of a command) when an available command is executed using a mouse click on its name.
That could also help the user learn the expected pronunciation in English in case the speech recognition engine doesn’t understand some of the commands as voiced by the user. One can assume most of what the Speech Synthesis engine outputs to be recognizable by the Speech Recognition engine.
An issue with this approach though, is that the Speech Recognition can be fired accidentally by the speech synthesis commands, if the speech recognition engine doesn’t handle this case automatically, ignoring synthesized speech that is being generated in parallel by the speech engine.
In fact this can also be a security issue, with a malicious agent delivering voice commands to your system via some audio or video file/stream they lure you into listening/watching, or some web page they lure you into visiting (even if a webpage is not malicious, it might have been served and hosting a malicious ad by an ad network).
So, we need some way to pause the speech recognition while speaking, to avoid misfiring of recognition, since from my experience, the speech synthesis and recognition engines from .NET’s System.Speech namespace on recent Windows versions (tried with Windows 10) do have this issue.
In SpeechLib (that SpeechTurtle uses via the SpeechLib NuGet package), I’ve added commands Pause and Resume to the ISpeechRecognition interface (defined in SpeechLib.Models project and respective NuGet package and implemented at SpeechLib.Recognition and SpeechLib.Recognition.KinectV1 projects and NuGet packages).
So, in SpeechTurtle, I can do:
public void SpeakCommand(string command) {
speechRecognition.Pause(); //pause the speech recognizer
speechSynthesis.Speak(command);
speechRecognition.Resume();
}
Note the pattern used in SpeechRecognition.cs to retry 10 times to pause the speech recognition engine, since errors are thrown if one tries to Stop it or Set its audio input to none while it is trying to perform some recognition.
public void Pause() { for (int i=0; i<10; i++) //(re)try 10 times
//(since we wait 100 ms at failure below before retrying, max wait is 1000ms=1sec) try { SetInputToNone(); return; //exit retry loop if succeeded } catch //catch and ignore any error saying that recognition is currently running { Thread.Sleep(100); //retry in 100ms } }
Update 1:
After more testing, it seems the above approach with the loop and try/catch won’t work
if one uses the async versions of Speech Recognition methods, since the exceptions are thrown from another thread. In that case one need to add a global exception handler.
Update 2:
After lots of trial and error, I ended up with this working pattern for Pause and Resume in SpeechLib’s SpeechRecognition.cs (note that paused is a bool(ean) field of that class, defaulting to false and PAUSE_LOOP_SLEEP is a const(ant) int(eger) set to 10 (msec):
public void Pause() {
paused = true; speechRecognitionEngine.RequestRecognizerUpdate(); } public void Resume() {
paused = false;
}
At the constructor of that SpeechRecognition class I do:
speechRecognitionEngine.RecognizerUpdateReached +=
(s, e) => { while (paused) Thread.Sleep(PAUSE_LOOP_SLEEP); };
I do a loop at RecognizerUpdateReached event handler to make sure the Speech Recognition
thread is waiting for the pause field to change value back to false. That event occurs after the call to RequestRecognizerUpdate in Pause method (which is done after first setting paused=true there).
HowTo: Get and combine executable path with subfolder and filename
Based on others answers at
here’s an example that shows how to remove the executable name from the path and combine the result with some subfolder and filename:
At my updated version of Hotspotizer (http://github.com/birbilis/Hotspotizer), I’ve just added support for loading a Gesture Collection file at startup, if found at Library\Default.hsjson, by using the following code:
const string GESTURE_COLLECTION_LIBRARY_PATH = "Library"
const string DEFAULT_GESTURE_COLLECTION = "Default.hsjson"
//...
LoadGestureCollection(
Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location),
GESTURE_COLLECTION_LIBRARY_PATH,
DEFAULT_GESTURE_COLLECTION));Difference between LocalizableAttribute and LocalizabilityAttribute in .NET
I’ve just updated an older answer of mine at:
In case you’re wondering too what’s the difference between Localizable and Localizability attributes in .NET, maybe this helps a bit:
https://msdn.microsoft.com/en-us/library/ms753944(v=vs.100).aspx
- LocalizableAttribute – Specifies whether a property should be localized
- LocalizabilityAttribute – Specifies the localization attributes for a binary XAML (BAML) class or class member
Seems the Localizability attribute is BAML-specific and makes sure localization-related comments (probably to make use by localization tools and show to the translators) are preserved/exposed when WPF XAML is compiled from text XML form into binary BAML.
Suggestion: Visual Studio should offer to implement callbacks
I type-in new PropertyMetadata(OnCenterXPropertyChanged) but since I haven’t yet implemented On…, I get a suggestion by the IDE to implement it but it suggests to add field, property or read-only field, not to implement the callback for me with the given name. It can find the method signature needed from the delegate that PropertyMetadata (one of its overloaded versions) expects.
It came to me while I was trying to implement Silverlight’s CompositeTransform for WPF:
public static readonly DependencyProperty CenterXProperty =
DependencyProperty.Register("CenterX", typeof(double),
typeof(CompositeTransform),
new PropertyMetadata(OnCenterXPropertyChanged));
for the Compatibility library I maintain at http://github.com/zoomicon/Compatibility. I have used that library a lot in ClipFlair to maintain a common C# source and XAML between Silverlight and WPF projects (I do code sharing between projects via linked files).
Can vote for this suggestion at:
Suggestion: Initialize multiple fields to same value at constructor call in C#
When using http://github.com/zoomicon/ZUI I would like to write:
FloatingWindow window = new FloatingWindow()
{
Content = display,
Title = IconText = title
};
but I have to write:
FloatingWindow window = new FloatingWindow()
{
Content = display,
Title = title,
IconText = title
};
instead. For consistency, I’d prefer that it supported such assignment. Now it thinks IconText is some external field or similar
you can vote for this suggestion at:
Gotcha: WPF UserControl SizeChanged event not firing at resizing
Useful to know:
If you set the Width and Height on the UserControl though, you have set a fixed size and thus even if its parent tool window changes size, the UserControl never will. You should not set Width and Height on the UserControl if you want that event to be raised as the parent tool window changes size.
from:
http://www.actiprosoftware.com/community/thread/20365/size-change-event-for-the-usercontrol
HowTo: Remove unused references and using clauses in Visual Studio
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:
https://www.jetbrains.com/resharper/help/Refactorings__Remove_Unused_References.html
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
George Birbilis @zoomicon 