Beste Möglichkeit zum verwalten der Netzwerk-Status in Windows Mobile

Ich Sie einfach erstellen Sie eine einfache shared-Klasse, kann ich rufen wie diese:

If MyConnectionClass.IsConnected then
     'Do connected stuff
Else
     'Do local save
End If

Dann alle meine aktuellen business-Klassen/Funktionen verwenden können, dies zu verbergen, diese Gemeinheiten aus dem UI-code.

Den MyConnectionClass' Eigenschaft IsConnected, wäre so etwas wie dieses:

Public ReadOnly Property IsConnected As Boolean
   Get
    Try

        Dim HostName As String = Dns.GetHostName()
        Dim thisHost As IPHostEntry = Dns.GetHostByName(HostName)
        Dim thisIpAddr As String = thisHost.AddressList(0).ToString

        return (thisIpAddr <> Net.IPAddress.Parse("127.0.0.1").ToString())

    Catch ex As Exception
        Return False
    End Try
   End Get
End Property

Es wird auch empfohlen, dass Sie die Umfrage zum status der Verbindung mit einem hintergrund-thread und dann Feuer ein Ereignis zurück zu der Haupt-app-thread, wenn sich der Status ändert. Hier ist der ausführliche Kommentar:

Testen und die Reaktion auf Netzwerk-verbindungen in den .NET Compact Framework

EDIT:

Nun, für GPRS Unterstützung:

Wenn Sie der Verwendung von Web-Anfragen oder Web-Services, die Rahmen um die Verbindung für Sie. Wenn Sie Tauchen tiefer in TCPClient oder UDPClient, müssen Sie behandeln Sie mit dem Verbindungs-manager-API, die sich etwa so:

public class GPRSConnection
{
    const int S_OK = 0;
    const uint CONNMGR_PARAM_GUIDDESTNET = 0x1;
    const uint CONNMGR_FLAG_PROXY_HTTP = 0x1;
    const uint CONNMGR_PRIORITY_USERINTERACTIVE = 0x08000;
    const uint INFINITE = 0xffffffff;
    const uint CONNMGR_STATUS_CONNECTED = 0x10;
    static Hashtable ht = new Hashtable();

    static GPRSConnection()
    {
        ManualResetEvent mre = new ManualResetEvent(false);
        mre.Handle = ConnMgrApiReadyEvent();
        mre.WaitOne();
        CloseHandle(mre.Handle);
    }

    ~GPRSConnection()
    {
        ReleaseAll();
    }

    public static bool Setup(Uri url)
    {
        return Setup(url.ToString());
    }

    public static bool Setup(string urlStr)
    {
        ConnectionInfo ci = new ConnectionInfo();
        IntPtr phConnection = IntPtr.Zero;
        uint status = 0;

        if (ht[urlStr] != null)
            return true;

        if (ConnMgrMapURL(urlStr, ref ci.guidDestNet, IntPtr.Zero) != S_OK)
            return false;

        ci.cbSize = (uint) Marshal.SizeOf(ci);
        ci.dwParams = CONNMGR_PARAM_GUIDDESTNET;
        ci.dwFlags = CONNMGR_FLAG_PROXY_HTTP;
        ci.dwPriority = CONNMGR_PRIORITY_USERINTERACTIVE;
        ci.bExclusive = 0;
        ci.bDisabled = 0;
        ci.hWnd = IntPtr.Zero;
        ci.uMsg = 0;
        ci.lParam = 0;

        if (ConnMgrEstablishConnectionSync(ref ci, ref phConnection, INFINITE, ref status) != S_OK &&
            status != CONNMGR_STATUS_CONNECTED)
            return false;

        ht[urlStr] = phConnection;
        return true;
    }

    public static bool Release(Uri url)
    {
        return Release(url.ToString());
    }

    public static bool Release(string urlStr)
    {
        return Release(urlStr, true);
    }

    private static bool Release(string urlStr, bool removeNode)
    {
        bool res = true;
        IntPtr ph = IntPtr.Zero;
        if (ht[urlStr] == null)
            return true;
        ph = (IntPtr)ht[urlStr];
        if (ConnMgrReleaseConnection(ph, 1) != S_OK)
            res = false;
        CloseHandle(ph);
        if (removeNode)
            ht.Remove(urlStr);
        return res;
    }

    public static void ReleaseAll()
    {
       foreach(DictionaryEntry de in ht)
       {
           Release((string)de.Key, false);
       }
       ht.Clear();
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct ConnectionInfo
    {
        public uint cbSize;
        public uint dwParams;
        public uint dwFlags;
        public uint dwPriority;
        public int bExclusive;
        public int bDisabled;
        public Guid guidDestNet;
        public IntPtr hWnd;
        public uint uMsg;
        public uint lParam;
        public uint ulMaxCost;
        public uint ulMinRcvBw;
        public uint ulMaxConnLatency;
    }

    [DllImport("cellcore.dll")]
    private static extern int ConnMgrMapURL(string pwszURL, ref Guid pguid, IntPtr pdwIndex);

    [DllImport("cellcore.dll")]
    private static extern int ConnMgrEstablishConnectionSync(ref ConnectionInfo ci, ref IntPtr phConnection, uint dwTimeout, ref uint pdwStatus);

    [DllImport("cellcore.dll")]
    private static extern IntPtr ConnMgrApiReadyEvent();

    [DllImport("cellcore.dll")]
    private static extern int ConnMgrReleaseConnection(IntPtr hConnection, int bCache);

    [DllImport("coredll.dll")]
    private static extern int CloseHandle(IntPtr hObject);
}

Nehmen und zu nutzen, dies zu tun:

public void DoTcpConnection()
    {
        string url = "www.msn.com";
        bool res = GPRSConnection.Setup("http://" + url + "/");
        if (res)
        {
            TcpClient tc = new TcpClient(url, 80);
            NetworkStream ns = tc.GetStream();
            byte[] buf = new byte[100];
            ns.Write(buf, 0, 100);
            tc.Client.Shutdown(SocketShutdown.Both);
            ns.Close();
            tc.Close();
            MessageBox.Show("Wrote 100 bytes");
        }
        else
        {
            MessageBox.Show("Connection establishment failed");
        }
    }

Diese wurde von Anthony Wong blog hier:

Anthony Wong

Und denken Sie daran, Sie müssen nur dieses für die untere Ebene TCP-oder UDP-Zeug. HTTPRequests brauche das nicht.

Ich versuche zu schreiben, Mobile apps, so dass Sie gar nicht wissen, es gibt ein Netzwerk eingebunden. Ich halte gut-genug-Validierung Daten lokal und dann schreiben-Transaktionen, um eine lokale queue, die klärt, während verbunden; der queue-reader beinhaltet einen timer zu wiederholen, wenn nicht angeschlossen. Queue-Nachrichten sind bidirektional, so dass lokale erfrischt geliefert werden kann als gut. Basic Message-Queue-Muster.

Dies ermöglicht es mir, behandeln Sie die Netzwerk-Verbindung auf einfachste Weise die Verwendung der basic-socket-open/close/read/write/ioctl Logik, die ' s sehr portabel; und Ihre verbindungen müssen nicht anhalten, jede bedeutende Zeit. (Ich würde es hassen zu denken, was erforderlich wäre, um zu bleiben in-sync mit allen MS-Architektur-Varianten im Laufe der letzten Jahre - die immer noch nicht entschieden aus IMHO.)