Code Conversion
This section provides some transformation that we apply so that some elements will be upgraded as you need it.
GoSub statements can be transformed to local functions only when C# is the target language.
Choosing this option, the VBUC will not apply any special pattern recognition mechanism. GoSub statements are not supported by default in .NET structured code.
Original VB6 code:
Public Sub Main()
Dim i As Integer
i = 4
If i = 1 Then
GoSub printOne
ElseIf i = 2 Then
GoSub printTwo
ElseIf i = 3 Then
GoSub printThree
Else
GoSub SomethingElse
End If
GoTo exitLabel
printOne:
MsgBox "Value = 1"
Return
printTwo:
MsgBox "Value = 2"
Return
printThree:
MsgBox "Value = 3"
Return
SomethingElse:
MsgBox "Invalid Value!"
Return
exitLabel:
End Sub
C# code:
public static void Main()
{
int i = 4;
if (i == 1)
{
//UPGRADE_ISSUE: (1014) GoSub statement is not supported.
//UPGRADE_TODO: (1065) Error handling statement (Go Sub) could not be converted.
UpgradeHelpers.Helpers.NotUpgradedHelper.NotifyNotUpgradedElement("GoSub Label (printOne)");
}
else if (i == 2)
{
//UPGRADE_ISSUE: (1014) GoSub statement is not supported.
//UPGRADE_TODO: (1065) Error handling statement (Go Sub) could not be converted.
UpgradeHelpers.Helpers.NotUpgradedHelper.NotifyNotUpgradedElement("GoSub Label (printTwo)");
}
else if (i == 3)
{
//UPGRADE_ISSUE: (1014) GoSub statement is not supported.
//UPGRADE_TODO: (1065) Error handling statement (Go Sub) could not be converted.
UpgradeHelpers.Helpers.NotUpgradedHelper.NotifyNotUpgradedElement("GoSub Label (printThree)");
}
else
{
//UPGRADE_ISSUE: (1014) GoSub statement is not supported.
//UPGRADE_TODO: (1065) Error handling statement (Go Sub) could not be converted.
UpgradeHelpers.Helpers.NotUpgradedHelper.NotifyNotUpgradedElement("GoSub Label (SomethingElse)");
}
return;
printOne:
MessageBox.Show("Value = 1", AssemblyHelper.GetTitle(System.Reflection.Assembly.GetExecutingAssembly()));
//UPGRADE_WARNING: (2081) Return has a new behavior.
return;
printTwo:
MessageBox.Show("Value = 2", AssemblyHelper.GetTitle(System.Reflection.Assembly.GetExecutingAssembly()));
//UPGRADE_WARNING: (2081) Return has a new behavior.
return;
printThree:
MessageBox.Show("Value = 3", AssemblyHelper.GetTitle(System.Reflection.Assembly.GetExecutingAssembly()));
//UPGRADE_WARNING: (2081) Return has a new behavior.
return;
SomethingElse:
MessageBox.Show("Invalid Value!", AssemblyHelper.GetTitle(System.Reflection.Assembly.GetExecutingAssembly()));
//UPGRADE_WARNING: (2081) Return has a new behavior.
return;
}
Choosing this option, the VBUC will apply the special pattern recognition mechanism, to support the GoSub statement. This feature will only be applied when generating C# code.
General Description:
Visual Basic 6.0 provides the ability to jump into the code from one portion to another thru "labels" and create code that is not structured, according to the suggested coding patterns.
However, using GoSub and return statements gives the VB6 programmer certain functionality that used with certain restrictions can create "structured code".
By turning this feature on, the VBUC will recognize some of these patterns and will convert them to local functions for C#.
Original VB6 code:
Public Sub Main()
Dim i As Integer
i = 4
If i = 1 Then
GoSub printOne
ElseIf i = 2 Then
GoSub printTwo
ElseIf i = 3 Then
GoSub printThree
Else
GoSub SomethingElse
End If
GoTo exitLabel
printOne:
MsgBox "Value = 1"
Return
printTwo:
MsgBox "Value = 2"
Return
printThree:
MsgBox "Value = 3"
Return
SomethingElse:
MsgBox "Invalid Value!"
Return
exitLabel:
End Sub
C# code:
public static void Main()
{
int i = 4;
if (i == 1)
{
printOne();
}
else if (i == 2)
{
printTwo();
}
else if (i == 3)
{
printThree();
}
else
{
SomethingElse();
}
return;
void printOne()
{
MessageBox.Show("Value = 1", AssemblyHelper.GetTitle(System.Reflection.Assembly.GetExecutingAssembly()));
}
void printTwo()
{
MessageBox.Show("Value = 2", AssemblyHelper.GetTitle(System.Reflection.Assembly.GetExecutingAssembly()));
}
void printThree()
{
MessageBox.Show("Value = 3", AssemblyHelper.GetTitle(System.Reflection.Assembly.GetExecutingAssembly()));
}
void SomethingElse()
{
MessageBox.Show("Invalid Value!", AssemblyHelper.GetTitle(System.Reflection.Assembly.GetExecutingAssembly()));
}
}
Choosing this option, the VBUC will convert, when possible, GoTo and GoSub statements to internal functions. This feature is only available for C#.
This feature will select GoSub/Return blocks to convert to functions. The label corresponding to a GoSub call must be at the same level as the Return statement. The GoSub statement will be replaced by a call to the function that checks for its return value to see if an exit condition was met (Exit Function or Exit Sub, for example).
Original VB6 Code
Public Sub BasicGoSubExample()
Dim i As Integer
i = 0
MsgBox i ' Display 0
GoSub Increase
MsgBox i ' Display 1
Exit Sub
Increase:
i = i + 1
Return
End Sub
Public Sub BasicGoSubExampleWithExit()
Dim i As Integer
i = 0
MsgBox i ' Display 0
GoSub Increase
MsgBox i ' Will not display
Exit Sub
Increase:
i = i + 1
If i = 1 Then
Exit Sub
End If
Return
End Sub
C# Code
public void BasicGoSubExample()
{
int i = 0;
MessageBox.Show(i.ToString(), ...)); // Display 0
if (label_Increase_function())
{
return;
}
MessageBox.Show(i.ToString(), ...)); // Display 1
return;
bool label_Increase_function()
{
i++;
return false;
}
}
public void BasicGoSubExampleWithExit()
{
int i = 0;
MessageBox.Show(i.ToString(), ...)); // Display 0
if (label_Increase_function())
{
return;
}
MessageBox.Show(i.ToString(), ...)); // Will not display
return;
bool label_Increase_function()
{
i++;
if (i == 1)
{
return true;
}
return false;
}
}
In order to convert GoTo statements to functions, the VBUC will look for a pattern that starts with the label, and could end in another label, a Return statement, an Exit statement, or another GoTo statement. These blocks will be extracted as internal functions an calls to them placed where the GoTo statements. Since GoTo statements are one-way, they will be replaced with a call to the function followed by a return statement (if it's not the last line of of code), because the code after a GoTo statement should not be executed. Some code after a GoTo statement will be detected as dead code and will be commented.
Original VB6 Code
Public Sub BasicGoToExample()
Dim i As Integer
i = 0
MsgBox i ' Display 0
GoTo Increase
MsgBox i
Increase:
i = i + 1
End Sub
Public Sub BasicGoToExampleWithTwoGoTos()
Dim i As Integer
i = 0
MsgBox i ' Display 0
GoTo Increase
MsgBox i
Continue:
MsgBox i ' Display 1
Exit Sub
Increase:
i = i + 1
GoTo Continue
End Sub
C# Code
public void BasicGoToExample()
{
int i = 0;
MessageBox.Show(i.ToString(), ...)); // Display 0
label_Increase_function();
//UPGRADE_NOTE: (7001) The following code block (dead code detected by GoSub/GoTo feature) seems to be dead code...
//MessageBox.Show(i.ToString(), ...));
//label_Increase_function();
bool label_Increase_function()
{
i++;
return false;
}
}
public void BasicGoToExampleWithTwoGoTos()
{
int i = 0;
MessageBox.Show(i.ToString(), ...)); // Display 0
label_Increase_function();
//UPGRADE_NOTE: (7001) The following code block (dead code detected by GoSub/GoTo feature) seems to be dead code...
//MessageBox.Show(i.ToString(), ...));
//label_Continue_function();
//return;
bool label_Continue_function()
{
MessageBox.Show(i.ToString(), ...)); // Display 1
return true;
}
bool label_Increase_function()
{
i++;
return label_Continue_function();
}
}
This feature uses boolean return values to control the flow of the code so it is consistent with the original VB6 code. When one of these internal functions returns true, it is because the original method has ended (due to an Exit Sub or Exit Function), and so the return value is used to stop execution all the way back to the initical calling point. The way calls to internal functions are migrated varies depending on if the function is called from the main method, or from within another function.
Original VB6 Code
//Public Sub CodeFlowExample()
Dim i As Integer
i = 0
MsgBox i
GoSub Increase
MsgBox i
GoTo Decrease
Exit Sub
Multiply:
i = i * 2
Return
Increase:
i = i + 1
GoSub Divide
GoTo Multiply
Decrease:
i = i - 1
Exit Sub
Divide:
If i > 0 Then
i = i / 2
Else
Exit Sub
End If
Return
End Sub
C# Code
public void CodeFlowExample()
{
int i = 0;
MessageBox.Show(i.ToString(), ...));
if (label_Increase_function())
{
return;
}
MessageBox.Show(i.ToString(), ...));
label_Decrease_function();
return;
bool label_Multiply_function()
{
i *= 2;
return false;
}
bool label_Increase_function()
{
i++;
if (label_Divide_function())
{
return true;
}
return label_Multiply_function();
}
bool label_Decrease_function()
{
i--;
return true;
}
bool label_Divide_function()
{
if (i > 0)
{
i = Convert.ToInt32(i / 2d);
}
else
{
return true;
}
return false;
}
}
This option will generate special attributes for the converted classes and their members in order to keep the resulting assemblies exposed through a COM interface.
This feature enables the resulting .NET components to be called from other non-managed components or applications via COM.
General Description:
The VBUC converts Visual Basic 6 ActiveX binaries to .NET assemblies. By default, the resulting assemblies can be used only from managed code. This option should be selected to generate the .NET attributes required to expose these assemblies as COM Objects if it’s necessary to use them from non-managed code.
In addition to the “COMVisible” attribute on the class members, the resulting project is also marked as COM Visible.
COM-Visible option
Original VB6 code:
Code declared in an Activex EXE:
Module1.bas
Public myVar As String
Customer.cls
Attribute VB_Name = "Customer"
Private g_TheNumber As Integer
Public Property Let TheNumber(ByVal new_value As Integer)
g_TheNumber = new_value
End Property
Public Property Get TheNumber() As Integer
TheNumber = g_TheNumber
End Property
Code located in the main application that uses the Activex EXE:
Private m_Customer1 As ExeBillingObjects.Customer
Private m_Customer2 As ExeBillingObjects.Customer
Private Sub Form_Load()
Set m_Customer1 = New ExeBillingObjects.Customer
Set m_Customer2 = New ExeBillingObjects.Customer
End Sub
Private Sub cmdGet_Click()
txtTheNumber.Text = m_Customer1.TheNumber
End Sub
C# code:
Code declared in an Activex EXE:
Module1.cs
internal static class Module1
{
public static string myVar = "";
}
Customer.cs
[ComVisible(true)][ProgId("ExeBillingObjects.Customer")][ClassInterface(ClassInterfaceType.AutoDual)]
public class Customer
{
public int TheNumber
{
get
{
return Module1.g_TheNumber;
}
set
{
Module1.g_TheNumber = value;
}
}
}
Code located in the main application that uses the Activex EXE:
private ExeBillingObjects.Customer m_Customer1 = null;
private ExeBillingObjects.Customer m_Customer2 = null;
private void cmdSet_Click( Object eventSender, EventArgs eventArgs)
{
m_Customer1.TheNumber = Convert.ToInt32(Double.Parse(txtTheNumber.Text));
txtTheNumber.Text = "";
}
private void Form1_Load( Object eventSender, EventArgs eventArgs)
{
m_Customer1 = new ExeBillingObjects.Customer();
m_Customer2 = new ExeBillingObjects.Customer();
}
VB.NET code:
Code declared in an Activex EXE:
Module1.vb
Module Module1
Public myVar As String = ""
End Module
Customer.vb
<ComVisible(True)> _
<ProgId("ExeBillingObjects.Customer")> _
<ClassInterface(ClassInterfaceType.AutoDual)> _
Public Class Customer
Public Property TheNumber() As Integer
Get
Return g_TheNumber
End Get
Set(ByVal Value As Integer)
g_TheNumber = Value
End Set
End Property
End Class
Code located in the main application that uses the Activex EXE:
Private m_Customer1 As ExeBillingObjects.Customer
Private m_Customer2 As ExeBillingObjects.Customer
Private Sub cmdGet_Click(ByVal eventSender As Object, ByVal eventArgs As EventArgs) Handles cmdGet.Click
txtTheNumber.Text = CStr(m_Customer1.TheNumber)
End Sub
Private Sub Form1_Load(ByVal eventSender As Object, ByVal eventArgs As EventArgs) Handles MyBase.Load
m_Customer1 = New ExeBillingObjects.Customer()
m_Customer2 = New ExeBillingObjects.Customer()
End Sub
This optional feature enables the conversion of ActiveX DLLs and EXEs (with global variables in a .bas module) via a helper class (ComponentClassHelper) that controls the instantiation of the generated classes.
- ActiveX EXEs are converted to out-of-process .NET EXEs.
- ActiveX DLLs are converted to .NET class libraries using application domains.
- Component instantiation is performed using helper classes. With this approach most of the ActiveX functionality is replicated in the converted code.
General Description:
The VBUC converts Visual Basic 6 ActiveX EXEs to .NET EXE projects (out-of-process) and ActiveX DLLs to .NET assemblies (class library projects).
One of the main differences between Visual Basic 6 ActiveX binaries and .NET assemblies is how the components are instantiated and how their initialization determines its lifetime behavior.
When this feature is active, a helper class is used to replicate the following ActiveX instantiation types:
- Private
- PublicNotCreatable
- SingleUse
- GlobalSingleUse
- MultiUse
- GlobalMultiUse
Original VB6 code:
Code declared in an Activex EXE:
Module1.bas
Public myVar As String
Customer.cls
Attribute VB_Name = "Customer"
Private g_TheNumber As Integer
Public Property Let TheNumber(ByVal new_value As Integer)
g_TheNumber = new_value
End Property
Public Property Get TheNumber() As Integer
TheNumber = g_TheNumber
End Property
Code located in the main application that uses the Activex EXE:
Private m_Customer1 As ExeBillingObjects.Customer
Private m_Customer2 As ExeBillingObjects.Customer
Private Sub Form_Load()
Set m_Customer1 = New ExeBillingObjects.Customer
Set m_Customer2 = New ExeBillingObjects.Customer
End Sub
Private Sub cmdGet_Click()
txtTheNumber.Text = m_Customer1.TheNumber
End Sub
C# code:
Code declared in an Activex EXE:
Module1.cs
internal static class Module1
{
public static string myVar = "";
internal static void InitGlobalVars()
{
myVar = "";
}
}
Customer.cs
public class Customer : UpgradeHelpers.Activex.ComponentClassHelper
{
public int TheNumber
{
get
{
return g_TheNumber;
}
set
{
g_TheNumber = value;
}
}
}
Code located in the main application that uses the Activex EXE:
private ExeBillingObjects.Customer m_Customer1 = null;
private ExeBillingObjects.Customer m_Customer2 = null;
private void cmdGet_Click( Object eventSender, EventArgs eventArgs)
{
txtTheNumber.Text = Convert.ToString(m_Customer1.TheNumber);
}
private void Form1_Load( Object eventSender, EventArgs eventArgs)
{
m_Customer1 = ExeBillingObjects.ExeBillingObjectsFactory.Create <ExeBillingObjects.Customer>(m_Customer1);
m_Customer2 = ExeBillingObjects.ExeBillingObjectsFactory.Create <ExeBillingObjects.Customer>(m_Customer2);
VB.NET code:
Code declared in an Activex EXE:
Module1.vb
Module Module1
Public myVar As String = ""
Public Sub InitGlobalVars()
myVar = ""
End Sub
End Module
Customer.vb
Public Class Customer Inherits UpgradeHelpers.Activex.ComponentClassHelper
Public Property TheNumber() As Integer
Get
Return g_TheNumber
End Get
Set(ByVal Value As Integer)
g_TheNumber = Value
End Set
End Property
End Class
Code located in the main application that uses the Activex EXE:
Private m_Customer1 As ExeBillingObjects.Customer
Private m_Customer2 As ExeBillingObjects.Customer
Private Sub cmdGet_Click(ByVal eventSender As Object, ByVal eventArgs As EventArgs) Handles cmdGet.Click
txtTheNumber.Text = CStr(m_Customer1.TheNumber)
End Sub
Private Sub Form1_Load(ByVal eventSender As Object, ByVal eventArgs As EventArgs) Handles MyBase.Load
m_Customer1 = ExeBillingObjects.ExeBillingObjectsFactory.Create(Of ExeBillingObjects.Customer)(m_Customer1)
m_Customer2 = ExeBillingObjects.ExeBillingObjectsFactory.Create(Of ExeBillingObjects.Customer)(m_Customer2)
End Sub
This optional feature converts the ActiveX DLLs and EXEs to .NET class libraries (DLLs).
- All ActiveX binaries are converted to native .NET assemblies (class libraries).
- With this approach, the converted code can be used only from managed code and the different ActiveX instantiation models (e.g MultiUse, GlobalMultiuse, etc) won’t be supported.
General Description:
The VBUC converts Visual Basic 6 ActiveX EXEs and ActiveX DLLs to .NET class libraries (DLLs).
One of the main differences between Visual Basic 6 ActiveX binaries and .NET assemblies is how the components are instantiated and how their initialization determines its lifetime behavior.
With this option switched on, the code is converted to pure .NET code and the ActiveX instantiation models won’t be supported.
Original VB6 code:
Code declared in an Activex EXE:
Module1.bas
Public myVar As String
Customer.cls
Attribute VB_Name = "Customer"
Private g_TheNumber As Integer
Public Property Let TheNumber(ByVal new_value As Integer)
g_TheNumber = new_value
End Property
Public Property Get TheNumber() As Integer
TheNumber = g_TheNumber
End Property
Code located in the main application that uses the Activex EXE:
Private m_Customer1 As ExeBillingObjects.Customer
Private m_Customer2 As ExeBillingObjects.Customer
Private Sub Form_Load()
Set m_Customer1 = New ExeBillingObjects.Customer
Set m_Customer2 = New ExeBillingObjects.Customer
End Sub
Private Sub cmdGet_Click()
txtTheNumber.Text = m_Customer1.TheNumber
End Sub
C# code:
Code declared in an Activex EXE:
Module1.cs
internal static class Module1
{
public static string myVar = "";
}
Customer.cs
public class Customer
{
public int TheNumber
{
get
{
return g_TheNumber;
}
set
{
g_TheNumber = value;
}
}
}
Code located in the main application that uses the Activex EXE:
private ExeBillingObjects.Customer m_Customer1 = null;
private ExeBillingObjects.Customer m_Customer2 = null;
private void cmdGet_Click( Object eventSender, EventArgs eventArgs)
{
txtTheNumber.Text = m_Customer1.TheNumber.ToString();
}
private void Form1_Load( Object eventSender, EventArgs eventArgs)
{
m_Customer1 = new ExeBillingObjects.Customer();
m_Customer2 = new ExeBillingObjects.Customer();
}
VB.NET code:
Code declared in an Activex EXE:
Module1.vb
Module Module1
Public myVar As String = ""
End Module
Customer.vb
Public Class Customer
Public Property TheNumber() As Integer
Get
Return g_TheNumber
End Get
Set(ByVal Value As Integer)
g_TheNumber = Value
End Set
End Property
End Class
Code located in the main application that uses the Activex EXE:
Private m_Customer1 As ExeBillingObjects.Customer
Private m_Customer2 As ExeBillingObjects.Customer
Private Sub cmdGet_Click(ByVal eventSender As Object, ByVal eventArgs As EventArgs) Handles cmdGet.Click
txtTheNumber.Text = CStr(m_Customer1.TheNumber)
End Sub
Private Sub Form1_Load(ByVal eventSender As Object, ByVal eventArgs As EventArgs) Handles MyBase.Load
m_Customer1 = New ExeBillingObjects.Customer()
m_Customer2 = New ExeBillingObjects.Customer()
End Sub
Auto-Implemented Properties will be generated when the original VB6 properties follow the basic standard pattern.
This feature verifies if there is a property defined on a local private field (both shares the same type) and it removes the field declarations and just leaves an auto-implemented property, replacing any reference to the field with a reference to the property in the class.
This feature is available for C# only.
Original VB6 code:
Private IntVar As Integer
Private BoolVar As Boolean
Private StrVar As String
Public Property Let IntVarProp(value As Integer)
'some comments for IntVarProp property header'
IntVar = value
'some comments for IntVarProp property footer'
End Property
Public Property Get IntVarProp() As Integer
'some comments for IntVarProp property header'
IntVarProp = IntVar
'some comments for IntVarProp property footer'
End Property
Public Property Let BoolVarProp(value As Boolean)
BoolVar = value
End Property
Public Property Get BoolVarProp() As Boolean
BoolVarProp = BoolVar
End Property
Public Property Let StrVarProp(value As String)
StrVar = value
End Property
Public Property Get StrVarProp() As String
StrVarProp = StrVar
End Property
Public Sub FieldsUsage()
IntVar = 0
BoolVar = False
StrVar = "Hello World"
parameterFieldsUsage IntVar, BoolVar, StrVar
End Sub
Public Sub PropertiesUsage()
IntVarProp = 0
BoolVarProp = False
StrVarProp = "Hello World"
parameterProperiesUsage IntVarProp, BoolVarProp, StrVarProp
End Sub
Public Sub parameterFieldsUsage(IntVar As Integer, BoolVar As Boolean, StrVar As String)
''
End Sub
Public Sub parameterProperiesUsage(IntVar As Integer, BoolVar As Boolean, StrVar As String)
''
End Sub
C# code:
public int IntVarProp
{
//some comments for IntVarProp property header
get;
//some comments for IntVarProp property footer
//some comments for IntVarProp property header
set;
//some comments for IntVarProp property footer
}
public bool BoolVarProp
{
get;
set;
}
public string StrVarProp
{
get;
set;
}
public void FieldsUsage()
{
this.IntVarProp = 0;
this.BoolVarProp = false;
this.StrVarProp = "Hello World";
parameterFieldsUsage(this.IntVarProp, this.BoolVarProp, this.StrVarProp);
}
public void PropertiesUsage()
{
IntVarProp = 0;
BoolVarProp = false;
StrVarProp = "Hello World";
parameterProperiesUsage(IntVarProp, BoolVarProp, StrVarProp);
}
public void parameterFieldsUsage(int IntVar, bool BoolVar, string StrVar)
{
//
}
public void parameterProperiesUsage(int IntVar, bool BoolVar, string StrVar)
{
//
}
No Auto-Implemented Properties will be generated from the original VB6 ones.
Original VB6 code:
Private IntVar As Integer
Private BoolVar As Boolean
Private StrVar As String
Public Property Let IntVarProp(value As Integer)
'some comments for IntVarProp property header'
IntVar = value
'some comments for IntVarProp property footer'
End Property
Public Property Get IntVarProp() As Integer
'some comments for IntVarProp property header'
IntVarProp = IntVar
'some comments for IntVarProp property footer'
End Property
Public Property Let BoolVarProp(value As Boolean)
BoolVar = value
End Property
Public Property Get BoolVarProp() As Boolean
BoolVarProp = BoolVar
End Property
Public Property Let StrVarProp(value As String)
StrVar = value
End Property
Public Property Get StrVarProp() As String
StrVarProp = StrVar
End Property
Public Sub FieldsUsage()
IntVar = 0
BoolVar = False
StrVar = "Hello World"
parameterFieldsUsage IntVar, BoolVar, StrVar
End Sub
Public Sub PropertiesUsage()
IntVarProp = 0
BoolVarProp = False
StrVarProp = "Hello World"
parameterProperiesUsage IntVarProp, BoolVarProp, StrVarProp
End Sub
Public Sub parameterFieldsUsage(IntVar As Integer, BoolVar As Boolean, StrVar As String)
''
End Sub
Public Sub parameterProperiesUsage(IntVar As Integer, BoolVar As Boolean, StrVar As String)
''
End Sub
C# code:
private int IntVar = 0;
private bool BoolVar = false;
private string StrVar = "";
public int IntVarProp
{
get
{
//some comments for IntVarProp property header
return IntVar;
//some comments for IntVarProp property footer
}
set
{
//some comments for IntVarProp property header
IntVar = value;
//some comments for IntVarProp property footer
}
}
public bool BoolVarProp
{
get
{
return BoolVar;
}
set
{
BoolVar = value;
}
}
public string StrVarProp
{
get
{
return StrVar;
}