Yes, at this point you have two variables referring to the same
string.

The difference in C# is that you can't change a string (like you did
with wcscpy). .NET strings are immutable.

Well the eaasy solution would be to write

if (sender == txtCompany)
    customerClass.Company.Name = txt.Text;
else if (sender == txtCompanyAddress)
    customerClass.Company.Address = txt.Text;

But you may also want to look at data binding.

Mattias

Let's get the whole "pointer to string" thing out of the way.  There's not  
really any way to do that in C#, except possibly with "unsafe" code.  But  
given your description so far, I doubt you really want a pointer to a  
string.  Surely we can come up with some way to do what you want without  
actually needing a reference to a string reference.

So, let's look at your code:

So, I have the impression you want changes in the Text property to be  
reflected in the associated property in a given class instance.

I can think of at least three different ways to do that.  One involves  
reflection, which I try to stay away from so I'm going to ignore that.  

better way to implement data binding than how I show it here.  But you can  
do something like this:

    this.txtCompany.DataBindings.Add("Text", customerClass.Company,  
"Name");
    this.txtCompanyAddress.DataBindings.Add("Text", customerClass.Company,  
"Address");

By default, the property should be updated on validation, so as long as  
the control is validating (which it would be by default) the property will  
get set properly (validation usually happens when focus leaves the  
control).  Using this method, you don't even need to initialize the  
control, nor provide an event handler for the Leave event.

The third way uses an anonymous method.  In this particular scenario, I  
think it's the clumsy way to do it.  But seeing the technique you may find  
it useful for other things in the future (just keep in mind that as was  
the case here, there might be an easier way :) ):

    // This creates an anonymous method that will copy the control's Text  
property to
    // class's corresponding property.
    this.txtCompany.Tag = delegate() { customerClass.Company.Name =  
this.txtCompany.Text; }

    // Alternatively, if you really want to check the previous value first:
    this.txtCompany.Tag = delegate() { if (customerClass.Company.Name !=  
this.txtCompany.Text) customerClass.Company.Name = this.txtCompany.Text; }

then in the Leave handler:

private void txtOnLostFocus(object sender, EventArgs e)
{
     TextBox txt = (TextBox)sender;
     MethodInvoker setter = (MethodInvoker)txt.Tag;

     // This line of code executes the anonymous method you created  
before.  Since each
     // control would have a different anonymous method, assigning the  
control's Text
     // property to the appropriate data property, executing it here  
accomplishes what
     // you want.
     setter();
}

This sort of thing can work pretty much anywhere there's some specific  
code you want to execute every time for a specific situation, but you  
don't want to have to create a whole new named method each time.  It's  
especially common when using Control.Invoke() or predicates for the  
various generic collection search, sorting, etc. methods.  Using it here  
is kind of contrived.  :)

Pete