Tag: .NET Framework from The Visual Studio Blog

How to Convince Your Management to Upgrade to Visual Studio 2017 for C# and C++ Developers

Kasey UhlenhuthJuly 31, 2018Jul 31, 201807/31/18

Visual Studio 2017 is our best IDE yet. To help you write great code, it’s packed with new Refactorings and Quick Actions, and offers unit testing, debugging, navigation, and code style improvements. It loads solutions faster than ever, and ships with C# 7.3 and the MSVC compiler toolset that conforms to the latest C++ standards.

The .NET Journey: Recapping the last year

Visual Studio BlogDecember 10, 2015Dec 10, 201512/10/15

Having just completed Connect(); // 2015, we thought to take a moment to review everything that’s happened with .NET over the last year, between last year’s and this year’s Connect();. And what a year it’s been! We’ve seen significant developments in the .NET Framework,

Visual Studio Update 1 RTM

Visual Studio BlogNovember 30, 2015Nov 30, 201511/30/15

Today we’re releasing Visual Studio 2015 Update 1. Let me be the first to thank everyone who installed these earlier releases, provided feedback, and helped us iron out the kinks. [The final release of Team Foundation Server Update 1 is also available today,

Top News for September 2015

Visual Studio BlogOctober 27, 2015Oct 27, 201510/27/15

Hello everyone! Every month we share some top stories from the previous month, and here’s our round-up for September.
Open-source, cross-platform MSBuild: Continuing the open-source, cross-platform .NET story that is already well underway with .NET Core and the .NET Compiler Platform (“Roslyn”),

IntelliTest for .NET – Test More with Less (effort)

Visual Studio BlogSeptember 30, 2015Sep 30, 201509/30/15

Writing a suit of unit tests that exhaustively exercise and validate the logic of the code under test is not easy. It can even be considered too expensive to do at all. Fortunately, the IntelliTest feature shipping in the Visual Studio 2015 Enterprise Edition addresses both concerns: it helps you achieve high code coverage at a fraction of the cost.

Covariance and Contravariance FAQ

Visual Studio BlogFebruary 16, 2010Feb 16, 201002/16/10

In this post I’ll try to answer the most common questions I find on forums and in documentation feedback about C# covariance and contravariance. It’s a big topic for a single blog post, so expect to see a lot of “more information”

Getting Information About Objects, Types, and Members with Expression Trees

Visual Studio BlogJanuary 6, 2010Jan 6, 201001/6/10

Starting with C# 3.0 and Visual Studio 2008, you can use expression trees to get information about objects, types, and members. In this post I’m going to show some examples and explain what benefits you can get by using this technique.

Debugging Expression Trees in Visual Studio 2010

Visual Studio BlogNovember 19, 2009Nov 19, 200911/19/09

First of all, let’s take a look at the example from one of my previous posts. It creates an expression tree for calculating the factorial of a number.

<span>ParameterExpression </span>value =
    <span>Expression</span>.Parameter(<span>typeof</span>(<span>int</span>), <span>"value"</span>);
<span>ParameterExpression </span>result =
    <span>Expression</span>.Parameter(<span>typeof</span>(<span>int</span>), <span>"result"</span>);
<span>LabelTarget </span>label = <span>Expression</span>.Label(<span>typeof</span>(<span>int</span>));
<span>BlockExpression </span>block = <span>Expression</span>.Block(
    <span>new</span>[] { result },
    <span>Expression</span>.Assign(result, <span>Expression</span>.Constant(<span>1</span>)),
    <span>Expression</span>.Loop(
        <span>Expression</span>.IfThenElse(
            <span>Expression</span>.GreaterThan(value,
                <span>Expression</span>.Constant(<span>1</span>)),
            <span>Expression</span>.MultiplyAssign(result,
                <span>Expression</span>.PostDecrementAssign(value)),
        <span>Expression</span>.Break(label, result)
        ),
        label
    )
);
<span>Expression</span><<span>Func</span><<span>int</span>, <span>int</span>>> lambda =
    <span>Expression</span>.Lambda<<span>Func</span><<span>int</span>, <span>int</span>>>(block, value);
<span>Console</span>.WriteLine(lambda.Compile()(<span>5</span>));

ParameterExpression value =

Expression.Parameter(typeof(int), "value");

ParameterExpression result =

Expression.Parameter(typeof(int), "result");

LabelTarget label = Expression.Label(typeof(int));

BlockExpression block = Expression.Block(

new[] { result },

Expression.Assign(result, Expression.Constant(1)),

Expression.Loop(

Expression.IfThenElse(

Expression.GreaterThan(value,

Expression.Constant(1)),

Expression.MultiplyAssign(result,

Expression.PostDecrementAssign(value)),

Expression.Break(label, result)

label

)

);

Expression<Func<int, int>> lambda =

Expression.Lambda<Func<int, int>>(block, value);

Console.WriteLine(lambda.Compile()(5));

Now, what if you want to see the content of this tree in debug mode?

Dynamic in C# 4.0: Creating Wrappers with DynamicObject

Visual Studio BlogOctober 19, 2009Oct 19, 200910/19/09

In the previous post I showed how you can use the new dynamic feature and the ExpandoObject class to add and remove properties at run time, and how this can make your code more readable and flexible than code written with LINQ to XML syntax.

Dynamic in C# 4.0: Introducing the ExpandoObject

Visual Studio BlogSeptember 30, 2009Sep 30, 200909/30/09

You have probably already heard about the new dynamic feature in C# 4.0 and how it is used to support COM interop. If you haven’t, I strongly recommend reading the following MSDN articles: Using Type dynamic and How to: Access Office Interop Objects by Using Visual C# 2010 Features.