Discussions

stevo_ said:

VB will use its own library to do string comparisons, of which is will essentially say that, null is nothing, zero length is nothing. If you pull the IL apart, you'll find VB calling a visual basic compiler services method of some sort.

Kinda one of the reasons I don't like VB, brings a ton of crap with it (althought I think I heard you can tell the compiler not to do this now).

littleguru said:

TommyCarlier said:

*snip*

This looks exactly like the property initializers in C# 3.5...

Open up the Solution Explorer and expand the References tab. You should delete System.Web.Extentions and then re-add the file via Add Reference and it'll be in the .NET tab.

Yggdrasil said:

TommyCarlier said:

*snip*

VB also had the With keyword to do the same. I don't know if it's available still in VB.NET.
It's not actually the same thing, since this implies that all method calls work on the same instance, while the fluent interfaces can, theoretically, modify the object being passed between them, like the "20.minutes().ago()" example.

Bas said:

evildictaitor said:

*snip*

So why didn't they change it to just say "button_Click(); (Press Tab to insert)"?

Bas said:

Why does Visual Studio still come up with the "New EventHandler(button_Click); (Press tab to insert)" tooltip when that approach is no longer necessary?

Dexter said:

evildictaitor said:

*snip*

Depends on what you really mean by "contract" in this case. In any case:

- .NET/C# interfaces are a weak form of contracts. All they do is require a class to implement some methods, everything else is left to the documentation.
- There's nothing stopping an implementation to exceed contract requirements.
- Stream's IDisposable implementation exceeds contract requirements and documents that thus becoming a contract in itself because that's how contracts are defined in .NET/C#.
- Contract or not, the fact that Stream.Dispose writes changes to the store was documented and no matter how the internal implementation changs this must remain true.


And since _stevo mentioned transactions: the TransactionScope is a perfect example of exceeding IDisposable's "contract". It does the opposite of Stream, it rollbacks any changes that were made. Not only it does that but that's the only way to rollback a transaction because there's no Rollback method provided. Even more, TransactionScope.Dispose documentation does not mention anything about realising managed and unmanaged resources.

I guess TransactionScope's creation was the moment when IDisposable silently converted to a general purpose interface beyond its "release managed and unmanaged resources" original intent. Because this interface was used by the using C# keyword it is now used to model scope based lifetime similar to C++. Now this is not strictly related to "to Close or not to Close" but about what an "IDisposable contract" can really mean.

jh71283 said:

This is a total guess, but would Object.GetType.ToString work?

If so, you could switch on that...

You won't be able to get a strongly typed version if the type isn't known until runtime. Strong-typing is a compiler protection which relys on the type of the variable being known at compile-time.

The alternative is that if you know that at such-and-such a point in your code that such-and-such an object is definitely an int then you can tell the compiler this fact using the cast-directive:

public void main(){
  someFunc(42, true);
}

public void someFunc (object o, bool oIsDefinitelyAnInt){
  if(oIsDefinitelyAnInt){
    int i = (int)o;  // casts o to an int, and from here on you can use i as if it were an int. Note that if your assertion is wrong you'll get an exception here.
  }
}

blowdart said:

evildictaitor said:

*snip*

Actually that's what I do elsewhere *grin*

The problem arises due to WCF error handlers; you can apply a global error handler to each endpoint. It gets exceptions as a parameter; which you may well then want to turn into SOAP faults.

Now in my case it's reasonably easy; there's only 5 exceptions I want to marshal to faults (so a small if IS else if IS works); but I thought it would be nice to open it up.