C#

<Window Height="480" Title="Window2" Width="640" x:Class="WpfApplication5.Window2"
     x:Name="Window" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
<Window.Resources>
<Storyboard x:Key="OnLoaded1">
<DoubleAnimationUsingKeyFrames Storyboard.TargetName="ctrCircle" 
    Storyboard.TargetProperty="(UIElement.RenderTransform).( TransformGroup.Children)[3].(TranslateTransform.X)">
<EasingDoubleKeyFrame KeyTime="0:0:0.8" Value="1">
<EasingDoubleKeyFrame.EasingFunction>
<ExponentialEase EasingMode="EaseOut" />
</EasingDoubleKeyFrame.EasingFunction>
</EasingDoubleKeyFrame>
        </DoubleAnimationUsingKeyFrames>
        <DoubleAnimationUsingKeyFrames Storyboard.TargetName="ctrCircle" 
            Storyboard.TargetProperty="(UIElement.RenderTransform).(TransformGroup.Children)[3].(TranslateTransform.Y)">
                <EasingDoubleKeyFrame KeyTime="0:0:0.8" Value="1">
                    <EasingDoubleKeyFrame.EasingFunction>
                        <ExponentialEase EasingMode="EaseOut" />
                    </EasingDoubleKeyFrame.EasingFunction>
                </EasingDoubleKeyFrame>
            </DoubleAnimationUsingKeyFrames>
        </Storyboard>
        <Style TargetType="Ellipse">
       <Setter Property="RenderTransform">
            <Setter.Value>
                <ScaleTransform ScaleX="1" ScaleY="1"/>
           </Setter.Value>
        </Setter>
       <Setter Property="RenderTransformOrigin" Value="0.5,0.5"/>
    </Style>
    </Window.Resources>
 <Canvas MouseMove="mov" x:Name="LayoutRoot">
    <Border ackground="Black" B="" Canvas.Left="178" Canvas.Top="103" 
        CornerRadius="250" Height="255.5" Width="290" x:Name="border_eye">
        <Ellipse Fill="#FFFFC600" Height="12" HorizontalAlignment="Left" 
            Margin="0" RenderTransformOrigin="0.5,0.5" Stroke="{x:Null}" 
            VerticalAlignment="Center" Visibility="Visible" Width="12" x:Name="ctrCircle">
            <Ellipse.RenderTransform>
                <TransformGroup>
                     <ScaleTransform />
                    <SkewTransform />
                    <RotateTransform />
                    <TranslateTransform />                 
                </TransformGroup>
            </Ellipse.RenderTransform>
        </Ellipse>
    </Border>
</Canvas>
</Window>

private void mov(object sender, MouseEventArgs e)
        {
	 System.Windows.Point pt = e.GetPosition((Canvas)sender);
          Storyboard invokeStoryboard = this.Resources["OnLoaded1"] as Storyboard;
            ((DoubleAnimationUsingKeyFrames)invokeStoryboard.Children[0]).KeyFrames[0].Value = pt.X;
            ((DoubleAnimationUsingKeyFrames)invokeStoryboard.Children[1]).KeyFrames[0].Value = pt.Y;
            invokeStoryboard.Begin();
        }

//call SetOwner(@"\\servername\share\filename.ext",@"domain\username");
public static void SetOwner(string uri, string account)
{
    System.Security.AccessControl.FileSecurity security = File.GetAccessControl(uri);
    IdentityReference owner = new NTAccount(account);
    security.SetOwner(owner); 
    File.SetAccessControl(uri, security); 
}

//call SetOwner(@"\\servername\share\filename.ext",@"domain\username");
public static void SetOwner(string uri, string account)
{
    StartImpersonating(account);
    System.Security.AccessControl.FileSecurity security = File.GetAccessControl(uri);
    IdentityReference owner = new NTAccount(account);
    security.SetOwner(owner); 
    File.SetAccessControl(uri, security); 
    StopImpersonating();
}

static void StartImpersonating(string account, string password)
{
    System.Security.Principal.WindowsIdentity.Impersonate(account, password);
}
static void StartImpersonating(string account)
{
    string password = GetPasswordFromSecureStore(account);
    StartImpersonating(account, password);
}
static void StartImpersonating(string domain, string username)
{
    StartImpersonating(string.Format("{0}\\{1}",domain,username));
}
static void StopImpersonating()
{
    StartImpersonating(System.Environment.UserDomainName,System.Environment.UserName);
}

