C#

using System;
using System.IO;
using System.Threading;
using System.Windows.Forms;

namespace MultiThreadedFileRead
{
    public partial class Form1 : Form
    {
        private readonly object _syncRoot = new object();

        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            if (openFileDialog1.ShowDialog() == DialogResult.OK)
            {
                listBox1.Items.Add(openFileDialog1.FileName);
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            foreach (object file in listBox1.Items)
            {
                ThreadPool.QueueUserWorkItem(ThreadFunc, file);
            }
        }


        private void WouldBeEventHandler(string s)
        {
            if (InvokeRequired)
            {
                Action<string> d = WouldBeEventHandler;
                BeginInvoke(d, new object[]{s});
                return;
            }

            lock (_syncRoot)
            {
                listBox2.Items.Add(s);
            }
        }

        private void ThreadFunc(object state)
        {
            string filename = state as string;
            if (!string.IsNullOrEmpty(filename))
            {
                using (StreamReader fs = File.OpenText(filename))
                {
                    while (!fs.EndOfStream)
                    {
                        WouldBeEventHandler(fs.ReadLine());
                        Application.DoEvents();
                    }
                }
            }
        }
    }
}

using System;
using System.IO.Ports;
using System.Threading;
using System.Windows.Forms;

namespace MultiThreadedFileRead
{
    public partial class Form1 : Form
    {
        private readonly object _syncRoot = new object();

        public Form1()
        {
            InitializeComponent();
        }


        private void Form1_Load(object sender, EventArgs e)
        {
            serialPort1.DataReceived += SerialPort1DataReceived;
            serialPort2.DataReceived += SerialPort2DataReceived;
            serialPort3.DataReceived += SerialPort3DataReceived;
        }

        private void SerialPort1DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            ThreadPool.QueueUserWorkItem(ThreadFunc, sender);
        }

        private void SerialPort2DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            ThreadPool.QueueUserWorkItem(ThreadFunc, sender);
        }

        private void SerialPort3DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            ThreadPool.QueueUserWorkItem(ThreadFunc, sender);
        }

        private void ThreadFunc(object state)
        {
            SerialPort port = state as SerialPort;
            if (port != null)
            {
                try
                {
                    //do processing here.
                    
                }
                catch (Exception)
                {
                    //don't let the thread throw directly
                }
            }
        }
    }
}

dataminers wrote:

Following code not get created domain when call from different Win Application.

I are Troll

dataminers wrote:

Following code not get created domain when call from different Win Application.

dataminers wrote:

I think Mutex Class not related about my problem.

I are Troll

using System;
using System.Runtime.InteropServices;

namespace MyLibrary
{
    public class CrossAppDomainSingleton<T> : MarshalByRefObject where T : new() 
    { 
        private static readonly string AppDomainName = "Singleton AppDomain"; 
        private static T _instance;

        private static AppDomain GetAppDomain(string friendlyName) 
        { 
            IntPtr enumHandle = IntPtr.Zero; 
            mscoree.CorRuntimeHostClass host = new mscoree.CorRuntimeHostClass(); 
            
            try 
            { 
                host.EnumDomains(out enumHandle); 
                object domain = null; 
                
                while (true) 
                { 
                    host.NextDomain(enumHandle, out domain); 
                    if (domain == null) 
                    { 
                        break; 
                    } 
                    
                    AppDomain appDomain = (AppDomain)domain; 
                    
                    if (appDomain.FriendlyName.Equals(friendlyName)) 
                    { 
                        return appDomain; 
                    }
                }
            }
            finally 
            { 
                host.CloseEnum(enumHandle); 
                Marshal.ReleaseComObject(host); 
                host = null; 
            }
            
            return null; 
        } 
        
        public static T Instance 
        { 
            get 
            { 
                if (null == _instance) 
                { 
                    AppDomain appDomain = GetAppDomain(AppDomainName); 
                    
                    if (null == appDomain) 
                    { 
                        appDomain = AppDomain.CreateDomain(AppDomainName); 
                    } 
                    
                    Type type = typeof(T); 
                    T instance = (T)appDomain.GetData(type.FullName); 
                    
                    if (null == instance) 
                    { 
                        instance = (T)appDomain.CreateInstanceAndUnwrap(type.Assembly.FullName, type.FullName); 
                        appDomain.SetData(type.FullName, instance); 
                    } 
                    
                    _instance = instance; 
                } 
                
                return _instance; 
            } 
        } 
    }
}

using System.Collections.Generic;

namespace MyLibrary
{
    public class MySingleton : CrossAppDomainSingleton<MySingleton>
    {
        private List<string> m_List = new List<string>();

        public void Add(string pValue)
        {
            m_List.Add(pValue);
        }

        public List<string> Get()
        {
            return m_List;
        }

    }
}

MySingleton.Instance.Add("test");

List<string> res = MySingleton.Instance.Get();

return (ulong)1 << (i % BITS_IN_WORD);

But if you need to access it very often or in "long" loops I would cache it, because 0,5kB aren't that amount of memory.

movzx  rax, bit
xor    rdx, rdx
div    64  // = BITS_IN_WORD
mov    cl, dl
movzx  rax, bit
shl    rax, cl

movzx  rax, bit
xor    rdx, rdx
div    64     // = BITS_IN_WORD
shl    rdx, 3 // *= 8 (rdx = offset of the entry in mem)
add    rdx, (pointer to the "table" in memory)
mov    rax, [rdx]

Covean wrote:

limited your GetBit function only to be able to access 2147483648 bits!

Covean wrote:

I just found it funny to not be limited and then limit the get function to int.

Covean wrote:

return (ulong)1 << (i & 0x000000000000003F);