VB.NET Array parentheses do not translate to C# brackets

Example (VB.NET):

Dim pts(2) As Point
pts(0) = New Point(left + arrowWidth / 2 - 2 -extra - 2, top + height / 2 - 1)
pts(1) = New Point(left + arrowWidth / 2 + 3 +extra - 1, top + height / 2 - 1)
pts(2) = New Point(left + arrowWidth / 2 - 1,(top + height / 2 - 1) + 3 + extra)

Translates to (C#):

Point[] pts = new Point[3];
pts(0) = new Point(left + arrowWidth / 2 - 2 - extra - 2, top + height / 2 - 1);
pts(1) = new Point(left + arrowWidth / 2 + 3 + extra - 1, top + height / 2 - 1);
pts(2) = new Point(left + arrowWidth / 2 - 1, (top + height / 2 - 1) + 3 + extra);

Should be:

Point[] pts = new Point[3];
pts[0] = new Point(left + arrowWidth / 2 - 2 - extra - 2, top + height / 2 - 1);
pts[1] = new Point(left + arrowWidth / 2 + 3 + extra - 1, top + height / 2 - 1);
pts[2] = new Point(left + arrowWidth / 2 - 1, (top + height / 2 - 1) + 3 + extra);

In my example below, none of the ViewState, Session or Request Params (arrays) have their round brackets converted to square brackets.

Example:
Protected Property CurrentSortColumn() As String
Get
If (ViewState("SortColumn") <> Nothing) Then
Return ViewState("SortColumn").ToString()
Else
ViewState("SortColumn") = "ADD_BOOK_ID"
Return "ADD_BOOK_ID"
End If
End Get

Set(ByVal value As String)
ViewState("SortColumn") = value
End Set

End Property

Private Sub Test

ParentControlID = Request.Params("ParentCtlID")

If DirectCast(Session("USER_TOKEN"), Int32) > 0 Then
UserCanEditAddBook = True
End If

End Sub

I had a bit of an issue with a StringDictionary collection when converting.

Original Code: (VB)
sServiceName = Me.Context.Parameters.Item("name")
sServiceDescription = Me.Context.Parameters.Item("description")
sServiceDisplayName = Me.Context.Parameters.Item("displayname")

Converted Code: (C#)
sServiceName = this.Context.Parameters.Item("name");
sServiceDescription = this.Context.Parameters.Item("description");
sServiceDisplayName = this.Context.Parameters.Item("displayname");

Correct Code: (C#)
sServiceName = this.Context.Parameters["name"];
sServiceDescription = this.Context.Parameters["description"];
sServiceDisplayName = this.Context.Parameters["displayname"];

In C#, Array.Item(key) is not valid. It should be Array[key].

Here's an example from Microsoft's Tailspin Spyworks tutorials that translates very poorly.

============
var query = (from ProductOrders in db.OrderDetails
join SelectedProducts in db.Products on ProductOrders.ProductID equals SelectedProducts.ProductID
group ProductOrders by new
{
ProductId = SelectedProducts.ProductID,
ModelName = SelectedProducts.ModelName

} into grp
select new
{
ModelName = grp.Key.ModelName,
ProductId = grp.Key.ProductId,
Quantity = grp.Sum(o => o.Quantity)
} into orderdgrp
where orderdgrp.Quantity > 0
orderby orderdgrp.Quantity descending
select orderdgrp).Take(5);

========
If you run the convertor on this, you'll find several statements that merge together, "select" disappears entirely and whatever was on either side of it merges into a single word, "equals" turns into "=", and many other bizarre things happen.

Methods with Optional Parameters,
Private Sub ThisMethod(Optional byRef strVal as String = "me")

Are not converted . creating overloaded methods might be a way to go, just add into the base method the additional variables assigned with default values.
see below example.
//method assigns argument to default inside the class
private void ThisMethod() {
string strVal = "me";
}

// method has variable as argument
private void ThisMethod(string strVal) {

}

There are multiple special cases where hard logic cant decide which way to go. e.g:

1. Array variables, Known properties like ViewState, Session etc
Current: Request.QueryString("key") -> Request.QueryString("key");
Correct: Request.QueryString("key") -> Request.QueryString["key"];

2. Optional brackets in VB methods are not so optional in C#
Current: myvar.ToString -> mycar.ToString;
Correct: myvar.ToString -> mycar.ToString();

2. Char literals
Current: If "hello"(0) = "h" Then : End If -> if("hello"[0] == "h") { }
Correct: If("hello"(0) = "h") Then : End if -> if("hello"[0] == 'h') { }

and other similar peculiarities..

There could be a variety of solutions, specially for known .Net properties/items like ViewState etc where you can reflect on and identify the type etc.

You can also keep track for declarations to identify the type of a item so that correct conversion can be done, known array types for example.

There can also be a advanced settings mode to the converter, where a user can specify known array types for example.

These attempts at intelligence can be controlled via the settings so that the User can decide it is it good for them or not.

I would also love the ability to specify my own custom code that would be run after/before conversion, sort of like creating onBeforeConvertion and onAfterConvertion events. Here the user can specify their own logic like regex, search-replace and other code that you deem safe.

Most of this is probably overkill but I am just thinking out loud so thanks for you patience in reading this.

You tool has helped me a lot over the years and I have seen it grow. Thanks

In VB, parameter-less class methods that are used in assignment declarations do not require parentheses. However, in C#, these functions must have parentheses or they generate a compiler error.

For example, take the following VB code:

Private Sub DisplayString()
MessageBox.Show(Me.ReturnString)
End Sub

Private Function ReturnString() As String
Return "test"
End Function

Converts to the following C# code using your tool:

private void DisplayString()
{
    Console.Write(this.ReturnString);
}

private string ReturnString()
{
    return "test";
}

The line: "Console.Write(this.ReturnString);" returns a compiler error:
"Cannot convert from 'method group' to 'string'"

because in C# this.ReturnString requires parentheses at the end.

It would be helpful if the missing parentheses were added automatically (wherever it's possible to determine that they're needed).

Note that this also happens with .NET parameter-less class functions, such as [string].ToLower, [object].ToString, [sqlcommand].ExecuteReader, etc.

Manually changing these items isn't very difficult, mind you. But I figured I'd at least document this issue here. :)

Thanks for this wonderful time-saving tool.