<br />
  public Window1()<br />
        {<br />
            InitializeComponent();<br />
           <br />
<br />
               ...other code<br />
             //Start the server...<br />
            connectionAccept();<br />
<br />
             }<br />

<br />
 private void connectionAccept()<br />
        {<br />
            try<br />
            {<br />
                listener = new Socket(AddressFamily.InterNetwork,<br />
                                             SocketType.Stream,<br />
                                             ProtocolType.Tcp);<br />
<br />
                IPEndPoint LocalIP = new IPEndPoint(IPAddress.Any, 2112);<br />
<br />
                listener.Bind(LocalIP);<br />
<br />
                listener.Listen(0);<br />
<br />
                listener.BeginAccept(new AsyncCallback(OnClientConnect), null);<br />
<br />
            }//End of try<br />
<br />
            catch (SocketException se)<br />
            {<br />
                MessageBox.Show(se.Message);<br />
            }//End of catch<br />
<br />
        }// End of connectionAccept method<br />
<br />
        //On client call....<br />
        public void OnClientConnect(IAsyncResult asyn)<br />
        {<br />
            try<br />
            {<br />
                otherListener[numberOfClients] = listener.EndAccept(asyn);<br />
<br />
                WaitForData(otherListener[numberOfClients]);<br />
<br />
                ++numberOfClients;<br />
<br />
                String strData = Convert.ToString(numberOfClients);<br />
                MessageBox.Show(strData);<br />
<br />
                listener.BeginAccept(new AsyncCallback(OnClientConnect), null);<br />
            }<br />
            catch (ObjectDisposedException)<br />
            {<br />
                System.Diagnostics.Debugger.Log(0, "1", "\n OnClientConnection: Socket has been closed\n");<br />
            }//End of first catch<br />
<br />
            catch (SocketException se)<br />
            {<br />
                MessageBox.Show(se.Message);<br />
<br />
            }//End of second catch<br />
<br />
        }//End of OnClientConnect method<br />
<br />
        public class SocketPacket<br />
        {<br />
            public System.Net.Sockets.Socket currentSoc;<br />
            public byte[] dataBuffer = new byte[0];<br />
<br />
        }//End of Socket packet<br />
<br />
        public void WaitForData(System.Net.Sockets.Socket soc)<br />
        {<br />
            try<br />
            {<br />
<br />
                if (pfnListnerCallBack == null)<br />
                {<br />
                    pfnListnerCallBack = new AsyncCallback(OnDataReceived);<br />
<br />
<br />
                    SocketPacket socPkt = new SocketPacket();<br />
                    socPkt.currentSoc = soc;<br />
<br />
<br />
                    soc.BeginReceive(socPkt.dataBuffer, 0,<br />
                                          socPkt.dataBuffer.Length,<br />
                                           SocketFlags.None,<br />
                                           pfnListnerCallBack,<br />
                                           socPkt);<br />
<br />
<br />
                }//End of if statement<br />
<br />
            }//End of try<br />
<br />
            catch (SocketException se)<br />
            {<br />
                MessageBox.Show(se.Message);<br />
<br />
            }//End of catch<br />
<br />
        }//End of wait for data<br />
<br />
        public void OnDataReceived(IAsyncResult asyn)<br />
        {<br />
            try<br />
            {<br />
                SocketPacket socketData = (SocketPacket)asyn.AsyncState;<br />
                string receivedValue = string.Empty;<br />
<br />
                byte[] receivedBytes = new byte[1024];<br />
                int numBytes = socketData.currentSoc.Receive(receivedBytes);<br />
<br />
                receivedValue = Encoding.ASCII.GetString(receivedBytes);               <br />
               <br />
               MessageBox.Show(receivedValue);               <br />
                WaitForData(socketData.currentSoc);              <br />
<br />
            }//End of try<br />
<br />
            catch (ObjectDisposedException)<br />
            {<br />
                System.Diagnostics.Debugger.Log(0, "1", "\nOnDataReceived: Socket has been closed\n");<br />
<br />
            }//End of catch1<br />
<br />
            catch (SocketException se)<br />
            {<br />
                MessageBox.Show(se.Message);<br />
            }//End of catch2 <br />
<br />
        }//End of OnDataReceived method..<br />
        <br />
    }<br />
<br />

using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Linq;
using System.Text;
using System.Threading;
using log4net;

