Лабораторный практикум по технологиям Bluetooth и Wi-Fi

public abstract class Connection
{
    private string  _clientName;
    private Thread  _receiveThread;

    public delegate void UsersListHandler(string[] names);
    public delegate void MessageReceiveHandler(string from,
                 string message,
                 bool isPrivate);
    public delegate void UsersChangedHandler(string name, bool isJoin);
    public delegate void ServerQuitHandler();

    public event UsersListHandler      UsersListEvent;
    public event MessageReceiveHandler MessageReceiveEvent;
    public event UsersChangedHandler   UsersChangedEvent;
    public event ServerQuitHandler     ServerQuitEvent;

    public Connection(string clientName)
    {
        _clientName = clientName;
    }

    public virtual void Start()
    {
        _receiveThread = new Thread(new ThreadStart(ConnectionThread));
        _receiveThread.Start();

        string message = String.Format("CONN|{0}", _clientName);
        Send(message);
    }

    public virtual void Dispose()
    {
        _receiveThread.Abort();
        _receiveThread = null;
    }

    protected virtual void OnClose()
    {
    }

    public abstract void Send(string message);

    protected abstract string Receive();

    private void ConnectionThread()
    {
        bool keepAlive = true;
 
        while (keepAlive)
        {
            string   message = Receive();
            string[] tokens  = message.Split(new Char[]{'|'});

            switch (tokens[0])
            {
                case "LIST":
                    string[] names = new string[tokens.Length-1];
                    Array.Copy(tokens, 1, names, 0, tokens.Length-1);
                    UsersListEvent(names);
                    break;

                case "CHAT":
                    MessageReceiveEvent(tokens[1], tokens[2], false);
                    break;

                case "PRIV":
                    MessageReceiveEvent(tokens[1], tokens[3], true);
                    break;

                case "JOIN":
                    UsersChangedEvent(tokens[1], true);
                    break;

                case "GONE":
                    UsersChangedEvent(tokens[1], false);
                    break;

                case "QUIT":
                    OnClose();

                    ServerQuitEvent();
                    keepAlive = false;
                    break;
            }
        }
    }
}

public abstract class Connection
{
    protected Thread    _thread;
    protected ArrayList _connections; // Список всех соединений
    protected string    _clientName;

    public event EventHandler ClientsChanged;

    public string ClientName
    {
        get { return _clientName; }
    }

    public Connection(ArrayList connections)
    {
        _connections  = connections;
    }

    public virtual void Start()
    {
        _thread = new Thread(new ThreadStart(ConnectionThread));
        _thread.Start();
    }

    public virtual void Dispose()
    {
        if (_thread != null)
        {
            _thread.Abort();
            _thread = null;
        }

        OnClose();
    }

    protected virtual void OnClose()
    {
    }

    public abstract void Send(string message);

    protected abstract string Receive();

    protected virtual void ConnectionThread()
    {
        bool keepAlive = true;

        while (keepAlive)
        {
            string message = null;

            try
            {
                message = Receive();
            }
            catch
            {
                _connections.Remove(this);
                SendToAll(String.Format("GONE|{0}", _clientName));

                EventArgs e = new EventArgs();
                ClientsChanged(this, e);

                OnClose();
                return;
            }

            string[] tokens  = message.Split(new Char[]{'|'});

            switch (tokens[0])
            {
            case "CONN":
                _clientName = tokens[1];

                SendToAll("JOIN|" + _clientName);

                _connections.Add(this);

                Send("LIST|" + GetChatterList());

                EventArgs ea = new EventArgs();
                ClientsChanged(this, ea);

                break;

            case "CHAT":
                SendToAll(message);
                break;

            case "PRIV":
                string destinationClient = tokens[2];

                foreach (Connection c in _connections)
                {
                    if (c.ClientName.CompareTo(tokens[1]) == 0 ||
                        c.ClientName.CompareTo(tokens[2]) == 0)
                        c.Send(message);
                }
                break;

            case "GONE":
                SendToAll(message);

                _connections.Remove(this);
                OnClose();

                EventArgs e = new EventArgs();
                ClientsChanged(this, e);

                keepAlive = false;
                break;
            }
        }
    }

