csharpfuture Forum Rss Feed

NEW POST: Dynamic interface implementation, asif/islike operators

tomen130 — Fri, 06 Nov 2009 08:28:45 GMT

I posted an idea on the MS Connect site (https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=476545) a while ago, but I'll post it here as well, since it seems more active and it would be nice to see if someone knows a way to do it with the current framework. I think it should be possible, but I haven't given it much thought. Here it is:

Similar to the "as" operator I would like to have an "asif" operator. It would work just as the "as" operator, but only on interfaces and the big difference is that the instance type doesn't really implement the interface. The "asif" operator would return null if the instance type doesn't implement the same members as the wanted interface, but it returns the instance wrapped as the wanted interface if it does. An "islike" operator could similar to the "is" operator.

var interfaceType = anyType asif INotImplementedInterface;
I haven't really looked into the new dynamic type that much, but this way you could do a check that the instance isn't null, and only continue if it isn't. With the dynamic type you would get an error at runtime, right?

NEW POST: Make curly bracket assignment more general

z5ivan — Wed, 04 Nov 2009 10:44:30 GMT

Make { } assigning more general. Today it only works on constructors, it should work on any function call.
Today you can not do curly bracket assignment, if an object i made in eg. af factory. Therefore is factory pattern not nice to use in a linq expression

class Foo
{
public string Name;
}

class Factory
{
static public Foo CreateFoo()
{
return new Foo();
}
}

new Foo{ Name = "test" } // constructor assigning is possible today

It should also be possible to assign members after af function call, like this:

Factory.CreateFoo(){ Name = "test" } //should be possible in the future

NEW POST: [Suggestion] Support of inline ASM or at least pre-defined classes for SIMD Extensions

Heandel — Sat, 24 Oct 2009 17:29:54 GMT

Hello,

I program applications that require 3D computation, and I really miss something in C# that could take advantage of SIMD (SSE2 and 3DNow!) instructions.
It's such an important thing, and my C# code cannot get close to raw C++ performance. For example, matrix multiplications are about 30%-40% slower in C# than in C++.
I noticed Mono has support for SIMD, I really hope .NET will have too !

The ideal would be something like asm { } from C/C++, but a simpler thing (for .NET developpers) would be creating Matrix classes that use SIMD instructions, that we could use.

Please think about it :)

Thank you,
Heandel

NEW POST: Reducing Syntactic Noise: Auto Generation of Boilerplate Code

reinux — Thu, 15 Oct 2009 09:39:09 GMT

It is too late.

I once wrote a library that had similar requirements for event routing and bindable properties without having access to the WPF libraries and without inheriting from FrameworkElement. As it turns out, all those extra steps that WPF make you do are necessary and minimal in solving the problem.

One way this could have been resolved is if dependency properties and routed and weak events (or at least INotifyPropertyChanged and INotifyCollectionChanged) had been implemented in the BCL rather than in WPF. But that hasn't been the case, so it's somewhat impossible for any latter version of C# to support this sort of functionality syntactically, and there are no standard interfaces or libraries that library developers could use to gain this sort of functionality outside of WPF or WF.

I don't remember when or where, but someone from Microsoft responded that the issue is by design -- which is obviously a spin. There's no way that this functionality wouldn't be useful outside of WPF. It's really because WPF isn't really part of .NET despite the frustrating misnomer, and because there's no communication between the BCL team and the WPF team.

The good news though is that you could try a language like Boo, which has syntactical extensibility. I haven't looked into it myself, but it should at least cut down the boilerplate code. Of course, there probably aren't any good WPF designers that support Boo.

NEW POST: Reducing Syntactic Noise: Auto Generation of Boilerplate Code

ivank — Thu, 27 Aug 2009 14:58:51 GMT

As the time goes by, my desire for an intelligent boilerplate code generation facility becomes stronger and stronger. I probably would not call it "macros", since this became almost a swear word due to the bad fame of C macros. But just because C macros are bad, does not mean that we should allow ourselves to get buried in the syntactic noise.

