I think this would make the bar much lower for creating frameworks that are both dynamic and yet very performant as well.

Would there ever be consideration for a syntax that allows declaration of extension methods/properties via a different kind of class definition?

For example:

// extension class
// can only access public members of parent type
// only methods and properties can be defined; no fields
public extension class ListExtensions<T> : List<T> 
{

  // extension method
  public int foo() 
  {
    /* ... */
    return this.size(); // this refers to any List<T> instance.
  }

  // extension property
  public int bar
  {
    get { /* ... */ return this.size(); }
    set { /* ... */ }
  }

}

I think it would be a nice thing to have. And in the future it would give any other additions to the "extension" concept a nice home.

Sven Groot said:

vesuvius said:

*snip*

Oh I agree with that. CS students should learn about the unmanaged side of things too. Whether it's sane to start out with C++ though, I don't know. My university was strictly C++ in first year, and way too much time was spent by people trying to figure out C++ the language rather than the problem they were trying to solve. This was even more apparent when I was assistant for that very same first year class a few years later.

 

However, the main issue I was getting at before is that you said you exclude C# because it's managed, yet you did put Java on the list in an earlier post.

I tend to agree that since C# has introduced several new paradigms (functional, declarative, dynamic, etc...), it has become the best language for the majority of projects out there.

However, with all these new capabilities comes complexity.  For a CS student with no experience with programming languages, C# is generally (IMHO) not a good first language.  The language is so powerful and broad now that it is hard to know where to start if you've never been exposed to programming.

C# has had a flood of innovation (LINQ, lambdas, dynamic programming, extension methods, etc...).  Not to mention all of the additional features that C# 1.0 had over Java (delegates, properties, etc...).  The truth is that to you and me C# is beautiful but to a beginner it is simply daunting.

Sven Groot said:

ktr said:

*snip*

Yeah, I thought of that after posting it, but couldn't be arsed to change it.

 

Note that if you do that, you should calculate start incrementally by adding count, not the way it's done now.

Ah, true.

Sven Groot said:

cro said:

*snip*

I think you'll have to use wait handles (in this case I'm using ManualResetEvent which is the most appropriate here I think):

 

public static void ComputeUnits(Unit[] units)
{
    int threadCount = Environment.ProcessorCount;
    int unitsPerThread = units.Length / threadCount;
    int remainder = units.Length % threadCount;
    ManualResetEvent[] evts = new ManualResetEvent[threadCount];

    try
    {
        for( int t = 0; t < threadCount; ++t )
        {
            evts[t] = new ManualResetEvent(false);

            int count = unitsPerThread;
            if( t == threadCount - 1 )
                count += remainder; // Give the last thread the remainder

            int start = t * unitsPerThread;
            ManualResetEvent evt = evts[t]
            ThreadPool.QueueUserWorkItem(obj => ComputeThread(units, start, count, evt));
        }

        WaitHandle.WaitAll(evts);
    }
    finally
    {
        foreach( ManualResetEvent evt in evts )
            evt.Dispose();
    }
}

private static void ComputeThread(Unit[] units, int start, int count, ManualResetEvent evt)
{
    for( int x = start; x < start + count; ++x )
        Compute(units[x]);
    evt.Set();
}

 

Note: never, ever do this if ComputeUnits itself is on a thread pool thread. Waiting on a thread pool thread from another thread pool thread can cause deadlock.

BitFlipper said:

exoteric said:

*snip*

Well, if you look at anonymous methods and captured variables etc, the compiler already creates anonymous classes in that case as you mention. We don't really care too much about the signature of these classes, since they are mostly hidden from us (although you can certainly see them in the debugger). In addition, when you use IEnumerable and yield return, the compiler infers the type from the return value. So if you combine those two concepts, you can basically have tuples with named items, right?

 

So in my example, the type of "result", would be something like "<Tuple>a__1" or whatever, but it would contain the public members with the correct names and types. Edit: And this is also what you would see if you used reflection to query the enclosing class's properties.

 

BTW, in my example then it should really be returned like this:

 

public ITuple Result
{ 
    get { return (Count = runCount, Min = runMin, Max = runMax, Avg = runAvg); } 
}

 

So just like you use IEnumerable when using yield return, you use ITuple, and the return type determines its true signature.

 

 

This is very similar to anonymous types:

var x = new { Count = runCount, Min = runMin, Max = runMax, Avg = runAvg };

The only difference is that anonymous types can only be used in a local scope.  I think that you should be able to return them from methods.  It is still just as type-safe but a lot more succinct:

public var GetAnonymous() {
  return new { Count = runCount, Min = runMin, Max = runMax, Avg = runAvg };
}

W3bbo said:

exoteric said:

*snip*

Methods for working with lists to allow editing them within foreach loops without needing to manage a separate itemsToRemove list yourself:

 

