ReconnectingTcpAppender | C# Online Compiler

ReconnectingTcpAppender by Anonymous

#region Apache License
//
// Licensed to the Apache Software Foundation (ASF) under one or more 
// contributor license agreements. See the NOTICE file distributed with
// this work for additional information regarding copyright ownership. 
// The ASF licenses this file to you under the Apache License, Version 2.0
// (the "License"); you may not use this file except in compliance with 
// the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#endregion

using System;
using System.Globalization;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using log4net.Appender;
using log4net.Core;
using System.Threading.Tasks;
using System.Collections.Concurrent;
using System.Linq;
using System.Runtime.InteropServices;

namespace Utilities
{
    /// <summary>
    /// Sends logging events through TCP connection to a remote host
    /// </summary>
    /// <remarks>
    /// <para>
    /// TCP guarantees delivery and order
    /// </para>
    /// <para>
    /// To view the logging results, a custom application can be developed that listens for logging 
    /// events.
    /// </para>
    /// <para>
    /// When decoding events send via this appender remember to use the same encoding
    /// to decode the events as was used to send the events. See the <see cref="Encoding"/>
    /// property to specify the encoding to use.
    /// </para>
    /// </remarks>
    /// <example>
    /// This example shows how to log receive logging events that are sent 
    /// on IP address 244.0.0.1 and port 8080 to the console. The event is 
    /// encoded in the packet as a unicode string and it is decoded as such. 
    /// <code lang="C#">
    /// IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
    /// TcpClient TcpClient;
    /// byte[] buffer;
    /// string loggingEvent;
    /// 
    /// try 
    /// {
    ///     TcpClient = new TcpClient(8080);
    ///     
    ///     while(true) 
    ///     {
    ///         buffer = TcpClient.Receive(ref remoteEndPoint);
    ///         loggingEvent = System.Text.Encoding.Unicode.GetString(buffer);
    ///         Console.WriteLine(loggingEvent);
    ///     }
    /// } 
    /// catch(Exception e) 
    /// {
    ///     Console.WriteLine(e.ToString());
    /// }
    /// </code>
    /// <code lang="Visual Basic">
    /// Dim remoteEndPoint as IPEndPoint
    /// Dim TcpClient as TcpClient
    /// Dim buffer as Byte()
    /// Dim loggingEvent as String
    /// 
    /// Try 
    ///     remoteEndPoint = new IPEndPoint(IPAddress.Any, 0)
    ///     TcpClient = new TcpClient(8080)
    ///
    ///     While True
    ///         buffer = TcpClient.Receive(ByRef remoteEndPoint)
    ///         loggingEvent = System.Text.Encoding.Unicode.GetString(buffer)
    ///         Console.WriteLine(loggingEvent)
    ///     Wend
    /// Catch e As Exception
    ///     Console.WriteLine(e.ToString())
    /// End Try
    /// </code>
    /// <para>
    /// An example configuration section to log information using this appender to the 
    /// IP 224.0.0.1 on port 8080:
    /// </para>
    /// <code lang="XML" escaped="true">
    /// <appender name="TcpAppender" type="log4net.Appender.TcpAppender">
    ///     <remoteAddress value="224.0.0.1" />
    ///     <remotePort value="8080" />
    ///     <layout type="log4net.Layout.PatternLayout" value="%-5level %logger [%ndc] - %message%newline" />
    /// </appender>
    /// </code>
    /// </example>
    /// <author>Gert Driesen</author>
    /// <author>Nicko Cadell</author>
    public class ReconnectingTcpAppender : AppenderSkeleton
    {
        #region Public Instance Constructors

        /// <summary>
        /// Initializes a new instance of the <see cref="ReconnectingTcpAppender" /> class.
        /// </summary>
        /// <remarks>
        /// The default constructor initializes all fields to their default values.
        /// </remarks>
        public ReconnectingTcpAppender()
        {
            // set port to some invalid value, forcing you to set the port
            _remotePort = IPEndPoint.MinPort - 1;
        }

        private class AsyncLoggingData
        {
            internal TcpClient Client { get; set; }
            internal LoggingEvent LoggingEvent { get; set; }
        }

        #endregion Public Instance Constructors

        #region Public Instance Properties

