C# 4.0
-
I do sort of like the idea but isn't a function by definition a thing that only returns a single value? Maybe we need anonymous returns instead so that you define a struct on the fly, thus returning a single entity that contains the multiple values. public {Max int, Min int} MinMax(int[] numbers) { int min, max; // Code to calculate min/max return {min, max}; } called with var v= MinMax(myArray); system.out.println(v.Min); system.out.println(v.Max); otherwise you'd end up having to create something wierd like this to get the values back int min, max = MinMax(myArray); Russell
You could consider the tuple to be a single value. The single value is the tuple as a whole thing. public [int,int] MinMax(int[] numbers) { int min, max; // Compute min and max return tuple[min,max]; } tuple[int,int] result = MinMax(new[] { 1, 2, 3, 5, 8, 13 }); If tuples were added to C# 4.0, I think they should be added properly, with a native syntax for defining them. Perhapse even support for "anonymous" tuples akin to var: public [int,string,string,DateTime] TupleFunc() { return tuple[1, "String 1", "String 2", DateTime.Now]; } tuple result = TupleFunc(); int number = result[0]; string firstString = result[1];
-
Pawel Krakowiak wrote:
add new functionality to the existing classes
They do nothing of the sort!
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?
-
How about a way to check against all values in an array or enumerabale at once with perhaps the keyword 'any' like below.
int[] supportedValues = new int[] { 3, 4, 5 }
int x = 4;if (x == any supportedValues)
{
// Do something.
}Instead of:
int[] supportedValues = new int[] { 3, 4, 5 }
int x = 4;
bool xIsSupported = false;foreach (int value in supportedValues)
{
if (x == value)
xIsSupported = true;
}if (xIsSupported)
{
// Do something.
}Good idea?
-
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.
Interesting. I thought that C# originally was to be more OO than C++. Even in C++, you can write a completely procedural language type program (the C language). Maybe, Microsoft, in their zeal to make it easier to write software, is turning C# into an all in one language where you can get a job done any way you want. Maybe, at some later date, the keyword class will not be deprecated (not a first class item). Already, the anonymous type and var keyword are reducing the OO aspect of the language. Then, maybe, the hardcore OO engineers will move to Java.
-
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.
-
Here here!
varshould only be used when you don't know the type!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. ;)
-
Design by Contract. There's support for it in one of those little extra languages that they fiddle around with, but I'd like to see support (language-level? just a library?) for it in C#.
I agree, I think Spec# should be integrated into C# 4.0. Design by Contract is better than just adding support for const. I want all my contractual features...function purity, non-null parameters, input requirements and output ensures, etc. I can't wait for the day when my code is not only well written, but contractually secure.
-
1. Retry keyword, from VB.NET (structured error handling) 2. Dyanmic intefaces, from VB.NET 3. AppActivate function, from VB.NET 4. Non-beta version of the parallel task library 5. Better WPF designers 6. Better user experience when working on single code file shared between .NET Framework and .NET Compact Framework projects 7. Improved keyboard/focus and dynamic control creation support in .NET Compact Framework (support for ActiveControl, ControlAdded/Removed events etc). 8. Fix for the (very rare) bug caused by compiler optimisations on the String.IsNullOrEmpty function. 9. A version of the various TryParse functions that returns the default value for expected type, instead of returning true/false with an out parameter. 10. TryParse on System.Enum. Probably a lot of other stuff too, but that's all I can think of off the top of my head :-D Tuples would also be cool :cool:
-
Interesting. I thought that C# originally was to be more OO than C++. Even in C++, you can write a completely procedural language type program (the C language). Maybe, Microsoft, in their zeal to make it easier to write software, is turning C# into an all in one language where you can get a job done any way you want. Maybe, at some later date, the keyword class will not be deprecated (not a first class item). Already, the anonymous type and var keyword are reducing the OO aspect of the language. Then, maybe, the hardcore OO engineers will move to Java.
I think that the extension methods resemble more of a dynamic language features rather than procedural programming. You still need to have an object instance to call on such method and they are created for only the particular type. So an extension method added to the String class cannot be called from anything that is not a string. I think Microsoft is looking for a more dynamic language and extension methods work a little like JavaScript where you can attach new methods and properties to an existing object, but in C# it is still static and strong typing is preserved. I know you people whine about the fact that using the extension methods I don't inherit from the said class... Sometimes you want to only add a single method, perhaps it's laziness (not good). Good thing is that in order to make your extension methods work you must put the using keyword in the file where you plan to use them. Moreover - extension method don't just float there, they themselves must be contained in a static class. So what is the difference between creating a utility class with static methods like you would do in C# 2.0 and creating a static class with extension methods in C# 3.0? In the latter case you get cleaner syntax, being able to call the methods on the object directly, rather than passing it to a utility class method to get the same result. All in all, I understand the concerns, but I just couldn't resist the productivity boost it gave me the first time I saw extension methods.
-
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, you can educate the programmers until you're blue in the face. But, when crunch time comes and all hell breaks loose, then we all take the quick and easy way out. Once you get used to using var (as with any shortcut), you'll continue using it. Usually, the best way to prevent using it (in a company or an organization) is to specifically disallow it in the coding standards and check for it in the code reviews.
-
I think that the extension methods resemble more of a dynamic language features rather than procedural programming. You still need to have an object instance to call on such method and they are created for only the particular type. So an extension method added to the String class cannot be called from anything that is not a string. I think Microsoft is looking for a more dynamic language and extension methods work a little like JavaScript where you can attach new methods and properties to an existing object, but in C# it is still static and strong typing is preserved. I know you people whine about the fact that using the extension methods I don't inherit from the said class... Sometimes you want to only add a single method, perhaps it's laziness (not good). Good thing is that in order to make your extension methods work you must put the using keyword in the file where you plan to use them. Moreover - extension method don't just float there, they themselves must be contained in a static class. So what is the difference between creating a utility class with static methods like you would do in C# 2.0 and creating a static class with extension methods in C# 3.0? In the latter case you get cleaner syntax, being able to call the methods on the object directly, rather than passing it to a utility class method to get the same result. All in all, I understand the concerns, but I just couldn't resist the productivity boost it gave me the first time I saw extension methods.
Agreed, extension methods arn't really procedural programming, but they arn't object oriented either. They DO definitely have a place, and DO definitely provide useful value when used properly. Same goes for the var keyword...it has its uses, and considering that it is local-scoped, the range of missuse of var is very, very limited. I used to be a hard-core, object-oriented purist. It was only when I finally let go if my bias that I realized the freedom one can have when you take full and proper advantage of a language like C#. Correctly used, C# is probably the most powerful, effective language on the planet for efficiently providing solutions to business problems...and that, ultimately, is what we programmers are here for...providing solutions.
-
Interesting. I thought that C# originally was to be more OO than C++. Even in C++, you can write a completely procedural language type program (the C language). Maybe, Microsoft, in their zeal to make it easier to write software, is turning C# into an all in one language where you can get a job done any way you want. Maybe, at some later date, the keyword class will not be deprecated (not a first class item). Already, the anonymous type and var keyword are reducing the OO aspect of the language. Then, maybe, the hardcore OO engineers will move to Java.
C# is what I call a progressive language. It started out in a very simple, Java-like form in v1.0. But it has continually evolved into a richer, stronger, more expressive language that has only served to do one thing: Improve my productivity. Hard-core OO programming is a very limiting form of software engineering. Objects don't solve everything in the simplest way...on the contrary, rich object models with full inheritance and associative relationships can get in the way of providing a simple, effective, easily maintained solution. You have to use the right tool for the job, and objects are most assuredly NOT the right tool for every job. I for one am extremely grateful that Microsoft did not allow C# to stagnate like Sun allowed Java to. I use C# for what it is...a progressive, evolving language that has an EXTENSIVE amount of analysis and design behind it to ensure that features that are added provide benefit...not detriment. The end result, IMO, is an extremely powerful, expressive, flexible language that allows me to quickly solve problems without always having to resort to a complex OO mechanism. Sometimes, an enumerable collection of simple structures (tuples say), is all one needs to get the job done.
-
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.