Browse by Tags

Tagged Content List
  • Blog Post: The Pain of deploying Primary Interop Assemblies

    Alright, first of all, what are Primary Interop Assemblies (PIAs), and why am I devoting an entire post to the pains caused by deploying these things? And secondly, how do they relate with what we’ve been talking about thus far? The answer to the second question is simple – we’ve been talking about COM...
  • Blog Post: Channel 9: Dynamic in C#

    Not too long ago, I did another Channel 9 video on Dynamic in C# with another compiler dev, Chris Burrows. In this video, we discuss the making of dynamic, as well as some of the drawbacks, design decisions, and philosophies behind the feature. Enjoy! link: http://channel9.msdn.com/posts/CharlieCalvert...
  • Blog Post: Com interop in C# 4.0: Indexed Properties

    One of the things I love about my job is that I get to make people happy. How do I do that? By giving them what they want of course! One of the things I don’t like so much about my job is going back on a decision that we made before, and having to revert some of the behavior. Well, we’ve been talking...
  • Blog Post: COM Interop in C# 4.0

    Wow, it’s been a while since I’ve last posted! Don’t worry, I’m still alive and kickin’, and we’re still workin’ on cool stuff for y’all to use. Let’s take a bit of a recap of how far we’ve come. We’ve chatted about dynamic binding in C# and how that all plays in with the DLR, and about named and optional...
  • Blog Post: Named and Optional arguments – ties and philosophies

    Okay, my attempt at a clever title failed… Ties and Philosophers? I oughtta stick with technical writing. :) We’re almost done with our chat about named and optional arguments. We’ve covered what the feature is about , and covered overload resolution in more detail . This time I want to do a quick wrap...
  • Blog Post: Named arguments and overload resolution

    Last time we talked about the basics of named arguments, optional arguments, and default values . From here on out, I’m just going to refer to the whole feature group as “named and optional arguments” – it’s just too much typing otherwise (we actually just refer to the feature as N&O internally)...
  • Blog Post: Named arguments, optional arguments, and default values

    C# 4.0 introduces the concept of optional parameter values into the language. Now, this has been a controversial subject in the past, and we have had many requests for the feature, but have traditionally stayed away from it. So, why now? Well, before we get into the philosophy of why we decided to add...
  • Blog Post: Dynamic in C# VII: Phantom Method Semantics

    By now, my hope is that you all have a well-rounded view of dynamic. We started this series by introducing dynamic and talking about the basics of the feature , and have just finished talking about some of the feature's limitations with the intent that giving both the good and the bad will help us gain...
  • Blog Post: Dynamic in C# VI: What dynamic does NOT do

    As I mentioned last time , there are a few gotchas that we'll need to look at in order to get a full understanding of the dynamic feature and its capabilities. Today we'll take a look at some of those limitations. As we go along, I'll try to shed some insights as to how the decision making process came...
  • Blog Post: Dynamic in C# V: Indexers, Operators, and More!

    Now that we're all experts in how dynamic invocations work for regular method calls, lets extrapolate from our previous discussion about phantom methods a bit and take a look at how those basic concepts apply to other dynamic operations. Today we'll just go through a laundry list of each type of operation...
  • Blog Post: Dynamic in C# IV: The Phantom Method

    Yes, this does sound like a Star Wars movie, but no, I'm not a Star Wars geek that just likes to pull lines from my favorite movies (though I rather enjoyed Star Wars). This post will deal with what we've coined "the phantom method". It's the method that the static compiler will bind to during...
  • Blog Post: Dynamic in C# III: A slight twist

    Last time we dealt with the basics of dynamic binding . This time, we'll add a small twist. First, lets recall the example we were using last time: static void Main( string [] args) { dynamic d = 10; C c = new C(); // (1) Dynamic receivers. d.Foo(); // Call. d.PropOrField = 10; // Property...
  • Blog Post: Channel 9!

    A few weeks ago, a few of us on the compiler team did a Channel9 interview, discussing some of the new features that we're working on and how they fit into the whole Visual Studio 2010 story. The video is now online ! In it, we talk in quite length about the dynamic feature, so if you've been following...
  • Blog Post: Dynamic in C# II: Basics

    Last time , we began to dive into dynamic binding in C# and what happens through the pipeline. This time, we'll take a simple scenario and pick apart the details of what happens under the covers, both during compile time and runtime. We can break down what the compiler does into three parts: type and...
  • Blog Post: Dynamic in C#

    The other day I was playing around with some office code, and I found myself writing a lot of code much like the following sample that Anders used at his PDC talk : static void Main( string [] args) { var xl = new Excel .Application(); (( Excel . Range )xl.Cells[1, 1]).Value2 = "Process Name"...
  • Blog Post: Microsoft Visual Studio 2010

    The cat's out of the bag! Hours ago at PDC '08 , I got to watch Anders unveiled the new C# 4.0 language features that we've been working on. This unveiling was accompanied by some fantastic demos of our work in action. Even though I've been working on this stuff for the past year, I was still completely...
Page 1 of 1 (16 items)