What has managed code achieved?

[John]

Hi

What are the advantages actually achieved of managed code? I am not talking
of theory but in reality.

Thanks

Regards

[Cor Ligthert[MVP]]

Tom,

As I often forgot(maybe I do this still) the question mark, this time it was
no question. I simply knew that you was knowing this.

:-)

Cor

"Tom Shelton" <to*********@comcastXXXXXXX.netschreef in bericht
news:_-******************************@comcast.com...

On 2008-10-23, Cor Ligthert[MVP] <No************@planet.nlwrote:

>>
Tom,

>>>
With module level values, then in both VB6 and VB.NET you must
explicitly
set
the object to nothing (or set it to a new reference) if you want the
object to
go away before the program terminates. Oops, in VB.NET you might have
to
also
call dispose on that object.

You know that in VB.Net the object is not removed by either dispose or
setting it to nothing.

That is done by the Garbage Collector

Yes, but it will never be collected as long at the reference remains
active -
which is the point. Just as a VB6 object will never terminate under the
same
circumstances.

--
Tom Shelton

[Paul Clement]

On Wed, 22 Oct 2008 14:11:59 -0400, "Juan T. Llibre" <no***********@nowhere.comwrote:

¤ re:
¤ !Of course with #2 you could actually kill the process that the web app
¤ !was executing under (with Process Explorer) without needing to stop IIS
¤
¤ The process that the web app was executing under *was* the IIS process.
¤ The only way to update/change a dll in classic ASP was to kill the IIS process.

That's true if the application is configured to run with "Low" application protection. Otherwise,
you have a bit more flexibility when running a web application pooled (Medium) or isolated (High)
since they run in a shared or their own process.
Paul
~~~~
Microsoft MVP (Visual Basic)

[Juan T. Llibre]

re:
!That's true if the application is configured to run with "Low" application protection

Yes, Ben had made the same observation...and the statement was qualified.

Juan T. Llibre, asp.net MVP
asp.net faq : http://asp.net.do/faq/
foros de asp.net, en español : http://asp.net.do/foros/
======================================
"Paul Clement" <Us***********************@swspectrum.comwrote in message
news:9a********************************@4ax.com...

On Wed, 22 Oct 2008 14:11:59 -0400, "Juan T. Llibre" <no***********@nowhere.comwrote:

¤ re:
¤ !Of course with #2 you could actually kill the process that the web app
¤ !was executing under (with Process Explorer) without needing to stop IIS
¤
¤ The process that the web app was executing under *was* the IIS process.
¤ The only way to update/change a dll in classic ASP was to kill the IIS process.

That's true if the application is configured to run with "Low" application protection. Otherwise,
you have a bit more flexibility when running a web application pooled (Medium) or isolated (High)
since they run in a shared or their own process.
Paul
~~~~
Microsoft MVP (Visual Basic)

[Alex Clark]

.Net goes a long way toward sandboxing all programmers

who are not MS or MS partners. Each new OS version
also continues in that direction. If MS goes the rest of
the way, blocking all "unsafe" code, they'll have the pieces
in place to achieve a radical transformation of the Windows
product, greatly increasing their own control over how the
product is used and enabling the full redefinition of Windows
as the brains of a service appliance rather than as a software
platform.

The chances of such a thing ever happening is marginal at best. MS implied
that the API in Vista would be primarily managed with unmanaged/COM as a
secondary route for programmers not willing to make the .NET leap - but it
never happened. The majority of Vista's API is still unmanaged, and I seem
to recall a variety of new bits were actually COM related (the supposedly
dead technology).

If MS had wanted to try something like this, they could've done so with
COM - and they made more of an effort with that IMO given some of the APIs
that were available back in the Win2K (and prior) days.

Not to mention that if the Euro courts go nuts over something as simple as
an Office XML standard, something tells me MS wouldn't have much luck
forcing a .NET-only programming model down anyone's throats either :-)

[mayayana]

.Net goes a long way toward sandboxing all programmers

who are not MS or MS partners. Each new OS version
also continues in that direction. If MS goes the rest of
the way, blocking all "unsafe" code, they'll have the pieces
in place to achieve a radical transformation of the Windows
product, greatly increasing their own control over how the
product is used and enabling the full redefinition of Windows
as the brains of a service appliance rather than as a software
platform.

