Good programming practice question

[alex]

Hi,

I was just wandering which one is correct, better, or better programming
practice?

//Case #1
public class Main
{
ClassA a = new ClassA();
a.Value = "some value";
a = ModifyClassA(a);
Console.WriteLine(a.Value);
}
private ClassA ModifyClassA(ClassA a)
{
a.Value += "something";
return a;
}

Or this:

//Case #2
public class Main
{
ClassA a = new ClassA();
a.Value = "some value";
ModifyClassA(a);
Console.WriteLine(a.Value);
}
private void ModifyClassA(ClassA a)
{
a.Value += "something";
}

//Where CassA is:

public class ClassA
{
string m_value;
public ClassA(){ m_value = "";}
public string Value
{
get{return m_value;}
set{m_value = value;}
}
}

I'm writing this on the fly so sorry if it doesn't compile.
I would appriciage your oppinion.

Thanks,
Alex

[news.microsoft.com]

whats easier for you is what you should use.
"alex" <al*****@yahoo.com> wrote in message
news:uC**************@TK2MSFTNGP12.phx.gbl...

Hi,

I was just wandering which one is correct, better, or better programming
practice?

//Case #1
public class Main
{
ClassA a = new ClassA();
a.Value = "some value";
a = ModifyClassA(a);
Console.WriteLine(a.Value);
}
private ClassA ModifyClassA(ClassA a)
{
a.Value += "something";
return a;
}

Or this:

//Case #2
public class Main
{
ClassA a = new ClassA();
a.Value = "some value";
ModifyClassA(a);
Console.WriteLine(a.Value);
}
private void ModifyClassA(ClassA a)
{
a.Value += "something";
}

//Where CassA is:

public class ClassA
{
string m_value;
public ClassA(){ m_value = "";}
public string Value
{
get{return m_value;}
set{m_value = value;}
}
}

I'm writing this on the fly so sorry if it doesn't compile.
I would appriciage your oppinion.

Thanks,
Alex

[Kevin Carter]

This is subjective, but your Case #2 example seems to be
more clear. If I was going to write it, I'd write
something like #2.

-----Original Message-----
Hi,

I was just wandering which one is correct, better, or better programmingpractice?

//Case #1
public class Main
{
ClassA a = new ClassA();
a.Value = "some value";
a = ModifyClassA(a);
Console.WriteLine(a.Value);
}
private ClassA ModifyClassA(ClassA a)
{
a.Value += "something";
return a;
}

Or this:

//Case #2
public class Main
{
ClassA a = new ClassA();
a.Value = "some value";
ModifyClassA(a);
Console.WriteLine(a.Value);
}
private void ModifyClassA(ClassA a)
{
a.Value += "something";
}

//Where CassA is:

public class ClassA
{
string m_value;
public ClassA(){ m_value = "";}
public string Value
{
get{return m_value;}
set{m_value = value;}
}
}

I'm writing this on the fly so sorry if it doesn't compile.I would appriciage your oppinion.

Thanks,
Alex
.

[news.microsoft.com]

What colour of panties should I wear.

Whats everybody else wearing, I wana copy.

*bleet**bleet**bleet**bleet*

"Kevin Carter" <an*******@discussions.microsoft.com> wrote in message
news:04****************************@phx.gbl...

This is subjective, but your Case #2 example seems to be
more clear. If I was going to write it, I'd write
something like #2.

-----Original Message-----
Hi,

I was just wandering which one is correct, better, or

better programming

practice?

//Case #1
public class Main
{
ClassA a = new ClassA();
a.Value = "some value";
a = ModifyClassA(a);
Console.WriteLine(a.Value);
}
private ClassA ModifyClassA(ClassA a)
{
a.Value += "something";
return a;
}

Or this:

//Case #2
public class Main
{
ClassA a = new ClassA();
a.Value = "some value";
ModifyClassA(a);
Console.WriteLine(a.Value);
}
private void ModifyClassA(ClassA a)
{
a.Value += "something";
}

//Where CassA is:

public class ClassA
{
string m_value;
public ClassA(){ m_value = "";}
public string Value
{
get{return m_value;}
set{m_value = value;}
}
}

I'm writing this on the fly so sorry if it doesn't

compile.

I would appriciage your oppinion.

Thanks,
Alex
.

[Arran Pearce]

Good code practise is quite a big issue when your working in a team, so its
not as if the question deserves that sort of response.
"news.microsoft.com" <di********@discussion.microsoft.com> wrote in message
news:u2**************@TK2MSFTNGP12.phx.gbl...