        /// <summary>
        /// Gets or sets the IP address of the remote host to which
        /// the underlying <see cref="TcpClient" /> should sent the logging event.
        /// </summary>
        /// <value>
        /// The IP address of the remote host  to which the logging event will be sent.
        /// </value>
        /// <remarks>
        /// <para>
        /// Multicast addresses are identified by IP class <b>D</b> addresses (in the range 224.0.0.0 to
        /// 239.255.255.255).  Multicast packets can pass across different networks through routers, so
        /// it is possible to use multicasts in an Internet scenario as long as your network provider 
        /// supports multicasting.
        /// </para>
        /// <para>
        /// Hosts that want to receive particular multicast messages must register their interest by joining
        /// the multicast group.  Multicast messages are not sent to networks where no host has joined
        /// the multicast group.  Class <b>D</b> IP addresses are used for multicast groups, to differentiate
        /// them from normal host addresses, allowing nodes to easily detect if a message is of interest.
        /// </para>
        /// <para>
        /// Static multicast addresses that are needed globally are assigned by IANA.  A few examples are listed in the table below:
        /// </para>
        /// <para>
        /// <list type="table">
        ///     <listheader>
        ///         <term>IP Address</term>
        ///         <description>Description</description>
        ///     </listheader>
        ///     <item>
        ///         <term>224.0.0.1</term>
        ///         <description>
        ///             <para>
        ///             Sends a message to all system on the subnet.
        ///             </para>
        ///         </description>
        ///     </item>
        ///     <item>
        ///         <term>224.0.0.2</term>
        ///         <description>
        ///             <para>
        ///             Sends a message to all routers on the subnet.
        ///             </para>
        ///         </description>
        ///     </item>
        ///     <item>
        ///         <term>224.0.0.12</term>
        ///         <description>
        ///             <para>
        ///             The DHCP server answers messages on the IP address 224.0.0.12, but only on a subnet.
        ///             </para>
        ///         </description>
        ///     </item>
        /// </list>
        /// </para>
        /// <para>
        /// A complete list of actually reserved multicast addresses and their owners in the ranges
        /// defined by RFC 3171 can be found at the <A href="http://www.iana.org/assignments/multicast-addresses">IANA web site</A>. 
        /// </para>
        /// <para>
        /// The address range 239.0.0.0 to 239.255.255.255 is reserved for administrative scope-relative 
        /// addresses.  These addresses can be reused with other local groups.  Routers are typically 
        /// configured with filters to prevent multicast traffic in this range from flowing outside
        /// of the local network.
        /// </para>
        /// </remarks>
        public string RemoteAddress
        {
            get { return _remoteAddress; }
            set { _remoteAddress = value; }
        }

        TcpClient Client { get; set; }

        /// <summary>
        /// Gets or sets the TCP port number of the remote host or multicast group to which 
        /// the underlying <see cref="TcpClient" /> should sent the logging event.
        /// </summary>
        /// <value>
        /// An integer value in the range <see cref="IPEndPoint.MinPort" /> to <see cref="IPEndPoint.MaxPort" /> 
        /// indicating the TCP port number of the remote host or multicast group to which the logging event 
        /// will be sent.
        /// </value>
        /// <remarks>
        /// The underlying <see cref="TcpClient" /> will send messages to this TCP port number
        /// on the remote host or multicast group.
        /// </remarks>
        /// <exception cref="ArgumentOutOfRangeException">The value specified is less than <see cref="IPEndPoint.MinPort" /> or greater than <see cref="IPEndPoint.MaxPort" />.</exception>
        public int RemotePort
        {
            get { return _remotePort; }
            set
            {
                if (value < IPEndPoint.MinPort || value > IPEndPoint.MaxPort)
                {
                    throw log4net.Util.SystemInfo.CreateArgumentOutOfRangeException("value", value,
                        "The value specified is less than " +
                        IPEndPoint.MinPort.ToString(NumberFormatInfo.InvariantInfo) +
                        " or greater than " +
                        IPEndPoint.MaxPort.ToString(NumberFormatInfo.InvariantInfo) + ".");
                }
                else
                {
                    _remotePort = value;
                }
            }
        }

        /// <summary>
        /// Gets or sets <see cref="Encoding"/> used to write the packets.
        /// </summary>
        /// <value>
        /// The <see cref="Encoding"/> used to write the packets.
        /// </value>
        /// <remarks>
        /// <para>
        /// The <see cref="Encoding"/> used to write the packets.
        /// </para>
        /// </remarks>
        public Encoding Encoding
        {
            get { return _encoding; }
            set { _encoding = value; }
        }

        readonly ConcurrentQueue<LoggingEvent> mEventBuffer = new ConcurrentQueue<LoggingEvent>();

        #endregion Public Instance Properties

        #region Implementation of IOptionHandler