The chances of such a thing ever happening is marginal at best. MS

implied

that the API in Vista would be primarily managed with unmanaged/COM as a
secondary route for programmers not willing to make the .NET leap - but it
never happened. The majority of Vista's API is still unmanaged, and I

seem

to recall a variety of new bits were actually COM related (the supposedly
dead technology).

The progress is going slow, but the direction is
unmistakable. I think the main holdup on Vista
was the problem that .Net is simply far too bloated:

http://www.microsoft-watch.com/artic...1820607,00.asp

If MS had wanted to try something like this, they could've done so with
COM - and they made more of an effort with that IMO given some of the APIs
that were available back in the Win2K (and prior) days.

Not to mention that if the Euro courts go nuts over something as simple as
an Office XML standard, something tells me MS wouldn't have much luck
forcing a .NET-only programming model down anyone's throats either :-)

I don't think it's a matter of shoving it down anyone's
throat. It's a gradual transition, based on the idea that
selling software has seen its heyday and that services
are the way of the future. (Or at least it's the only idea
anyone has right now for keeping profits up.)

There have been great strides already made in the direction
of a services appliance. In 1999 people were outraged to find
that Windows Update was recording registration data from
visitors. MS promised to stop. By the time of WinXP we had
an OS that updates itself without asking, even if you tell it not to...
An OS that's basically spyware... An OS that reports home
periodically for various things, not least of which is WGA
software that challenges your ownership of the Windows install
every 2 weeks. As I understand it, on Vista even the "real"
admin. can't control the system folder. Only MS has rights there.
Meanwhile, any software that's not signed with MS authenticode
elicits security warnings. And with Vista the average Windows
user is being acclimated to having the same rights on their own
PC as a corporate employee has at work.

In all of those cases there are one or more valid reasons
for the changes made. Nevertheless, those changes are
all going in one direction. They all dovetail with Microsoft's
stated plans. And they're all serving to gradually acclimate both
programmers and end users to the notion that what happens on
their PC is not under their control. Meanwhile, people are
encouraged to pay for software by subscription and are being
acclimated to software that "needs" to check online for
updates on a regular basis....software that blurs the line
between online and local.

MS doesn't need to shove anything down anyone's throat.
They can just gradually make it more and more awkward for
"unmanaged" code to run, while simultaneously increasing the
limits on what unmanaged code is capable of doing, and at
the same time expanding their online offerings.

[Cor Ligthert[MVP]]

John,

I was yesterday as well looking to HKW his message, but he wrote it
completely correct. (It looks likes that he givis every year shorter, but as
well even more correct answers)

An object is only removed by the Garbage Collector, when it has itself no
reference anymore (that can simple be because it goes out of scope) and
which everybody forgets, no other object are pointing anymore to it (to use
another word).

This is in fact impossible to do by hand in complex situations and is
therefore one of the main advantages from managed code.

What HKW wrote about dispose in your follow up question is in my idea as
well the only correct answer about the Dispose methods.

Cor


"John Saunders" <[e-mail] in bericht
news:OY**************@TK2MSFTNGP06.phx.gbl...

"Herfried K. Wagner [MVP]" <hi***************@gmx.atwrote in message
news:eW*************@TK2MSFTNGP06.phx.gbl...

>"Scott M." <s-***@nospam.nospamschrieb:

>>The point being that in .NET, the developer doesn't write memory
management code, as was required in VB 6, and that is one advantage of
working in a managed environment.

Well, I have to disagree. Even in VB you have to remove references to
objects if you do not need them any more. For sure, you do not have to
clean up circular references, but it has even been possible to avoid
circular references in VB (by chosing another architecture or by using
weak references).

Would you mind being more specific? Do you mean that in VB.NET we have to
remove references to objects if we don't need them? Do you mean that this
is done by calling Dispose?

--
John Saunders | MVP - Connected System Developer

[Cor Ligthert[MVP]]

Mayama,

Why don't you make it yourself and sell it, you become rich man, you should
not shout that here.

jmo

Cor

