pls tell me in which version dynamic keyword is introduced ? I found strange behavior in VS2010. I set target framework to 3.5. But there is no compiler error. just crate a console application with target framework to .net 3.5 and use dynamic keyword .
The dynamic type was introduced in .Net 4.0.
The dynamic type is not a language only feature (i.e purely supported by the compiler). It relies on the DLR which is a .Net 4.0 feature which needs library support.
You cannot use dynamic and target the .Net 3.5 framework.
When you use Visual Studio 2010, it defaults to C# 4.0.
You can not use C# 3.0 with Visual Studio 2010.
Even if you target .Net Framework 3.5, it will just use Framework 3.5 and not C# 3.0.
Now, since it defaults to C# 4.0, you get to use dynamic. But for that to work, you have to reference Microsoft.CSharp.dll. That assembly is compiled with v 4.0. You can't use it under v 3.5.
dynamic needs DLR (Dynamic Language Runtime) which is not there for previous framework versions.
That is why when you try to use dynamic under Framework 3.5 project, it will freak out.
So, to summarize, to use dynamic, use Framework 4.0.
Dynamic keyword was introduced as part of C# 4.0 language - the compiler comes with VS 2010. Its a language feature and does not need runtime support (AFAIK) hence once complied with C# 4.0 compiler, shouldn't have any issue with earlier version of runtime. Changing target framework in VS 2010 does not switch the compiler (which remains at 4.0) - we will receive compiler error only if you use feature that targets new library or runtime. For example, in VS 2008, you could use lambda expressions or var keyword for target runtime 2.0 but extension methods were not available because extension attribute was part of 3.5 assembly.
EDIT: Above is wrong - dynamic keyword requires Framework 4.0. I couldn't even compile in VS2010 when target fx was changed to 3.5. I believe that OP might not have used the dynamic var later in the code so that compiler optimization would have removed it making OP believe that its working.
Just for the sake of the knowledge:
This technique is called 'Polymorphism through late binding'
It was introduced in .NET Framework 1.1. C# acquired this feature in version 4.0. In Visual Basic it was possible to start this withoud compilation errors.
Public Class Foo
Public Sub Bar()
End Sub
End Class
Public Class Test
Public Sub Test()
Dim o as Object
o = New Foo()
' This will compile and work
o.Bar()
' This will also compile but will throw an exception
o.NonExistingMember()
End Sub
End Class
`
All the trick is in that the type "Object" played the role of the top level parent as well as acted as a dynamic variable
Related
I have a legacy application that uses .NET 4.
I tried to use a C# 6 feature when I was changing the code, but my visual studio generates the following error:
Feature 'interpolated strings' is not available in C# 4. Please use language version 6 or greater.
I was wondering if there is a way to use the features of the latest versions of C# without updating the version of the framework?
Or is the C# version directly linked with the framework?
obs: updating the framework is not an option.
The language-version only relies on the version of Visual Studio. To use features intorduced in C#6 you need at least VS2015. This has nothing to do with the installed .NET-framework-version. In fact you can use VS2015 and its compiler-features (e.g. auto-implemented properties with an initial value) and compile against .Net 2.0:
int MyProperty { get; set; } = -1;
To change the target-framework (e.g. .Net 2.0) use Project properties-->Application-->Target framework.
To change the language version via Project properties-->Build-->Advanced-->Language version.
Let´s consider the following example: Beginning with C#3 you can write the following:
var a = new { MyProperty = 1 };
This compiles for any .Net-version. However the most common use-case for anonymous types is when using Linq to fetch data from a database. Linq was introuced in framework-version 3.5 and heavily depends on lambda-expressions and extension-methods, which both were introduced in C#3:
var result = myCollection.Select(x => new { MyProperty = x.MyProperty });
So although you could use anonymous types in earlier versions of the framework, there was little need to do so.
To get a better view on the difference between the C#- (=language)-version and the framework-version read this post. This thread on the other side lists the language-versions and in which version of VS they were released.
The Language version is a Compiler feature, not a runtime one.
Regardless which source code language language or source code language version you use, the end result will always be the same MSIL code. You can freely pick which Framework version to compile against. Which limits your available .NET Libraries. But it does not affect the C# version you are using in any way.
Of course there might be some Language Features that make little sense without supporting libraries. I can just not think of a concrete example of the top of my head.
Edit: Remembered a concrete example: Named and Optional Parameters. IL always supported that. VB.Net had that already for ages. It was a very important part of COM compatibility, especially using the Office COM inter-op. But Prior to C# 4 we C# programmers could not use it: https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/named-and-optional-arguments
You Need Either Visual Studio 2013 or # 2015 to use c sharp version 6 u can change the .net version in the project settings. .NET version Wont be a problem
I created a project in Visual Studio 2017 RC to check whether I can use new C# 7.0 language features in a .NET Framework 4.5 project. It seems to me that after referencing System.ValueTuple NuGet, new tuples are working fine. Is there anything else I should think about, or is this going to work?
After checking System.ValueTuple NuGet dependencies, it looks like .NET Framework 4.0 is not supported. Is this the case, or is there some way to make the new language work in this runtime also?
Let's go through the features new in C# 7.0:
Tuples: The System.ValueTuple package has a version for the portable-net40+sl4+win8+wp8 profile. That means it is usable on .Net 4.0. (Not sure why dependencies list only .Net 4.5.)
If you wanted to use tuples on even lower versions of .Net, it should still work, as long as you add the code for ValueTuple and related types to your project.
out variables, pattern matching, local functions, more expression-bodied members, throw expressions, numeric literal syntax improvements: All these features are just syntax sugar, so they don't need any new capabilities from the framework.
ref locals and returns: This feature exposes in C# what the framework supported since the start, so no changes in the framework are needed here either.
Generalized async return types: To use this feature, you need a type that has the AsyncMethodBuilder attribute, which is in the System.Threading.Tasks.Extensions package (along with one such type, ValueTask<T>). This package is only supported on .Net 4.5, so for .Net 4.0, you would need to compile the relevant types yourself. (Using await on .Net 4.0 also requires Microsoft.Bcl.Async, but that's nothing new.)
To sum up: All of C# 7.0 should work on .Net 4.5 after installing the required packages and most of it should work on .Net 4.0 too.
Running a C# 7 compiled application on .NET 4.5 should be fine at this moment, but note that running ASP.NET applications that use ASP.NET Dynamic Compilation won't work on .NET 4.5 because the C# 7.0 compiler requires .NET 4.6 to run.
Source: https://github.com/dotnet/roslyn/issues/17908:
The C# 7.0 compiler (2.0 and higher) requires .NET 4.6 to run
The information on https://www.nuget.org/packages/Microsoft.Net.Compilers/2.0.1 (about supporting .NET 4.5) seems to be outdated.
I've inherited an app. The app has to use .NET 2.0. However, I would like to make use of a feature introduce in C# 4.0 (optional arguments). I understand that a framework is separate from a language. However, what I'm not sure of is, can I use this C# feature in the context of .NET 2.0?
The code compiles. I wasn't sure if this was legitimate, or if I just got lucky :).
Thank you for your insights.
Optional arguments/parameters have been supported in CLR since CLR 1.0. This is due to CLR support for VB.net.
This is why your code compiles. Other new 4.0 features may not work the same.
Other post-C# 2.0 features that will compile into a .NET 2.0 application include named arguments, lambda expressions, auto properties, & extension methods.
This is, probably, a very simple answer for someone. I have a method with an Optional Parameter like so;
public static Email From(string emailAddress, string name = "")
{
var email = new Email();
email.Message.From = new MailAddress(emailAddress, name);
return email;
}
Now, I must target .Net 3.5 and it was my understanding that Optional Parameters are part of .Net 4. However, my project builds and I double checked the Properties - Application page which states 3.5 as the target framework. Then I found a article on MSDN saying it's a feature of C#4 in VS2010. (MSDN Article --> Named and Optional Arguments)
Can someone help clarify this for me. C#4 does not require .Net4? What are Optional Parameters ACTUALLY a part of?
Thank you.
Optional parameters have been supported in the CLR since 1.0. Languages like VB.Net's have been using them since the start. While the first version of C# to support them is 4.0, it can still generate valid code for a 2.0 CLR and in fact does so. Hence you can use default parameters in 2010 if you are targeting the 3.5 CLR (or 2.0, 3.0, etc ...)
This type of support is not limited to default parameters. Many new C# features can be used on older version of the framework because they do not rely on CLR changes. Here are a few more which are supported on CLR versions 2.0 and above
Named Arguments: Added C# 4.0
Lambda Expressions: Added C# 3.0
Auto Properties: Added C# 3.0
Extension Methods: Added C# 3.0
Co/Contra Variance: Added C# 4.0
If you compile that up and examine the output using a tool like ILDASM you'll see that the optional parameter is simply implemented by adding an attribute to the metadata that describes the method's formal parameters. As long as that attribute class is available on the target platform there should be no problem with using the emitted code on a downlevel platform.
The language version is independent of the framework version. For C# they happen to run mostly in parallel, i.e. C# 4 and framework 4.0 came with Visual Studio 2010. (However there is no 3.5 version of C#.)
With VB the version numbers are different, as VB 7 was the first VB.NET version. So, VB 10 comes at the same time as framework 4.0.
The optional parameters is a language feature introduced in C# 4. When you use VS 2010 you use C# 4, even if you target framework 2.0, so you can use all C# 4 features.
C# 4.0 is included with Visual Studio 2010, and the C# compiler understands optional parameters. So yes, the C# 4.0 language definition is something different than .NET 4.0. I guess a method with optional parameters compiled for .NET 3.5 will show overloaded methods when opening with eg. VS 2008
I created new project in Visual Studio with target framework 2.0. But even if I left somewhere var keyword Visual Studio successfully compiles project. Is this the correct behavior as var is 3.0 feature? Is there any settings to prevent code with var to be compiled?
var is a feature of C# 3.0, but it doesn't require any framework features. In other words, it's absolutely fine to use within a project targeting .NET 2.0. The same is true of many other features - anonymous types, automatic properties, lambda expressions etc.
See my versions article for more information. (I need to update it for C# 4 at some point...)
If you want to restrict yourself to C# 2.0, you can specify the language version by clicking on "Advanced" in the Build tab of the project properties, IIRC. (It's definitely there somewhere, but I'd rather have a cup of coffee than check for the exact location right now.)
var is purely a compile-time feature, once the assembly is compiled, the compiler inserts the actual type and the fact that you had used var is "lost".
So a project that's targetting version 2.0 of the framework can still make use of the var feature, because it doesn't actually affect the outputted assembly in any way.
As long as your project will always be compiled with Visual Studio 2008 or newer, you're safe to use C# 3.0 features. The .NET 2.0 target only restricts what libraries you can use, not what language features.
Either do full text replace of var by 1var1 and manually replace them or use pre 3.0 versions of compiler.