        /// <summary>
        /// Initialize the appender based on the options set.
        /// </summary>
        /// <remarks>
        /// <para>
        /// This is part of the <see cref="IOptionHandler"/> delayed object
        /// activation scheme. The <see cref="ActivateOptions"/> method must 
        /// be called on this object after the configuration properties have
        /// been set. Until <see cref="ActivateOptions"/> is called this
        /// object is in an undefined state and must not be used. 
        /// </para>
        /// <para>
        /// If any of the configuration properties are modified then 
        /// <see cref="ActivateOptions"/> must be called again.
        /// </para>
        /// <para>
        /// The appender will be ignored if no <see cref="RemoteAddress" /> was specified or 
        /// an invalid remote or local TCP port number was specified.
        /// </para>
        /// </remarks>
        /// <exception cref="ArgumentNullException">The required property <see cref="RemoteAddress" /> was not specified.</exception>
        /// <exception cref="ArgumentOutOfRangeException">The TCP port number assigned to <see cref="RemotePort" /> is less than <see cref="IPEndPoint.MinPort" /> or greater than <see cref="IPEndPoint.MaxPort" />.</exception>
        public override void ActivateOptions()
        {
            base.ActivateOptions();

            if (string.IsNullOrWhiteSpace(RemoteAddress))
            {
                throw new ArgumentNullException("RemoteAddress");
            }
            
            if (RemotePort < IPEndPoint.MinPort || RemotePort > IPEndPoint.MaxPort)
            {
                throw log4net.Util.SystemInfo.CreateArgumentOutOfRangeException("RemotePort", RemotePort,
                    "The RemotePort is less than " +
                    IPEndPoint.MinPort.ToString(NumberFormatInfo.InvariantInfo) +
                    " or greater than " +
                    IPEndPoint.MaxPort.ToString(NumberFormatInfo.InvariantInfo) + ".");
            }
        }

        #endregion

        #region Override implementation of AppenderSkeleton

        /// <summary>
        /// This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
        /// </summary>
        /// <param name="loggingEvent">The event to log.</param>
        /// <remarks>
        /// <para>
        /// Sends the event using an Tcp datagram.
        /// </para>
        /// <para>
        /// Exceptions are passed to the <see cref="AppenderSkeleton.ErrorHandler"/>.
        /// </para>
        /// </remarks>
        protected override void Append(LoggingEvent loggingEvent)
        {
            if (null != Client && Client.Connected)
            {
                WriteEvent(loggingEvent);
            }
            else
            {
                Reconnect(loggingEvent, 0);
            }
        }

        protected override void Append(LoggingEvent[] loggingEvents)
        {
            if (Client.Connected)
            {
                Array.ForEach(loggingEvents, le => WriteEvent(le));
            }
            else
            {
                Array.ForEach(loggingEvents, le => mEventBuffer.Enqueue(le));
                Reconnect(null, 0);
            }
        }

        [DllImport("dnsapi.dll",EntryPoint="DnsFlushResolverCache")]
        private static extern UInt32 DnsFlushResolverCache ();

        Task<IPAddress[]> GetAddress()
        {
            DnsFlushResolverCache();
            var currDnsTimeout = ServicePointManager.DnsRefreshTimeout;
            ServicePointManager.DnsRefreshTimeout = 0;
            try
            {
              return Task.Factory.FromAsync<IPHostEntry>(Dns.BeginGetHostEntry(RemoteAddress, null, null)
                  , Dns.EndGetHostEntry)
                  .ContinueWith(t =>
                      {
                        ServicePointManager.DnsRefreshTimeout = currDnsTimeout;
                        if (t.IsFaulted)
                        {
                          ErrorHandler.Error(string.Format("Failed to resolve remote host {0} in dns", RemoteAddress)
                              , t.Exception);
                          return null;
                        }

                        return t.Result.AddressList;
                      });
            }
            catch (Exception)
            {
              ServicePointManager.DnsRefreshTimeout = currDnsTimeout;
              return Task.Factory.StartNew(() => new IPAddress[0]);
            }
        }

        Task ConnectTask { get; set; }

        void Reconnect(LoggingEvent loggingEvent, int waitMilliSecs = 3000)
        {
            if (null != loggingEvent)
                mEventBuffer.Enqueue(loggingEvent);

            lock (this)
            {
              if (null != ConnectTask && !ConnectTask.IsCompleted)
                return;
            
              var ct = new System.Threading.CancellationToken();
              ConnectTask = TaskEx.Delay(waitMilliSecs, ct)
                  .ContinueWith(td => 
                      {
                          Connect(waitMilliSecs);
                          var c = ct.CanBeCanceled; //just to force reference
                      });
            }
        }

        void Connect(int lastWait=0)
        {
            if (null != Client)
            {
                if (Client.Connected)
                    Client.Close();
                Client = null;
            }

            ConnectTask = GetAddress()
            .ContinueWith(t =>
            {
              var ipAddresses = t.Result;
              if (null == ipAddresses || !ipAddresses.Any())
              {
                //ConnectTask = null;
                //Reconnect(null, lastWait + new Random().Next(lastWait >> 2));
                return;
              }

              var client = new TcpClient();
              var ipAddress = ipAddresses.First(a => a.AddressFamily == AddressFamily.InterNetwork);
              ConnectTask = Task.Factory.FromAsync(client.BeginConnect(ipAddress,
                      RemotePort,
                      null,
                      client)
                      , client.EndConnect)
                  .ContinueWith(tc =>
                  {
                    if (tc.IsFaulted)
                    {
                      ErrorHandler.Error(string.Format("Failed to connect to {0}", RemoteAddress)
                          , tc.Exception);
                      //Reconnect(null, lastWait + new Random().Next(lastWait >> 2));
                      return;
                    }
                    Client = client;
                    lock (this)
                    {
                      ConnectTask = null;
                    }
                    LoggingEvent e;
                    while (mEventBuffer.TryDequeue(out e))
                      WriteEvent(e);
                  });
            });
        }