"mayayana" <ma********@rcXXn.comschreef in bericht
news:et**************@TK2MSFTNGP04.phx.gbl...

.Net goes a long way toward sandboxing all programmers
who are not MS or MS partners. Each new OS version
also continues in that direction. If MS goes the rest of
the way, blocking all "unsafe" code, they'll have the pieces
in place to achieve a radical transformation of the Windows
product, greatly increasing their own control over how the
product is used and enabling the full redefinition of Windows
as the brains of a service appliance rather than as a software
platform.

The chances of such a thing ever happening is marginal at best. MS

implied

>that the API in Vista would be primarily managed with unmanaged/COM as a
secondary route for programmers not willing to make the .NET leap - but
it
never happened. The majority of Vista's API is still unmanaged, and I

seem

>to recall a variety of new bits were actually COM related (the supposedly
dead technology).

The progress is going slow, but the direction is
unmistakable. I think the main holdup on Vista
was the problem that .Net is simply far too bloated:

http://www.microsoft-watch.com/artic...1820607,00.asp

>If MS had wanted to try something like this, they could've done so with
COM - and they made more of an effort with that IMO given some of the
APIs
that were available back in the Win2K (and prior) days.

Not to mention that if the Euro courts go nuts over something as simple
as
an Office XML standard, something tells me MS wouldn't have much luck
forcing a .NET-only programming model down anyone's throats either :-)

I don't think it's a matter of shoving it down anyone's
throat. It's a gradual transition, based on the idea that
selling software has seen its heyday and that services
are the way of the future. (Or at least it's the only idea
anyone has right now for keeping profits up.)

There have been great strides already made in the direction
of a services appliance. In 1999 people were outraged to find
that Windows Update was recording registration data from
visitors. MS promised to stop. By the time of WinXP we had
an OS that updates itself without asking, even if you tell it not to...
An OS that's basically spyware... An OS that reports home
periodically for various things, not least of which is WGA
software that challenges your ownership of the Windows install
every 2 weeks. As I understand it, on Vista even the "real"
admin. can't control the system folder. Only MS has rights there.
Meanwhile, any software that's not signed with MS authenticode
elicits security warnings. And with Vista the average Windows
user is being acclimated to having the same rights on their own
PC as a corporate employee has at work.

In all of those cases there are one or more valid reasons
for the changes made. Nevertheless, those changes are
all going in one direction. They all dovetail with Microsoft's
stated plans. And they're all serving to gradually acclimate both
programmers and end users to the notion that what happens on
their PC is not under their control. Meanwhile, people are
encouraged to pay for software by subscription and are being
acclimated to software that "needs" to check online for
updates on a regular basis....software that blurs the line
between online and local.

MS doesn't need to shove anything down anyone's throat.
They can just gradually make it more and more awkward for
"unmanaged" code to run, while simultaneously increasing the
limits on what unmanaged code is capable of doing, and at
the same time expanding their online offerings.

[Herfried K. Wagner [MVP]]

"Cor Ligthert[MVP]" <no************@planet.nlschrieb:

An object is only removed by the Garbage Collector, when it has itself no
reference anymore (that can simple be because it goes out of scope) and
which everybody forgets, no other object are pointing anymore to it (to
use another word).

That's not what I said.

Consider the objects A, B, and C, and -denoting a reference:

A -B -C

If A can be reached from the "running code", B and C cannot be finalized.

However, when removing the reference from A to B

A B -C

and neither B nor C can be reached from the "running code", both objects can
be destroyed by the GC although there is a reference from B to C. This even
works if there are circular references between these objects.

--
M S Herfried K. Wagner
M V P <URL:http://dotnet.mvps.org/>
V B <URL:http://dotnet.mvps.org/dotnet/faqs/>

[Gregory A. Beamer \(Cowboy\) - MVP]

"Ben Voigt [C++ MVP]" <rb*@nospam.nospamwrote in message
news:el*************@TK2MSFTNGP02.phx.gbl...

Gregory A. Beamer (Cowboy) - MVP wrote:

>Less Blue Screens by junior developers. ;-)

Blue screens result from kernel-mode bugs. Always. .NET doesn't change
anything in kernel mode.

