<None Include="App.Debug.config">
      <DependentUpon>App.config</DependentUpon>
    </None>
    <None Include="App.Release.config">
      <DependentUpon>App.config</DependentUpon>
    </None>

<UsingTask TaskName="TransformXml" AssemblyFile="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\Web\Microsoft.Web.Publishing.Tasks.dll" />
  <Target Name="AfterCompile" Condition="Exists('App.$(Configuration).config')">
    <!--Generate transformed app config in the intermediate directory-->
    <TransformXml Source="App.config" Destination="$(IntermediateOutputPath)$(TargetFileName).config" Transform="App.$(Configuration).config" />
    <!--Force build process to use the transformed configuration file from now on.-->
    <ItemGroup>
      <AppConfigWithTargetPath Remove="App.config" />
      <AppConfigWithTargetPath Include="$(IntermediateOutputPath)$(TargetFileName).config">
        <TargetPath>$(TargetFileName).config</TargetPath>
      </AppConfigWithTargetPath>
    </ItemGroup>
  </Target>

static class Logger
    {
        public static NLog.Logger Log { get; private set; }
        public static NLog.Logger Archive { get; private set; }

        static Logger()
        {
            Log = LogManager.GetLogger("Global");
            Archive = LogManager.GetLogger("Archivator");
        }
    }

namespace TopCrawler.Singleton
{
    /// <summary>
    /// Singleton: zabbix sender class
    /// </summary>
    static class Zabbix
    {
        public static ZabbixSender Sender { get; private set; }

        static Zabbix()
        {
            Sender = new ZabbixSender(Config.ZabbixServer, Config.ZabbixPort);
        }
    }

    struct ZabbixItem
    {
        public string Host;
        public string Key;
        public string Value;
    }

    class ZabbixSender
    {
        internal struct SendItem
        {
            // ReSharper disable InconsistentNaming - Zabbix is case sensitive
            public string host;
            public string key;
            public string value;
            public string clock;
            // ReSharper restore InconsistentNaming
        }

        #pragma warning disable 0649
        internal struct ZabbixResponse
        {
            public string Response;
            public string Info;
        }
        #pragma warning restore 0649

        #region --- Constants ---

        public const string DefaultHeader = "ZBXD\x01";
        public const string SendRequest = "sender data";
        public const int DefaultTimeout = 10000;

        #endregion

        #region --- Fields ---
        private readonly DateTime _dtUnixMinTime = DateTime.SpecifyKind(new DateTime(1970, 1, 1), DateTimeKind.Utc);
        private readonly int _timeout;
        private readonly string _zabbixserver;
        private readonly int _zabbixport;
        #endregion

        #region --- Constructors ---

        public ZabbixSender(string zabbixserver, int zabbixport)
            : this(zabbixserver, zabbixport, DefaultTimeout)
        {
        }

        public ZabbixSender(string zabbixserver, int zabbixport, int timeout)
        {
            _zabbixserver = zabbixserver;
            _zabbixport = zabbixport;
            _timeout = timeout;
        }
        #endregion

        #region --- Methods ---

        public string SendData(ZabbixItem itm)
        {
            return SendData(new List<ZabbixItem>(1) { itm });
        }

