C# Discussion Boards - CodeProject

create our own unit testing framework in C#

Sakhalean26-Mar-23 18:32

26-Mar-23 18:32

Hi All,

I want to create my own unit testing framework using C#.
Can anybody please suggest me any websites or articles for creating our own unit testing framework using C#.

Thank you All

Re: create our own unit testing framework in C#

OriginalGriff26-Mar-23 21:00

OriginalGriff

26-Mar-23 21:00

Why? Visual Studio includes a UT framework already ... you are reinventing the wheel and adding a layer of possible bugs to the testing environment as well as spending some considerable time developing what already exists.

"I have no idea what I did, but I'm taking full credit for it." - ThisOldTony
"Common sense is so rare these days, it should be classified as a super power" - Random T-shirt
AntiTwitter: @DalekDave is now a follower!

Re: create our own unit testing framework in C#

jschell27-Mar-23 7:00

jschell

27-Mar-23 7:00

I doubt such a thing exists.

The idea itself is fairly obvious so I am not sure what you would need to know other than having used one at one time.

Now lets say you want to hook it into VS itself. That is not trivial. But you can't do that until you create the rest of it anyways.

Best thing I can suggest it so look at source code for log4net. And maybe read through questions and bugs for that.

Re: create our own unit testing framework in C#

Gerry Schmitz27-Mar-23 11:39

Gerry Schmitz

27-Mar-23 11:39

Yes ... go for ~~NUnit2.~~ NUnit4.

NUnit.org

"Before entering on an understanding, I have meditated for a long time, and have foreseen what might happen. It is not genius which reveals to me suddenly, secretly, what I have to say or to do in a circumstance unexpected by other people; it is reflection, it is meditation." - Napoleon I

Re: create our own unit testing framework in C#

mtoha13-Apr-23 16:39

mtoha

13-Apr-23 16:39

above is correct answer. search public Unit test project. Like NUnit in this case.

GitHub - nunit/nunit: NUnit 3 Framework[^]

I think you do not begin from scratch but if you confident with your abilities, you contact original writer and suggest yourself as contributor on NUnit project in example.

Regards
Toha

Management of window coordinates and sizes for multiple screens of different resolutions

temuco25-Mar-23 13:14

temuco

25-Mar-23 13:14

Hello,

first of all I just need a hint on how to approach this topic in the most sensible way.

I have an older application that can only determine its coordinates correctly when it is running on only one monitor. Now the application needs to run in environments with multiple screens with different resolutions. Example: Notebook with 1920x1080 + 3840×2160 + 1920x1200 (main screen). In addition, screens with a scaling other than just 100% can be run (e.g. 175%). As you can see here, a colourful mixture.

I would like to determine the exact position and window size of the program.

I am primarily a backend developer, so I have never had anything to do with this topic before. For this reason, I am turning to you in the hope of getting a push before I go the wrong direction.

Many thanks in advance and best regards

René

Re: Management of window coordinates and sizes for multiple screens of different resolutions

OriginalGriff25-Mar-23 20:18

OriginalGriff

25-Mar-23 20:18

Hi René!
You are going to have to give more detail as to what exactly you need help with - I have three monitors here, all different resolutions (1920x1080, 1080x1920, and 1280x1024 @ 100%), plus my Surface Go 2 (1920x1280 @ 150%) which I can write / test apps on (plus gawd knows what once the software is released) and generally it's not a problem.

Why does you app need to "know where it is"? What is it doing that it needs this? What will it do with the info? What's the problem in finding out?

My apps generally "remember" where they were, and restore their position on that particular system:

#region Event Handlers
#region Form
/// <summary>
/// Restore size and location (if the user doesn't
/// override it)
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void FrmMain_Load(object sender, EventArgs e)
    {
    if ((ModifierKeys & Keys.Shift) == 0)
        {
        this.LoadLocation();
        }
    }
/// <summary>
/// Save the size and location (if the user doesn't
/// override it)
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void FrmMain_FormClosing(object sender, FormClosingEventArgs e)
    {
    if ((ModifierKeys & Keys.Shift) == 0)
        {
        this.SaveLocation();
        }
    }

Is part of my standard "new form" code, along with the support methods:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using System.Data;
using System.Drawing;
using System.Diagnostics;