There was a smiley, but my statement still holds. He asked for advantages of
CLR. As you have stated, I cannot get that deep in the CLR, so no blue
screens. ;-)

--
Gregory A. Beamer
MVP, MCP: +I, SE, SD, DBA

Subscribe to my blog
http://feeds.feedburner.com/GregoryBeamer#

or just read it:
http://feeds.feedburner.com/GregoryBeamer

********************************************
| Think outside the box! |
********************************************

[Cor Ligthert[MVP]]

Herfried,

It is friday evening, and you know as one of the few exactly what that means
for me, I give you an answer in the weekend.

:-)

Cor

"Herfried K. Wagner [MVP]" <hi***************@gmx.atwrote in message
news:e1**************@TK2MSFTNGP05.phx.gbl...

"Cor Ligthert[MVP]" <no************@planet.nlschrieb:

>An object is only removed by the Garbage Collector, when it has itself no
reference anymore (that can simple be because it goes out of scope) and
which everybody forgets, no other object are pointing anymore to it (to
use another word).

That's not what I said.

Consider the objects A, B, and C, and -denoting a reference:

A -B -C

If A can be reached from the "running code", B and C cannot be finalized.

However, when removing the reference from A to B

A B -C

and neither B nor C can be reached from the "running code", both objects
can be destroyed by the GC although there is a reference from B to C.
This even works if there are circular references between these objects.

--
M S Herfried K. Wagner
M V P <URL:http://dotnet.mvps.org/>
V B <URL:http://dotnet.mvps.org/dotnet/faqs/>

[Alex Clark]

The progress is going slow, but the direction is

unmistakable. I think the main holdup on Vista
was the problem that .Net is simply far too bloated:

Something being "far too bloated" has never been a deal-breaker for
Microsoft before, and I doubt it ever will be. One could argue that Windows
and its various subsystems is far too bloated as it stands. Making .NET an
embedded component of the OS and using managed libraries as the only API
method would hardly change that.

I don't think it's a matter of shoving it down anyone's
throat. It's a gradual transition, based on the idea that
selling software has seen its heyday and that services
are the way of the future. (Or at least it's the only idea
anyone has right now for keeping profits up.)

What you're talking about isn't related to embedding the framework into
Windows and using that as the primary API method, you're talking about
software as a service - an idea which MS has been touting and selling (to
varying degrees of success) even before .NET was around.

<largely irrelevant snip>

MS doesn't need to shove anything down anyone's throat.
They can just gradually make it more and more awkward for
"unmanaged" code to run, while simultaneously increasing the
limits on what unmanaged code is capable of doing, and at
the same time expanding their online offerings.

Then they gradually transited in completely the wrong direction with Vista,
didn't they? Aero is completely unmanaged. Why wasn't that .NET based,
seeing as how it was a totally new component of the OS?

I think MS realise that the CLR still hasn't reached the state it needs to
be in to be such an integral part of the OS itself. In future we might see
a change, but I don't see that harming anyone. I don't see it as MS
enforcing their will onto users either. So long as performance doesn't
suffer and we don't lose anything, I'd happily see unmanaged APIs and
(particularly) COM get flushed down the drain in favour of something more
secure, more easily governed, and a whole lot less archaic.

As it stands, I think they'll have to work very hard to kill off unmanaged
code and the C++ gurus that swear by it - after all, they employ a large
number of them. There are also a lot of things that managed code simply
cannot and will never be able to do, namely low level operations. I'd much
rather see a clear distinction where all high level APIs are managed and low
level hardware access is kept unmanaged and raw for performance reasons.

[Wolfgang Enzinger]

On Fri, 24 Oct 2008 14:01:58 -0500, "Alex Clark" wrote:

>Just to clarify, are you saying that in VB6 if you didn't de-reference an
object before it went out of scope, it would automatically be cleaned up
anyway? I'm not saying this in an accusatory manner, but everything I ever
read in terms of good practice and even articles on MSDN seemed to imply
otherwise - in fact I can even remember it being touted as a selling point
to upgrade to VB.NET.

Example (VB6):

Private Sub Test()

Dim objRef As SomeClass
Set objRef = New SomeClass
' ...
' ...
Set objRef = Nothing ' <--- Dereferencing before it goes out of scope