        public string SendData(List<ZabbixItem> lstData)
        {
            try
            {
                var serializer = new JavaScriptSerializer();
                var values = new List<SendItem>(lstData.Count);

                values.AddRange(lstData.Select(itm => new SendItem
                {
                    host = itm.Host,
                    key = itm.Key,
                    value = itm.Value,
                    clock = Math.Floor((DateTime.Now.ToUniversalTime() - _dtUnixMinTime).TotalSeconds).ToString(CultureInfo.InvariantCulture)
                }));

                var json = serializer.Serialize(new
                {
                    request = SendRequest,
                    data = values.ToArray()
                });

                var header = Encoding.ASCII.GetBytes(DefaultHeader);
                var length = BitConverter.GetBytes((long)json.Length);
                var data = Encoding.ASCII.GetBytes(json);

                var packet = new byte[header.Length + length.Length + data.Length];
                Buffer.BlockCopy(header, 0, packet, 0, header.Length);
                Buffer.BlockCopy(length, 0, packet, header.Length, length.Length);
                Buffer.BlockCopy(data, 0, packet, header.Length + length.Length, data.Length);

                using (var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
                {
                    socket.Connect(_zabbixserver, _zabbixport);

                    socket.Send(packet);

                    //Header
                    var buffer = new byte[5];
                    ReceivData(socket, buffer, 0, buffer.Length, _timeout);

                    if (DefaultHeader != Encoding.ASCII.GetString(buffer, 0, buffer.Length))
                        throw new Exception("Invalid header");

                    //Message length
                    buffer = new byte[8];
                    ReceivData(socket, buffer, 0, buffer.Length, _timeout);
                    var dataLength = BitConverter.ToInt32(buffer, 0);

                    if (dataLength == 0)
                        throw new Exception("Invalid data length");

                    //Message
                    buffer = new byte[dataLength];
                    ReceivData(socket, buffer, 0, buffer.Length, _timeout);

                    var response = serializer.Deserialize<ZabbixResponse>(Encoding.ASCII.GetString(buffer, 0, buffer.Length));
                    return string.Format("Response: {0}, Info: {1}", response.Response, response.Info);
                }
            }
            catch (Exception e)
            {
                return string.Format("Exception: {0}", e);
            }
        }

        private static void ReceivData(Socket pObjSocket, byte[] buffer, int offset, int size, int timeout)
        {
            var startTickCount = Environment.TickCount;
            var received = 0;
            do
            {
                if (Environment.TickCount > startTickCount + timeout)
                    throw new TimeoutException();

                try
                {
                    received += pObjSocket.Receive(buffer, offset + received, size - received, SocketFlags.None);
                }
                catch (SocketException ex)
                {
                    if (ex.SocketErrorCode == SocketError.WouldBlock || ex.SocketErrorCode == SocketError.IOPending || ex.SocketErrorCode == SocketError.NoBufferSpaceAvailable)
                        Thread.Sleep(30);
                    else
                        throw;
                }
            } while (received < size);
        }

        #endregion
    }
}

    <CredentialsList>
      <credentials hostname="8.8.8.8" username="popka@example.com" password="123" port="110" type="fbl" /> 
      <credentials hostname="8.8.8.8" username="kesha@example.com" password="123" port="110" type="bounce" />
    </CredentialsList>
    <DataFlowOptionsList>
      <datablockoptions name="_sortMailDataBlock" maxdop="4" boundedcapacity="4" />
      <datablockoptions name="_spamFilterDataBlock" maxdop="4" boundedcapacity="4" />
      <datablockoptions name="_checkBounceDataBlock" maxdop="16" boundedcapacity="16" />
      <datablockoptions name="_identifyDataBlock" maxdop="16" boundedcapacity="16" />
      <datablockoptions name="_addToCrmDataBlock" maxdop="16" boundedcapacity="16" />
      <datablockoptions name="_addToFblDataBlock" maxdop="16" boundedcapacity="16" />
      <datablockoptions name="_addToBounceDataBlock" maxdop="16" boundedcapacity="16" />
    </DataFlowOptionsList>

    #region --- Types ---
    static class MailboxType
    {
        public const string Bo = "bo";
        public const string Crm = "crm";
        public const string Fbl = "fbl";
        public const string Bounce = "bounce";
    }

    class MailboxInfo
    {
        public string Type { get; set; }
        public string Hostname { get; set; }
        public string User { get; set; }
        public string Password { get; set; }
        public int Port { get; set; }
    }

    class DataBlockOptions
    {
        public int Maxdop { get; set; }
        public int BoundedCapacity { get; set; }

        public DataBlockOptions()
        {
            Maxdop = 1;
            BoundedCapacity = 1;
        }
    }
    #endregion

    /// <summary>
    /// Custom config section
    /// </summary>
    public class CustomSettingsConfigSection : ConfigurationSection
    {
        [ConfigurationProperty("CredentialsList")]
        public CredentialsCollection CredentialItems
        {
            get { return base["CredentialsList"] as CredentialsCollection; }
        }

