Comment (rapidement) vérifier si le Chemin d'accès UNC est disponible

Comment est-ce une façon rapide et sale à l'arrivée d'exécuter windows net use de commande et d'analyser les données en sortie de la ligne avec le chemin d'accès réseau de l'intérêt (par exemple,\\vault2) et OK. Voici un exemple de sortie:

C:\>net use
New connections will be remembered.

Status       Local     Remote                    Network

-------------------------------------------------------------------------------
OK           O:        \\smarty\Data       Microsoft Windows Network
Disconnected P:        \\dummy\Data       Microsoft Windows Network
OK                     \\vault2\vault2           Microsoft Windows Network
The command completed successfully.

Ce n'est pas une très .netish solution, mais il est très rapide, et parfois que les questions les plus :-).

Et voici le code pour le faire (et LINQPad me dit qu'il ne prend 150ms, donc c'est agréable)

void Main()
{
    bool available = QuickBestGuessAboutAccessibilityOfNetworkPath(@"\\vault2\vault2\dir1\dir2");
    Console.WriteLine(available);
}

public static bool QuickBestGuessAboutAccessibilityOfNetworkPath(string path)
{
    if (string.IsNullOrEmpty(path)) return false;
    string pathRoot = Path.GetPathRoot(path);
    if (string.IsNullOrEmpty(pathRoot)) return false;
    ProcessStartInfo pinfo = new ProcessStartInfo("net", "use");
    pinfo.CreateNoWindow = true;
    pinfo.RedirectStandardOutput = true;
    pinfo.UseShellExecute = false;
    string output;
    using (Process p = Process.Start(pinfo)) {
        output = p.StandardOutput.ReadToEnd();
    }
    foreach (string line in output.Split('\n'))
    {
        if (line.Contains(pathRoot) && line.Contains("OK"))
        {
            return true; //shareIsProbablyConnected
        }
    }
    return false;
}

Ou vous pourriez probablement suivre la voie de l'aide WMI, comme mentionné dans cette réponse à Comment assurer les lecteurs réseau sont connectés à une application?

Dans un projet de mine, j'ai eu à vérifier si un serveur de connexion a été établie ou non. J'ai utilisé un Socket TCP pour asynchronically vérifier si le serveur pourrait être atteint ou non. Je me demande si vous pouvez l'utiliser pour vérifier sur un partage réseau. L'async Socket TCP connect va tellement vite que j'ai testé pour la connexion 10 fois moins de 60 millisecondes. Peut-être que vous pourriez jouer avec un peu ?

EDIT: Ici, c'est le Socket Asynchrones j'ai utilisé pour mon projet. Utilisez cette classe pour vérifier certaines IP ou l'adresse. J'espère que c'est de l'utiliser pour vous

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Net;
using System.Threading;
namespace Base.BaseObjects
{
public class AsynchronousClient
{
#region Properties
private int _port = 0000, currentTry = 0, _buffersize, _fastpingdelay = 80;
private string _server = "localhost";
private Socket client;
private static IPEndPoint remoteEP;
//Delegates & Events
public delegate void SendMessageDelegate(string message);
public event SendMessageDelegate SendMessageEvent;
public delegate void ConnectionStatusDelegate(bool connected, bool reconnect);
public event ConnectionStatusDelegate ConnectionStatusChanged;
//ManualResetEvent instances signal completion.
private static ManualResetEvent connectDone = new ManualResetEvent(false);
private static ManualResetEvent sendDone = new ManualResetEvent(false);
private static ManualResetEvent receiveDone = new ManualResetEvent(false);
///<summary>
///Port to monitor
///</summary>
public int Port { get { return _port; } }
///<summary>
///Number of packages to buffer until system reports connection loss
///</summary>
public int BufferSize { get { return _buffersize; }  }
///<summary>
///Time in milliseconds between two pings
///</summary>
public int FastPingDelay { get { return _fastpingdelay; } }
///<summary>
///Servername to connect to
///</summary>
public string Server
{
get { return _server; }
set
{
_server = value;
//Resolve the remote endpoint for the socket.
try
{
IPAddress ipAddress = (IPAddress)Dns.GetHostAddresses(value)[0];
remoteEP = new IPEndPoint(ipAddress, Port);
}
catch (SocketException ex)
{
SendMessage(ex.Message);
}
}
}
#endregion
#region Events & Delegates
protected void SendMessage(string message)
{
if (SendMessageEvent != null)
SendMessageEvent(message);
}
protected void UpdateConnectionStatus(bool connected, bool reconnect)
{
if (ConnectionStatusChanged != null)
ConnectionStatusChanged(connected, reconnect);
}
private void ConnectCallback(IAsyncResult ar)
{
try
{
//Retrieve the socket from the state object.
Socket client = (Socket)ar.AsyncState;
//Complete the connection.
client.EndConnect(ar);
SendMessage(String.Format("Socket connected to {0}", client.RemoteEndPoint.ToString()));
//UpdateConnectionStatus(true, false);
//Signal that the connection has been made.
connectDone.Set();
}
catch (Exception e)
{
SendMessage(e.ToString());
UpdateConnectionStatus(false, true);
}
}
#endregion
#region methods
public AsynchronousClient(int port, string server)
{
_port = port;
Server = server;
_buffersize = 10;
_fastpingdelay = 20;
}
public void CreateSocket()
{
try
{
StopClient();
}
catch (Exception ex)
{
SendMessage(ex.Message);
}
finally
{
client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
}
}
public bool FastPingSocket()
{
for (currentTry = 0; currentTry <= BufferSize; currentTry++)
{
try
{
CreateSocket();
client.BeginConnect(remoteEP, new AsyncCallback(ConnectCallback), client);
connectDone.WaitOne();
System.Threading.Thread.Sleep(FastPingDelay);
client.Shutdown(SocketShutdown.Receive);
connectDone.WaitOne();
client.Close();
return true;
}
catch (SocketException ex)
{
SendMessage(ex.Message);
}
catch (ObjectDisposedException ex)
{
currentTry--;
SendMessage(ex.Message);
CreateSocket();
}
catch (NullReferenceException ex)
{
currentTry--;
SendMessage(ex.Message);
CreateSocket();
}
catch (ArgumentNullException ex)
{
SendMessage(ex.Message);
CreateSocket();
}
catch (InvalidOperationException ex)
{
SendMessage(ex.Message);
CreateSocket();
currentTry--;
}
finally
{
StopClient();
}
}
UpdateConnectionStatus(false, true);
return false;
}
public void StopClient()
{
//Release the socket.
try
{
client.Shutdown(SocketShutdown.Both);
client.Close();
}
catch (Exception) { }
finally
{
UpdateConnectionStatus(false, false);
}
}
#endregion
}
}

Edit: s'il vous Plaît ne pas simplement copier/coller. Essayer de comprendre le code de sorte que vous pouvez l'utiliser à votre avantage, et affiner vos besoins.

C'est probablement le moyen le plus rapide, le délai sera le réseau général/vitesse d'accès au disque etc.

Si cela est la cause d'un retard de l'utilisateur, vous pouvez essayer de vérifier cela de façon asynchrone?

Peut-être que vous devriez essayer de créer le dossier s'il n'existe pas, il retournera un message d'erreur que vous pourriez attraper. Il devrait y avoir aucun délai d'attente par défaut.