End Sub

Are you saying that the last line, "Set objRef = Nothing", was therefore
unneccesary in VB6?

I think that this is what Ben is saying, and I can confirm that it is
absolutely true. The above "Set objRef = Nothing" is like setting a
string to vbNullString before leaving a sub/function ... it frees
memory but that would happen automatically anyway.

Apart from API calls handled improperly, the only way to produce those
memory leaks that VB is allegedly well known for is to have unresolved
circular object references.

>[...] then apparently VB6 was a bit smarter than I gave it credit for!

Hehe! :-)

Wolfgang

[Herfried K. Wagner [MVP]]

"Alex Clark" <qu****@noemail.noemailschrieb:

Just to clarify, are you saying that in VB6 if you didn't de-reference an
object before it went out of scope, it would automatically be cleaned up
anyway? I'm not saying this in an accusatory manner, but everything I
ever read in terms of good practice and even articles on MSDN seemed to
imply otherwise - in fact I can even remember it being touted as a selling
point to upgrade to VB.NET.

Example (VB6):

Private Sub Test()

Dim objRef As SomeClass
Set objRef = New SomeClass
' ...
' ...
Set objRef = Nothing ' <--- Dereferencing before it goes out of scope

End Sub

Are you saying that the last line, "Set objRef = Nothing", was therefore
unneccesary in VB6? I was always under the impression that memory leaks
courtesy of objects that are still referenced (but out of scope) would
occur if you did *not* de-reference before they went out of scope

No, the reference stored in the local variable would have been removed
automatically. However, there were some pitfalls: Jumping out of a 'With'
block, for example, led to a reference which could not be removed but
prevented the object from being destroyed:

\\\
Private Declare Sub CopyMemory _
Lib "Kernel32.dll" _
Alias "RtlMoveMemory" _
( _
ByRef Destination As Any, _
ByRef Source As Any, _
ByVal Length As Long _
)

Private Sub Form_Click()
Dim f As Form1
Set f = New Form1
Call MsgBox(GetRefCount(f)) ' 1.

' Increments reference count.
With f

' Jumping out of the block does not decrement the
' reference count.
GoTo Label

' Decrements reference count.
End With
Label:
Call MsgBox(GetRefCount(f)) ' 2.
End Sub

Private Function GetRefCount(ByRef Object As IUnknown) As Long
Call CopyMemory(GetRefCount, ByVal ObjPtr(Object) + 4, 4)
GetRefCount = GetRefCount - 2
End Function
///

--
M S Herfried K. Wagner
M V P <URL:http://dotnet.mvps.org/>
V B <URL:http://dotnet.mvps.org/dotnet/faqs/>

[Cor Ligthert[MVP]]

Ok, let me than complete what you did not say.

An object is removed as soon as it has no existing reference anymore itself,
or that its reference is used in another object (not being the object
itself).