    private void SendToAll(string message)
    {
        ArrayList closedConnections = new ArrayList();

        foreach (Connection c in _connections)
        {
            try
            {
                c.Send(message);
            }
            catch (Exception)
            {
                closedConnections.Add(c);
            }
        }

        foreach (Connection c in closedConnections)
        {
            _connections.Remove(c);
            Dispose();
        }
    }

    private string GetChatterList()
    {
        StringBuilder chatters = new StringBuilder();

        foreach (Connection c in _connections)
            chatters.AppendFormat("{0}|", c.ClientName);

        chatters.Length--;

        return chatters.ToString();
    }
}

public class BluetoothConnection : Connection
{
    private BtPort _btPort;
 
    // ...

    protected override void ConnectionThread()
    {
        while (true)
        {
            _btPort.Listen();

            base.ConnectionThread();
        }
    }
}

[DllImport("mpr.dll", CharSet=CharSet.Auto)]
public static extern int WNetEnumResource(IntPtr hEnum, ref int lpcCount, IntPtr lpBuffer, ref int lpBufferSize );

[DllImport("mpr.dll", CharSet=CharSet.Auto)]
public static extern int WNetOpenEnum(RESOURCE_SCOPE dwScope, RESOURCE_TYPE dwType, 
RESOURCE_USAGE dwUsage, [MarshalAs(UnmanagedType.AsAny)][In] Object lpNetResource, out IntPtr lphEnum);

[DllImport("mpr.dll", CharSet=CharSet.Auto)]
public static extern int WNetCloseEnum( IntPtr hEnum );
public enum RESOURCE_SCOPE
{
    RESOURCE_isConnected = 0x00000001,
    RESOURCE_GLOBALNET = 0x00000002,
    RESOURCE_REMEMBERED = 0x00000003,
    RESOURCE_RECENT= 0x00000004,
    RESOURCE_CONTEXT= 0x00000005
}
public enum RESOURCE_TYPE
{
    RESOURCETYPE_ANY= 0x00000000,
    RESOURCETYPE_DISK= 0x00000001,
    RESOURCETYPE_PRINT = 0x00000002,
    RESOURCETYPE_RESERVED = 0x00000008,
}
public enum RESOURCE_USAGE
{
    RESOURCEUSAGE_CONNECTABLE =0x00000001,
    RESOURCEUSAGE_CONTAINER=0x00000002,
    RESOURCEUSAGE_NOLOCALDEVICE =0x00000004,
    RESOURCEUSAGE_SIBLING=0x00000008,
    RESOURCEUSAGE_ATTACHED=0x00000010,
    RESOURCEUSAGE_ALL =(RESOURCEUSAGE_CONNECTABLE | 
    RESOURCEUSAGE_CONTAINER | RESOURCEUSAGE_ATTACHED),
}
public enum RESOURCE_DISPLAYTYPE
{
    RESOURCEDISPLAYTYPE_GENERIC= 0x00000000,
    RESOURCEDISPLAYTYPE_DOMAIN= 0x00000001,
    RESOURCEDISPLAYTYPE_SERVER= 0x00000002,
    RESOURCEDISPLAYTYPE_SHARE= 0x00000003,
    RESOURCEDISPLAYTYPE_FILE = 0x00000004,
    RESOURCEDISPLAYTYPE_GROUP= 0x00000005,
    RESOURCEDISPLAYTYPE_NETWORK= 0x00000006,
    RESOURCEDISPLAYTYPE_ROOT = 0x00000007,
    RESOURCEDISPLAYTYPE_SHAREADMIN = 0x00000008,
    RESOURCEDISPLAYTYPE_DIRECTORY = 0x00000009,
    RESOURCEDISPLAYTYPE_TREE = 0x0000000A,
    RESOURCEDISPLAYTYPE_NDSCONTAINER = 0x0000000B
}
public struct NETRESOURCE
{
    public RESOURCE_SCOPE dwScope;
    public RESOURCE_TYPE dwType;
    public RESOURCE_DISPLAYTYPE dwDisplayType;
    public RESOURCE_USAGE dwUsage;
    [MarshalAs(System.Runtime.InteropServices.UnmanagedType.LPTStr)] 
    public string lpLocalName;
    [MarshalAs(System.Runtime.InteropServices.UnmanagedType.LPTStr)] 
    public string lpRemoteName;
    [MarshalAs(System.Runtime.InteropServices.UnmanagedType.LPTStr)] 
    public string lpComment;
    [MarshalAs(System.Runtime.InteropServices.UnmanagedType.LPTStr)] 
    public string lpProvider;
}