namespace ICMPTest
{
    public class ICMPCheck
    {
        private static ManualResetEvent gotMessage;
        private static IPAddress ipAddress;
        private static IntPtr stateHandle; // Dont know what it is for, or what to do with it
        private static ICMP.Disposables.StateObject so = null;
        private static Socket icmpClient;
        private static EndPoint remoteRawEndPoint = (EndPoint)new IPEndPoint(IPAddress.Any, 0);
        public static Queue<byte[]> m_icmpQueue = new Queue<byte[]>();
        public static object m_syncLock = new object();
        private static IPEndPoint NIC = null;
        private static int Queued = 0;
        private static int DeQueued = 0;
        private static int CallCount = 0;
        public static IAsyncResult iar;

        public static void Start()
        {
            try
            {
                using (icmpClient = new Socket(AddressFamily.InterNetwork, SocketType.Raw, ProtocolType.Icmp))
                {
                    IPHostEntry hostEntry = Dns.GetHostEntry(Dns.GetHostName());
                    IPHostEntry hostInfo = Dns.Resolve(Dns.GetHostName());
                    IPAddress[] address = hostInfo.AddressList;
                    ipAddress = address[0];
                    NIC = new IPEndPoint(ipAddress, 0);
                    icmpClient.Bind(NIC); // Bind to localhost, port any
                    byte[] inBytes = new byte[] { 1, 0, 0, 0 };
                    byte[] outBytes = new byte[] { 0, 0, 0, 0 };
                    icmpClient.IOControl(IOControlCode.ReceiveAll, inBytes, outBytes); //only outgoing packets
                    icmpClient.ReceiveBufferSize = 1024;

                    while (true)
                    {
                        //gotMessage = new ManualResetEvent(false);
                        using (so = new ICMP.Disposables.StateObject(stateHandle))
                        {
                            so.workSocket = icmpClient;

                            iar = icmpClient.BeginReceiveFrom(so.buffer, 0, ICMP.Disposables.StateObject.BUFFER_SIZE, 0, ref remoteRawEndPoint, new AsyncCallback(ReceiveFromCallback), so); //blocking

                            //gotMessage.WaitOne(); //iar.AsyncWaitHandle.WaitOne(); // seems to be unreliable
                            iar.AsyncWaitHandle.WaitOne();

                            for (int i = DeQueued; i < Queued; i++)
                            {
                                //DequeueParse.DequeueAndParse(ref so);
                                Interlocked.Increment(ref DeQueued);
                                ICMP.ICMPProgram.logger.Debug("ICMPCheck-0: Signal + Message received: " + remoteRawEndPoint.ToString() + " Queue: " + m_icmpQueue.Count.ToString() + " " + Queued.ToString() + " " + DeQueued.ToString());
                            }
                        } // using StateObject
                        //gotMessage.Dispose();
                    }// while
                }//using Socket
            } // try
            catch (Exception excp)
            {
                ICMP.ICMPProgram.logger.Error("ICMPCheck: Exception Mainblock. " + excp.Message);
            }
            return;
        }
        // Your callback method should implement the EndReceiveFrom method. When your application calls BeginReceiveFrom, the system will use a separate thread to execute the 
        // specified callback method, and it will block on EndReceiveFrom until the Socket reads data or throws an exception. If you want the original thread to block after you 
        // call the BeginReceiveFrom method, use WaitHandle.WaitOne. Call ManualResetEvent.Set in the callback method when you want the original thread to continue executing. 
        // For additional information on writing callback methods, see Callback Sample.