        void WriteEvent(LoggingEvent loggingEvent)
        {
            var rendered = RenderLoggingEvent(loggingEvent);
            var ca = rendered.ToCharArray();
            var buffer = Encoding.GetBytes(ca);
            var client = Client;
            if (null == client || !client.Connected)
            {
                Reconnect(loggingEvent);
                return;
            }

            try
            {
                var netStream = client.GetStream();
                var writeTask = Task.Factory.FromAsync(netStream.BeginWrite(buffer, 0, buffer.Length, null, Client)
                    , netStream.EndWrite);
                writeTask.ContinueWith(tf =>
                {
                    ErrorHandler.Error(
                        "Unable to send logging event to remote host " + RemoteAddress.ToString() + " on port " +
                        RemotePort + ".", tf.Exception, ErrorCode.WriteFailure);

                    Reconnect(loggingEvent);
                }, TaskContinuationOptions.NotOnRanToCompletion);
                //writeTask.ContinueWith(ts =>
                //{
                //    try
                //    {
                //        var readTask = Task.Factory.FromAsync<int>(netStream.BeginRead(new byte[] { }, 0, 0, null, Client)
                //            , netStream.EndRead);
                //        readTask.ContinueWith(tf =>
                //        {
                //            ErrorHandler.Error(
                //                "Unable to read from remote host " + this.RemoteAddress.ToString() + " on port " +
                //                this.RemotePort + ".", tf.Exception, ErrorCode.WriteFailure);

                //            Reconnect(loggingEvent);
                //        }, TaskContinuationOptions.NotOnRanToCompletion);
                //    }
                //    catch (Exception e)
                //    {
                //        ErrorHandler.Error(
                //            "Unable to read from remote host " + this.RemoteAddress.ToString() + " on port " +
                //            this.RemotePort + ".", e, ErrorCode.WriteFailure);

                //        Reconnect(loggingEvent);
                //    }

                //}, TaskContinuationOptions.OnlyOnRanToCompletion);
            }
            catch (ObjectDisposedException e)
            {
                ErrorHandler.Error(
                    string.Format("Unable to send logging event to remote host {0} on port {1}", RemoteAddress, RemotePort)
                    , e
                    , ErrorCode.WriteFailure);

                Reconnect(loggingEvent);
            }
            catch (System.IO.IOException e)
            {
                ErrorHandler.Error(
                    string.Format("Unable to send logging event to remote host {0} on port {1}", RemoteAddress, RemotePort)
                    , e
                    , ErrorCode.WriteFailure);

                Reconnect(loggingEvent);
            }
        }

        /// <summary>
        /// This appender requires a <see cref="log4net.Layout"/> to be set.
        /// </summary>
        /// <value><c>true</c></value>
        /// <remarks>
        /// <para>
        /// This appender requires a <see cref="log4net.Layout"/> to be set.
        /// </para>
        /// </remarks>
        override protected bool RequiresLayout
        {
            get { return true; }
        }

        /// <summary>
        /// Closes the Tcp connection and releases all resources associated with 
        /// this <see cref="ReconnectingTcpAppender" /> instance.
        /// </summary>
        /// <remarks>
        /// <para>
        /// Disables the underlying <see cref="TcpClient" /> and releases all managed 
        /// and unmanaged resources associated with the <see cref="ReconnectingTcpAppender" />.
        /// </para>
        /// </remarks>
        override protected void OnClose()
        {
            base.OnClose();
        }

        #endregion Override implementation of AppenderSkeleton

        #region Private Instance Fields

        /// <summary>
        /// The IP address of the remote host or multicast group to which 
        /// the logging event will be sent.
        /// </summary>
        private string _remoteAddress;

        /// <summary>
        /// The TCP port number of the remote host or multicast group to 
        /// which the logging event will be sent.
        /// </summary>
        private int _remotePort;

        /// <summary>
        /// The encoding to use for the packet.
        /// </summary>
        private Encoding _encoding = Encoding.Default;

        #endregion Private Instance Fields
    }
}

​x
 
