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

​

    [DataContract]

    public class AppSetting

    {

        [DataMember(Name = "DataSource")]

        private string _dataSource;

        [DataMember(Name = "IntitialCatalog")]

        private string _intitialCatalog;

        [DataMember(Name = "UserId")]

        private string _userId;

        [DataMember(Name = "Password")]

        private string _password;

​

        // Remainder unchanged

​

        public string DataSource

        {

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

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

        }

​

        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 serializer = new DataContractSerializer(typeof(AppSetting));

            using (var stream = new FileStream(GlobalConstants.XmlFile, FileMode.Create))

            {

                serializer.WriteObject(stream, appSetting);

            }

        }

​

        public static AppSetting GetAppSettingsFromXmlFile()

        {

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

            {

                return new AppSetting();

            }

​

            using (var stream = File.OpenRead(GlobalConstants.XmlFile))

            {

                var serializer = new DataContractSerializer(typeof(AppSetting));

                return (AppSetting)serializer.ReadObject(stream);

            }

        }

    }

​

    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 static class XmlAssert

    {

        // https://weblogs.asp.net/marianor/easy-way-to-compare-two-xmls-for-equality

        // https://stackoverflow.com/questions/7318157/best-way-to-compare-xelement-objects

        // Adapted from the answer https://stackoverflow.com/a/14463137 by https://stackoverflow.com/users/1102100/robjohnson

        public static void AreEqual(

            XElement expected,

            XElement actual)

        {

            Assert.IsTrue(XNode.DeepEquals(Normalize(expected), Normalize(actual)));

        }

​

        private static XElement Normalize(XElement element)

        {

            if (element.HasElements)

            {

                return new XElement(

                    element.Name,

                    element.Attributes()

                           .OrderBy(a => a.Name.ToString()),

                    element.Elements()

                           .OrderBy(a => a.Name.ToString())

                           .Select(e => Normalize(e)));

​

            }

​

            if (element.IsEmpty)

            {

                return new XElement(

                    element.Name,

                    "",

                    element.Attributes()

                           .OrderBy(a => a.Name.ToString()));

            }

​

            return new XElement(element.Name, element.Attributes()

                .OrderBy(a => a.Name.ToString()), element.Value);

        }

    }

    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;

        }

    }

​