Boilerplate code is verbose and repetitive, and it distracts the reader from the main purpose of the program, thus reducing the readability. The classic example of boilerplate code is "straight-through" properties in earlier version of C#:

private int _totalCount;
public int TotalCount { get { return _totalCount; } set { _totalCount = value; } }

This became so big an annoyance, that newer versions of C# introduced a special shortcut:

public int TotalCount { get; set; }

This is good, but this is only one special case. Look how much code needs to be written for a WPF dependency property: http://www.ikriv.com/blog/?p=264.

public static readonly DependencyProperty CenterProperty =
DependencyProperty.Register("Center", typeof(Point3D), typeof(Sphere),
new PropertyMetadata(new Point3D(0, 0, 0), CenterChanged));

public Point3D Center
{
get { return (Point3D)GetValue(CenterProperty); }
set { SetValue(CenterProperty, value); }
}

private static void OnCenterChanged(Object sender, DependencyPropertyChangedEventArgs e)
{
Sphere s = ((Sphere)sender);
s.DoUpdateWhenCenterChanges();
}

This is a lot of code that repeats itself over and over again. I do want to be able to replace it with something like

DependencyProperty
Point3D Center { get; set; }

Of course, one cannot throw support for all one-off cases into the language. We need a generic boilrerplate code generation facility, maybe something similar to LISP macros. Yes, I know that LISP macros can work only in an interpreted language, I am talking conceptually here.

Of course, there are code generation tools out there that would happily create boilerplate code snippets for you. But this is only 10% of the issue. Typically, once generated, the snippets cannot be maintained, and they do not improve readability. Generating snippets is a one-time deal, and I don't consider it a real solution.

If anyone in C# team feels the same way I do, we can work out a meaningful proposal, unless it is too late :)

NEW POST: Instead Of Macro

kaveh_shahbazian — Wed, 12 Aug 2009 10:55:33 GMT

As C# won't have a macro system...and it is not good (IMO & Taste) for DSLs, I think these are harmless features that give me a great bunch of what I like:
- defining infix, generic operators and functions
- statically and dynamically typed protocols(duck typing, anonymous interface implementation, proxies, ... whatever you call it and every derivation you like)

