Question on operator 'new' in c#.

[Andrea]

I found in internet this example of code. I'd like to know somthing about
what happens behind the scenes when these lines of code are executed:

//----------- Code Snippet ----------------------------

GenericCustomer[] Customers = new GenericCustomer[2];

Customers[0] = a;

Customers[1] = b;

//------------End Of Code Snippet-------------------------------------------

If i would be in a C/C++ environment this should be a dangling reference,
but since i've a garbage collector, what happen to the two objects created
with "new[2]", are they replaced by the two objects or are they passed to
the Garbage Collector to determine they life-time...?

//--------------------------------------Complete
Example---------------------------

public abstract class GenericCustomer {

private string name;

protected decimal balance;

public override string toString() {

string Result = "Customer: "+name;

Result+= ", owing: "+balance;

return Result;

}
public string Name {

get {

return name;

}

set {

name = value;

}

}
public decimal Balance {

get {

return balance;

}

}
public void RecordPayment(decimal amountPaid) {

balance += amountPaid;

}
public abstract void RecordCal(uint nMinutes)

}

public class PayAsYouGoCustomer : GenericCustomer {

public override void RecordCall(uint nMinutes) {

balance += nMinutes*0.5;

}

}

public class GoldCustomer : GenericCustomer {

public override void RecordCall(uint nMinutes) {

balance += nMinutes*0.1;

}

}

public class EntryPoint {

public static void Main() {

GenericCustomer a = new GoldCustomer();
GenericCustomer b = new PayAsYouGoCustomer();

a.name = "A";
b.name = "B";

GenericCustomer[] Customers = new GenericCustomer[2];

Customers[0] = a;
Customers[0].RecordCall(25);
Customers[0].RecordCall(75);
Customers[1] = b;
Customers[1].RecordCall(75);

foreach (GenericCustomer customer in Customers) {

Console.WriteLine("{0} owes {1}", customer.Name, customer.Balance);

}
}

}

//--------------------------------------End of Complete
Example---------------------------

[Kevin Chandler]

The new[2] does not create 2 GenericCustomer objects. This is a big
difference between c/c++ and c#. The new does nothing more than create the
array. The contents of the array are empty.

In c#, if you want to create an array and fill it with object (like what
c/c++ does), you need to assign each element in the array to a new
GenericCustomer.

I hope I understood your question and that this helps,
Kevin

"Andrea" <ky*****@hotmail.com> wrote in message
news:eU**************@TK2MSFTNGP11.phx.gbl...

I found in internet this example of code. I'd like to know somthing about
what happens behind the scenes when these lines of code are executed:

//----------- Code Snippet ----------------------------

GenericCustomer[] Customers = new GenericCustomer[2];

Customers[0] = a;

Customers[1] = b;

//------------End Of Code

Snippet-------------------------------------------

[Rob Windsor]

Hi Andrea,

Your basically right. The two GenericCustomer objects created in the first
line will no longer have references to them after the third line completes
and thus they will be destroyed the next time the garbage collector runs. It
should be noted that unless you explicitly request a garbage collection
there is no way to know when the next collection will occur, it may not
happen until just before the application terminates.

--
Rob Windsor
G6 Consulting
Toronto, Canada
"Andrea" <ky*****@hotmail.com> wrote in message
news:eU**************@TK2MSFTNGP11.phx.gbl...

I found in internet this example of code. I'd like to know somthing about
what happens behind the scenes when these lines of code are executed:

//----------- Code Snippet ----------------------------

GenericCustomer[] Customers = new GenericCustomer[2];

Customers[0] = a;

Customers[1] = b;

//------------End Of Code Snippet-------------------------------------------
If i would be in a C/C++ environment this should be a dangling reference,
but since i've a garbage collector, what happen to the two objects created
with "new[2]", are they replaced by the two objects or are they passed to
the Garbage Collector to determine they life-time...?

//--------------------------------------Complete
Example---------------------------

public abstract class GenericCustomer {

private string name;

protected decimal balance;

public override string toString() {

string Result = "Customer: "+name;

Result+= ", owing: "+balance;

return Result;

}
public string Name {

get {

return name;

}

set {

name = value;

}

}
public decimal Balance {

get {

return balance;

}

}
public void RecordPayment(decimal amountPaid) {

balance += amountPaid;

}
public abstract void RecordCal(uint nMinutes)

}

public class PayAsYouGoCustomer : GenericCustomer {

public override void RecordCall(uint nMinutes) {

balance += nMinutes*0.5;

}

}

public class GoldCustomer : GenericCustomer {

public override void RecordCall(uint nMinutes) {

balance += nMinutes*0.1;

}

}

public class EntryPoint {

public static void Main() {

GenericCustomer a = new GoldCustomer();
GenericCustomer b = new PayAsYouGoCustomer();

a.name = "A";
b.name = "B";

GenericCustomer[] Customers = new GenericCustomer[2];

Customers[0] = a;
Customers[0].RecordCall(25);
Customers[0].RecordCall(75);
Customers[1] = b;
Customers[1].RecordCall(75);

foreach (GenericCustomer customer in Customers) {

Console.WriteLine("{0} owes {1}", customer.Name, customer.Balance);

}
}

}

//--------------------------------------End of Complete
Example---------------------------

[Frank Oquendo]

Thus spake Andrea:

GenericCustomer[] Customers = new GenericCustomer[2]; <snip> If i would be in a C/C++ environment this should be a dangling
reference, but since i've a garbage collector, what happen to the two
objects created with "new[2]", are they replaced by the two objects
or are they passed to the Garbage Collector to determine they
life-time...?