        [ConfigurationProperty("DataFlowOptionsList")]
        public DataBlockOptionsCollection DataFlowOptionsItems
        {
            get { return base["DataFlowOptionsList"] as DataBlockOptionsCollection; }
        }
    }

    /// <summary>
    /// Custom collection - credentials list
    /// </summary>
    [ConfigurationCollection(typeof(CredentialsElement), AddItemName = "credentials")]
    public class CredentialsCollection : ConfigurationElementCollection, IEnumerable<CredentialsElement>
    {
        protected override ConfigurationElement CreateNewElement()
        {
            return new CredentialsElement();
        }

        protected override object GetElementKey(ConfigurationElement element)
        {
            return ((CredentialsElement)element).Username;
        }

        public CredentialsElement this[int index]
        {
            get { return BaseGet(index) as CredentialsElement; }
        }

        public new IEnumerator<CredentialsElement> GetEnumerator()
        {
            for (var i = 0; i < Count; i++)
            {
                yield return BaseGet(i) as CredentialsElement;
            }
        }
    }

    /// <summary>
    /// Custom credentials item
    /// </summary>
    public class CredentialsElement : ConfigurationElement
    {
        [ConfigurationProperty("hostname", DefaultValue = "")]
        public string Hostname
        {
            get { return base["hostname"] as string; }
        }

        [ConfigurationProperty("username", DefaultValue = "", IsKey = true)]
        public string Username
        {
            get { return base["username"] as string; }
        }

        [ConfigurationProperty("password", DefaultValue = "")]
        public string Password
        {
            get { return base["password"] as string; }
        }

        [ConfigurationProperty("type", DefaultValue = "")]
        public string Type
        {
            get { return base["type"] as string; }
        }

        [ConfigurationProperty("port", DefaultValue = "")]
        public string Port
        {
            get { return base["port"] as string; }
        }
    }

    /// <summary>
    /// Custom collection - DataBlock options list
    /// </summary>
    [ConfigurationCollection(typeof(DataBlockOptionsElement), AddItemName = "datablockoptions")]
    public class DataBlockOptionsCollection : ConfigurationElementCollection, IEnumerable<DataBlockOptionsElement>
    {
        protected override ConfigurationElement CreateNewElement()
        {
            return new DataBlockOptionsElement();
        }

        protected override object GetElementKey(ConfigurationElement element)
        {
            return ((DataBlockOptionsElement)element).Name;
        }

        public CredentialsElement this[int index]
        {
            get { return BaseGet(index) as CredentialsElement; }
        }

        public new IEnumerator<DataBlockOptionsElement> GetEnumerator()
        {
            for (var i = 0; i < Count; i++)
            {
                yield return BaseGet(i) as DataBlockOptionsElement;
            }
        }
    }

    /// <summary>
    /// Custom DataBlock options item
    /// </summary>
    public class DataBlockOptionsElement : ConfigurationElement
    {
        [ConfigurationProperty("name", DefaultValue = "", IsKey = true)]
        public string Name
        {
            get { return base["name"] as string; }
        }

        [ConfigurationProperty("maxdop", DefaultValue = "")]
        public string Maxdop
        {
            get { return base["maxdop"] as string; }
        }

        [ConfigurationProperty("boundedcapacity", DefaultValue = "")]
        public string BoundedCapacity
        {
            get { return base["boundedcapacity"] as string; }
        }
    }

        public List<MailboxInfo> CredentialsList { get; private set; }
        public Dictionary<string, DataBlockOptions> DataFlowOptionsList { get; private set; }
        ...
	static Config()
        {
            try
			{
                var customConfig = (CustomSettingsConfigSection)ConfigurationManager.GetSection("CustomSettings");

				//Get mailboxes
				foreach (var item in customConfig.CredentialItems)
					CredentialsList.Add(new MailboxInfo
					{
						Hostname = item.Hostname,
						Port = Convert.ToInt32(item.Port),
						User = item.Username,
						Type = item.Type,
						Password = item.Password
					});

				//Get DataFlow settings
				foreach (var item in customConfig.DataFlowOptionsItems)
					DataFlowOptionsList.Add(item.Name, new DataBlockOptions
					{
						Maxdop = Convert.ToInt32(item.Maxdop),
						BoundedCapacity = Convert.ToInt32(item.BoundedCapacity)
					});
            }
            catch (Exception ex)
            {
                Logger.Log.Fatal("Error at reading config: {0}", ex.Message);
                throw;
            }
        }

