/*
Nice idea, but I think creating a new thread is a bit heavyweight, especially if the wrapped function needs to be called many times a second. Why not use the standard .Net async pattern? Something like this (untested):
*/
public static T Limex(Func F, int Timeout, out bool Completed)
{
var iar = F.BeginInvoke(null, new object());
if (iar.AsyncWaitHandle.WaitOne(Timeout))
{
Completed = true;
return F.EndInvoke(iar);
}

Completed = false;
return default(T);
}

public static T RunAsync3<T>(Func<T> func, int timeout, out bool completed)
{
    IAsyncResult ar = null;
    var hasResult = false;
    var cookie = new object();
    lock (cookie)
    {
        ar = func.BeginInvoke((_) =>
        {
            lock (cookie)
            {
                if (!hasResult)
                {
                    func.EndInvoke(ar);
                }
            }
        }, null);
        if (ar.AsyncWaitHandle.WaitOne(timeout))
        {
            completed = true;
            hasResult = true;
            return func.EndInvoke(ar);
        }
    }
    completed = false;
    return default(T);
}

public static T RunAsync<T>(Func<T> func, int timeout, out bool completed)
{
    IAsyncResult ar = null;
    var hasResult = false;
    var cookie = new object();
    lock (cookie) //1
    {
        ar = func.BeginInvoke((_) => //2
        {
            lock (cookie) //3
            {
                if (!hasResult)
                {
                    func.EndInvoke(ar); //4
                }
            }
        }, null);
        if (ar.AsyncWaitHandle.WaitOne(timeout))
        {
            completed = true;
            hasResult = true;
            return func.EndInvoke(ar); //5
        }
    }
    completed = false; //6
    return default(T);
}

public static T RunAsync<T>(Func<T> func, int timeout, out bool completed)
{
    var hasResult = false;
    var cookie = new object();
    var result = default(T);
    var ar = func.BeginInvoke((tmp) =>
    {
        lock (cookie)
        {
            if (!hasResult)
            {
                hasResult = true;
                result = func.EndInvoke(tmp);
            }
        }
    }, null);
    if (ar.AsyncWaitHandle.WaitOne(timeout))
    {
        completed = true;
        lock (cookie)
        {
            if (hasResult)
            {
                return result;
            }
            hasResult = true;
            return func.EndInvoke(ar);
        }
    }
    completed = false;
    return default(T);
}

Public Class Class1
    Private Class State(Of T)
        Public Sub Callback(ByVal ar As IAsyncResult)
            SyncLock Me.cookie
                If Not Me.hasResult Then
                    Me.hasResult = True
                    Me.result = Me.func.EndInvoke(ar)
                End If
            End SyncLock
        End Sub

        Public cookie As Object
        Public func As Func(Of T)
        Public hasResult As Boolean
        Public result As T
    End Class

    Public Shared Function RunAsync(Of T)(ByVal func As Func(Of T), ByVal timeout As Integer, ByRef completed As Boolean) As T
        Dim state As New State(Of T)
        state.cookie = New Object
        state.func = func
        Dim ar As IAsyncResult = func.BeginInvoke(New AsyncCallback(AddressOf state.Callback), Nothing)
        If ar.AsyncWaitHandle.WaitOne(timeout) Then
            completed = True
            SyncLock state.cookie
                If state.hasResult Then
                    Return state.result
                End If
                state.hasResult = True
                Return func.EndInvoke(ar)
            End SyncLock
        End If
        completed = False
        Return CType(Nothing, T)
    End Function
End Class

Public Shared Function RunAsync(Of T)(ByVal func As Func(Of T), ByVal timeout As Integer, <Out> ByRef completed As Boolean) As T
    Dim callback As AsyncCallback = Nothing
    Dim ar As IAsyncResult = Nothing
    Dim hasResult As Boolean = False
    Dim cookie As New Object
    SyncLock cookie
        If (callback Is Nothing) Then
            callback = Function (ByVal _ As IAsyncResult) 
                SyncLock MyBase.cookie
                    If Not MyBase.hasResult Then
                        MyBase.func.EndInvoke(MyBase.ar)
                    End If
                End SyncLock
            End Function
        End If
        ar = func.BeginInvoke(callback, Nothing)
        If ar.AsyncWaitHandle.WaitOne(timeout) Then
            completed = True
            hasResult = True
            Return func.EndInvoke(ar)
        End If
    End SyncLock
    completed = False
    Return CType(Nothing, T)
End Function

    public static T RunAsync<T>(Func<T> func, int timeout, out bool completed)
    {
        int state = 0;
        var result = default(T);
        var ar = func.BeginInvoke((tmp) =>
        {
            if (Interlocked.CompareExchange(ref state, 1, 0) == 0)
            {
                result = func.EndInvoke(tmp);
                Thread.VolatileWrite(ref state, 2);
            }
        }, null);
        if (ar.AsyncWaitHandle.WaitOne(timeout))
        {
            completed = true;
            if (Interlocked.CompareExchange(ref state, 2, 0) == 0)
            {
                return func.EndInvoke(ar);
            }
            while (Thread.VolatileRead(ref state) != 2)
            {
            }
            return result;
        }
        completed = false;
        return default(T);
    }

Public Shared Function VerifyDB(ByVal dbFilePath As String, ByRef result As DBTESTSRESULTS) As Boolean
...
End Function

Public Shared Sub CallVerifyDB()
    Dim result As DBTESTSRESULTS
    Dim completed As Boolean
    Dim funcResult As Boolean

    funcResult = RunAsync(Function() VerifyDB("path", result), 1000, completed)
    If (completed) Then
        Console.WriteLine("Function completed")
    Else
        Console.WriteLine("Timeout expired")
    End If
End Sub

db.GetTable<GeoName>().Insert(() => new GeoName
                    {
                        GeonameId = nID,
                        Name = sName,
                        AsciiName = sNameAsc,
                        Countrycode = sCntry,
                        Alternatenames = sAlt
                    });