What colour of panties should I wear.

Whats everybody else wearing, I wana copy.

*bleet**bleet**bleet**bleet*

"Kevin Carter" <an*******@discussions.microsoft.com> wrote in message
news:04****************************@phx.gbl...

This is subjective, but your Case #2 example seems to be
more clear. If I was going to write it, I'd write
something like #2.

-----Original Message-----
Hi,

I was just wandering which one is correct, better, or

better programming

practice?

//Case #1
public class Main
{
ClassA a = new ClassA();
a.Value = "some value";
a = ModifyClassA(a);
Console.WriteLine(a.Value);
}
private ClassA ModifyClassA(ClassA a)
{
a.Value += "something";
return a;
}

Or this:

//Case #2
public class Main
{
ClassA a = new ClassA();
a.Value = "some value";
ModifyClassA(a);
Console.WriteLine(a.Value);
}
private void ModifyClassA(ClassA a)
{
a.Value += "something";
}

//Where CassA is:

public class ClassA
{
string m_value;
public ClassA(){ m_value = "";}
public string Value
{
get{return m_value;}
set{m_value = value;}
}
}

I'm writing this on the fly so sorry if it doesn't

compile.

I would appriciage your oppinion.

Thanks,
Alex
.

[Erik Frey]

A third solution (to consolidate functionality) is this:

//Case #1
public class Main
{
ClassA a = new ClassA();
a.Value = "some value";
a.Modify();
Console.WriteLine(a.Value);
}

//Where ClassA is:

public class ClassA
{
string m_value;
public ClassA(){ m_value = "";}
public string Value
{
get{return m_value;}
set{m_value = value;}
}
public void Modify()
{
m_value += "something";
}
}

[Richard A. Lowe]

Kevin is right #2 is clearer - it avoids a completely non-functional
reference copy, as you have in Case #1. In fact Case #2 could be said to be
a refactor of Case #1 with the non-functional code removed. #1 implies you
are changing out the reference to a for some reason, when in fact you are
always re-assigning it to the same thing again - pointless, IMO.

Richard

--
Veuillez m'excuser, mon Français est très pauvre. Cependant, si vous voyez
mauvais C #, c'est mon défaut!
"alex" <al*****@yahoo.com> wrote in message
news:uC**************@TK2MSFTNGP12.phx.gbl...

Hi,

I was just wandering which one is correct, better, or better programming
practice?

//Case #1
public class Main
{
ClassA a = new ClassA();
a.Value = "some value";
a = ModifyClassA(a);
Console.WriteLine(a.Value);
}
private ClassA ModifyClassA(ClassA a)
{
a.Value += "something";
return a;
}

Or this:

//Case #2
public class Main
{
ClassA a = new ClassA();
a.Value = "some value";
ModifyClassA(a);
Console.WriteLine(a.Value);
}
private void ModifyClassA(ClassA a)
{
a.Value += "something";
}

//Where CassA is:

public class ClassA
{
string m_value;
public ClassA(){ m_value = "";}
public string Value
{
get{return m_value;}
set{m_value = value;}
}
}

I'm writing this on the fly so sorry if it doesn't compile.
I would appriciage your oppinion.

Thanks,
Alex

[news.microsoft.com]

Then discuss it with ur team.
"Arran Pearce" <ar**********@bacoll.ac.uk> wrote in message
news:%2****************@TK2MSFTNGP10.phx.gbl...

Good code practise is quite a big issue when your working in a team, so its not as if the question deserves that sort of response.
"news.microsoft.com" <di********@discussion.microsoft.com> wrote in message news:u2**************@TK2MSFTNGP12.phx.gbl...

What colour of panties should I wear.

Whats everybody else wearing, I wana copy.

*bleet**bleet**bleet**bleet*

"Kevin Carter" <an*******@discussions.microsoft.com> wrote in message
news:04****************************@phx.gbl...

This is subjective, but your Case #2 example seems to be
more clear. If I was going to write it, I'd write
something like #2.