And everything can be verified at compile time (not as horrifying thing like Lisp macros...yet this `dynamic` part of C# 4.0...anyway); for example I can define an infix function 'feed_into':

IItem item =...;
IRSSFeed feed =...;
item feed_into feed;

Or a more generic one or even an operator like ??? (Ok; I can live with just infix syntax for functions).

(I had my other long lists too; but here I emphasis on some syntax extending facilities or some tools that mock syntax extending)

NEW POST: Suggestion: introduce 'nameof' key word to get string names of method arguments, properties and etc.

rsmckinney — Thu, 06 Aug 2009 02:49:10 GMT

You can probably build a utility that does this via expression trees. For instance, you could define a method that takes an arbitrary expression tree and simply return the expression as a string.

I'm not a .net/c# programmer, but from what I know of the language it might go something like this:

public String nameof( Expression<Func<object>> expr )
{
return expr.ToString();
}

Using your example:

throw new ArgumentNullException( arg1, nameof( ()=>arg1 ) );

Questions:
- Can the lambda syntax omit the '()'? e.g., =>arg1 instead of ()=>arg1
- Will the new covariance rules in c# 4.0 allow Expression<Func<object>> to work?

NEW POST: vNext Idea - Taking Initializer Notation a Step Further

tah9m9 — Wed, 05 Aug 2009 19:18:23 GMT

I'd like the ability to set properties of an object via "initializer" notation whenever I have any reference to it, not just at construction.
Currently:

var car = new Car() { Doors = 4, Type = Types.Convertible, Spare = Spares.FullSize, License = "123ABC" };

and if not constructing, then:

var car = GiveMeACar();
car.Doors = 4;
car.Type = Types.Convertible;
car.Spare = Spares.FullSize;
car.License = "123ABC" ;

I would like to see something like:

var car = GiveMeACar();
car set { Doors = 4, Type = Types.Convertible, Spare = Spares.FullSize, License = "123ABC" };

or simply:

car { Doors = 4, Type = Types.Convertible, Spare = Spares.FullSize, License = "123ABC" };

this allows chaining:

var car = GiveMeACar() { Doors = 4, Type = Types.Convertible, Spare = Spares.FullSize, License = "123ABC" };

NEW POST: Suggestion: introduce 'nameof' key word to get string names of method arguments, properties and etc.

stasetz — Thu, 23 Jul 2009 07:26:47 GMT

Introduce 'nameof' key word that would return string representation of identifier in C# code. E.g. currently for argument check we need implement something like this:
if (arg1 == null)
{
throw new ArgumentNullException(arg1, "arg1");
}
Then is someone renames arg1 into e.g. arg2, ArgumentNullException constructor could still have "arg1" as name of an argument. To avoid such Inconsistency it will be nice to have mechanism that returns string name of identifier. Then this sample code could look like:
if (arg1 == null)
{
throw new ArgumentNullException(arg1, nameof(arg1));
}
The same issue can be addressed to usage of interface INotifyPropertyChanged:
public string PhoneNumber
{
get
{
return this.phoneNumberValue;
}
set
{
if (value != this.phoneNumberValue)
{
this.phoneNumberValue = value;
NotifyPropertyChanged(nameof(PhoneNumber));
}
}
}

NEW POST: Symbol

bfscordeiro — Mon, 06 Jul 2009 04:10:51 GMT

I think that C# need Symbols like Ruby, this is a great way to do any things.

NEW POST: C# vNext Idea - Delegate Interface Implementation

tah9m9 — Wed, 01 Jul 2009 15:49:14 GMT

This one is complicated and there are OO patterns for accomplishing this; but as C# moves in a more Functional direction, I've had the desire a few times for the ability to implement interfaces through classes using delegate members to fulfill the interface contract. See example:

interface IRunnable
{
void Run();
}

public class Runner : IRunnable
{
public Action Run { get; set; } // matches the Run contract defined in IRunnable
}

Action run = () => Console.WriteLine("Running...");

var runnable = new Runner() { Run = run };
runable.Run();

NEW POST: C# vNext Idea - Anonymous Interface Implementation

tah9m9 — Wed, 01 Jul 2009 15:40:49 GMT

One feature I'd like to see in a future version of C# is the ability to define an anonymous implementation of an interface. See below:

interface IRunnable
{
void Run();
}

var runnable = new IRunnable()
{
public void Run()
{
Console.WriteLine("Running...");
// Do your running
}
};

runnable.Run();

This would be so handy for some quick dependency injection scenarios where I don't want to have to create a type that implements the interface and just write my functionality inline. Imagine the possibilities when you factor in closures.

NEW POST: Suggesting a null safe member access operator

ChrisH — Sat, 20 Jun 2009 06:54:26 GMT

I have often wanted a way to abbreviate code such as:

int? id = obj == null ? null : obj.id;

Imagine an alternative member access operator, say the (!) exclamation mark, which allowed the following syntax:

int? id = obj!id;

This combines the converse of the ?? operator with member access. In the case of ! a null would be returned as soon as an object reference turned out to be null; otherwise - in the case of a reference type - further member access could be pursued:

int? len = obj!name!Length;

The null safe member access would need to lift the type to its nullable equivalent, where the ultimate property is of a value type.

An alternative syntax might be !? but ! would seem more elegant and familiar in this regard.

NEW POST: Suggestion: C# Functions

algotron — Thu, 04 Jun 2009 14:54:42 GMT

I can define a function C++ but not in C#. Consider the following C++ code:

namespace MyNamespace
{
int MyFunction(int x, int y)
{
return x + y;
}

class MyClass
{
private:
std::string _name;

public:
std::string GetName() const {return _name;}
void SetName(std::string& name) { _name = name;}
};
}

I can do something similar with C# using a static class like so:

namespace MyNamespace
{
static class MyFunctions
{
static int MyFunction(int x, int y)
{
return x + y;
}
}

class MyClass
{
private string _name;
public string GetName() { return _name; }
public void SetName(string name) { _name = name; }
}
}

I like being able to have a function that isn't defined as a static method on a static class. I know that with a static class you can have static members that the method can refer to and you can't do that with a namespace... but there are many times when a function doesn't refer to any members. It would be nice if the language allowed me to express this in a straightforward way instead of requiring me to use a static class. Also, wouldn't this make exports from language that allow this (like F#) more natural to work with in C#?

NEW POST: Language Assistance

AlexanderMorou — Mon, 25 May 2009 19:13:19 GMT

I'm just curious,

I'm writing a compiler framework for a language framework I'm trying to build. I'm interested to know where I can find technical information on how to implement certain 4.0 features, such as baking the essential PIA into the target assembly, call-site embedding, runtime call-site resolution (for proper interop with other languages on the DLR).

I know enough to realize that the entire thing won't be easy, and I'm also curious as to how to properly cache the call-site once it's resolved, is it cached per instance, per type, handled by the DLR itself, or some other mixture? Perhaps there's something else I'm missing, because certain DLR languages have object instances that can self modify their method availability.

Any response is appreciated.

NEW POST: Operator Overloading

Avel — Sat, 16 May 2009 15:53:28 GMT

When develop a set of mathematical classes I noticed a pattern in my coding:
(These are generic examples)

static public ReturnType operator + (InType1 left, InType2 right)
{
ReturnType result = new ReturnType();

result.somemember = left.someothermember + right.yetanothermember;

return result;
}

static public ReturnType operator - (InType1 left, InType2 right)
{
ReturnType result = new ReturnType();

result.somemember = left.someothermember - right.yetanothermember;

return result;
}

// Same operations but with the order of the input types reversed.
static public ReturnType operator + (InType2 left, InType1 right)
{
ReturnType result = new ReturnType();

result.somemember = left.someothermember + right.yetanothermember;

return result;
}

static public ReturnType operator - (InType2 left, InType1 right)
{
ReturnType result = new ReturnType();

result.somemember = left.someothermember - right.yetanothermember;

return result;
}

This is suggestive of a type of templating. How about the following tokens?

static public ReturnType operator +- (~ InType1 left, InType2 right)
{
ReturnType result = new ReturnType();

result.somemember = left.someothermember +- right.yetanothermember;

return result;
}

Usage:

InType1 first = new InType1();
InType2 second = new InType2();
ReturnType result;

// Useless code of course, but works for the purpose of demonstration.
result = first + second;
result = second + first;
result = first - second;
result = second - first;

The "-", "*/", "-*/", "<>", etc. tokens inside the function block would indicate where the proper operator would be substituted. The "(~" would simply mean that the order of the arguments can be reversed. The compiler would essentially do this:

function x(arg1 x, arg2 y) {...}
function x(arg2 x, arg1 y) {return x(y,x);}

This is simply much what the compiler does already for "+=", "-=" and other automatically overloaded operators.

NEW POST: add reference

chandra2ravi — Wed, 06 May 2009 08:08:12 GMT

if any refernce error comes that time automatically add refernce to project.

NEW POST: Decompile C# Exe&Dll

MACIR — Sun, 03 May 2009 04:06:11 GMT

Are there any works in C# 4, for prevent "decompile exe and dll files" which are written in .NET ?
I mean, I want to protect my exe and dll files from decompilers. I don't want to pay money to obfuscators.
Has Microsoft Visual Studio 2010 compiler any new protection method for this ?

Sorry for my bad English,
Best Regards.

NEW POST: Suggestion: Enum

Gritcsenko — Thu, 30 Apr 2009 09:23:54 GMT

I want to derive one enum from another
For example: I have some error codes and I need to extend enum with extended/additional codes.

NEW POST: New feature: Keyword 'that'

MarioTP — Fri, 17 Apr 2009 18:52:45 GMT

Hhmm, nice idea.
But if you use "class" instead, then it has to be "object" instead of "this" ;-)!