C#

#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();
        }
    }

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
        }
    }

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);
}

Member 14055879 wrote:

Is it possible to highlight all rows in listbox between two index values?

Member 14055879 wrote:

If it possible how is it done?

@

Assuming you are using a standard ListBox control in a graphical user interface (GUI) application, here is an example in Python using the Tkinter library:

# Let's say you have a ListBox named "my_listbox"

# First, get the start and end index values
start_index = 2
end_index = 5

# Next, iterate over the indices and change the background color
for i in range(start_index, end_index+1):
    my_listbox.itemconfig(i, bg='yellow')

This code iterates over the indices between start_index and end_index (inclusive), and uses the itemconfig method to change the background color of each item to yellow. You can adjust the background color to whatever you like.

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);
	}
}

0001852
1.85