>-----Original Message-----
>Hi,
>
>I was just wandering which one is correct, better, or
better programming
>practice?
>
>//Case #1
>public class Main
>{
> ClassA a = new ClassA();
> a.Value = "some value";
> a = ModifyClassA(a);
> Console.WriteLine(a.Value);
>}
>private ClassA ModifyClassA(ClassA a)
>{
> a.Value += "something";
> return a;
>}
>
>Or this:
>
>//Case #2
>public class Main
>{
> ClassA a = new ClassA();
> a.Value = "some value";
> ModifyClassA(a);
> Console.WriteLine(a.Value);
>}
>private void ModifyClassA(ClassA a)
>{
> a.Value += "something";
>}
>
>//Where CassA is:
>
>public class ClassA
>{
> string m_value;
> public ClassA(){ m_value = "";}
> public string Value
> {
> get{return m_value;}
> set{m_value = value;}
> }
>}
>
>I'm writing this on the fly so sorry if it doesn't
compile.
>I would appriciage your oppinion.
>
>Thanks,
>Alex
>
>
>.
>

[news.microsoft.com]

What is good for youre team may not work for our team. Its a subjective
matter.

If it where the case we wouldnt need software engineers, we would have that
ONE PERFECT APP, or one perect API call.

But we dont.

"news.microsoft.com" <di********@discussion.microsoft.com> wrote in message
news:u%****************@TK2MSFTNGP09.phx.gbl...

Then discuss it with ur team.
"Arran Pearce" <ar**********@bacoll.ac.uk> wrote in message
news:%2****************@TK2MSFTNGP10.phx.gbl...

Good code practise is quite a big issue when your working in a team, so

its

not as if the question deserves that sort of response.
"news.microsoft.com" <di********@discussion.microsoft.com> wrote in

message

news:u2**************@TK2MSFTNGP12.phx.gbl...

What colour of panties should I wear.

Whats everybody else wearing, I wana copy.

*bleet**bleet**bleet**bleet*

"Kevin Carter" <an*******@discussions.microsoft.com> wrote in message
news:04****************************@phx.gbl...
> This is subjective, but your Case #2 example seems to be
> more clear. If I was going to write it, I'd write
> something like #2.
>
> >-----Original Message-----
> >Hi,
> >
> >I was just wandering which one is correct, better, or
> better programming
> >practice?
> >
> >//Case #1
> >public class Main
> >{
> > ClassA a = new ClassA();
> > a.Value = "some value";
> > a = ModifyClassA(a);
> > Console.WriteLine(a.Value);
> >}
> >private ClassA ModifyClassA(ClassA a)
> >{
> > a.Value += "something";
> > return a;
> >}
> >
> >Or this:
> >
> >//Case #2
> >public class Main
> >{
> > ClassA a = new ClassA();
> > a.Value = "some value";
> > ModifyClassA(a);
> > Console.WriteLine(a.Value);
> >}
> >private void ModifyClassA(ClassA a)
> >{
> > a.Value += "something";
> >}
> >
> >//Where CassA is:
> >
> >public class ClassA
> >{
> > string m_value;
> > public ClassA(){ m_value = "";}
> > public string Value
> > {
> > get{return m_value;}
> > set{m_value = value;}
> > }
> >}
> >
> >I'm writing this on the fly so sorry if it doesn't
> compile.
> >I would appriciage your oppinion.
> >
> >Thanks,
> >Alex
> >
> >
> >.
> >

[news.microsoft.com]

Use yer noggin.

*takes notes* "Cannot work under own iniative..."
"news.microsoft.com" <di********@discussion.microsoft.com> wrote in message
news:u%****************@TK2MSFTNGP09.phx.gbl...

Then discuss it with ur team.
"Arran Pearce" <ar**********@bacoll.ac.uk> wrote in message
news:%2****************@TK2MSFTNGP10.phx.gbl...

Good code practise is quite a big issue when your working in a team, so

its

not as if the question deserves that sort of response.
"news.microsoft.com" <di********@discussion.microsoft.com> wrote in

message

news:u2**************@TK2MSFTNGP12.phx.gbl...

What colour of panties should I wear.

Whats everybody else wearing, I wana copy.

*bleet**bleet**bleet**bleet*