It can have a reference in a Module or the Class is Shared (static in C#),
Global or in a method. His own reference will set to nothing: as method
goes out of scope, as its object class goes out of scope "me" ("this" in C#)
or as soon as the program stops; or as a reference is set to another object.

But that is not everything, it will not be removed as long as another
something is pointing to the object, while that object itself is not an
object in the list of that.

An Example.

Drag a datagridview on your form, it will be set in the global part of your
form
Create a datatable with a row and add that to your datatable row collection.
Set that datatable as the dataset of your grid

Now the datatable will not be removed as long as you don't set the
dataSource of the datagridview to nothing or to another datatable.

This is an example as we have often seen here, where people thought it went
wrong (a bug) because they did not understand this.

Cor

>
That's not what I said.

Consider the objects A, B, and C, and -denoting a reference:

A -B -C

If A can be reached from the "running code", B and C cannot be finalized.

However, when removing the reference from A to B

A B -C

[Wolfgang Enzinger]

On Sat, 25 Oct 2008 03:47:55 +0200, "Herfried K. Wagner [MVP]" wrote:

>No, the reference stored in the local variable would have been removed
automatically. However, there were some pitfalls: Jumping out of a 'With'
block, for example, led to a reference which could not be removed but
prevented the object from being destroyed:

Good point, forgot to mention this.

Jumping out of a With block is generally dangerous as can be seen
here:

'***
Option Explicit

Private Type TestType
Value As Long
End Type

Sub main()
Dim tt() As TestType
Dim l As Long
ReDim tt(2)
l = 0
Do
With tt(l)
.Value = l
If .Value = 2 Then Exit Do 'jumps out of block
End With
l = l + 1
Loop
ReDim Preserve tt(1) '->fails with RTE 10, array is locked
End Sub
'***

However, you were talking about *some* pitfalls and jumping out of a
With block as an *example*. Which other situations that lead to
omitted dereferencing do you have in mind?

Wolfgang

[Herfried K. Wagner [MVP]]

"Wolfgang Enzinger" <we******@temporaryforwarding.comschrieb:

However, you were talking about *some* pitfalls and jumping out of a
With block as an *example*. Which other situations that lead to
omitted dereferencing do you have in mind?

Well, I only had the particular scenario I showed in my post in my mind, but
I was thinking about different reasons for jumping out of a 'With' block.

--
M S Herfried K. Wagner
M V P <URL:http://dotnet.mvps.org/>
V B <URL:http://dotnet.mvps.org/dotnet/faqs/>

[William Vaughn \(MVP\)]

I asked around and got this response:
Most "serious" apps that Microsoft ships (including the OS) has a mix of
both .NET managed code and COM/ASM code--some more than others. Some are
nearly all .NET while others are built to use COM and need to be implemented
with COM.

--
__________________________________________________ ________________________
William R. Vaughn
President and Founder Beta V Corporation
Author, Mentor, Dad, Grandpa
Microsoft MVP
[phone] (Pacific time)
Hitchhiker's Guide to Visual Studio and SQL Server (7th Edition)
__________________________________________________ __________________________________________

"Herfried K. Wagner [MVP]" <hi***************@gmx.atwrote in message
news:uv**************@TK2MSFTNGP05.phx.gbl...

"Wolfgang Enzinger" <we******@temporaryforwarding.comschrieb:

>However, you were talking about *some* pitfalls and jumping out of a
With block as an *example*. Which other situations that lead to
omitted dereferencing do you have in mind?

Well, I only had the particular scenario I showed in my post in my mind,
but I was thinking about different reasons for jumping out of a 'With'
block.

--
M S Herfried K. Wagner
M V P <URL:http://dotnet.mvps.org/>
V B <URL:http://dotnet.mvps.org/dotnet/faqs/>

[Cor Ligthert[MVP]]

Hi Bill,

I get the idea that you are answering a message from somebody in a newsgroup
which has removed some groups in the grouplist.

In the VB language group it shows up as an answer to Herfried, but it has in
my idea not anything to do with his message.

Cor

"William Vaughn (MVP)" <bi****@NoSpamBetav.comwrote in message
news:%2****************@TK2MSFTNGP03.phx.gbl...

>I asked around and got this response:
Most "serious" apps that Microsoft ships (including the OS) has a mix of
both .NET managed code and COM/ASM code--some more than others. Some are
nearly all .NET while others are built to use COM and need to be
implemented with COM.

--
__________________________________________________ ________________________
William R. Vaughn
President and Founder Beta V Corporation
Author, Mentor, Dad, Grandpa
Microsoft MVP
[phone] (Pacific time)
Hitchhiker's Guide to Visual Studio and SQL Server (7th Edition)
__________________________________________________ __________________________________________

"Herfried K. Wagner [MVP]" <hi***************@gmx.atwrote in message
news:uv**************@TK2MSFTNGP05.phx.gbl...

>"Wolfgang Enzinger" <we******@temporaryforwarding.comschrieb:

>>However, you were talking about *some* pitfalls and jumping out of a
With block as an *example*. Which other situations that lead to
omitted dereferencing do you have in mind?

Well, I only had the particular scenario I showed in my post in my mind,
but I was thinking about different reasons for jumping out of a 'With'
block.

--
M S Herfried K. Wagner
M V P <URL:http://dotnet.mvps.org/>
V B <URL:http://dotnet.mvps.org/dotnet/faqs/>