namespace OneOffJobs
    {
    /// <summary>
    /// Provides the storage related code
    /// </summary>
    public static class Storage
        {
        #region Constants
        /// <summary>
        /// Restore command, used as a parameter to ShowWindow
        /// </summary>
        private const int SW_RESTORE = 9;
        #endregion

        #region DLL Imports
        // Sets the window to be foreground
        [DllImport("User32")]
        private static extern int SetForegroundWindow(IntPtr hwnd);
        // Activate or minimize a window
        [DllImportAttribute("User32.DLL")]
        private static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
        #endregion

        #region Fields
        #region Internal
        #endregion

        #region Property bases
        #endregion
        #endregion

        #region Properties
        /// <summary>
        /// Get the Application Guid
        /// </summary>
        public static Guid AppGuid
            {
            get
                {
                Assembly asm = Assembly.GetEntryAssembly();
                object[] attr = (asm.GetCustomAttributes(typeof(GuidAttribute), true));
                return new Guid((attr[0] as GuidAttribute).Value);
                }
            }
        /// <summary>
        /// Get the current assembly Guid.
        /// <remarks>
        /// Note that the Assembly Guid is not necessarily the same as the
        /// Application Guid - if this code is in a DLL, the Assembly Guid
        /// will be the Guid for the DLL, not the active EXE file.
        /// </remarks>
        /// </summary>
        public static Guid AssemblyGuid
            {
            get
                {
                Assembly asm = Assembly.GetExecutingAssembly();
                object[] attr = (asm.GetCustomAttributes(typeof(GuidAttribute), true));
                return new Guid((attr[0] as GuidAttribute).Value);
                }
            }
        /// <summary>
        /// Get the current user data folder
        /// </summary>
        public static string UserDataFolder
            {
            get
                {
                Guid appGuid = AppGuid;
                string folderBase = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
                string dir = string.Format(@"{0}\{1}\", folderBase, appGuid.ToString("B").ToUpper());
                return CheckDir(dir);
                }
            }
        /// <summary>
        /// Get the current user roaming data folder
        /// </summary>
        public static string UserRoamingDataFolder
            {
            get
                {
                Guid appGuid = AppGuid;
                string folderBase = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
                string dir = string.Format(@"{0}\{1}\", folderBase, appGuid.ToString("B").ToUpper());
                return CheckDir(dir);
                }
            }
        /// <summary>
        /// Get all users data folder
        /// </summary>
        public static string AllUsersDataFolder
            {
            get
                {
                Guid appGuid = AppGuid;
                string folderBase = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData);
                string dir = string.Format(@"{0}\{1}\", folderBase, appGuid.ToString("B").ToUpper());
                return CheckDir(dir);
                }
            }
        /// <summary>
        /// Location to store control locations in.
        /// </summary>
        public static string LocationsStorageFile { get; private set; }
        #endregion

        #region Regular Expressions
        #endregion

        #region Enums
        #endregion

        #region Constructors
        /// <summary>
        /// Fill out the static properties
        /// </summary>
        static Storage()
            {
            LocationsStorageFile = UserDataFolder + "control.storage.locations";
            }
        #endregion

        #region Events
        #region Event Constructors
        #endregion

        #region Event Handlers
        #endregion
        #endregion

        #region Public Methods
        /// <summary>
        /// Save the control location
        /// (Because a Form is derived from Control, it works
        /// for them as well)
        /// </summary>
        /// <param name="control">Form to save location of</param>
        /// <param name="instance">Instance identifier (for use with multiple instances)</param>
        public static void SaveLocation(this Control control, string instance = null)
            {
            string controlName = control.GetType().Name;
            if (!File.Exists(LocationsStorageFile))
                {
                CreateBlankLocationFile();
                }
            if (!(control is Form f) || (f.Visible && f.WindowState == FormWindowState.Normal))
                {
                // For Forms, we don't want to save if hidden, or if maximized / minimized
                // If we did, it causes the form to be misplaced, or far too small to see.
                DataTable dt = ReadXML(LocationsStorageFile);
                if (dt.Columns.Count >= 6)
                    {
                    bool ignoreInstance = string.IsNullOrWhiteSpace(instance);
                    DataRow current = dt.NewRow();    // Assume new row or instance.
                    current["ControlName"] = controlName;
                    current["Instance"] = instance ?? "";
                    foreach (DataRow row in dt.Rows)
                        {
                        if (row["ControlName"] as string == controlName && (ignoreInstance || row["Instance"] as string == instance))
                            {
                            // Found it!
                            //current = row;
                            dt.Rows.Remove(row);
                            break;
                            }
                        }
                    current["LocationX"] = control.Location.X;
                    current["LocationY"] = control.Location.Y;
                    current["SizeW"] = control.Size.Width;
                    current["SizeH"] = control.Size.Height;
                    dt.Rows.Add(current);
                    WriteXML(dt, LocationsStorageFile);
                    }
                }
            }
        /// <summary>
        /// Load the Control location
        /// (Because a Form is derived from Control, it works
        /// for them as well)
        /// </summary>
        /// <param name="control">Form to load location of</param>
        /// <param name="instance">Instance identifier (for use with multiple instances)</param>
        public static void LoadLocation(this Control control, string instance = null)
            {
            string controlName = control.GetType().Name;
            if (!File.Exists(LocationsStorageFile))
                {
                CreateBlankLocationFile();
                }
            DataTable dt = ReadXML(LocationsStorageFile);
            if (dt.Columns.Count >= 6)
                {
                bool ignoreInstance = string.IsNullOrWhiteSpace(instance);
                DataRow current = dt.NewRow();    // Assume new row or instance.
                current["ControlName"] = controlName;
                current["Instance"] = instance ?? "";
                current["LocationX"] = control.Location.X;
                current["LocationY"] = control.Location.Y;
                current["SizeW"] = control.Size.Width;
                current["SizeH"] = control.Size.Height;
                foreach (DataRow row in dt.Rows)
                    {
                    if (row["ControlName"] as string == controlName && (ignoreInstance || row["Instance"] as string == instance))
                        {
                        // Found it!
                        current = row;
                        if (int.TryParse(current["LocationX"].ToString(), out int x) &&
                            int.TryParse(current["LocationY"].ToString(), out int y) &&
                            int.TryParse(current["SizeW"].ToString(), out int w) &&
                            int.TryParse(current["SizeH"].ToString(), out int h))
                            {
                            control.Location = new Point(x, y);
                            control.Size = new Size(w, h);
                            }
                        break;
                        }
                    }
                }
            }
        /// <summary>
        /// Ensures that just a single instance of an application is running.
        /// </summary>
        /// <remarks>
        /// Checks if this is the only executing example of this process.
        /// If it is, all well and good.
        /// Otherwise, switches the focus to the other instance, and 
        /// terminates this process.
        /// </remarks>
        /// <example>
        /// In program.cs:
        /// 
        /// [STAThread]
        /// static void Main()
        ///     {
        ///     Process.GetCurrentProcess().SingleInstance();
        ///     Application.EnableVisualStyles();
        ///     Application.SetCompatibleTextRenderingDefault(false);
        ///     Application.Run(new frmMain());
        ///     }
        /// </example>
        /// <param name="thisProcess"></param>
        public static void SingleInstance(this Process thisProcess)
            {
            foreach (Process proc in Process.GetProcessesByName(thisProcess.ProcessName))
                {
                if (proc.Id != thisProcess.Id)
                    {
                    ShowWindow(proc.MainWindowHandle, SW_RESTORE);
                    SetForegroundWindow(proc.MainWindowHandle);
                    thisProcess.Kill();
                    }
                }
            }
        #endregion

        #region Overrides
        #endregion

        #region Private Methods
        /// <summary>
        /// Check the specified folder, and create if it doesn't exist.
        /// </summary>
        /// <param name="dir"></param>
        /// <returns></returns>
        private static string CheckDir(string dir)
            {
            if (!Directory.Exists(dir))
                {
                Directory.CreateDirectory(dir);
                }
            return dir;
            }
        /// <summary>
        /// Read the data from the XML file
        /// </summary>
        /// <param name="file"></param>
        /// <returns></returns>
        private static DataTable ReadXML(string file)
            {
            using (DataSet ds = new DataSet())
                {
                ds.ReadXml(file);
                DataTable dt;
                if (ds.Tables.Count > 0)
                    {
                    // Can't leave it attached to the DataSet, even if the set is Disposed!
                    dt = ds.Tables[0];
                    ds.Tables.Remove(dt);
                    }
                else
                    {
                    dt = new DataTable("Empty");
                    }
                return dt;
                }
            }
        /// <summary>
        /// Write the data to the XML file
        /// </summary>
        /// <param name="dt"></param>
        /// <param name="file"></param>
        private static void WriteXML(DataTable dt, string file)
            {
            using (DataSet ds = new DataSet())
                {
                ds.Tables.Add(dt);
                ds.WriteXml(file);
                ds.Tables.Remove(dt);
                }
            }
        /// <summary>
        /// Create a blank file template
        /// </summary>
        private static void CreateBlankLocationFile()
            {
            DataTable dtNew = new DataTable("Locations");
            dtNew.Columns.Add("ControlName", typeof(string));
            dtNew.Columns.Add("Instance", typeof(string));
            dtNew.Columns.Add("LocationX", typeof(int));
            dtNew.Columns.Add("LocationY", typeof(int));
            dtNew.Columns.Add("SizeW", typeof(int));
            dtNew.Columns.Add("SizeH", typeof(int));
            DataRow dr = dtNew.NewRow();
            dr["ControlName"] = "%%SAMPLE%%";
            dr["Instance"] = "%%INSTANCE%%";
            dr["LocationX"] = 0;
            dr["LocationY"] = 0;
            dr["SizeW"] = 200;
            dr["SizeH"] = 200;
            dtNew.Rows.Add(dr);
            WriteXML(dtNew, LocationsStorageFile);
            }
        #endregion
        }
    }

Re: Management of window coordinates and sizes for multiple screens of different resolutions

temuco26-Mar-23 1:22

temuco

26-Mar-23 1:22

Hello "OriginalGriff"

first of all, thank you for your post. With my poor English, I'll try to explain the problem a little better.

We have an application that was programmed with SAL. SAL is a programming language developed by the Gupta company in the 90s. Gupta has a colourful history: first it was called Gupta, then Centura, later Unify and today it is owned by OpenText.

As far as window management is concerned, SAL applications unfortunately only work correctly with one screen. Working with several different screens causes SAL applications major problems.

Now SAL can integrate and use .NET DLLs developed with Framework 4.8. This is where I would like to start in order to take over the window management myself. I want to be able to determine and restore the window position and size of the SAL application on any screen, regardless of resolution and scaling.

Thank you again and best regards

René

Re: Management of window coordinates and sizes for multiple screens of different resolutions

Dave Kreskowiak26-Mar-23 5:38

Dave Kreskowiak

26-Mar-23 5:38

THe screen resolutions and DPI settings don't matter. All you need is the Top, Left, Width, and Height properties of the window. That's it.

How you do that is a custom programming language nobody has ever heard of is entirely on you. You may be able to use .NET DLL's, but the windows are not being created by those DLL's, I assume? In that case, you're going to have to get the window handle of your apps main window somehow, then use that to call the GetWindowRect function[^] to get the screen coordinates and size rectangle.

Asking questions is a skill
CodeProject Forum Guidelines
Google: C# How to debug code
Seriously, go read these articles.

Dave Kreskowiak

Re: Management of window coordinates and sizes for multiple screens of different resolutions

temuco26-Mar-23 22:28

temuco

26-Mar-23 22:28

Why do screen resolutions and DPI settings not matter?

The windows are not created by .NET. But I have a window handle that I could use.

Re: Management of window coordinates and sizes for multiple screens of different resolutions

Dave Kreskowiak27-Mar-23 1:30

Dave Kreskowiak

27-Mar-23 1:30

Because you're going to get screen coordinates no matter what the resolution and DPI are.

Asking questions is a skill
CodeProject Forum Guidelines
Google: C# How to debug code
Seriously, go read these articles.

Dave Kreskowiak

Re: Management of window coordinates and sizes for multiple screens of different resolutions

temuco27-Mar-23 21:18

temuco

27-Mar-23 21:18

Yes.

I have looked into the subject more closely. Here I find that Windows always ensures that the dpi number remains the same with different scaling. To do this, Windows changes the number of pixels. Here is an example from my Dell XPS with 3840x2400 pixels: with a scaling of 175%, Windows calculates with a screen resolution of 2194x1371. This means that the scaling at this resolution remains 100% at 96 dpi.

Nevertheless, our old software gets confused with this. I assume that it calculates the scaling factor internally incorrectly - actually, this should not be taken into account at all as long as Windows programmatically delivers a scaling of 100% at 96 dpi.

Here is a programme code that shows me (and confirms) everything essential in the debugger:

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Windows.Forms;

namespace multimonitor1
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // Abrufen der DPI-Skalierung und Skalierungsstufe jedes Bildschirms
            List<(float, float, int)> screenDpiScales = new List<(float, float, int)>();

            while (true)
            {
                foreach (Screen screen in Screen.AllScreens)
                {
                    using (var form = new Form() { Bounds = screen.Bounds, TopMost = true })
                    {
                        form.Show();

                        Graphics g = Graphics.FromHwnd(form.Handle);

                        float	dpiX	= g.DpiX;
                        float	dpiY	= g.DpiY;
                        int		scale	= (int) Math.Round(dpiX / 96.0 * 100);
                        
						screenDpiScales.Add((dpiX, dpiY, scale));
                        
						form.Hide();
                    }
                }

                // Ermitteln der Größe und Position der Anwendung
                int appLeft		= 0;
                int appTop		= 0;
                int appWidth	= 0;
                int appHeight	= 0;

                // Hier müssen die genauen Koordinaten der Anwendung in Bezug auf den Bildschirm ermittelt werden.
                // *** [English] The exact coordinates of the application in relation to the screen must be determined here. ***

                // Berechnen der Größe und Position der Anwendung auf jedem Bildschirm
                for (int i = 0; i < Screen.AllScreens.Length; i++)
                {
                    Screen screen = Screen.AllScreens[i];

                    (float, float, int) dpiScale = screenDpiScales[i];

                    Rectangle screenBounds = screen.Bounds;

                    float	dpiX	= dpiScale.Item1;
                    float	dpiY	= dpiScale.Item2;
                    int		scale	= dpiScale.Item3;

                    appLeft		= (int) (appLeft	* screenBounds.Width	/ (dpiX / 96.0 * scale));
                    appTop		= (int) (appTop		* screenBounds.Height	/ (dpiY / 96.0 * scale));
                    appWidth	= (int) (appWidth	* screenBounds.Width	/ (dpiX / 96.0 * scale));
                    appHeight	= (int) (appHeight	* screenBounds.Height	/ (dpiY / 96.0 * scale));

                    // Ausgabe der Größe und Position der Anwendung
                    Console.WriteLine($"Left:   {appLeft}");
                    Console.WriteLine($"Top:    {appTop}");
                    Console.WriteLine($"Width:  {appWidth}");
                    Console.WriteLine($"Height: {appHeight}");
                }

                Console.ReadLine();
            }
        }
    }
}

