What are the bad features of C#?

[Dave Kerr]

Lack of support for C++ style 'const' (but this is a .NET limitation) and the inability to create generics for maths, i.e. class Matrix { } you can't make a matrix template for ints/floats/complex numbers because you cannot say in a template definition something like: class Matrix where T : *,+,-,/ So mathematical templates are darn near impossible to make. But other than that C# is pretty darn good. also 'dynamic' types are a nice time saver syntactically, but not very sensible in a static language.

My Blog: www.dwmkerr.com My Charity: Children's Homes Nepal

[OriginalGriff]

All listed here[^] I'm afraid.

If you get an email telling you that you can catch Swine Flu from tinned pork then just delete it. It's Spam.

[BobJanova]

They are nice (I love Linq extension methods), but still not as nice as if the language did it natively.

[dusty_dex]

Not being able to convert an old project in order to recompile against later frameworks, if you didn't get the version of VS that did the conversion. VS2003 will convert 2001 projects. VS2005 won't. It's a similar situation converting Visual C/C++ 6 projects. in VS2005 it can't be done unless you happen to have VS2003 lying around to do an intermediate conversion. I suppose the fear factor will keep the money rolling in for Microsoft when developers get wind of these issues. A syntax shortcoming recently discussed on CP.

break <label>;

"It's true that hard work never killed anyone. But I figure, why take the chance." - Ronald Reagan That's what machines are for. Got a problem? Sleep on it.

[AspDotNetDev]

BobJanova wrote:

not as nice as if the language did it natively

That's the second time somebody has said that recently. I don't understand why it matters if the language does it natively. The language supports LINQ, and LINQ does it, so what's the problem with that? If you really wanted, you could even extend LINQ (e.g., myList.AllToString()), overload the plus operator (e.g., new MyArray(a) + new MyArray(b)), or create an extension method and overloaded operator (e.g., a.Extras() + b.Extras()).

Thou mewling ill-breeding pignut!

[Lost User]

It's got a bad pedigree. It's from Mickeysoft.

Sent from my BatComputer via HAL 9000 and M5

[Richard Deeming]

In your first example, it's not immediately obvious what you're expecting to happen. Should the output be:

{ 1, 4, 6, 8, 21, 2, 1, -3, 5, 9 }

Or:

{ 3, 5, 3, 13, 30 }

If it's the second option, what should happen if the operands have different lengths? Different types? Different ranks? Your solution has a much higher cognitive overhead than simply:

int[] c = a.Zip(b, (x, y) => x + y).ToArray();

For your second example, you could use:

List<string> textReps = myList.ConvertAll(Convert.ToString);

It even works with arrays:

string[] testReps = Array.ConvertAll(myArray, Convert.ToString);

---

"These people looked deep within my soul and assigned me a number based on the order in which I joined." - Homer

[Richard Deeming]

AspDotNetDev wrote:

List<string> textReps = myList.Select((x) => x.ToString()).ToList();

Easy to break: ;P

List<object> myList = new List<object> { 1, "dragon", null };

---

"These people looked deep within my soul and assigned me a number based on the order in which I joined." - Homer

[Richard Deeming]

It's quite easy to use LINQ expressions to create generic operators. There's a decent example in the MiscUtil project: http://www.yoda.arachsys.com/csharp/miscutil/[^] You essentially do something like this:

public static class GenericOperator<T>
{
private static Func<T, T, TResult> Create<TResult>(Func<Expression, Expression, BinaryExpression> body)
{
try
{
Type typeT = typeof(T);
var left = Expression.Parameter(typeT, "left");
var right = Expression.Parameter(typeT, "right");

        if (typeT.IsEnum)
        {
            Type enumType = Enum.GetUnderlyingType(typeT);
            var x = Expression.Convert(left, enumType);
            var y = Expression.Convert(right, enumType);

            Expression op = body(x, y);
            if (op.Type == enumType) op = Expression.Convert(op, typeT);

            return Expression.Lambda<Func<T, T, TResult>>(op, left, right).Compile();
        }

        return Expression.Lambda<Func<T, T, TResult>>(body(left, right), left, right).Compile();
    }
    catch (InvalidOperationException ex)
    {
        string message = ex.Message;
        return delegate { throw new InvalidOperationException(message); };
    }
    catch (ArgumentException ex)
    {
        string message = ex.Message;
        return delegate { throw new InvalidOperationException(message); };
    }
}

private static readonly Lazy<Func<T, T, T>> \_add = Create<T>(Expression.Add);

public static Func<T, T, T> Add
{
    get { return \_add.Value; }
}

}

