Question: I have some code like:

```
Lookup(Of String)("Testing")
Lookup(Of Integer)("Testing")

```

And both of those Lookups work great. What I'm trying to is call the appropriate LookUp based on the type of another variable. Something that would look like...

```
Lookup(Of GetType(MyStringVariable))("Testing")

```

I've tried to Google this but I'm having a hard time coming up with an appropriate search. Can anyone tell me how to do what I want?

Answer: 
You do not specify the full signature for the method that you're calling, but my psychic powers tell me that it is this:

```
Function Lookup(Of T)(key As String) As T

```

And you want to avoid having to repeat `Integer` twice as in the example below:

```
Dim x As Integer
x = Lookup(Of Integer)("foo");

```

The problem is that type parameters are only deduced when they're used in argument context, but never in return value context. So, you need a helper function with a `ByRef` argument to do the trick:

```
Sub Lookup(Of T)(key As String, ByRef result As T)
    T = Lookup(Of T)(key)
End Sub

```

With that, you can write:

```
Dim x As Integer
Lookup("foo", x);

```
The VB.NET compiler in VS2008 actually uses type-inference. That means if you are using a generic method, and one of the parameters is of the generic type, then you don't need to specify the generic type in your call. 

Take the following definition... 

```
Function DoSomething(Of T)(Target As T) As Boolean 

```

If you call it with a strongly-typed String for **Target**, and don't specify the generic parameter, it will infer **T** as String.  

If you call it with a strongly-typed Integer for **Target**, and don't specify the generic parameter, it will infer **T** as Integer. 

So you could call this function as follows: 

```
Dim myResult As Boolean = DoSomething("my new string")

```

And it will automatically infer the type of **T** as String. 

**EDIT:**  

NOTE: This works for single or multiple generic parameters.  

NOTE: This works also for variables in the argument list, not just literals.