C# 4.0
-
Perhapse this (.NET 3.5 IEnumerable extensions): int[] supportedValues = new int[] {3,4,5}; int x = 4; if (supportedValues.Any(v => v == x)) { // Do something }
The idea is so good they already implemented it in 3.5! ;P Perhaps I should stop using 2.0. I played with 3.5 briefly to check out WPF and Linq and didn't particularly see much use for them so I decided to stay away because of the performance drawbacks that came with WPF and didn't want to be tempted to use it. I missed the IEnumerable extensions and probably many more features that could come in handy. Am I the only one that WPF runs like molasses for? If not are there any other features to stay away from in order to perform decent on lowend and older machines? P.S. - Thanks for the Line Counter add-in! I've been using it for a couple months now.
modified on Friday, October 3, 2008 2:30 AM
-
I think what your asking for can be fairly closely achieved already in C# 3.0..its just slightly more verbose: int[] tupleFunc() { double w, h, d; // ... return new[] { w, h, d }; } int[] tuple = tupleFunc();
On the flip side, native tuples in C# would be nice: public [int,int] MinMax(IEnumerable numbers) { int min, max; // Compute min and max return tuple[min,max]; } tuple[int,int] result = MinMax(new[] { 1, 2, 3, 5, 8, 13 }); int first = result[0]; A more complex example with an "anonymous" tuple might be: public [int,string,string,DateTime] TupleFunc() { return tuple[1,"String1","String2",DateTime.Now]; } tuple result = TupleFunc(); int num = result[0]; string first = result[1]; //...
-
So now that C# 4.0 is being talked about, I was wondering what people thought would be good additions to the language. Sorry if this is a repost, but I went through several pages, and didn't see anything, so... What I'd frankly love to see would be tuples. Rather than having to use multiple 'out' parameters, you'd just return multiple values:
public int,int MinMax(int[] numbers)
{
int min, max;
// Code to calculate min/maxreturn min, max;
}What do you think? What would be good for the next version?
Kyosa Jamie Nordmeyer - Taekwondo Yi (2nd) Dan Portland, Oregon, USA
-
So now that C# 4.0 is being talked about, I was wondering what people thought would be good additions to the language. Sorry if this is a repost, but I went through several pages, and didn't see anything, so... What I'd frankly love to see would be tuples. Rather than having to use multiple 'out' parameters, you'd just return multiple values:
public int,int MinMax(int[] numbers)
{
int min, max;
// Code to calculate min/maxreturn min, max;
}What do you think? What would be good for the next version?
Kyosa Jamie Nordmeyer - Taekwondo Yi (2nd) Dan Portland, Oregon, USA
Namely i'd like to see the following: 1. Implementing Interfaces by delegation to fields 2. Anonymous type return values 3. Some Duck-typing or Structural Subtyping support 4. Safe Null Dereferencing Operator as someone already mentioned (eg) Customer?.Orders?.Last?.Address I have expanded more on this some time ago here: http://anastasiosyal.com/archive/2008/07/19/4-features-for-c-4.0.aspx
-
I saw someone comment on that on another forum. Basically, you'd have something like this (using his sample syntax):
int? x = Company?.Person["Bob"]?.Age;
If Company or Company.Person["Bob"] were null, then x would be set to null, rather than getting an exception. I likes.
Kyosa Jamie Nordmeyer - Taekwondo Yi (2nd) Dan Portland, Oregon, USA
Lol I just realized this morning as I got up how dumb that was of me last night. You didn't forget anything--null would of course be the default, that's the whole point. :P "?? null" is redundant. :doh:
“Time and space can be a bitch.” –Gushie, Quantum Leap {o,o}.oO( Check out my blog! ) |)””’) piHole.org -”-”-
-
Jamie Nordmeyer wrote:
I saw someone comment on that on another forum.
Daniel Grunwald, TheCodeKing and myself came up with that here[^]. You're missing the final part tho, which is a ?? operator to act as the "default": int? x = Company?.Person["Bob"]?.Age ?? null; Of course setting null as the "default default" would also work and be handy.
“Time and space can be a bitch.” –Gushie, Quantum Leap {o,o}.oO( Check out my blog! ) |)””’) piHole.org -”-”-
Actually, the posting I saw wasn't on CodeProject. It may still have been yours, but it wasn't here. Either way, it's a fantastic idea, and I really like it!
Kyosa Jamie Nordmeyer - Taekwondo Yi (2nd) Dan Portland, Oregon, USA
-
Actually, the posting I saw wasn't on CodeProject. It may still have been yours, but it wasn't here. Either way, it's a fantastic idea, and I really like it!
Kyosa Jamie Nordmeyer - Taekwondo Yi (2nd) Dan Portland, Oregon, USA
Wasn't likely mine, then--that's the only place I remember discussing it; but it could have been one of the other guys. On the other hand it could have been someone else entirely, which only goes to show it must be a good idea if people are coming up with it independently! If you do find the link, let me know; it would be interesting to read what other people suggested. It would definitely be nice to have in an upcoming version of C#.
“Time and space can be a bitch.” –Gushie, Quantum Leap {o,o}.oO( Check out my blog! ) |)””’) piHole.org -”-”-
-
Perhapse that should be worded "can't" know the type...as in the case of anonymous types. Its easy enough to debug and find out a type you don't know. Var has its uses, but like almost any language feature, it can be missused. I think rather than restricting its use, though, better educating our programmers and instilling good practices is the first thing we should try. ;)
Jon Rista wrote:
should be worded "can't"
Yes, but for me they're pretty much equivalent; if I can know it I do know it. Unfortuntely there are some who can know it but are too darn lazy to find out.
-
I think what your asking for can be fairly closely achieved already in C# 3.0..its just slightly more verbose: int[] tupleFunc() { double w, h, d; // ... return new[] { w, h, d }; } int[] tuple = tupleFunc();
Jon Rista wrote:
int[] tuple = tupleFunc();
But what i really want is to avoid having to unpack the array on the callee side of things.
----
You're right. These facts that you've laid out totally contradict the wild ramblings that I pulled off the back of cornflakes packets.
-
Static verification would be awesome. Contracts[^] would be nice too if they could get some of those features in without making too much of a mess. For instance, Spec# will throw a compile-time error (and squiggly underline in Visual Studio) with this code:
public float Divide(float x, float y)
{
return x / y;
}But this would be valid:
public float Divide(float x, float y)
requires y != 0
{
return x / y;
}As would this:
public float Divide(float x, float y)
{
if(y == 0)
throw new ArgumentException("y");
return x / y;
}I wholly agree. Contracts will help us write less buggy code, which should be a primary focus of new C# features.
Tech, life, family, faith: Give me a visit. I'm currently blogging about: Feelings-Based Morality of the Secular World The apostle Paul, modernly speaking: Epistles of Paul Judah Himango
-
They absolutely do! Look at IEnumerable...EVERY type that implements IEnumerable DOES INDEED get the full functionality of all extension methods written for IEnumerable (so long as the proper using statement(s) are included). You don't have to "implement" the extension methods on each class that implements IEnumerable...the extension methods absolutely do add new functionality without you having to do any extra implementation. And that functionality is accessed through class INSTANCES...not static methods or utility types. You anti-progressive types drive me nuts sometimes...get off your high horse and USE the tools at your disposal. You might find that you actually like them.
Jon Rista wrote:
anti-progressive types
No, I'm a pedantic type! I do use one or two Extension Methods I've written. I know what Extension Methods do, and "adding functionality to classes" isn't it. They simply masquerade as class members. They are still just static methods and can be used as such. They have absolutely zero effect on the class involved. Any benefits (over classic static usage) they offer are purely superficial. I'm not saying they don't work. I'm not saying that the static methods that implement them aren't useful. I (and I'm not the only one) think that having a static method look like a class method is a bad idea; they seem to break orthogonality for one thing. When I see a snippet of code posted here or elsewhere (where Intellisense isn't involved) I can't tell one from the other. Other than that, I don't like the implementation; the change to the syntax was unnecessary, the developer should be allowed to put the attribute on the method directly.
-
PIEBALDconsult wrote:
They do nothing of the sort!
string lookingFor = "Wash";
lookingFor.ToSqlLike(SqlLikePlacement.Front); // returns "Wash%"
lookingFor.ToSqlLike(SqlLikePlacement.Middle); // returns "%Wash%"
lookingFor.ToSqlLike(SqlLikePlacement.End); // returns "%Wash"I understand I missed something and the above code is possible without extension methods and without creation of a new class?
Bad example. How is that better than:
lookingFor = "%" + lookingFor ; lookingFor = lookingFor + "%" ; lookingFor = "%" + lookingFor + "%" ;The standard way is much clearer (at least in this case). -
Who says object-orientation is the sole valid way to write code? Object-orientation can get in the way when something simpler would suffice to get the job done. Extension methods allow you to add a great deal of expressiveness to your code, extend base types you don't have direct control of to provide a cleaner API, etc. etc. Whats with all the hostility towards useful language features and non-object-orientedness? Objects don't solve every problem. Portability? Where are you going to "port" a C# or VB.NET app to...they only run on the .NET platform anyway. Use the features for what they are. As a programmer, your job is to provide solutions to business problems in the most effective, efficient, maintainable way possible...don't get so hung up on all the "rules" and "regulations" of OOP...objects arn't the only option.
Jon Rista wrote:
Portability? Where are you going to "port" a C# or VB.NET app to...they only run on the .NET platform anyway.
Wrong. Look up Portable.NET[^] and Mono[^] There are also other compilation techniques out there. See IL2CPU on Cosmos[^] and Bartok used for the Singularity project.[^] I don't understand why programmers can't seem to separate C# from .NET. C# is a programming language with a syntax and rules. The C# life cycle of your project ends after you successfully compile your project. The framework you are using then executes the compiled binaries (and it doesn't have to be IL).
Sunny Ahuwanya "The beauty of the desert is that it hides a well somewhere" -- Antoine de Saint Exupéry
-
But using them as Extension Methods is no more "powerful and useful" than using them as regular static methods. The "Extension Method-ness" isn't what makes the methods "powerful and useful".
-
They absolutely do! Look at IEnumerable...EVERY type that implements IEnumerable DOES INDEED get the full functionality of all extension methods written for IEnumerable (so long as the proper using statement(s) are included). You don't have to "implement" the extension methods on each class that implements IEnumerable...the extension methods absolutely do add new functionality without you having to do any extra implementation. And that functionality is accessed through class INSTANCES...not static methods or utility types. You anti-progressive types drive me nuts sometimes...get off your high horse and USE the tools at your disposal. You might find that you actually like them.
Jon Rista wrote:
And that functionality is accessed through class INSTANCES...not static methods or utility types.
:omg: This is exactly why I said extension methods should come with a warning tag.
Sunny Ahuwanya "The beauty of the desert is that it hides a well somewhere" -- Antoine de Saint Exupéry
-
So now that C# 4.0 is being talked about, I was wondering what people thought would be good additions to the language. Sorry if this is a repost, but I went through several pages, and didn't see anything, so... What I'd frankly love to see would be tuples. Rather than having to use multiple 'out' parameters, you'd just return multiple values:
public int,int MinMax(int[] numbers)
{
int min, max;
// Code to calculate min/maxreturn min, max;
}What do you think? What would be good for the next version?
Kyosa Jamie Nordmeyer - Taekwondo Yi (2nd) Dan Portland, Oregon, USA
A lot of the stuff from Spec#. At a minimum - preconditions, postconditions and invariants.
Kevin
-
Ennis Ray Lynch, Jr. wrote:
I have always said that developers need to focus on mastering what has been provided in 2.0 before even thinking about adding more candy.
Would it really be hard to "master" tuples as a return paramter? I love that feature as part of LUA and Python especially over out parametes. Spec# sounds interesting which adds support for explicit programming by contract.
Todd Smith
Todd Smith wrote:
Spec# sounds interesting which adds support for explicit programming by contract.
Yea! :)
Kevin
-
I'd love to see a const keyword on parameters to methods, and optional parameters. Both of which seem simple enough.
Christian Graus No longer a Microsoft MVP, but still happy to answer your questions.
I miss const more than optional parameters. I did VB .NET for a year. It has optional parameters and it put me off them really. Even though prior to this I've been a C++ dev and didn't seem to mind them then! Perhaps it was just the way they were used in VB? Or maybe I've just changed my taste?
Kevin
-
The methods implemented as part of IEnumerable are now intrinsic to the .NET framework. Any decent developer would avoid using identifiers already used in the framework. Your argument about IEnumerable.Where is the same as saying Developer B creates a new class called String... Simple solution, don't do that. Almost any language feature can be missused. Don't missuse them.
Not every developer writing C# code targets the .NET framework. I used IEnumerable.Where as an example which everyone would understand but it could be any set of extension methods from XYZ company.
Sunny Ahuwanya "The beauty of the desert is that it hides a well somewhere" -- Antoine de Saint Exupéry
-
The good answer to 'constness' is spec#. The 'constness', the 'nonnullness', the 'checkedexceptionness' , the 'immutabilityness' etc ... are all describable with contracts. I think Spec# will be a real revolution in the .NET world. In fact the .NET infrastructure should evolve to include contract metadata so that every .NET language will manage contracts in a similar way. Try it here http://research.microsoft.com/SpecSharp/[^] ... and cry because I am sure that c#4 won't include spec# :-(
higelino wrote:
I am sure that c#4 won't include spec#
Yes, I bet it won't. Unfortunately. :(
Kevin