The Visual Studio goes away

Sometimes I wonder if I have a natural gift for finding bugs in visual studio, or just bad luck. I’ll be typing along and then… no visual studio. Today I found my fifth type of magic phrase to make visual studio go away. Paste this anywhere inside visual basic code in the visual studio 2012 release candidate:

    Class C(Of T)
        Shared Widening Operator CType(value As T) As C(Of T)
            Return Nothing
        End Operator
        Async Function Wrap(Of T)(task As System.Threading.Tasks.Task(Of T)) 
                        As System.Threading.Tasks.Task(Of C(Of T))
            Return await task
        End Function
    End Class

Since VB is continuously compiling in the background the bug triggers almost immediately, instead of later when you manually build the project. It appears that the implementation of ‘async’ in VB doesn’t like some types of implicit casts.

Hopefully Microsoft will fix this bug (I submitted it to Connect), as well as the other instabilities in the VS2012 RC, before the full release.

Comments are closed.

Twisted Oak Studios offers consulting and development on high-tech interactive projects. Check out our portfolio, or Give us a shout if you have anything you think some really rad engineers should help you with.

Archive

• strilanc
• What Quantum Computers Do Faster, with Caveats
• Naming Things: Fail-Useful
• Detecting Simple Cycles Forming, Faster
• Third Party Bit Commitment
• Angular Velocity is Simple
• Collection Equality is Hard
• Deadlocks in Practice: Don’t Hold Locks While Notifying
• Brute Force Parallelization
• A Year’s Worth of Opinions about Objective-C
• Referencing Substrings Faster, without Leaking Memory
• Not Crying Over Old Code
• Exploring Universal Ternary Gates
• Impractical Experiments #2: Securing Peer to Peer Fog of War against Map Hacks
• Achieving Exponential Slowdown by Enumerating Twice
• Using Immortality to Kill Accidental Callback Cycles
• Cancellation Tokens (and Collapsing Futures) for Objective-C
• Visualizing the Eigenvectors of a Rotation
• Collapsing Futures in Objective-C
• Bug Hunting #1: Garbled Audio from End to End
• Impractical Experiments #1: Representing Numbers as Polynomials
• Implementing Quantum Pseudo-Telepathy
• Turn On Your Damn Warnings
• Big-O Made Trivial
• Unfathomable Bugs #7: The Broken Oven
• Solomonoff’s Mad Scientist
• Yearly Blogging Roundup #1
• What isn’t a Monad
• Searching a Sorted Matrix Faster
• How to Read Nested Ternary Operators
• Making Sublime Text 2 Jump to the Correct Line with Unity on OS X
• My Bug, My Bad #4: Reading Concurrently
• Whole API Testing with Reflection
• Optimizing a Parser Combinator into a memcpy
• Don’t Treat Paths Like Strings
• Breaking a Toy Hash Function
• Counting Iterators Lazily
• Unfathomable Bugs #6: Pretend Precision
• My Bug, My Bad #3: Accidentally Attacking WarCraft 3
• Collapsing Types vs Monads (followup)
• Collapsing Futures: Easy to Use, Hard to Represent
• Eventual Exceptions vs Programming in a Minimal Functional Style
• The Mystery of Flunf
• Explain it like I’m Five: The Socialist Millionaire Problem and Secure Multi-Party Computation
• Computer Science Blows My Mind
• A visit to Execution Labs in Montréal
• Transmuting Dice, Conserving Entropy
• Rule of Thumb: Ask for the Clock
• Rule of Thumb: Use Purposefully Weakened Methods
• Rule of thumb: Preconditions Should be Checked Explicitly
• Intersecting Linked Lists Faster
• Mouse Path Smoothing for Jack Lumber
• My Bug, My Bad #2: Sunk by Float
• Repeat Yourself Differently
• Grover’s Quantum Search Algorithm
• Followup to Non-Nullable Types vs C#
• Optimizing Just in Time with Expression Trees
• When One-Way Latency Doesn’t Matter
• Determining exactly if/when/where a moving line intersected a moving point
• Emulating Actors in C# with Async/Await
• Making an immutable queue with guaranteed constant time operations
• Improving Checked Exceptions
• Perishable Collections: The Benefits of Removal-by-Lifetime
• Decoupling shared control
• Decoupling inlined UI code
• Linq to Collections: Beyond IEnumerable<T>
• Publish your .Net library as a NuGet package
• When null is not enough: an option type for C#
• Unfathomable Bugs #5: Readonly or not
• Minkowski sums: examples
• My Bug, My Bad #1: Fractal Spheres
• Working around the brittle UI Virtualization in Windows 8
• Encapsulating Angles
• Unfathomable Bugs #4: Keys that aren’t
• How would I even use a monad (in C#)?
• Useful/Interesting Methods #1: Observable.WhenEach
• Unfathomable Bugs #3: Stringing you along
• Anonymous Implementation Classes – A Design Pattern for C#
• Tasks for ActionScript 3 – Improving on Event-Driven Programming
• Minkowski sums and differences
• Non-Nullable Types vs C#: Fixing the Billion Dollar Mistake
• Unfathomable Bugs #2: Slashing Out
• Script templates and base classes
• Unity font extraction
• Abusing “Phantom Types” to Encode List Lengths Into Their Type
• Constructive Criticism of the Reactive Extensions API
• Quaternions part 3
• Quaternions part 2
• Quaternions part 1
• Unfathomable Bugs #1: You can have things! You can have things IN things! You can have …
• Coroutines – More than you want to know
• Asset Bundle Helper
• The Visual Studio goes away
• .Net’s time traveling StopWatch
• Introducing Catalyst