  <targets>
    <!-- add your targets here -->
    
    <target name="logfile" xsi:type="File" fileName="${basedir}\logs\${shortdate}-message.log" />
    <target name="Archivefile" xsi:type="File" fileName="${basedir}\archive\${shortdate}-archive.dat" />
  
  </targets>

class Counter
    {
        private long _counter;

        public Counter()
        {
            _counter = 0;
        }

        public void Increment()
        {
            Interlocked.Increment(ref _counter);
        }

        public long Read()
        {
            return _counter;
        }

        public long Refresh()
        {
            return Interlocked.Exchange(ref _counter, 0);
        }

        public void Add(long value)
        {
            Interlocked.Add(ref _counter, value);
        }

        public void Set(long value)
        {
            Interlocked.Exchange(ref _counter, value);
        }
    }

       public void Start()
        {
            do
            {
                var getMailsTasks = _config.CredentialsList.Select(credentials => Task.Run(() => GetMails(credentials))).ToList();

                foreach (var task in getMailsTasks)
                    task.Wait();

                Thread.Sleep(2000);
            } while (!_stopPipeline);

            //Stop pipeline - wait for completion of all endpoints
            _sortMailDataBlock.Complete();
            _addToCrmDataBlock.Completion.Wait();
            _addToFblDataBlock.Completion.Wait();
            _addToBounceDataBlock.Completion.Wait();
            if (_stopPipeline)
                Logger.Log.Warn("Pipeline has been stopped by user");
        }

       public static long BounceAdd(MessageInfo message)
        {
            using (var conn = new SqlConnection(ConnectionString))
            using (var cmd = new SqlDataAdapter("BounceAdd", conn))
            {
                var body = message.Mail.FindFirstPlainTextVersion() == null
                    ? message.Mail.FindFirstHtmlVersion().GetBodyAsText()
                    : message.Mail.FindFirstPlainTextVersion().GetBodyAsText();

                var outId = new SqlParameter("@ID", SqlDbType.BigInt)
                {
                    Direction = ParameterDirection.Output
                };
                cmd.SelectCommand.CommandType = CommandType.StoredProcedure;
                cmd.SelectCommand.Parameters.Add(new SqlParameter("@RawMessage", message.Mail.RawMessage));
                cmd.SelectCommand.Parameters.Add(new SqlParameter("@Message", body));
                cmd.SelectCommand.Parameters.Add(new SqlParameter("@Subject", message.Mail.Headers.Subject ?? ""));
                cmd.SelectCommand.Parameters.Add(new SqlParameter("@MessageID", message.Mail.Headers.MessageId ?? ""));
                cmd.SelectCommand.Parameters.Add(new SqlParameter("@AddressTo", message.Mail.Headers.To[0].Address ?? ""));
                cmd.SelectCommand.Parameters.Add(new SqlParameter("@AddressFrom", message.Mail.Headers.From.Address ?? ""));
                cmd.SelectCommand.Parameters.Add(new SqlParameter("@DateRecieved", DateTime.Now));
                cmd.SelectCommand.Parameters.Add(new SqlParameter("@BounceTypeSysName", (object)message.Subtype ?? DBNull.Value));
                cmd.SelectCommand.Parameters.Add(new SqlParameter("@SourceFrom", (object)message.Recipient ?? DBNull.Value));
                // TODO: Add ListId support
                cmd.SelectCommand.Parameters.Add(new SqlParameter("@ListId", DBNull.Value));
                cmd.SelectCommand.Parameters.Add(outId);

                conn.Open();
                cmd.SelectCommand.ExecuteNonQuery();

                return outId.Value as long? ?? 0;
            }
        }