C# Discussion Boards - CodeProject

Re: Univoter strikes!

OriginalGriff12-Mar-10 21:59

OriginalGriff

12-Mar-10 21:59

riced wrote:
I don't really take any notice of the voting but thanks anyway.

Yeah, but a one vote implies to someone reading "this answer contains garbage" - since yours doesn't, I thought it should be corrected.

riced wrote:
My comment was triggered in part because I've seen horribly complex code to display the leading 0s...

Don't you just love internal consistancy? Laugh | :laugh:

With telephone numbers I do tend to leave them as strings - there is no useful manipulation to do most of the time, and people do get protective of their favourite format: "+44 (0)1111 1111111" is "better" than "011111111111" and vice versa. If you can get a company wide format for these things, great - but too many will see that as the IT dept trying to "run their lives"! You can't win either way... Big Grin | :-D

You should never use standby on an elephant. It always crashes when you lift the ears. - Mark Wallace

C/C++ (I dont see a huge difference between them, and the 'benefits' of C++ are questionable, who needs inheritance when you have copy and paste) - fat_boy

Re: Help with C#

The Man from U.N.C.L.E.12-Mar-10 8:21

The Man from U.N.C.L.E.

12-Mar-10 8:21

Most important question:

How are you comparing the variables?

Obviously the incoming data has to be string, and not so obviously the comparison values can be stored in any format you like, however the format should be picked dependant on the data contained. So integer for a pin number may be perfect, as long as you can only have integer pin numbers.

So, show us the comparison code and we can advise you further.

If you have knowledge, let others light their candles at it.
Margaret Fuller (1810 - 1850)
[My Articles] [My Website]

Message Removed

13-Mar-10 4:03

Janded

13-Mar-10 4:03

Message Removed

Re: Help with C#

The Man from U.N.C.L.E.14-Mar-10 23:40

The Man from U.N.C.L.E.

14-Mar-10 23:40

Firstly, all input from Console.ReadLine or from parameters passed to the exe are strings.

Secondly, in your code you are never capturing the input, and you have your logic back to front. For starters you never prompt for the age, and also you seem to refer to the name a lot, which is also never input.

Here is an example of how the code should start, showing the logic for the input and validation of the age. Apply the same locig throughout and you are home and dry.

int age;
string input;

//	Capture the age
Console.WriteLine("Please enter your age:");
input = Console.ReadLine();

if (!int.TryParse(input, out age)){
	Console.WriteLine("{0} is not a number!", input);
	Console.ReadLine();
	return;
}

if (age < 18) {
	Console.WriteLine("Sorry, Come back when your older");
	Console.ReadLine();
	return;
}

If you have knowledge, let others light their candles at it.
Margaret Fuller (1810 - 1850)
[My Articles] [My Website]

Re: Help with C#

Janded19-Mar-10 1:42

Janded

19-Mar-10 1:42

Can I use the technique below to ask a user for their security code as well. Assuming the scurity code is 2090, If the user enter a wrong code...a message comes up.