This solves the case for me.

Many thanks and best regards

René

Re: Management of window coordinates and sizes for multiple screens of different resolutions

Gerry Schmitz26-Mar-23 7:57

Gerry Schmitz

26-Mar-23 7:57

If it can "use and integrate .NET", you could bolt a WPF or Window Forms (or UWP?) "UI" onto SAL. Whether that's output only, can't tell from your post.

Entity Framework Code First - two Foreign Keys from same table

Alex Dunlop21-Mar-23 8:43

Alex Dunlop

21-Mar-23 8:43

I have the following models:

public class User
    {
        [Key]
        public int UserId { get; set; }
        public string Name { get; set; }
        public string LastName { get; set; }
        public string? ImageUrl { get; set; }

        //Navigation properties
        public virtual List<Request> Requests { get; set; }
        public virtual List<Message> Messages { get; set; }
    }

public class Request
    {
        [Key]
        public int RequestId { get; set; }
        public DateTime RequestTime { get; set; } = DateTime.Now;
        public bool? AcceptStatus { get; set; }

        //Navigation properties
        public User TargetUserRef { get; set; }
        public User SenderUserRef { get; set; }
    }

I want the Request table to have two foreign keys. I tried to use the following fluent API:

protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Request>()
                        .HasOne(m => m.SenderUserRef)
                        .WithMany(t => t.Requests)
                        .HasForeignKey(m => m.RequestId)
                        .OnDelete(DeleteBehavior.Restrict);

            modelBuilder.Entity<Request>()
                        .HasOne(m => m.TargetUserRef)
                        .WithMany(t => t.Requests)
                        .HasForeignKey(m => m.RequestId)
                        .OnDelete(DeleteBehavior.Restrict);
        }

