Хранить строку в приложении

using System;
using System.Collections.Generic;
 
namespace UsrMngmt
{
    /// <summary>
    /// Main Class of User Management
    /// </summary>
    public class UManager
    {
        public string LastErrorMessage { get; private set; }
 
 
        public UManager( string fpath = null, string fname = null )
        {
            FileManager.Path = fpath ?? AppDomain.CurrentDomain.BaseDirectory;
            FileManager.FileName = fname ?? "Users.txt";
            int result = FileManager.FileLoad();
 
        }
 
 
        public static List<string> GetLog() => LoggerSrv.GetLog();
 
    }
}

using System.Security.Cryptography;
using System.Text;
 
namespace UsrMngmt
{
    internal class Hash
    {
        /// <summary>
        /// Generate a Hash code from byte[] values
        /// </summary>
        public static string GetHash( string s )
        {
            byte[] hashValue;
            string result = "";
 
            using ( SHA256 hash256 = SHA256.Create() )
                hashValue = hash256.ComputeHash( Encoding.Default.GetBytes( s ) );
 
            for ( int i = 0; i < hashValue.Length; i++ )
                result += $"{hashValue[ i ]:x2}";
            return result;
        }
    }
}

using System;
using System.IO;
using System.Text;
 
namespace UsrMngmt
{
    internal static class FileManager
    {
        public static string Path { get; set; }
        public static string FileName { get; set; }
 
 
 
        public static bool IsFileExist
        {
            get => File.Exists( System.IO.Path.Combine( Path, FileName ) );
        }
 
 
 
        public static int FileLoad()
        {
            // Check if the file exist ...
            // If not, create it.
            if ( !IsFileExist )
            {
                try
                {
                    if ( !Directory.Exists( Path ) )
                        Directory.CreateDirectory( Path );
                    FileStream fs = new( System.IO.Path.Combine( Path, FileName ), FileMode.OpenOrCreate, FileAccess.Write );
                    fs.Dispose();
 
                    LoggerSrv.Write( $"File {FileName} not found!" );
                    LoggerSrv.Write( $"File {FileName} created!" );
                }
                catch ( Exception ex ) { LoggerSrv.Write( $"Exception: {ex}" ); }
            }
 
            try
            {
                string[] lines = File.ReadAllLines( System.IO.Path.Combine( Path, FileName ), Encoding.Default );
                if ( lines.Length == 0 )
                    LoggerSrv.Write( "Are no lines in the file!" );
                else
                {
                    LoggerSrv.Write( $"A {lines.Length} lines have been read" );
 
                    /*
                     * Вот здесь надо передавать полученный массив строк string[] lines
                     * в какую-то структуру или класс... Для дальнейшей обработки, так как
                     * эта задача уже не Файлового менеджера.
                     * Разрезать на составляющие (Имя/Роль/Пароль), дешифрование, редактирование,
                     * шифрование, упаковка... etc..
                     */
 
                    return lines.Length;
                }    
            }
 
            // It looks like it will never happen ))
            catch ( Exception ex ) { LoggerSrv.Write( $"Exception: {ex}" ); }
            return 0;
        }
 
 
 
        public static void FileWrite( string text )
        {
            using StreamWriter sw = new( System.IO.Path.Combine( Path, FileName ), false, Encoding.Default );
            sw.WriteLineAsync( text );
        }
    }
}

using System;
using System.Collections.Generic;
 
 
namespace UsrMngmt
{
    internal class LoggerSrv
    {
        private static List<string> Log = new List<string>()
        {
            "[--------------- Logger Servise ---------------]",
        };
 
        public static void Write( string _in ) => Log.Add( $"{DateTime.Now} --> " + _in );
 
        public static List<string> GetLog() => Log;
    }
}

    internal static class FileManager
    {
        public static string Path { get; set; }
        public static string FileName { get; set; }
 
 
 
        private static bool IsFileExist
        {
            get => File.Exists( System.IO.Path.Combine( Path, FileName ) );
        }
 
 
 
        public static int FileLoad()
        {
            // Check if the file exist ...
            // If not, create it.
            if ( !IsFileExist )
            {
                LoggerSrv.Write( $"File {FileName} not found!" );
 
                try
                {
                    if ( !Directory.Exists( Path ) )
                        Directory.CreateDirectory( Path );
                    FileStream fs = new( System.IO.Path.Combine( Path, FileName ), FileMode.OpenOrCreate, FileAccess.Write );
                    fs.Dispose();     
                    LoggerSrv.Write( $"File {FileName} created!" );
                }
                catch ( Exception ex ) { LoggerSrv.Write( $"Exception: {ex}" ); }
            }
 
            try
            {
                string[] lines = File.ReadAllLines( System.IO.Path.Combine( Path, FileName ), Encoding.Default );
                if ( lines.Length == 0 )
                    LoggerSrv.Write( "Are no lines in the file!" );
                else
                {
                    LoggerSrv.Write( "<-------- Reading Lines Result --------->" );
                    LoggerSrv.Write( $"A {lines.Length} lines have been read" );
                    LoggerSrv.Write( "Decrypt proccessing started....." );
                    Decrypt.Proccessing( lines );
                    return lines.Length;
                }    
            }
 
            // It looks like it will never happen ))
            catch ( Exception ex ) { LoggerSrv.Write( $"Exception: {ex}" ); }
            return 0;
        }
 
 
 
        public static void FileWrite( string text )
        {
            using StreamWriter sw = new( System.IO.Path.Combine( Path, FileName ), false, Encoding.Default );
            sw.WriteLineAsync( text );
        }
    }

