C#

control.Invoke(delegate() { control.Text=text; });

Cannot convert anonymous method to type 'System.Delegate' because it is not a delegate type

private void
ToggleEnable
(
    object           sender
,
    System.EventArgs e
)
{
    if ( this.InvokeRequired )
    {
        this.Invoke ( new System.EventHandler ( ToggleEnable ) , sender , e ) ;
    }
    else
    {
        System.Windows.Forms.Control c = sender as System.Windows.Forms.Control ;

        if ( c != null )
        {
            c.Enabled = !c.Enabled ;
        }
    }

    return ;
}

private void ToggleEnable(object sender,System.EventArgs e) {
	System.Windows.Forms.Control c = sender as System.Windows.Forms.Control;
	if (c!=null) {
		if (c.InvokeRequired) {
			c.Invoke(new System.EventHandler(ToggleEnable), sender, e);
		} else {
			c.Enabled = !c.Enabled;
		}
	}
}

Hankyaku wrote:

calculations in a separate thread

Hankyaku wrote:

hopefully I won't have to write again

PIEBALDconsult wrote:

I know the language doesn't require it, but it should

PIEBALDconsult wrote:

just as C used to require parameters around the value

return ;
return expression ;

Luc Pattyn wrote:

similar to breaks in switch cases

Luc Pattyn wrote:

you mean parentheses?

switch(myInt) {
case 0:
case 1:
    ...
    break;
case 2:
case 5:
case 6:
case 7:
    ...
    break;
}

switch ( myInt )
{
    case 0:
    case 1:
    {
        ...
    }

    case 2:
    case 5:
    case 6:
    case 7:
    {
        ...
    }
}

switch ( myInt ) {
   int x, y;
   case 1:
        x=...;
        y=...;
        return x*y;
   case 7:
        x=...;
        y=...;
        return x/y;
}

switch ( myInt ) {
   case 1:
	int x=2;
	int y=3;
	return x*y;
   case 7:
	x=3;
	y=4;
	return x/y;
}

switch (myInt)
{
    case 1:
        int x = 2;
        int y = 3;
        return x * y;
    case 7:
        return x / y;
}

switch ( x )
{
    int i = 42 ; // Will be uninitialized (no warning?)

    case 1 :
    {
        int j = 42 ; // This, of course, is limited to this scope
    }
}

Luc Pattyn wrote:

do you see a way to generalize without much expense

Luc Pattyn wrote:

generalize without much expense

private void
DoSomething
(
    object           sender
,
    System.EventArgs e
)
{
    System.Windows.Forms.Control c = sender as System.Windows.Forms.Control ;

    if ( c == null )
    {
        throw ( new System.InvalidCastException ( "sender must be a System.Windows.Forms.Control" ) ) ;
    }

    if ( c.InvokeRequired )
    {
        c.Invoke ( new System.EventHandler ( DoSomething ) , sender , e ) ;
    }
    else
    {
        EventArgsWrapper w = e as EventArgsWrapper ;

        if ( w == null )
        {
            throw ( new System.InvalidCastException ( "e must be an EventArgsWrapper" ) ) ;
        }

        if ( w is EnabledEventArgs )
        {
            c.Enabled = ((EnabledEventArgs) w).Enabled ;
        }
        else if ( w is TextEventArgs )
        {
            c.Text = ((TextEventArgs) w).Text ;
        }
    }

    return ;
}

            // sender is already known to be a Control in this case
            string temp = sender.Text ;

            this.DoSomething ( sender , new EnabledEventArgs ( false , e ) ) ;
            this.DoSomething ( sender , new TextEventArgs ( "Wait..." , e ) ) ;

            /* Long-running process */
            System.Threading.Thread.Sleep ( 5000 ) ;

            this.DoSomething ( sender , new TextEventArgs ( temp , e ) ) ;
            this.DoSomething ( sender , new EnabledEventArgs ( true , e ) ) ;

public abstract class EventArgsWrapper : System.EventArgs
{
    public System.EventArgs InnerEventArgs { get ; private set ; }

    public EventArgsWrapper
    (
        System.EventArgs InnerEventArgs
    )
    {
        this.InnerEventArgs = InnerEventArgs ;

        return ;
    }
}

public sealed class TextEventArgs : EventArgsWrapper
{
    public string Text { get ; private set ; }

    public TextEventArgs
    (
        string           Text
    ,
        System.EventArgs InnerEventArgs
    )
    : base
    (
        InnerEventArgs
    )
    {
        this.Text = Text ;

        return ;
    }
}

Luc Pattyn wrote:

Maybe use your style for