When I try to create migration, the following error is shown:

Quote:
Cannot create a relationship between 'User.Requests' and 'Request.TargetUserRef' because a relationship already exists between 'User.Requests' and 'Request.SenderUserRef'. Navigations can only participate in a single relationship. If you want to override an existing relationship call 'Ignore' on the navigation 'Request.TargetUserRef' first in 'OnModelCreating'.

How can I solve this problem?

Re: Entity Framework Code First - two Foreign Keys from same table

Gerry Schmitz21-Mar-23 9:30

Gerry Schmitz

21-Mar-23 9:30

This is where you build the (test) "database first" and have EF generate the model it undertstands; instead of having to guess what your "model building" code is trying to do. Then you can try again with having some idea of what works.

Re: Entity Framework Code First - two Foreign Keys from same table

jschell23-Mar-23 6:04

jschell

23-Mar-23 6:04

To me this is why relying on these sorts of APIs leads to problems.

Any API that attempts to simplify something always reduces complexity by removing features. That is of course the definition of simplification.

That works only as long as the needed usage is in fact simple. And more importantly that it is expected that over time it will remain simple.

If not then it will start to fail at some time. Then attempting to then use the API to solve the problem becomes a mess. Or perhaps even worse the API itself will introduce odd constructs with perhaps even odd restrictions and rules in an attempt to work around the original limitations. Those themselves will lead to problems over time.