#region Apache License
//
// Licensed to the Apache Software Foundation (ASF) under one or more 
// contributor license agreements. See the NOTICE file distributed with
// this work for additional information regarding copyright ownership. 
// The ASF licenses this file to you under the Apache License, Version 2.0
// (the "License"); you may not use this file except in compliance with 
// the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#endregion
​
using System;
using System.Globalization;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using log4net.Appender;
using log4net.Core;
using System.Threading.Tasks;
using System.Collections.Concurrent;
using System.Linq;
using System.Runtime.InteropServices;
​
namespace Utilities
{
    /// <summary>
    /// Sends logging events through TCP connection to a remote host
    /// </summary>
    /// <remarks>
    /// <para>
    /// TCP guarantees delivery and order
    /// </para>
    /// <para>
    /// To view the logging results, a custom application can be developed that listens for logging 
    /// events.
    /// </para>
    /// <para>
    /// When decoding events send via this appender remember to use the same encoding
    /// to decode the events as was used to send the events. See the <see cref="Encoding"/>
    /// property to specify the encoding to use.
    /// </para>
    /// </remarks>
    /// <example>
    /// This example shows how to log receive logging events that are sent 
    /// on IP address 244.0.0.1 and port 8080 to the console. The event is 
    /// encoded in the packet as a unicode string and it is decoded as such. 
    /// <code lang="C#">
    /// IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
    /// TcpClient TcpClient;
    /// byte[] buffer;
    /// string loggingEvent;
    /// 
    /// try 
    /// {
    ///     TcpClient = new TcpClient(8080);
    ///     
    ///     while(true) 
    ///     {
    ///         buffer = TcpClient.Receive(ref remoteEndPoint);
    ///         loggingEvent = System.Text.Encoding.Unicode.GetString(buffer);
    ///         Console.WriteLine(loggingEvent);
    ///     }
    /// } 
    /// catch(Exception e) 
    /// {
    ///     Console.WriteLine(e.ToString());
    /// }
    /// </code>
    /// <code lang="Visual Basic">
    /// Dim remoteEndPoint as IPEndPoint
    /// Dim TcpClient as TcpClient
    /// Dim buffer as Byte()
    /// Dim loggingEvent as String
    /// 
    /// Try 
    ///     remoteEndPoint = new IPEndPoint(IPAddress.Any, 0)
    ///     TcpClient = new TcpClient(8080)
    ///
    ///     While True
    ///         buffer = TcpClient.Receive(ByRef remoteEndPoint)
    ///         loggingEvent = System.Text.Encoding.Unicode.GetString(buffer)
    ///         Console.WriteLine(loggingEvent)
    ///     Wend
    /// Catch e As Exception
    ///     Console.WriteLine(e.ToString())
    /// End Try
    /// </code>
    /// <para>
    /// An example configuration section to log information using this appender to the 
    /// IP 224.0.0.1 on port 8080:
    /// </para>
    /// <code lang="XML" escaped="true">
    /// <appender name="TcpAppender" type="log4net.Appender.TcpAppender">
    ///     <remoteAddress value="224.0.0.1" />
    ///     <remotePort value="8080" />
    ///     <layout type="log4net.Layout.PatternLayout" value="%-5level %logger [%ndc] - %message%newline" />
    /// </appender>
    /// </code>
    /// </example>
    /// <author>Gert Driesen</author>
    /// <author>Nicko Cadell</author>
    public class ReconnectingTcpAppender : AppenderSkeleton
    {
        #region Public Instance Constructors
​
        /// <summary>
        /// Initializes a new instance of the <see cref="ReconnectingTcpAppender" /> class.
        /// </summary>
        /// <remarks>
        /// The default constructor initializes all fields to their default values.
        /// </remarks>
        public ReconnectingTcpAppender()
        {
            // set port to some invalid value, forcing you to set the port
            _remotePort = IPEndPoint.MinPort - 1;
        }
​
        private class AsyncLoggingData
        {
            internal TcpClient Client { get; set; }
            internal LoggingEvent LoggingEvent { get; set; }
        }
​
        #endregion Public Instance Constructors
​
        #region Public Instance Properties
​
        /// <summary>
        /// Gets or sets the IP address of the remote host to which
        /// the underlying <see cref="TcpClient" /> should sent the logging event.
        /// </summary>
        /// <value>
        /// The IP address of the remote host  to which the logging event will be sent.
        /// </value>
        /// <remarks>
        /// <para>
        /// Multicast addresses are identified by IP class <b>D</b> addresses (in the range 224.0.0.0 to
        /// 239.255.255.255).  Multicast packets can pass across different networks through routers, so
        /// it is possible to use multicasts in an Internet scenario as long as your network provider 
        /// supports multicasting.
        /// </para>
        /// <para>
        /// Hosts that want to receive particular multicast messages must register their interest by joining
        /// the multicast group.  Multicast messages are not sent to networks where no host has joined
        /// the multicast group.  Class <b>D</b> IP addresses are used for multicast groups, to differentiate
        /// them from normal host addresses, allowing nodes to easily detect if a message is of interest.
        /// </para>
        /// <para>
        /// Static multicast addresses that are needed globally are assigned by IANA.  A few examples are listed in the table below:
        /// </para>
        /// <para>
        /// <list type="table">
        ///     <listheader>
        ///         <term>IP Address</term>
        ///         <description>Description</description>
        ///     </listheader>
        ///     <item>
        ///         <term>224.0.0.1</term>
        ///         <description>
        ///             <para>
        ///             Sends a message to all system on the subnet.
        ///             </para>
        ///         </description>
        ///     </item>
        ///     <item>
        ///         <term>224.0.0.2</term>
        ///         <description>
        ///             <para>
        ///             Sends a message to all routers on the subnet.
        ///             </para>
        ///         </description>
        ///     </item>
        ///     <item>
        ///         <term>224.0.0.12</term>
        ///         <description>
        ///             <para>
        ///             The DHCP server answers messages on the IP address 224.0.0.12, but only on a subnet.
        ///             </para>
        ///         </description>
        ///     </item>
        /// </list>
        /// </para>
        /// <para>
        /// A complete list of actually reserved multicast addresses and their owners in the ranges
        /// defined by RFC 3171 can be found at the <A href="http://www.iana.org/assignments/multicast-addresses">IANA web site</A>. 
        /// </para>
        /// <para>
        /// The address range 239.0.0.0 to 239.255.255.255 is reserved for administrative scope-relative 
        /// addresses.  These addresses can be reused with other local groups.  Routers are typically 
        /// configured with filters to prevent multicast traffic in this range from flowing outside
        /// of the local network.
        /// </para>
        /// </remarks>
        public string RemoteAddress
        {
            get { return _remoteAddress; }
            set { _remoteAddress = value; }
        }
​
        TcpClient Client { get; set; }
​
        /// <summary>
        /// Gets or sets the TCP port number of the remote host or multicast group to which 
        /// the underlying <see cref="TcpClient" /> should sent the logging event.
        /// </summary>
        /// <value>
        /// An integer value in the range <see cref="IPEndPoint.MinPort" /> to <see cref="IPEndPoint.MaxPort" /> 
        /// indicating the TCP port number of the remote host or multicast group to which the logging event 
        /// will be sent.
        /// </value>
        /// <remarks>
        /// The underlying <see cref="TcpClient" /> will send messages to this TCP port number
        /// on the remote host or multicast group.
        /// </remarks>
        /// <exception cref="ArgumentOutOfRangeException">The value specified is less than <see cref="IPEndPoint.MinPort" /> or greater than <see cref="IPEndPoint.MaxPort" />.</exception>
        public int RemotePort
        {
            get { return _remotePort; }
            set
            {
                if (value < IPEndPoint.MinPort || value > IPEndPoint.MaxPort)
                {
                    throw log4net.Util.SystemInfo.CreateArgumentOutOfRangeException("value", value,
                        "The value specified is less than " +
                        IPEndPoint.MinPort.ToString(NumberFormatInfo.InvariantInfo) +
                        " or greater than " +
                        IPEndPoint.MaxPort.ToString(NumberFormatInfo.InvariantInfo) + ".");
                }
                else
                {
                    _remotePort = value;
                }
            }
        }
​
        /// <summary>
        /// Gets or sets <see cref="Encoding"/> used to write the packets.
        /// </summary>
        /// <value>
        /// The <see cref="Encoding"/> used to write the packets.
        /// </value>
        /// <remarks>
        /// <para>
        /// The <see cref="Encoding"/> used to write the packets.
        /// </para>
        /// </remarks>
        public Encoding Encoding
        {
            get { return _encoding; }
            set { _encoding = value; }
        }
​
        readonly ConcurrentQueue<LoggingEvent> mEventBuffer = new ConcurrentQueue<LoggingEvent>();
​
        #endregion Public Instance Properties
​
        #region Implementation of IOptionHandler
​
        /// <summary>
        /// Initialize the appender based on the options set.
        /// </summary>
        /// <remarks>
        /// <para>
        /// This is part of the <see cref="IOptionHandler"/> delayed object
        /// activation scheme. The <see cref="ActivateOptions"/> method must 
        /// be called on this object after the configuration properties have
        /// been set. Until <see cref="ActivateOptions"/> is called this
        /// object is in an undefined state and must not be used. 
        /// </para>
        /// <para>
        /// If any of the configuration properties are modified then 
        /// <see cref="ActivateOptions"/> must be called again.
        /// </para>
        /// <para>
        /// The appender will be ignored if no <see cref="RemoteAddress" /> was specified or 
        /// an invalid remote or local TCP port number was specified.
        /// </para>
        /// </remarks>
        /// <exception cref="ArgumentNullException">The required property <see cref="RemoteAddress" /> was not specified.</exception>
        /// <exception cref="ArgumentOutOfRangeException">The TCP port number assigned to <see cref="RemotePort" /> is less than <see cref="IPEndPoint.MinPort" /> or greater than <see cref="IPEndPoint.MaxPort" />.</exception>
        public override void ActivateOptions()
        {
            base.ActivateOptions();
​
            if (string.IsNullOrWhiteSpace(RemoteAddress))
            {
                throw new ArgumentNullException("RemoteAddress");
            }
            
            if (RemotePort < IPEndPoint.MinPort || RemotePort > IPEndPoint.MaxPort)
            {
                throw log4net.Util.SystemInfo.CreateArgumentOutOfRangeException("RemotePort", RemotePort,
                    "The RemotePort is less than " +
                    IPEndPoint.MinPort.ToString(NumberFormatInfo.InvariantInfo) +
                    " or greater than " +
                    IPEndPoint.MaxPort.ToString(NumberFormatInfo.InvariantInfo) + ".");
            }
        }
​
        #endregion
​
        #region Override implementation of AppenderSkeleton
​
        /// <summary>
        /// This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
        /// </summary>
        /// <param name="loggingEvent">The event to log.</param>
        /// <remarks>
        /// <para>
        /// Sends the event using an Tcp datagram.
        /// </para>
        /// <para>
        /// Exceptions are passed to the <see cref="AppenderSkeleton.ErrorHandler"/>.
        /// </para>
        /// </remarks>
        protected override void Append(LoggingEvent loggingEvent)
        {
            if (null != Client && Client.Connected)
            {
                WriteEvent(loggingEvent);
            }
            else
            {
                Reconnect(loggingEvent, 0);
            }
        }
​
        protected override void Append(LoggingEvent[] loggingEvents)
        {
            if (Client.Connected)
            {
                Array.ForEach(loggingEvents, le => WriteEvent(le));
            }
            else
            {
                Array.ForEach(loggingEvents, le => mEventBuffer.Enqueue(le));
                Reconnect(null, 0);
            }
        }
​
        [DllImport("dnsapi.dll",EntryPoint="DnsFlushResolverCache")]
        private static extern UInt32 DnsFlushResolverCache ();
​
        Task<IPAddress[]> GetAddress()
        {
            DnsFlushResolverCache();
            var currDnsTimeout = ServicePointManager.DnsRefreshTimeout;
            ServicePointManager.DnsRefreshTimeout = 0;
            try
            {
              return Task.Factory.FromAsync<IPHostEntry>(Dns.BeginGetHostEntry(RemoteAddress, null, null)
                  , Dns.EndGetHostEntry)
                  .ContinueWith(t =>
                      {
                        ServicePointManager.DnsRefreshTimeout = currDnsTimeout;
                        if (t.IsFaulted)
                        {
                          ErrorHandler.Error(string.Format("Failed to resolve remote host {0} in dns", RemoteAddress)
                              , t.Exception);
                          return null;
                        }
​
                        return t.Result.AddressList;
                      });
            }
            catch (Exception)
            {
              ServicePointManager.DnsRefreshTimeout = currDnsTimeout;
              return Task.Factory.StartNew(() => new IPAddress[0]);
            }
        }
​
        Task ConnectTask { get; set; }
​
        void Reconnect(LoggingEvent loggingEvent, int waitMilliSecs = 3000)
        {
            if (null != loggingEvent)
                mEventBuffer.Enqueue(loggingEvent);
​
            lock (this)
            {
              if (null != ConnectTask && !ConnectTask.IsCompleted)
                return;
            
              var ct = new System.Threading.CancellationToken();
              ConnectTask = TaskEx.Delay(waitMilliSecs, ct)
                  .ContinueWith(td => 
                      {
                          Connect(waitMilliSecs);
                          var c = ct.CanBeCanceled; //just to force reference
                      });
            }
        }
​
        void Connect(int lastWait=0)
        {
            if (null != Client)
            {
                if (Client.Connected)
                    Client.Close();
                Client = null;
            }
​
            ConnectTask = GetAddress()
            .ContinueWith(t =>
            {
              var ipAddresses = t.Result;
              if (null == ipAddresses || !ipAddresses.Any())
              {
                //ConnectTask = null;
                //Reconnect(null, lastWait + new Random().Next(lastWait >> 2));
                return;
              }
​
              var client = new TcpClient();
              var ipAddress = ipAddresses.First(a => a.AddressFamily == AddressFamily.InterNetwork);
              ConnectTask = Task.Factory.FromAsync(client.BeginConnect(ipAddress,
                      RemotePort,
                      null,
                      client)
                      , client.EndConnect)
                  .ContinueWith(tc =>
                  {
                    if (tc.IsFaulted)
                    {
                      ErrorHandler.Error(string.Format("Failed to connect to {0}", RemoteAddress)
                          , tc.Exception);
                      //Reconnect(null, lastWait + new Random().Next(lastWait >> 2));
                      return;
                    }
                    Client = client;
                    lock (this)
                    {
                      ConnectTask = null;
                    }
                    LoggingEvent e;
                    while (mEventBuffer.TryDequeue(out e))
                      WriteEvent(e);
                  });
            });
        }
​
        void WriteEvent(LoggingEvent loggingEvent)
        {
            var rendered = RenderLoggingEvent(loggingEvent);
            var ca = rendered.ToCharArray();
            var buffer = Encoding.GetBytes(ca);
            var client = Client;
            if (null == client || !client.Connected)
            {
                Reconnect(loggingEvent);
                return;
            }
​
            try
            {
                var netStream = client.GetStream();
                var writeTask = Task.Factory.FromAsync(netStream.BeginWrite(buffer, 0, buffer.Length, null, Client)
                    , netStream.EndWrite);
                writeTask.ContinueWith(tf =>
                {
                    ErrorHandler.Error(
                        "Unable to send logging event to remote host " + RemoteAddress.ToString() + " on port " +
                        RemotePort + ".", tf.Exception, ErrorCode.WriteFailure);
​
                    Reconnect(loggingEvent);
                }, TaskContinuationOptions.NotOnRanToCompletion);
                //writeTask.ContinueWith(ts =>
                //{
                //    try
                //    {
                //        var readTask = Task.Factory.FromAsync<int>(netStream.BeginRead(new byte[] { }, 0, 0, null, Client)
                //            , netStream.EndRead);
                //        readTask.ContinueWith(tf =>
                //        {
                //            ErrorHandler.Error(
                //                "Unable to read from remote host " + this.RemoteAddress.ToString() + " on port " +
                //                this.RemotePort + ".", tf.Exception, ErrorCode.WriteFailure);
​
                //            Reconnect(loggingEvent);
                //        }, TaskContinuationOptions.NotOnRanToCompletion);
                //    }
                //    catch (Exception e)
                //    {
                //        ErrorHandler.Error(
                //            "Unable to read from remote host " + this.RemoteAddress.ToString() + " on port " +
                //            this.RemotePort + ".", e, ErrorCode.WriteFailure);
​
                //        Reconnect(loggingEvent);
                //    }
​
                //}, TaskContinuationOptions.OnlyOnRanToCompletion);
            }
            catch (ObjectDisposedException e)
            {
                ErrorHandler.Error(
                    string.Format("Unable to send logging event to remote host {0} on port {1}", RemoteAddress, RemotePort)
                    , e
                    , ErrorCode.WriteFailure);
​
                Reconnect(loggingEvent);
            }
            catch (System.IO.IOException e)
            {
                ErrorHandler.Error(
                    string.Format("Unable to send logging event to remote host {0} on port {1}", RemoteAddress, RemotePort)
                    , e
                    , ErrorCode.WriteFailure);
​
                Reconnect(loggingEvent);
            }
        }
​
        /// <summary>
        /// This appender requires a <see cref="log4net.Layout"/> to be set.
        /// </summary>
        /// <value><c>true</c></value>
        /// <remarks>
        /// <para>
        /// This appender requires a <see cref="log4net.Layout"/> to be set.
        /// </para>
        /// </remarks>
        override protected bool RequiresLayout
        {
            get { return true; }
        }
​
        /// <summary>
        /// Closes the Tcp connection and releases all resources associated with 
        /// this <see cref="ReconnectingTcpAppender" /> instance.
        /// </summary>
        /// <remarks>
        /// <para>
        /// Disables the underlying <see cref="TcpClient" /> and releases all managed 
        /// and unmanaged resources associated with the <see cref="ReconnectingTcpAppender" />.
        /// </para>
        /// </remarks>
        override protected void OnClose()
        {
            base.OnClose();
        }
​
        #endregion Override implementation of AppenderSkeleton
​
        #region Private Instance Fields
​
        /// <summary>
        /// The IP address of the remote host or multicast group to which 
        /// the logging event will be sent.
        /// </summary>
        private string _remoteAddress;
​
        /// <summary>
        /// The TCP port number of the remote host or multicast group to 
        /// which the logging event will be sent.
        /// </summary>
        private int _remotePort;
​
        /// <summary>
        /// The encoding to use for the packet.
        /// </summary>
        private Encoding _encoding = Encoding.Default;
​
        #endregion Private Instance Fields
    }
}
​

Название: 1984, автор; G. Orwell, сумма: 315.4
Название: 1984, автор; G. Orwell, сумма: 315.4
книги Название: 1984, автор; G. Orwell, сумма: 315.4 и Название: 1984, автор; G. Orwell, сумма: 315.4 равны

Cached Result
Last Run:	7:23:05 am
Compile:	0.109s
Execute:	0s
Memory:	0b
CPU:	0s

View IL Code