init

Common/DTS.Common.Utilities/Property.cs

@@ -0,0 +1,210 @@
+/*
+Property.cs
+
+Copyright © 2008
+Diversified Technical Systems, Inc.
+All Rights Reserved
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Text;
+using DTS.Common.Utilities;
+
+namespace DTS.Common.Utilities.DotNetProgrammingConstructs
+{
+    /// <summary>
+    /// A class to implement self-checking, on-error-auto-syntax-building properties.
+    /// </summary>
+    /// 
+    /// <typeparam name="Type">
+    /// The property type.
+    /// </typeparam>
+    /// 
+    public partial class Property<Type>
+        : Exceptional
+    {
+        /// <summary>
+        /// value of the property
+        /// </summary>
+        public Type Value
+        {
+            get
+            {
+                try
+                {
+                    //if ( !_isValueInitialized )
+                    //    throw new NotInitializedException(Properties.Resources.Property_Value_NotInitializedString );
+                    //else
+                    return _Value;
+                }
+
+                catch (System.Exception ex)
+                {
+                    throw new Exception(
+                        string.Format(
+                            Properties.Resources.Property_Value_CouldNotGetValueString, !string.IsNullOrEmpty(_name) ? "\"" + _name + "\" " : ""),
+                    ex);
+                }
+            }
+
+            set
+            {
+                try
+                {
+                    if (!IsValidValue(value))
+                        throw new InvalidValueException(GetInvalidValueDescription(value));
+                    else
+                    {
+                        _Value = value;
+                        IsValueInitialized = true;
+                    }
+                }
+
+                catch (System.Exception ex)
+                {
+                    throw new Exception(
+                        string.Format(
+                            Properties.Resources.Property_Value_CouldNotSetValueString, !string.IsNullOrEmpty(_name) ? "\"" + _name + "\" " : ""),
+                        ex);
+                }
+            }
+        }
+        private Type _Value;
+        public bool IsValueInitialized { get; private set; } = false;
+
+        private string _name;
+
+        /// <summary>
+        /// Determine whether or not the specified value is valid for this property.
+        /// </summary>
+        /// 
+        /// <param name="value">
+        /// The value to be validity checked.
+        /// </param>
+        /// 
+        /// <returns>
+        /// <see cref="bool"/> true if the value is valid; false otherwise.
+        /// </returns>
+        /// 
+        public virtual bool IsValidValue(Type value)
+        {
+            return true;
+        }
+
+        /// <summary>
+        /// Get <see cref="bool"/> initialization status for this property.
+        /// </summary>
+        public bool IsInitialized => IsValueInitialized;
+
+        /// <summary>
+        /// "Deinitialize" this property.
+        /// </summary>
+        public void UnInitialize()
+        {
+            IsValueInitialized = false;
+        }
+
+        /// <summary>
+        /// Generate a user-readable explanation as to why the specified value is
+        /// not valid for this property. 
+        /// </summary>
+        /// 
+        /// <param name="value">
+        /// The value to be described.
+        /// </param>
+        /// 
+        /// <returns>
+        /// A <see cref="string"/> description explaining why the specified value
+        /// is not valid for this property.
+        /// </returns>
+        /// 
+        public virtual string GetInvalidValueDescription(Type value)
+        {
+            try
+            {
+                return string.Format(Properties.Resources.Property_GetInvalidValueDescription_CouldNotSetToValueString,
+                    !string.IsNullOrEmpty(_name) ? "\"" + _name + "\"" : "",
+                    null != value ? ("\"" + value.ToString() + "\"") : Properties.Resources.Generic_NullIndicatorString);
+            }
+            catch (System.Exception ex)
+            {
+                throw new Exception(Properties.Resources.Property_GetInvalidValueDescription_GetDescriptionFailedString, ex);
+            }
+        }
+
+        /// <summary>
+        /// Initialize an instance of the Property class.
+        /// </summary>
+        ///
+        /// <param name="name">
+        /// The name of the property this implementation is standing in for, so that
+        /// error messages will be more informative.  If a null name is passed, 
+        /// </param>
+        /// 
+        /// <param name="initialValue">
+        /// The initial value of the property.  Can be read if the property is almost
+        /// marked as "initialized".
+        /// </param>
+        /// 
+        /// <param name="isInitialized">
+        /// A <see cref="bool"/> switch that determines whether or not the property
+        /// is to be considered initialized immediately after instantiation.
+        /// </param>
+        /// 
+        public Property(string name, Type initialValue, bool isInitialized)
+        {
+            try
+            {
+                _name = name;
+                _Value = initialValue;
+                IsValueInitialized = isInitialized;
+            }
+
+            catch (System.Exception ex)
+            {
+                throw new ConstructionException(
+                    string.Format(
+                        Properties.Resources.Generic_EncounteredProblemConstructingClassString, GetType().FullName),
+                ex);
+            }
+        }
+
+        /// <summary>
+        /// Initialize an instance of the Property class.
+        /// </summary>
+        ///
+        /// <param name="initialValue">
+        /// The initial value of the property.  Can be read if the property is almost
+        /// marked as "initialized".
+        /// </param>
+        /// 
+        /// <param name="isInitialized">
+        /// A <see cref="bool"/> switch that determines whether or not the property
+        /// is to be considered initialized immediately after instantiation.
+        /// </param>
+        /// 
+        public Property(Type initialValue, bool isInitialized)
+            : this(null, initialValue, isInitialized)
+        {
+        }
+
+        /// <summary>
+        /// Generate user-readable string for this object.
+        /// </summary>
+        /// 
+        /// <returns>
+        /// A <see cref="string"/> representing the current state of the object.
+        /// </returns>
+        /// 
+        public override string ToString()
+        {
+            try { return _Value.ToString(); }
+            catch (System.Exception)
+            {
+                return base.ToString();
+            }
+        }
+    }
+}