Re: Entity Framework Code First - two Foreign Keys from same table

Richard Deeming27-Mar-23 0:35

Richard Deeming

27-Mar-23 0:35

You can't use the same collection navigation property to represent the requests where the user is the sender and the requests where the user is the target.

You also can't use the RequestId property as the foreign key to the users table - you're not creating a one-to-one relationship, so the request ID and the user ID will be different.

public class User
{
    ...
    public List<Request> SentRequests { get; set; }
    public List<Request> ReceivedRequests { get; set; }
    ...
}

...

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Request>()
                .HasOne(m => m.SenderUserRef)
                .WithMany(t => t.SentRequests)
                .OnDelete(DeleteBehavior.Restrict);

    modelBuilder.Entity<Request>()
                .HasOne(m => m.TargetUserRef)
                .WithMany(t => t.ReceivedRequests)
                .OnDelete(DeleteBehavior.Restrict);
}

"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer

How to highlight all rows in listbox between two index values?

Member 1405587917-Mar-23 1:25

Member 14055879

17-Mar-23 1:25

Is it possible to highlight all rows in listbox between two index values?
If it possible how is it done?

Re: How to highlight all rows in listbox between two index values?

Pete O'Hanlon17-Mar-23 1:33

Pete O'Hanlon

17-Mar-23 1:33