A simple test will reveal that you have an array of null references.

--
There are 10 kinds of people. Those who understand binary and those who
don't.

http://code.acadx.com

[100]

"Rob Windsor" <rw******@NO.MORE.SPAM.bigfoot.com> wrote in message
news:e3**************@TK2MSFTNGP11.phx.gbl...

Hi Andrea,

Your basically right. The two GenericCustomer objects created in the first
line will no longer have references to them after the third line completes
and thus they will be destroyed the next time the garbage collector runs. It should be noted that unless you explicitly request a garbage collection
there is no way to know when the next collection will occur, it may not
happen until just before the application terminates.

--
Rob Windsor
G6 Consulting
Toronto, Canada
Hi Rob,
Speaking of C# the first line creates only one object and it is of type
derived from System.Array. There is no GenericCustomer objects created. To
be more strict GenericCustomer objects will be created if GenericCustomer is
a vaue type. In the last case these value-type objects are not considered
for GC, though.

This is the big difference between C/C++ and C# arrays.

B\rgds
100


"Andrea" <ky*****@hotmail.com> wrote in message
news:eU**************@TK2MSFTNGP11.phx.gbl...

I found in internet this example of code. I'd like to know somthing about what happens behind the scenes when these lines of code are executed:

//----------- Code Snippet ----------------------------

GenericCustomer[] Customers = new GenericCustomer[2];

Customers[0] = a;

Customers[1] = b;

//------------End Of Code

Snippet-------------------------------------------

If i would be in a C/C++ environment this should be a dangling reference, but since i've a garbage collector, what happen to the two objects created with "new[2]", are they replaced by the two objects or are they passed to the Garbage Collector to determine they life-time...?

//--------------------------------------Complete
Example---------------------------

public abstract class GenericCustomer {

private string name;

protected decimal balance;

public override string toString() {

string Result = "Customer: "+name;

Result+= ", owing: "+balance;

return Result;

}
public string Name {

get {

return name;

}

set {

name = value;

}

}
public decimal Balance {

get {

return balance;

}

}
public void RecordPayment(decimal amountPaid) {

balance += amountPaid;

}
public abstract void RecordCal(uint nMinutes)

}

public class PayAsYouGoCustomer : GenericCustomer {

public override void RecordCall(uint nMinutes) {

balance += nMinutes*0.5;

}

}

public class GoldCustomer : GenericCustomer {

public override void RecordCall(uint nMinutes) {

balance += nMinutes*0.1;

}

}

public class EntryPoint {

public static void Main() {

GenericCustomer a = new GoldCustomer();
GenericCustomer b = new PayAsYouGoCustomer();

a.name = "A";
b.name = "B";

GenericCustomer[] Customers = new GenericCustomer[2];

Customers[0] = a;
Customers[0].RecordCall(25);
Customers[0].RecordCall(75);
Customers[1] = b;
Customers[1].RecordCall(75);

foreach (GenericCustomer customer in Customers) {

Console.WriteLine("{0} owes {1}", customer.Name, customer.Balance);

}
}

}

//--------------------------------------End of Complete
Example---------------------------

[Andrea]

thank you all.
How do you do this memory test?
"Frank Oquendo" <fr****@acadx.com> ha scritto nel messaggio
news:uw**************@tk2msftngp13.phx.gbl...

Thus spake Andrea:

GenericCustomer[] Customers = new GenericCustomer[2];

<snip>

If i would be in a C/C++ environment this should be a dangling
reference, but since i've a garbage collector, what happen to the two
objects created with "new[2]", are they replaced by the two objects
or are they passed to the Garbage Collector to determine they
life-time...?

A simple test will reveal that you have an array of null references.

--
There are 10 kinds of people. Those who understand binary and those who
don't.

http://code.acadx.com

[Frank Oquendo]

Thus spake Andrea:

thank you all.
How do you do this memory test?

Here's some code. Substitute your GenericCustomer class to make the test
more relevant to your scenario:

using System;

namespace ConsoleApplication3
{
class Class1
{
[STAThread]
static void Main(string[] args)
{
object[] objects = new object[2];
string temp;

for (int i = 0; i < objects.Length; i++)
{
temp = objects[i] == null ? "null" : "instantiated";
Console.WriteLine("Object {0} is {1}", i, temp);
}

Console.ReadLine();
}
}
}

--
There are 10 kinds of people. Those who understand binary and those who
don't.

http://code.acadx.com

[Andrea]

thanks again.

"Frank Oquendo" <fr****@acadx.com> ha scritto nel messaggio
news:%2****************@TK2MSFTNGP09.phx.gbl...

Thus spake Andrea:

thank you all.
How do you do this memory test?

Here's some code. Substitute your GenericCustomer class to make the test
more relevant to your scenario:

using System;

namespace ConsoleApplication3
{
class Class1
{
[STAThread]
static void Main(string[] args)
{
object[] objects = new object[2];
string temp;

for (int i = 0; i < objects.Length; i++)
{
temp = objects[i] == null ? "null" : "instantiated";
Console.WriteLine("Object {0} is {1}", i, temp);
}

Console.ReadLine();
}
}
}

--
There are 10 kinds of people. Those who understand binary and those who
don't.

http://code.acadx.com

[Jon Skeet]

Andrea <ky*****@hotmail.com> wrote:

How do you do this memory test?

if (Customers[0]==null)
...

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too