        private static void ReceiveFromCallback(IAsyncResult iar) // The callback method must accept the IAsyncResult returned by the BeginReceiveFrom method as a parameter.
        { //Monitor.Enter(((StateObject)ar.AsyncState).workSocket); is equivalent to: lock (((StateObject)ar.AsyncState).workSocket) without try..catch //Monitor.Exit(((StateObject)ar.AsyncState).workSocket);
            Interlocked.Increment(ref CallCount);
            try
            {
                ICMP.Disposables.StateObject state = (ICMP.Disposables.StateObject)iar.AsyncState;
                Socket client = ((ICMP.Disposables.StateObject)iar.AsyncState).workSocket;
                EndPoint tempRemoteEP = (EndPoint)new IPEndPoint(IPAddress.Any, 0);

                int bytesRead = client.EndReceiveFrom(iar, ref tempRemoteEP);

                if (bytesRead > 0)
                {
                    if (!(((IPEndPoint)tempRemoteEP).Address).Equals(NIC.Address)) // ignore packages from local host
                    {
                        byte[] _icmpData = new byte[bytesRead];
                        byte[] icmpType = new byte[1];
                        Buffer.BlockCopy(state.buffer, 20, icmpType, 0, 1);

                        //if (((int)icmpType[0] == 3)) // only Type 3
                        if (true) // all ICMP packages for now
                        {
                            Buffer.BlockCopy(state.buffer, 0, _icmpData, 0, bytesRead); // Socket to local copy
                            lock (m_syncLock)
                            {
                                m_icmpQueue.Enqueue(_icmpData);
                                Interlocked.Increment(ref Queued);
                            }
                        }
                        // the next callback is required when using AsyncWaitHandle.WaitOne signaling, not required (but useful for high volume) for ManualResetEvents
                        client.BeginReceiveFrom(state.buffer, 0, ICMP.Disposables.StateObject.BUFFER_SIZE, 0, ref tempRemoteEP, new AsyncCallback(ReceiveFromCallback), state); // suitable for high volume
                        remoteRawEndPoint = tempRemoteEP;
                        ICMP.ICMPProgram.logger.Debug("ICMPCheck: Bytes: " + bytesRead.ToString() + ", Type: " + icmpType[0].ToString() + " " + tempRemoteEP.ToString() + " " + m_icmpQueue.Count.ToString() + " " + Queued.ToString() + " " + CallCount.ToString() + " " + iar.IsCompleted.ToString());
                        //ICMPProgram.logger.Debug("ICMPCheck: Bytes: " + bytesRead.ToString() + ", Type: " + icmpType[0].ToString() + " " + tempRemoteEP.ToString() + " " + SrcIPStr + " " + sequence.ToString() + " " + CallCount.ToString() + " " + iar.IsCompleted.ToString());
                    }
                }
                else
                {
                    ICMP.ICMPProgram.logger.Debug("ICMPCheck: bytesRead = 0 ");
                }
            }
            catch (Exception excp)
            {
                ICMP.ICMPProgram.logger.Debug("ICMPCheck:ReceiveFromCallback main " + excp.Message);
            }
            finally
            {
                //gotMessage.Set();
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using System.Net.Sockets;

namespace ICMP
{
    public class Disposables
    {
        // A base class that implements IDisposable.
        // By implementing IDisposable, you are announcing that
        // instances of this type allocate scarce resources.
        public class StateObject : IDisposable
        {
            public Socket workSocket = null;
            public const int BUFFER_SIZE = 1024;
            public byte[] buffer = new byte[BUFFER_SIZE];
            public StringBuilder sb = new StringBuilder();

            private IntPtr handle; // Pointer to an external unmanaged resource.
            private Component component = new Component(); // Other managed resource this class uses.
            private bool disposed = false; // Track whether Dispose has been called.

            // The class constructor.
            public StateObject(IntPtr handle)
            {
                this.handle = handle;
            }

            // Implement IDisposable.
            // Do not make this method virtual.
            // A derived class should not be able to override this method.
            public void Dispose()
            {
                Dispose(true);
                // This object will be cleaned up by the Dispose method.
                // Therefore, you should call GC.SupressFinalize to
                // take this object off the finalization queue
                // and prevent finalization code for this object
                // from executing a second time.
                GC.SuppressFinalize(this);
            }

            // Dispose(bool disposing) executes in two distinct scenarios.
            // If disposing equals true, the method has been called directly
            // or indirectly by a user's code. Managed and unmanaged resources
            // can be disposed.
            // If disposing equals false, the method has been called by the
            // runtime from inside the finalizer and you should not reference
            // other objects. Only unmanaged resources can be disposed.
            private void Dispose(bool disposing)
            {
                // Check to see if Dispose has already been called.
                if (!this.disposed)
                {
                    // If disposing equals true, dispose all managed
                    // and unmanaged resources.
                    if (disposing)
                    {
                        // Dispose managed resources.
                        component.Dispose();
                    }

                    // Call the appropriate methods to clean up
                    // unmanaged resources here.
                    // If disposing is false,
                    // only the following code is executed.
                    CloseHandle(handle);
                    handle = IntPtr.Zero;

                    // Note disposing has been done.
                    disposed = true;

                }
            }

            // Use interop to call the method necessary
            // to clean up the unmanaged resource.
            [System.Runtime.InteropServices.DllImport("Kernel32")]
            private extern static Boolean CloseHandle(IntPtr handle);

            // Use C# destructor syntax for finalization code.
            // This destructor will run only if the Dispose method
            // does not get called.
            // It gives your base class the opportunity to finalize.
            // Do not provide destructors in types derived from this class.
            ~StateObject()
            {
                // Do not re-create Dispose clean-up code here.
                // Calling Dispose(false) is optimal in terms of
                // readability and maintainability.
                Dispose(false);
            }
        }
    }
}