Member 14055879 wrote:
Is it possible to highlight all rows in listbox between two index values?

Yes

Member 14055879 wrote:
If it possible how is it done?

By writing code. Beyond that answer, we can't really support you as there are too many open questions. What technology are you using here? WPF? WinForms? Maui? Platform x...? What do you mean by highlighting? Bolding the text? Changing the background colour? Causing the rows to blink?

When you ask a question of us, you have to remember that, unless you give us details, we don't know exactly what you want to achieve. Try to add as much detail as you can and that should help you get an answer closer to the one you want.

Advanced TypeScript Programming Projects

Re: How to highlight all rows in listbox between two index values?

RedDk17-Mar-23 6:26

RedDk

17-Mar-23 6:26

Surely someone as proficient at getting a

tag to make his post text stick out would have no troubles translating VBNET into C#: 50[^]

Wowie!

Message Closed

15-Mar-23 20:32

Sivanujan Sivaraja

15-Mar-23 20:32

Message Closed

modified 16-Mar-23 3:48am.

Re: Serial port listening application

OriginalGriff15-Mar-23 21:02

OriginalGriff

15-Mar-23 21:02

If I copy'n'paste your code into an online C# compiler:

using System;
					
public class Program
{
	public static void Main()
	{
		string inputString = "A1+0001852Kg 054";
		string weightValueString = inputString.Substring(3, inputString.IndexOf("Kg") - 3);
		Console.WriteLine(weightValueString);
		double weightKg = double.Parse(weightValueString) / 1000;
		string formattedWeight = weightKg.ToString("N2");
		Console.WriteLine(formattedWeight);
	}
}

And run it, I get what I expect:

Output

0001852
1.85

Which means that the problem isn't the code: it's the input string that you are actually processing - and we have no access to that, to it's source hardware, or to the code that reads it from the machine.

So, it's going to be up to you.
Fortunately, you have a tool available to you which will help you find out what is going on: the debugger. If you don't know how to use it then a quick Google for "Visual Studio debugger" should give you the info you need.

Put a breakpoint on the first line in the function, and run your code through the debugger. Then look at your code, and at your data and work out what should happen manually. Then single step each line checking that what you expected to happen is exactly what did. When it isn't, that's when you have a problem, and you can back-track (or run it again and look more closely) to find out why.

Sorry, but we can't do that for you - time for you to learn a new (and very, very useful) skill: debugging!

modified 16-Mar-23 3:19am.

Re: Serial port listening application

Richard MacCutchan15-Mar-23 22:34

Richard MacCutchan

15-Mar-23 22:34