using System;

using System.Collections.Generic;

using System.Text;

using System.Linq;

using System.Xml.Serialization;

using System.Xml;

using System.Xml.Linq;

using System.IO;

using System.Data;

using System.Runtime.Serialization;

using System.Runtime.Serialization.Formatters.Binary;

using System.IO.Compression;

using System.Reflection;

​

using NUnit.Framework; //NUnit.Framework.AssertionException

​

//https://stackoverflow.com/questions/58824043/encrypting-properties-before-saving-class-to-xml-file

​

    public class AppSetting

    {

        [System.ComponentModel.Browsable(false), System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never), System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]

        [XmlElement("DataSource")] // Optionally change the element name to be <DataSource>

        public string EncryptedDataSource { get; set; }

        [XmlIgnore]

        public string DataSource

        {

            set => EncryptedDataSource = Encryption.SimpleEncryptWithPassword(value, GlobalConstants.EncryptionPassword);

            get => Encryption.SimpleDecryptWithPassword(EncryptedDataSource, GlobalConstants.EncryptionPassword);

        }

​

        private string _intitialCatalog;

        private string _userId;

        private string _password;

​

        public string IntitialCatalog

        {

            set => _intitialCatalog = Encryption.SimpleEncryptWithPassword(value, GlobalConstants.EncryptionPassword);

            get => Encryption.SimpleDecryptWithPassword(_intitialCatalog, GlobalConstants.EncryptionPassword);

        }

​

        public string UserId

        {

            set => _userId = Encryption.SimpleEncryptWithPassword(value, GlobalConstants.EncryptionPassword);

            get => Encryption.SimpleDecryptWithPassword(_userId, GlobalConstants.EncryptionPassword);

        }

​

        public string Password

        {

            set => _password = Encryption.SimpleEncryptWithPassword(value, GlobalConstants.EncryptionPassword);

            get => Encryption.SimpleDecryptWithPassword(_password, GlobalConstants.EncryptionPassword);

        }

​

        public bool IntegratedSecurity { set; get; }

        public bool MultipleActiveResultSets { set; get; }

        public bool PersistSecurityInfo { set; get; }

    }

​

    public static class GlobalConstants

    {

        // Fakes for testing

        public const string EncryptionPassword = "password";

        public const string XmlFile = "Question58824043.xml";

    }

​

    internal static class XmlReader

    {

        public static void WriteAppSettingsToXmlFile(AppSetting appSetting)

        {

            var xs = new XmlSerializer(typeof(AppSetting));

            using (var tw = new StreamWriter(GlobalConstants.XmlFile))

            {

                xs.Serialize(tw, appSetting);

            }

        }

​

        public static AppSetting GetAppSettingsFromXmlFile()

        {

            if (!File.Exists(GlobalConstants.XmlFile))

            {

                return new AppSetting();

            }

            using (var sr = new StreamReader(GlobalConstants.XmlFile))

            {

                XmlSerializer xs = new XmlSerializer(typeof(AppSetting));

                return (AppSetting)xs.Deserialize(sr);

            }

        }

    }

​

    public static class Encryption

    {

        //https://stackoverflow.com/questions/472906/how-do-i-get-a-consistent-byte-representation-of-strings-in-c-sharp-without-manu

        // https://stackoverflow.com/a/10380166 by https://stackoverflow.com/users/541686/mehrdad

        static byte[] GetBytes(string str)

        {

            byte[] bytes = new byte[str.Length * sizeof(char)];

            System.Buffer.BlockCopy(str.ToCharArray(), 0, bytes, 0, bytes.Length);

            return bytes;

        }

​

        // Do NOT use on arbitrary bytes; only use on GetBytes's output on the SAME system

        static string GetString(byte[] bytes)

        {

            char[] chars = new char[bytes.Length / sizeof(char)];

            System.Buffer.BlockCopy(bytes, 0, chars, 0, bytes.Length);

            return new string(chars);

        }       

        // Fakes for testing

        public static string SimpleEncryptWithPassword(string value, string password)

        {

            return Convert.ToBase64String(GetBytes(value));

        }

        public static string SimpleDecryptWithPassword(string value, string password)

        {

            return GetString(Convert.FromBase64String(value));

        }

    }

​

    public class TestClass

    {

        public static void Test()

        {

            var settings = new AppSetting

            {

                DataSource = "my DataSource",

                IntitialCatalog = "my IntitialCatalog",

                UserId = "my UserId",

                Password = "my Password",

            };

            XmlReader.WriteAppSettingsToXmlFile(settings);

            Console.WriteLine(XElement.Parse(File.ReadAllText(GlobalConstants.XmlFile)));

            var settings2 = XmlReader.GetAppSettingsFromXmlFile();

            Assert.IsTrue(settings.DataSource == settings.DataSource);

​

            Assert.IsTrue(!File.ReadAllText(GlobalConstants.XmlFile).Contains(settings.DataSource));

        }

    }

​

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Environment version: {0} ({1})", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , GetNetCoreVersion());

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

                Console.WriteLine("Failed with unhandled exception: ");

                Console.WriteLine(ex);

                throw;

            }

        }

        public static string GetNetCoreVersion()

        {

            //https://techblog.dorogin.com/how-to-detect-net-core-version-in-runtime-ecd65ad695be

            //

            var assembly = typeof(System.Runtime.GCSettings).GetTypeInfo().Assembly;

            var assemblyPath = assembly.CodeBase.Split(new[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries);

            int netCoreAppIndex = Array.IndexOf(assemblyPath, "Microsoft.NETCore.App");

            if (netCoreAppIndex > 0 && netCoreAppIndex < assemblyPath.Length - 2)

                return assemblyPath[netCoreAppIndex + 1];

            return null;

        }

    }

​