private static void DiscoverComputersInternal(Object o, TreeNodeCollection tr)
{
    int iRet;
    IntPtr ptrHandle = new IntPtr();

    iRet = WNetOpenEnum(RESOURCE_SCOPE.RESOURCE_GLOBALNET, 
    RESOURCE_TYPE.RESOURCETYPE_ANY,RESOURCE_USAGE.RESOURCEUSAGE_ALL, o, out ptrHandle );

    if (iRet != 0)
    {
        return;
    }

    int entries;
    int buffer = 16384;
    IntPtr ptrBuffer = Marshal.AllocHGlobal(buffer);
    NETRESOURCE nr;

    while (true)
    {
        entries = -1;
        buffer = 16384;
        iRet = WNetEnumResource( ptrHandle, ref entries, ptrBuffer, ref buffer );

        if ((iRet != 0) || (entries < 1))
            break;

        Int32 ptr = ptrBuffer.ToInt32();

        for (int i = 0; i < entries; i++)
        {
            nr = (NETRESOURCE)Marshal.PtrToStructure(new IntPtr(ptr), typeof(NETRESOURCE));

            if (nr.dwDisplayType == RESOURCE_DISPLAYTYPE.RESOURCEDISPLAYTYPE_SERVER)
            {
                string serverName = nr.lpRemoteName.Remove(0, 2);

                TreeNode n = tr.Add(serverName);
                n.Tag = serverName;
            }
            else if (RESOURCE_USAGE.RESOURCEUSAGE_CONTAINER == 
            (nr.dwUsage & RESOURCE_USAGE.RESOURCEUSAGE_CONTAINER))
            {
                TreeNode n = tr.Add(nr.lpRemoteName);
                DiscoverComputersInternal(nr, n.Nodes);
            }

            ptr += Marshal.SizeOf(nr);
        }
    }
    Marshal.FreeHGlobal( ptrBuffer );
    iRet = WNetCloseEnum( ptrHandle );
}

// открываем базовую ветвь LocalMachine
rkey = Registry.LocalMachine;
// аналогично с остальными базовыми ветвями
rkey = Registry.CurrentUser;
// и т.д.

// далее открываем ветвь
rkey = rkey.OpenSubKey(folder.ToString(), true);
// здесь true – означает разрешение на запись
// и работаем с ключами
string data = (string)rkey.GetValue(keyName);
rkey.SetValue(keyName, keyValue);
// если такого ключа нет, он создается
rkey.DeleteValue(keyName);

// с ветвями также
rkey.CreateSubKey(keyName); // это также открывает имеющуюся ветвь
rkey.DeleteSubKeyTree(keyName);

// получение имен подветвей и ключей в ветви
string[] data = rkey.GetSubKeyNames();
string[] data = rkey.GetValueNames();

public static RegistryKey OpenRemoteBaseKey(
   RegistryHive hKey,
   string machineName
);