namespace UsrMngmt
{
    /// <summary>
    /// The structure of the one each User
    /// </summary>
    struct User
    {
        public string Name { get; set; }
        public int Role { get; set; }
        public string Hash { get; set; }
        public User( string n, int r, string h )
        {
            Name = n;
            Role = r;
            Hash = h;
        }
 
        public override string ToString() =>
            $"Name:\t{Name}\nRole:\t{Enum.GetName( typeof( UserType ), Role )}\nHash:\t{Hash}\n";
    }
}

    internal static class Decrypt
    {
        /// <summary>
        /// Array with decrypted data
        /// </summary>
        public static User[] DecriptedUsers { get; private set; }
 
 
        /// <summary>
        /// Decryption process
        /// </summary>
        /// <param name="_in">Array of raw data strings</param>
        public static void Proccessing( string[] _in )
        {
            DecriptedUsers = new User[ _in.Length ];
 
 
            /*
             * TODO:
             * There will be methods for decrypting strings, depending
             * on the algorithm used.
             * The specifics of the method can be pre-agreed and taken 
             * into account in the terms of reference.
             */
 
 
            // Number of successful decryption operations
            int count = 0;
 
            for ( int i = 0; i < _in.Length; i++ )
            {
                string name = _in[ i ].Split( ':' )[ 0 ];
                string hash = _in[ i ].Split( ':' )[ 2 ];
 
                if ( name != string.Empty && hash != string.Empty && int.TryParse( _in[ i ].Split( ':' )[ 1 ], out int role ) )
                {
                    DecriptedUsers[ i ] = new User( name, role, hash );
                    count++;
                }
                // otherwise the line is ignored.  
            }
            LoggerSrv.Write( "<---------- Decryption Result ---------->" );
            LoggerSrv.Write( $"--> {count} lines have been decrypted" );
        }
    }

namespace UsrMngmt
{
    /// <summary>
    /// Main Class of User Management
    /// </summary>
    public class UManager
    {
        public string LastErrorMessage { get; private set; }
 
 
        public UManager( string fpath = null, string fname = null )
        {
            FileManager.Path = fpath ?? AppDomain.CurrentDomain.BaseDirectory;
            FileManager.FileName = fname ?? "Users.txt";
            int result = FileManager.FileLoad();
 
        }
 
 
        public static List<string> PrintUsers()
        {
            List<string> users = new() { "<----- User List ----->" };
            if ( Decrypt.DecriptedUsers != null && Decrypt.DecriptedUsers.Length > 0 )
                foreach ( User u in Decrypt.DecriptedUsers )
                    users.Add( u.ToString() );
            return users;
        }
 
        public static List<string> GetLog() => LoggerSrv.GetLog();
 
 
    }
}

    /// <summary>
    /// Generic abstract class of User
    /// </summary>
    public abstract class Users
    {
        public string Name { get; set; }
        public UserRole Role { get; set; }
 
        public Users( string name, UserRole role )
        {
            Name = name;
            Role = role;
        }
 
        public override string ToString() =>
            $"Name: {Name}\tRights: {Enum.GetName( typeof( UserRole ), Role )}";
    }
 
 
 
    /// <summary>
    /// Derived class of User for internal use
    /// </summary>
    internal class RegisteredUser : Users
    {
        public string Hash { get; private set; }
        public RegisteredUser( string n, UserRole r, string h ) : base( n, r ) { Hash = h; }
    }
 
 
 
    /// <summary>
    /// User class for external use (?)
    /// </summary>
    public class User : Users
    {
        public User( string n, UserRole r ) : base( n, r ) { }
    }

    internal class Authorization
    {
        /// <summary>
        /// Registered Users
        /// </summary>
        public static List<RegisteredUser> RegisteredUsers = new();
 
 
        /// <summary>
        /// Registering new User
        /// </summary>
        public static void SignUp( User u, string passw ) =>
            RegisteredUsers.Add( new RegisteredUser( u.Name, u.Role, Hash.GetHash( passw ) ) );

        static void Main()
        {
            UManager umng = new();
            User[] users = umng.GetUsers();
            foreach ( User user in users )
                Console.WriteLine( user );

        public Form1()
        {
            InitializeComponent();
            UManager umng = new();
            User[] users = umng.GetUsers();
 
            lv1.Columns.Add( "Name" );
            lv1.Columns.Add( "Role" );
 
            foreach ( User u in users )
            {
                ListViewItem item = new ListViewItem { Text = u.Name };
                item.SubItems.Add( u.Role.ToString() );
                lv1.Items.Add( item );
            } 
        }