"Kevin Carter" <an*******@discussions.microsoft.com> wrote in message
news:04****************************@phx.gbl...
> This is subjective, but your Case #2 example seems to be
> more clear. If I was going to write it, I'd write
> something like #2.
>
> >-----Original Message-----
> >Hi,
> >
> >I was just wandering which one is correct, better, or
> better programming
> >practice?
> >
> >//Case #1
> >public class Main
> >{
> > ClassA a = new ClassA();
> > a.Value = "some value";
> > a = ModifyClassA(a);
> > Console.WriteLine(a.Value);
> >}
> >private ClassA ModifyClassA(ClassA a)
> >{
> > a.Value += "something";
> > return a;
> >}
> >
> >Or this:
> >
> >//Case #2
> >public class Main
> >{
> > ClassA a = new ClassA();
> > a.Value = "some value";
> > ModifyClassA(a);
> > Console.WriteLine(a.Value);
> >}
> >private void ModifyClassA(ClassA a)
> >{
> > a.Value += "something";
> >}
> >
> >//Where CassA is:
> >
> >public class ClassA
> >{
> > string m_value;
> > public ClassA(){ m_value = "";}
> > public string Value
> > {
> > get{return m_value;}
> > set{m_value = value;}
> > }
> >}
> >
> >I'm writing this on the fly so sorry if it doesn't
> compile.
> >I would appriciage your oppinion.
> >
> >Thanks,
> >Alex
> >
> >
> >.
> >

[alex]

Richard, thanks for your post. I also think that case #2 is better because
there is no reassignment of a reference. I just wan't sure how intuitive it
would be for people who would later read the code.

"Richard A. Lowe" <ch*****@yumspamyumYahoo.com> wrote in message
news:OS*************@TK2MSFTNGP10.phx.gbl...

Kevin is right #2 is clearer - it avoids a completely non-functional
reference copy, as you have in Case #1. In fact Case #2 could be said to be a refactor of Case #1 with the non-functional code removed. #1 implies you are changing out the reference to a for some reason, when in fact you are
always re-assigning it to the same thing again - pointless, IMO.

Richard

--
Veuillez m'excuser, mon Français est très pauvre. Cependant, si vous voyez mauvais C #, c'est mon défaut!
"alex" <al*****@yahoo.com> wrote in message
news:uC**************@TK2MSFTNGP12.phx.gbl...

Hi,

I was just wandering which one is correct, better, or better programming
practice?

//Case #1
public class Main
{
ClassA a = new ClassA();
a.Value = "some value";
a = ModifyClassA(a);
Console.WriteLine(a.Value);
}
private ClassA ModifyClassA(ClassA a)
{
a.Value += "something";
return a;
}

Or this:

//Case #2
public class Main
{
ClassA a = new ClassA();
a.Value = "some value";
ModifyClassA(a);
Console.WriteLine(a.Value);
}
private void ModifyClassA(ClassA a)
{
a.Value += "something";
}

//Where CassA is:

public class ClassA
{
string m_value;
public ClassA(){ m_value = "";}
public string Value
{
get{return m_value;}
set{m_value = value;}
}
}

I'm writing this on the fly so sorry if it doesn't compile.
I would appriciage your oppinion.

Thanks,
Alex

[alex]

I agree. But in my case I'm passing SqlParameter object to a function. I'm
too so sure if I want create my own derivative of SqlParameter class.

Thanks,
Alex
"Erik Frey" <er*******@hotmail.com> wrote in message
news:uh**************@TK2MSFTNGP12.phx.gbl...

A third solution (to consolidate functionality) is this:

//Case #1
public class Main
{
ClassA a = new ClassA();
a.Value = "some value";
a.Modify();
Console.WriteLine(a.Value);
}

//Where ClassA is:

public class ClassA
{
string m_value;
public ClassA(){ m_value = "";}
public string Value
{
get{return m_value;}
set{m_value = value;}
}
public void Modify()
{
m_value += "something";
}
}

[alex]

Thanks for your post Kevin. I agree.

"Kevin Carter" <an*******@discussions.microsoft.com> wrote in message
news:04****************************@phx.gbl...

This is subjective, but your Case #2 example seems to be
more clear. If I was going to write it, I'd write
something like #2.

-----Original Message-----
Hi,

I was just wandering which one is correct, better, or

better programming

practice?

//Case #1
public class Main
{
ClassA a = new ClassA();
a.Value = "some value";
a = ModifyClassA(a);
Console.WriteLine(a.Value);
}
private ClassA ModifyClassA(ClassA a)
{
a.Value += "something";
return a;
}

Or this:

//Case #2
public class Main
{
ClassA a = new ClassA();
a.Value = "some value";
ModifyClassA(a);
Console.WriteLine(a.Value);
}
private void ModifyClassA(ClassA a)
{
a.Value += "something";
}

//Where CassA is:

public class ClassA
{
string m_value;
public ClassA(){ m_value = "";}
public string Value
{
get{return m_value;}
set{m_value = value;}
}
}

I'm writing this on the fly so sorry if it doesn't

compile.

I would appriciage your oppinion.

Thanks,
Alex
.