Because C# 3.0 doesn't support generic covariance I couldn't avoid using the Object type in the dictionary.

 

 // how do you do a Dictionary<List<T>,List<T>> where T is unknown? the CLR doesn't support generic inheritance (So you can't do Dictionary<List<Object>,List<Object>> *AND* ensure Object == Object too) private static Dictionary<Object,Object>
 _pendingRemovals = new Dictionary<Object,Object>(); private static List<T> GetPendingRemovals<T>(IList<T> list) { if( !_pendingRemovals.ContainsKey( list ) ) _pendingRemovals.Add( list, new List<T>() ); List<T> pendingRemovals = (List<T>)_pendingRemovals[
 list ]; return pendingRemovals; } /// <summary>Removes <paramref name="removeThis"/> from the list when RemoveCommit is called.</summary> public static void RemovePending<T>(this IList<T> list, T removethis) { List<T> pendingRemovals = GetPendingRemovals(
 list ); pendingRemovals.Add( removethis ); } /// <summary>Removes all pending items from the list</summary> public static void RemoveCommit<T>(this IList<T> list) { List<T> pendingRemovals = GetPendingRemovals( list ); foreach(T item in pendingRemovals) {
 list.Remove( item ); } _pendingRemovals.Remove( list ); } /// <summary>Cancels all pending item removals from <param name="list" /></summary> public static void RemoveCancel<T>(this IList<T> list) { _pendingRemovals.Remove( list ); } /// <summary>Cancels a
 particular pending removal.</summary> public static void RemoveCancel<T>(this IList<T> list, T dontRemoveThis) { List<T> pendingRemovals = GetPendingRemovals( list ); pendingRemovals.Remove( dontRemoveThis ); }

 

Usage:

List<Bar> bar = GetBarList(); foreach(Foo foo in bar) { if( foo.NeedsDeleting ) bar.PendingRemove( foo ); } bar.PendingCommit();

That's pretty cool.  I prefer a different approach, however.

public static void RemoveWhere<T>(this IList<T> list, Func<T, bool> where) { for (int i = 0; i < list.Count; i++) if (where(list[i])) list.RemoveAt(i--); } //... var list = new List<string> { "Jon", "Bob", "Joe", "Herb", "Billy",
 "Boe" }; list.RemoveWhere(s => s.StartsWith("B")); // results in { "Jon", "Joe", "Herb" }

EDIT: Haha, and apparently the library designers agree.  List<T> already defines a RemoveAll method that does the same thing.  To be fair though, this works on any IList<T>.

enum FlyState {
  State1 = 0,
  State2 = 1,
  // ...
}
// ...
var flyStateColors = new Color[Enum.GetValues(typeof(FlyState)).Length];
// or
var flyStateColors = new Color[/* hardcoded value */];
// set a value
flyStateColors[(int)FlyState.State1] = Color.FromArgb(255, 0, 0);
// get a value
var color = flyStateColors[(int)someFlyState];

You could even make extension methods to get/set values of a color array based on FlyState values instead of integer indices.

ktr said:

