What are the bad features of C#?

[AspDotNetDev]

For the first, C# now supports initializer lists. EDIT: I misunderstood your first item. However, LINQ should allow this to be pretty minimal. For the second, you can use LINQ to perform mapping with minimal code.

Thou mewling ill-breeding pignut!

[AspDotNetDev]

How about these:

int[] a = { 1, 2, 3 }, b = { 4, 5, 6 };
int[] c = a.Select((x, index) => x + b[index]).ToArray();

List<object> myList = new List<object>() { 1, "dragon", new Object() };
List<string> textReps = myList.Select((x) => x.ToString()).ToList();

Thou mewling ill-breeding pignut!

[Matthew Faithfull]

1. Unnecessary loss of control. I'm a control freak like most good programmers. Garabage Collection is fine but I must be able to make it happen when I require it and prevent it happening when I require 100% of the available performance. 2. Loss of the compilation unit concept. Removing the separation between header and implementation files is often seen as a good thing but it has non obvious negative effects. I'm no longer able to specify a pure interface for the purposes of export or interop (within the language) which has an implementation but the declaration of which can be used without access to or depenedency on the implementation. The separation of .h and .cpp files was not a mistake, oversight, shortcut or side effect of some other inadequacy. It was a deliberate and sensible idea that certain people at Microsoft never really understood. 3. Loss of dependency control. Removing the #include concept, also related to the loss of compilation units, means I'll never really know precisely what the compiler does and doesn't reference when compiling a class in exact files access terms. Like many such things this is OK if it's right but a nightmare if I have 7 versions of Runtime library headers installed and I can't tell which one it is getting its definitions from. 4. The additional learning requirement of endless extra badly specified and poorly documented 'secondary' languages. Most of the mitigation Microsoft have put in for items 2 and 3 has lead to the addition of yet more different formats of files to a project. App configs, manifests, non compiled resources &c. Every one of these new files is in what is effectively a new language although it is seldom recognised as such. Each and every one requires additional tools and or more knowledge to use it properly. Anything which increases the number of languages, formats, conventions or rules I need to know in order to do my job makes it harder not easier. Every time I have to edit or otherwise interact with one of these kludges I have to to stop thinking in C++ and switch to something else, usually some hacked subset of XML. The switching cost in time, concentration and quality of perception is high and completely unaccounted for by those who promote more and more such sub-domain specific languages. 5. Forcing me to use a JIT compiler when Native compilation should and could be available is another unacceptable loss of control. 6. Not strictly a C# issue, however providing a class library (the CLR) but forcing me to learn and use a new language

[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