if (!int.TryParse(input, out code)){
Console.WriteLine("{0} is not a number!", input);
Console.ReadLine();

int code;
string codeInput;

I tried it using the technique above, but I had to press the enter key twice before I got any message from it

Re: Help with C#

Janded19-Mar-10 2:04

Janded

19-Mar-10 2:04

Can I use the technique below to ask a user for their security code as well. Assuming the scurity code is 2090, If the user enter a wrong code...a message comes up.

if (!int.TryParse(input, out code)){
Console.WriteLine("{0} is not a number!", input);
Console.ReadLine();

int code;
string codeInput;

or can I just do it this way int code = 2090;

I tried it using the technique above, but I had to press the enter key twice before I got any message from it

Re: Help with C#

The Man from U.N.C.L.E.19-Mar-10 2:20

The Man from U.N.C.L.E.

19-Mar-10 2:20

It will work if you use the same syntax as the example I gave you before.

The code you have posted is back-to-front and upside-down. You appear to be using the variables before you declare them. This is the same problem you had at the start, where you were testing the variables before inputing them!

If you have knowledge, let others light their candles at it.
Margaret Fuller (1810 - 1850)
[My Articles] [My Website]

Re: Help with C#

Janded20-Mar-10 2:42

Janded

20-Mar-10 2:42

Got it working, but I now need to enter numbers between 5 and 20 and print the users name requested the number of times.

This is what i intend to do..

Random random = new Random();
int randomNumber = random.next(5,20);

Re: Help with C#

Janded20-Mar-10 2:57

Janded

20-Mar-10 2:57

Or can I just say

int number;
number = int.Parse((console.Readline)); ?

write to app.config through c#

prasadbuddhika11-Mar-10 22:47

prasadbuddhika

11-Mar-10 22:47

i found a code segment to write new name/value pairs to app.config, but it doesn't work properly. means it doesn't change the app.config file permanently.

following is the code segment

Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
           config.AppSettings.Settings.Add("name", t2.Text);
           config.Save();
           ConfigurationManager.RefreshSection("appSettings");

when i restart the program again only the default values are there .

any help,

Re: write to app.config through c#

Estys11-Mar-10 23:36

Estys

11-Mar-10 23:36

If you are running your app from visual studio :

Not your app.config gets changed, in bin/<debug/release>-directory <YourAppName>.exe.config is altered.

Serial Port

Deepak.Prahlad11-Mar-10 22:14

Deepak.Prahlad

11-Mar-10 22:14

Hi
What are the things i need to look into when i use serial port class?

My issue is I am getting a Timeout Exception every now and then in Reading the port.
My understanding about the serial port class is as below

1. We need to set the baud rate, parity etc once
2. Timeout value (read timeout and write timeout) every time you read or write.

a. Read timeout timer starts when the first characeter arrives at the hardware buffer and code will wait till all the characters arrived as per the code

comPort.Read(buffer, 0, 100);

here it will wait for 100 bytes or timeout value whichever is earlier. ie. if it read 100 bytes it will return even if timeout (say 100mS) not reached. but what happens if there is lesser bytes? is there a interbyte timeout as in CPP here in C#? how to set it?

b. Write timeout functions in same fashion with writing to port. it will return after specified bytes have written unless timeout is not reached.

Am i correct in these assumptions?

Do I have to use some sort of thread locking in DataReceived event thread for proper displaying of the data? (I assume that the DataReceived event thread is system handled thread and does not have control over it. Am i correct?)

Message Closed

11-Mar-10 22:37

stancrm

11-Mar-10 22:37

Message Closed

modified 23-Nov-14 6:35am.

Re: Serial Port

Deepak.Prahlad11-Mar-10 22:50

Deepak.Prahlad

11-Mar-10 22:50

Yes. I have set the port name, baudrate, parity, stopbit and databit. and my timeout is 100mS

stancrm wrote:

at this line will be hold for 2000ms.
If in 2000ms no data received, then TimeoutException.

Does this mean that the received data can be less than 100 bytes? That is if a single byte is received within the timeout period (in my case it is 100mS) there will be no timeout exception right?

One more thing is that I jump to this code only when System generates a DataRecieved event as in

void comPort_DataReceived(object sender, SerialDataReceivedEventArgs e)
     {
         try
         {
             SetTimeOuts(true);
             byte[] buffer = new byte[101];
             int iReadBufSize = comPort.Read(buffer, 0, 100);
             string strData = String.Empty;
             for (int i = 0; i < iReadBufSize; i++)
             {
                 strData = strData + buffer[i].ToString() + " ";
             }
             DisplayRecievedData(buffer);
             strData = "Rcd <<--: " + strData;
             UpdateDisplayArea(strData);
             //comPort.DiscardOutBuffer();
             SetTimeOuts(true);
         }
         catch (Exception exp)
         {
             MessageBox.Show("Exception in comPort_DataReceived()" + Environment.NewLine + exp.Message);
         }
     }

this event was registered like this when the serial port was created as

comPort.DataReceived += new SerialDataReceivedEventHandler(comPort_DataReceived);

I observed that some times the byte[] buffer was null when I put break points there? Is it normal?

Message Closed

12-Mar-10 0:06

stancrm

12-Mar-10 0:06

Message Closed

modified 23-Nov-14 6:34am.

Re: Serial Port

Deepak.Prahlad12-Mar-10 0:25

Deepak.Prahlad

12-Mar-10 0:25

My data is 30 to 60 byte long
My question is

Will the code return with first few byte immediately when it recevies the first event for DataRecieved? (because of slight inter-byte delays?)

Or it will go for reading and if found (it should... because event was generated) something in Hardware Buffer wait for the entire stream till there is no more bytes?

In both case there is no chance for timeouts Confused | :confused:

Is there any thing like "De register the event once it is served" ?

PS: I can not say when the data will be pushed from the other side so I need to be continuously monitoring the port. Is there any other method to do this than dataReceived event?

Re: Serial Port

OriginalGriff12-Mar-10 1:46

OriginalGriff

12-Mar-10 1:46

Deepak.Prahlad wrote:
Is there any thing like "De register the event once it is served" ?

Yes - you can remove the handler in the same way you add them, but using -= instead of +=.
If for example it was a Timer event you would add with:

tim.Tick += new EventHandler(tim_Tick);

and remove it with:

tim.Tick -= tim_Tick;

Re: Serial Port

DotNetCoderJunior12-Mar-10 2:08

DotNetCoderJunior

12-Mar-10 2:08

Here is a nice Com Class that you can use.

using System;
using System.IO.Ports; 
using System.Runtime.Remoting.Messaging; 
using System.Drawing;
using System.Windows.Forms;
using System.Threading;
namespace ModemAPP
{    
    /// <summary>
    /// Routines for finding and accessing COM ports.
    /// </summary>

    public class ComPorts  
    {  
        private const string ModuleName = "ComPorts"; 
        
        //  Shared members - do not belong to a specific instance of the class.
        
        internal static bool comPortExists; 
        internal static string[] myPortNames; 
        internal static string noComPortsMessage = "No COM ports found. Please attach a COM-port device."; 
        
        internal delegate void UserInterfaceDataEventHandler( string action, string formText, Color textColor ); 
        internal static event UserInterfaceDataEventHandler UserInterfaceData;

        internal delegate void UserInterfaceResultEventHandler(string strResult);
        internal static event UserInterfaceResultEventHandler NumberCrunchInterface; 
        
        //  Non-shared members - belong to a specific instance of the class.
        
        internal delegate void SerialDataReceivedEventHandlerDelegate( object sender, SerialDataReceivedEventArgs e );
        internal delegate void SerialErrorReceivedEventHandlerDelegate( object sender, SerialErrorReceivedEventArgs e );
        internal delegate bool WriteToComPortDelegate( string textToWrite );
        internal delegate bool ReadComPortDelegate();
        delegate void SetTextDeleg(string text);      
        internal WriteToComPortDelegate WriteToComPortDelegate1;
        internal ReadComPortDelegate ReadComPortDelegate1;
        
        //  Local variables available as Properties.

        private bool m_ParameterChanged;
        private bool m_PortChanged;
        private bool m_PortOpen;
        private SerialPort m_PreviousPort = new SerialPort();
        private int m_ReceivedDataLength;
        private int m_SavedBitRate = 9600;
        private Handshake m_SavedHandshake = Handshake.None ;
        private string m_SavedPortName = "";
        private SerialPort m_SelectedPort = new SerialPort();
        
               
        internal bool ParameterChanged 
        { 
            get 
            { 
                return m_ParameterChanged; 
            } 
            set 
            { 
                m_ParameterChanged = value; 
            } 
        }
        
        
        internal bool PortChanged 
        { 
            get 
            { 
                return m_PortChanged; 
            } 
            set 
            { 
                m_PortChanged = value; 
            } 
        }         
      
        internal bool PortOpen 
        { 
            get 
            { 
                return m_PortOpen; 
            } 
            set 
            { 
                m_PortOpen = value; 
            } 
        }         
       
        internal SerialPort PreviousPort 
        { 
            get 
            { 
                return m_PreviousPort; 
            } 
            set 
            { 
                m_PreviousPort = value; 
            } 
        }         
       
        internal int ReceivedDataLength 
        { 
            get 
            { 
                return m_ReceivedDataLength; 
            } 
            set 
            { 
                m_ReceivedDataLength = value; 
            } 
        }         
       
        internal int SavedBitRate 
        { 
            get 
            { 
                return m_SavedBitRate; 
            } 
            set 
            { 
                m_SavedBitRate = value; 
            } 
        }         
        
        internal Handshake SavedHandshake 
        { 
            get 
            { 
                return m_SavedHandshake; 
            } 
            set 
            { 
                m_SavedHandshake = value; 
            } 
        }         
       
        internal string SavedPortName 
        { 
            get 
            { 
                return m_SavedPortName; 
            } 
            set 
            { 
                m_SavedPortName = value; 
            } 
        }         
       
        internal SerialPort SelectedPort 
        { 
            get 
            { 
                return m_SelectedPort; 
            } 
            set 
            { 
                m_SelectedPort = value; 
            } 
        } 
        
        private SerialDataReceivedEventHandler SerialDataReceivedEventHandler1;        
        private SerialErrorReceivedEventHandler SerialErrorReceivedEventHandler1; 
        
        /// <summary>
        /// If the COM port is open, close it.
        /// </summary>
        /// 
        /// <param name="portToClose"> the SerialPort object to close </param>  

        internal void CloseComPort( SerialPort portToClose ) 
        { 
            try 
            { 
                if ( null != UserInterfaceData ) UserInterfaceData( "DisplayStatus", "", Color.Black ); 
                
                object transTemp0 = portToClose; 
                if (  !(  transTemp0 == null ) ) 
                {                     
                    if ( portToClose.IsOpen ) 
                    {                         
                        portToClose.Close(); 
                        if ( null != UserInterfaceData ) UserInterfaceData( "DisplayCurrentSettings", "", Color.Black );                         
                    } 
                }                
           }
                                      
            catch ( InvalidOperationException ex ) 
            {                 
                ParameterChanged = true; 
                PortChanged = true; 
                DisplayException( ModuleName, ex );                 
            } 
            catch ( UnauthorizedAccessException ex ) 
            {                 
                ParameterChanged = true; 
                PortChanged = true; 
                DisplayException( ModuleName, ex );                 
            } 
            catch ( System.IO.IOException ex ) 
            {                 
                ParameterChanged = true; 
                PortChanged = true; 
                DisplayException( ModuleName, ex ); 
            }             
        } 

        /// <summary>
        /// Called when data is received on the COM port.
        /// Reads and displays the data.
        /// See FindPorts for the AddHandler statement for this routine.
        /// </summary>
                
        internal void DataReceived( object sender, SerialDataReceivedEventArgs e ) 
        {
            
            string newReceivedData = null;
            try
            {
                //  Get data from the COM port.
                Thread.Sleep(200);
                newReceivedData = SelectedPort.ReadExisting();
                Thread.Sleep(100);

                if (null != UserInterfaceData) UserInterfaceData("Dialing","",Color.Black);


                if (newReceivedData.Length > 6)
                {
                    if (null != UserInterfaceData) UserInterfaceData("RetrievingResults", "", Color.Black);
                    NumberCrunchInterface(newReceivedData);
                }
                    

            }
            catch (Exception ex)
            {
                DisplayException(ModuleName, ex);
            }  
        }
        

        /// <summary>
        /// Provide a central mechanism for displaying exception information.
        /// Display a message that describes the exception.
        /// </summary>
        /// 
        /// <param name="ex"> The exception </param> 
        /// <param name="moduleName" > the module where the exception was raised. </param>
        
        private void DisplayException( string moduleName, Exception ex ) 
        {
            string errorMessage = null; 
            
            errorMessage = "Exception: " + ex.Message + " Module: " + moduleName + ". Method: " + ex.TargetSite.Name; 
            
            if ( null != UserInterfaceData ) UserInterfaceData( "DisplayStatus", errorMessage, Color.Red ); 
            
            //  To display errors in a message box, uncomment this line:
            //  MessageBox.Show(errorMessage)
        }        

        /// <summary>
        /// Respond to error events.
        /// </summary>
        
        private void ErrorReceived( object sender, SerialErrorReceivedEventArgs e ) 
        { 
            SerialError SerialErrorReceived1 = 0; 
            
            SerialErrorReceived1 = e.EventType; 
            
            switch ( SerialErrorReceived1 ) 
            {
                case SerialError.Frame:
                    Console.WriteLine( "Framing error." ); 
                    
                    break;
                case SerialError.Overrun:
                    Console.WriteLine( "Character buffer overrun." ); 
                    
                    break;
                case SerialError.RXOver:
                    Console.WriteLine( "Input buffer overflow." ); 
                    
                    break;
                case SerialError.RXParity:
                    Console.WriteLine( "Parity error." ); 
                    
                    break;
                case SerialError.TXFull:
                    Console.WriteLine( "Output buffer full." ); 
                    break;
            }            
        }         

        /// <summary>
        /// Find the PC's COM ports and store parameters for each port.
        /// Use saved parameters if possible, otherwise use default values.  
        /// </summary>
        /// 
        /// <remarks> 
        /// The ports can change if a USB/COM-port converter is attached or removed,
        /// so this routine may need to run multiple times.
        /// </remarks>
        
       internal static void FindComPorts() 
        { 
            myPortNames = SerialPort.GetPortNames(); 
            
            //  Is there at least one COM port?
            
            if ( myPortNames.Length > 0 ) 
            {                 
                comPortExists = true; 
                Array.Sort( myPortNames );                 
            } 
            else 
            { 
                //  No COM ports found.
                
                comPortExists = false; 
            }             
        } 

        /// <summary>
        /// Open the SerialPort object selectedPort.
        /// If open, close the SerialPort object previousPort.
        /// </summary>
                
        internal bool OpenComPort() 
        { 
            bool success = false;
            SerialDataReceivedEventHandler1 = new SerialDataReceivedEventHandler(DataReceived);
            SerialErrorReceivedEventHandler1 = new SerialErrorReceivedEventHandler(ErrorReceived); 

            try 
            { 
                if ( comPortExists ) 
                {                     
                    //  The system has at least one COM port.
                    //  If the previously selected port is still open, close it.
                    
                    if ( PreviousPort.IsOpen ) 
                    { 
                        CloseComPort( PreviousPort ); 
                    } 
                    
                    if ( ( !( ( SelectedPort.IsOpen ) ) | PortChanged ) ) 
                    {                         
                        SelectedPort.Open(); 
                        
                        if ( SelectedPort.IsOpen ) 
                        {                             
                            //  The port is open. Set additional parameters.
                            //  Timeouts are in milliseconds.
                            
                            SelectedPort.ReadTimeout = 20000; 
                            SelectedPort.WriteTimeout = 20000; 
                            
                            //  Specify the routines that run when a DataReceived or ErrorReceived event occurs.
                           
                            SelectedPort.DataReceived += SerialDataReceivedEventHandler1; 
                            SelectedPort.ErrorReceived += SerialErrorReceivedEventHandler1; 
                           
                            //  Send data to other modules.
                            
                            if ( null != UserInterfaceData ) UserInterfaceData( "DisplayCurrentSettings", "", Color.Black ); 
                            if ( null != UserInterfaceData ) UserInterfaceData( "DisplayStatus", "", Color.Black ); 
                            
                            success = true; 
                            
                            //  The port is open with the current parameters.
                            
                            PortChanged = false;                             
                        } 
                    }                    
                }                 
            }
            
            catch ( InvalidOperationException ex ) 
            {                 
                ParameterChanged = true; 
                PortChanged = true; 
                DisplayException( ModuleName, ex );                 
            } 
            catch ( UnauthorizedAccessException ex ) 
            {                 
                ParameterChanged = true; 
                PortChanged = true; 
                DisplayException( ModuleName, ex );                 
            } 
            catch ( System.IO.IOException ex ) 
            {                 
                ParameterChanged = true; 
                PortChanged = true; 
                DisplayException( ModuleName, ex ); 
            } 
            
            return success;             
        } 

        /// <summary>
        ///  Executes when WriteToComPortDelegate1 completes.
        /// </summary>
        /// <param name="ar"> the value returned by the delegate's BeginInvoke method </param> 
                
        internal void WriteCompleted( IAsyncResult ar ) 
        {   
            WriteToComPortDelegate deleg = null; 
            string msg = null; 
            bool success = false; 
            
            //  Extract the value returned by BeginInvoke (optional).
            
            msg = System.Convert.ToString( ar.AsyncState ); 
            
            //  Get the value returned by the delegate.
            
            deleg = ( ( WriteToComPortDelegate )( ( ( AsyncResult )( ar ) ).AsyncDelegate ) ); 
            
            success = deleg.EndInvoke( ar );
            if ( success ) 
            { 
                if ( null != UserInterfaceData ) UserInterfaceData( "UpdateStatusLabel", "", Color.Black ); 
            } 
           
        }
        internal void ReadComplete(IAsyncResult ar)
        {
            ReadComPortDelegate deleg = null;
            string msg = null;
            bool success = false;

            //  Extract the value returned by BeginInvoke (optional).

            msg = System.Convert.ToString(ar.AsyncState);

            //  Get the value returned by the delegate.

            deleg = ((ReadComPortDelegate)(((AsyncResult)(ar)).AsyncDelegate));

            success = deleg.EndInvoke(ar);

            if (success)
            {
                if (null != UserInterfaceData) UserInterfaceData("UpdateStatusLabel", "", Color.Black);
            }

            //  Add any actions that need to be performed after a write to the COM port completes.
            //  This example displays the value passed to the BeginInvoke method
            //  and the value returned by EndInvoke.

            Console.WriteLine("Write operation began: " + msg);
            Console.WriteLine("Write operation succeeded: " + success);
        }

        /// <summary>
        /// Write a string to the SerialPort object selectedPort.
        /// </summary>
        /// 
        /// <param name="textToWrite"> A string to write </param>
                
        internal bool WriteToComPort( string textToWrite ) 
        { 
            bool success = false;
           
            try 
            { 
                //  Open the COM port if necessary.
                
                if ( ( !( ( SelectedPort == null ) ) ) ) 
                { 
                    if ( ( ( !( SelectedPort.IsOpen ) ) | PortChanged ) ) 
                    {                         
                        //  Close the port if needed and open the selected port.
                        
                        PortOpen = OpenComPort();                         
                    } 
                } 
                
                if ( SelectedPort.IsOpen ) 
                { 
                    SelectedPort.Write( textToWrite ); 
                    success = true;

                }                 
            }           
            catch ( TimeoutException ex ) 
            { 
                DisplayException( ModuleName, ex ); 
                
            } 
            catch ( InvalidOperationException ex ) 
            { 
                DisplayException( ModuleName, ex ); 
                ParameterChanged = true; 
                if ( null != UserInterfaceData ) UserInterfaceData( "DisplayCurrentSettings", "", Color.Black );                 
            } 
            catch ( UnauthorizedAccessException ex ) 
            { 
                DisplayException( ModuleName, ex ); 
                
                //  This exception can occur if the port was removed. 
                //  If the port was open, close it.
                
                CloseComPort( SelectedPort ); 
                ParameterChanged = true; 
                if ( null != UserInterfaceData ) UserInterfaceData( "DisplayCurrentSettings", "", Color.Black );                 
            }             
            return success;             
        }
        internal string ReadComPort()
        {
            bool success = false;
            string dataReadToDisplay = null;
            try
            {
                //  Open the COM port if necessary.

                if ((!((SelectedPort == null))))
                {
                    if (((!(SelectedPort.IsOpen)) | PortChanged))
                    {
                        //  Close the port if needed and open the selected port.

                        PortOpen = OpenComPort();
                    }
                }

                if (SelectedPort.IsOpen)
                {
                    //int iRead = SelectedPort.BytesToRead;
                    //byte[] a_byteArray = new byte[iRead];
                    //int iNread = 0;
                    //iNread = SelectedPort.Read(a_byteArray, 0, iRead);
                    //dataReadToDisplay = "";
                    //foreach (byte b in a_byteArray)
                    //{

                    //    dataReadToDisplay += b.ToString() + " ";

                    //}
                    dataReadToDisplay = SelectedPort.ReadLine();
                    success = true;
                }
            }
            catch (TimeoutException ex)
            {
                DisplayException(ModuleName, ex);

            }
            catch (InvalidOperationException ex)
            {
                DisplayException(ModuleName, ex);
                ParameterChanged = true;
                if (null != UserInterfaceData) UserInterfaceData("DisplayCurrentSettings", "", Color.Black);
            }
            catch (UnauthorizedAccessException ex)
            {
                DisplayException(ModuleName, ex);

                //  This exception can occur if the port was removed. 
                //  If the port was open, close it.

                CloseComPort(SelectedPort);
                ParameterChanged = true;
                if (null != UserInterfaceData) UserInterfaceData("DisplayCurrentSettings", "", Color.Black);
            }
            return dataReadToDisplay;
        }           
    }     
}

Re: Serial Port

Luc Pattyn12-Mar-10 2:51

Luc Pattyn

12-Mar-10 2:51

Deepak.Prahlad wrote:
Timeout value (read timeout and write timeout) every time you read or write

No, timeout is a property just like all others. You can set it once, it will hold its value.

Deepak.Prahlad wrote:
Read timeout timer starts when the first characeter arrives at the hardware buffer

No, read timeout starts when a read operation starts. The behavior you are referring to exists in Windows but AFAIK is not exposed to the SerialPort class.

Deepak.Prahlad wrote:
thread locking in DataReceived event

DataReceived is an asynchronous event; as such it is handled by a ThreadPool thread, which is not allowed to touch the Winform Controls directly. See this[^] and this[^] article.

One can never be sure that all the serial data that belongs together (a "message") will be received in one go; there always could be a hick-up somewhere, causing the message to be split over two DataReceived events. One approach that often leads to success is by having some delay between the start of the DataReceived event and the actual reading of the data.

Smile | :)

Luc Pattyn [Forum Guidelines] [Why QA sucks] [My Articles]

I only read code that is properly formatted, adding PRE tags is the easiest way to obtain that.

Re: Serial Port

PIEBALDconsult12-Mar-10 3:45

PIEBALDconsult

12-Mar-10 3:45

Here's a similar post[^]; maybe it could help.

Re: Serial Port

Deepak.Prahlad14-Mar-10 17:59

Deepak.Prahlad

14-Mar-10 17:59

Hi stancrm, OriginalGriff, DotNetCoderJunior, Luc Pattyn, PIEBALDconsult

I think I solved the issue by using a thread.sleep() at the bigining of the DataRecieved() as suggested by Luc Pattyn, Thumbs Up | :thumbsup:

Thanks for the help from every one! Blush | :O

Regards
Deepak

MouseEnter and MouseLeave not working if Enabled=false

stancrm11-Mar-10 22:01

stancrm

11-Mar-10 22:01

modified 23-Nov-14 6:36am.

Re: MouseEnter and MouseLeave not working if Enabled=false

#realJSOP12-Mar-10 1:48

#realJSOP

12-Mar-10 1:48

You could try creating a class that inherits from the control and provide the functionality there.

.45 ACP - because shooting twice is just silly
-----
"Why don't you tie a kerosene-soaked rag around your ankles so the ants won't climb up and eat your candy ass..." - Dale Earnhardt, 1997
-----
"The staggering layers of obscenity in your statement make it a work of art on so many levels." - J. Jystad, 2001

Re: MouseEnter and MouseLeave not working if Enabled=false

Dave Kreskowiak12-Mar-10 3:42

Dave Kreskowiak

12-Mar-10 3:42

If the control is disabled, none of those events fire. Like John said, you'd have to implement your own button class to support this. You'd be creating a button that never really disables. You'd keep track of the Enabled state as in a normal button, and keep certain events running while "disabling" others, like Click DoubleClick, MouseDown, MouseUp, ..., if the control is disabled. You'd also have to custom paint the button to show that it is "disabled" or not.

A guide to posting questions on CodeProject[^]

Dave Kreskowiak
Microsoft MVP
Visual Developer - Visual Basic
2006, 2007, 2008
But no longer in 2009...

Re: MouseEnter and MouseLeave not working if Enabled=false [modified]

#realJSOP12-Mar-10 5:41

#realJSOP

12-Mar-10 5:41

bool EverythingYouSaid = PainInTheAss;
bool IsItWorthIt = false;

modified on Friday, March 12, 2010 11:48 AM

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.