using System.Windows.Forms; using System.ComponentModel; namespace Test2 { class ProgressBar2 : ProgressBar { [Browsable(false)] [EditorBrowsable(EditorBrowsableState.Never)] [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 public new bool TabStop { get { return ((Control)this).TabStop; } set { ((Control)this).TabStop = value; } } } } 

Also, this won't hide the property from intellisense unless the project you are working on lives in a different DLL from the control.  You also can't have the project that the control lives in open in the same VS instance, otherwise intellisense will pick it up.

using System.Windows.Forms; using System.ComponentModel; namespace Test2 { class ProgressBar2 : ProgressBar { [Browsable(false)] [EditorBrowsable(EditorBrowsableState.Never)] [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 public new bool TabStop { get { return ((Control)this).TabStop; } set { ((Control)this).TabStop = value; } } } } 

sysrpl said:

Virtual constructors.

// public virtual SampleObject(string name)  {  }

 

Virtual static methods.

// public static virtual DoSomething() { }

 

Virtual static constructors.

 // public static virtual SampleObject(string name)  {  }

 

Enumeration set operations.

// textBox.Anchors += { AnchorStyles.Right, AnchorStyles.Bottom };

 

Implementation through delegation.

// public class SomeItems : IList<SomeItem> { private List<SomeItem> items; private implements IList<SomeItem> GetList() { return items; }  }

 

Static method extensions.

// public static void DoSomething(this SomeType, string message);

 

Property extensions.

// public string FunnyName { this SomeType; get; set; }

 

Static property extensions.

// public static string FunnyName { this SomeType; get; set; }

 

Type aliases.

// public typedef SomeItemList = List<SomeItem>;

 

Expando properties and methods.

// instance.SomeNewProperty = 12; instance.SomeNewMethod = (string message) => MessageBox.Show(message);

 

Class references.

// public SomeItemClass = class of SomeItem;

 

Message based dynamic methods.

// public message(1) void DoSomething(ref MessageArgs messageArgs) { }

instance.

@sysrpl

"Expando properties and methods.

// instance.SomeNewProperty = 12; instance.SomeNewMethod = (string message) => MessageBox.Show(message);"

I don't know... Perhaps only in a dynamic context?

dynamic instance = GetInstance();
instance.SomeNewProperty = 12;
instance.SomeNewMethod = (string message) => MessageBox.Show(message);

"You do know you can just use ToString() on an enum to get it's value in string form?"

That's true, but the naming rules for enums don't capture all of unicode  

• Extension Properties 
• Mixins
• Language support for tuple types:
  

  public (int, string) GetSomeTuple() { /* ... */ }

  Perhaps this could even extend to tuples with named properties (much like anonymous types):
  

  public (int Age, string Name) GetSomeTuple() { /* .. */ }

• Better language support for function types (unlimited args, named args)
• More type inference! this leads to my final request...
• Better support for anonymous types (shouldn't be limited to only a local scope):
  

  public anonymous GetSomeObject() { return new { Feature = "Anonymous Types", Version = 2 } }

  
  Still strongly typed, just a lot simpler.

Sven Groot said:

ktr said:

*snip*

Visual Studio's find dialog uses a different regex syntax. This ought to do the trick:

 

:b+x\:Uid="[^"]+"

Not when there are newlines between the quotes.

ktr said:

Harlequin said:

*snip*

Hmm.. that is strange.  That is definitely the right expression.  It works with C#'s regex engine and Javascript's engine too.  I tried using it in VS2008's find dialog and I got the same error.  I don't know how to fix that.  I think they have some custom searches you can perform that are prefixed with a colon.  That kind of botches the regex functionality...

Ok.. i finally figured it out... VS has a different syntax for finding whitespace (:Wh).  Anyway, here it is (this will only work in the find dialog):

:Whx\:Uid="([^"]|:Wh)*"

Harlequin said:

ktr said:

*snip*

Unknown operator on the :

 

Might need an escape or something?

Hmm.. that is strange.  That is definitely the right expression.  It works with C#'s regex engine and Javascript's engine too.  I tried using it in VS2008's find dialog and I got the same error.  I don't know how to fix that.  I think they have some custom searches you can perform that are prefixed with a colon.  That kind of botches the regex functionality...

\s+x:Uid=\"[^\"]+\"

in C#:

var regex = "\\s+x:Uid=\\\"[^\\\"]+\\\"";

... try that

Edit: Updated regex.

Cybermagellan said:

Cybermagellan said:

*snip*

I'm kinda stuck and before when I was at AOL this issue was bypassed by our API but...I digress.

I have my object and i'm chugging along....something isn't working and I think I might be missing the wrong implementation...

Off the Twitter response I'm doing....

xDocument.Descendants("status")

and that works just fine....but status has another decendant of user....that I need some data from....so the XMLObject looks like...

<status>
    <blah>
    <blah>
    <blah>
         <user>
              <name>
              <screen_name>

I can get anything under status, but trying to get the name I'm not able to....

I tried status.Decendants("name").Value but that didn't work....I'm sure it's something simple but I can't figure it out...any help? I also tried NextNode, and some other things and nothing.

EDIT: Figures after I posted I find what I wanted....

foreach(var node in doc.Elements("employees").Elements("employee").Elements("name"))

^- This actually works? it kinda made sense just never seen it before....

stun said:

littleguru said:

*snip*

This is a cool piece of code...I like it.

I haven't had a chance to watch those videos about C# 4.0 and something about dynamic language features...

I don't even have a clue about what they mean by "dynamic" yet.

Anyone who can explain it to me very quickly about what those new dynamic language features are in C# 4.0?

littleguru said:

TommyCarlier said:

*snip*

That's some kind of a nice implementation, very object oriented, awesome... but what about running it multiple times without having to re-create the instance over and over again...

TommyCarlier said:

littleguru said:

*snip*

I was too fast

I read over the constructor that stores the type of the object. I should just acknowledge I'm getting too old, and that young geniuses like LG can make me look stupid

littleguru said:

TommyCarlier said:

*snip*

But: he already extracts the type from the object that's passed in the constructor. Why not use that information and only store the handler that is intended for that type? I mean why storing all the handlers in the dictionary; that doesn't make any sense to me. I mean in the end he's again using the type information to get the appropriate handler and there's no way to change the object that's passed into the constructor after the "Switcher" has been created.

I wouldn't use a hashtable here because it's complete overkill and makes the whole thing slow... We can argue on this when you use some kind of inheritance chain to apply multiple handlers when some are registered for the base classes of the type etc... but in this scenario here, dunno.