public static class GenericMath
{
public static T Add<T>(T left, T right)
{
return GenericOperator<T>.Add(left, right);
}
}

And then in your generic class, you just use:

T x = someValue;
T y = someOtherValue;
T result = GenericMath.Add(x, y);

The only problem is that you can't constrain the type parameters to have the required operators. If they don't, you'll get an InvalidOperationException when you call the relevant method.

---

[Richard Deeming]

I haven't seen that problem. It's possibly related to the project file format changes when they switched to MSBuild. From what I've seen, VS2012 can open projects created in 2005, 2008 or 2010 without any problems (unless the project type has been discontinued, which happens far too often!).

---

"These people looked deep within my soul and assigned me a number based on the order in which I joined." - Homer

[dusty_dex]

Yes, the project file format changed between VS2003 and 2005, and like you say MSBUILD is the new way of doing things. I tried the express version of VS2008 but it drove me nuts. I'll be sticking with VS2005 until I find something equally stable/reliable. I don't need LINQ features right now, just x64 bits.

"It's true that hard work never killed anyone. But I figure, why take the chance." - Ronald Reagan That's what machines are for. Got a problem? Sleep on it.

[H Brydon]

The fact that (like C, C++, java, VB.NET) there are two (2) types of whitespace in source code, which give endless hours of argument between fanboys of the "tabs not spaces" and "spaces not tabs" religions.

-- Harvey

[AspDotNetDev]

It's a feature. Helps you find the nulls. :rolleyes:

Thou mewling ill-breeding pignut!

[Big Daddy Farang]

What problem have you had converting Visual C/C++ 6 workspaces? I've been able to convert them using VS2005, VS2008, and VS2010 by simply double clicking the .dsw file from Windows Explorer.

BDF I often make very large prints from unexposed film, and every one of them turns out to be a picture of myself as I once dreamed I would be. -- BillWoodruff

[PIEBALDconsult]

I thought we went over that last week. http://www.codeproject.com/Lounge.aspx?msg=4510499#xx4510499xx[^]

[BobJanova]

I meant piecewise add, as implemented in APL family languages, or R or Matlab etc. Different lengths, error; different types, depends on what arguments the function will accept; different ranks, fine if the function can take an array/list on one side and a scalar on the other, for example

int[][] a = { { 1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int[] b = {10, 20, 30};
int[][]c = a + b; // {{11, 12, 13}, {24, 25, 26}, {37, 38, 39}}

Your solution has a much higher cognitive overhead than simply:

What? How can something which has two function calls, an implicit loop and a lambda be 'simpler' than a single symbol, 'add these things up'? The second example was only using ToString as an example of a method call, you should be able to call any method on the element type.

[Richard Deeming]

BobJanova wrote:

What? How can something which has two function calls, an implicit loop and a lambda be 'simpler' than a single symbol, 'add these things up'?

My longer version is simpler to read and understand than your single-symbol version, because you don't have to stop and think about the precise behaviour of the symbol. As I mentioned, there are several possible things that (int[]) + (int[]) could mean; you've just chosen one arbitrarily based on another family of languages. Think of it like using XOR to swap integers[^]; it might look cool and avoid the need for a temporary holding variable, but it's much harder to understand at a glance than a simple swap.

---

"These people looked deep within my soul and assigned me a number based on the order in which I joined." - Homer

[Richard Deeming]

Don't forget line endings: http://www.hanselman.com/blog/YoureJustAnotherCarriageReturnLineFeedInTheWall.aspx[^] And I don't think these arguments are restricted to any particular language. The only languages which are immune are the ones where white-space is significant.

---

"These people looked deep within my soul and assigned me a number based on the order in which I joined." - Homer

[DaveyM69]

Don't know if this is specifically C# or a general .NET thing, but protected internal meaning protected OR internal so I can't have something restricted to only be accessible to derrived objects within the assembly :mad:

Dave
Binging is like googling, it just feels dirtier. Please take your VB.NET out of our nice case sensitive forum. Astonish us. Be exceptional. (Pete O'Hanlon)
BTW, in software, hope and pray is not a viable strategy. (Luc Pattyn)