Survey Results

dave.dolan wrote:

it would be better just to have the right object created with the right logic hard-coded as it's behavior.

dave.dolan wrote:

Use configuration to decide.

dave.dolan wrote:

I guess it's not a paradigm breaking thing for the USER, but it is for the implementer of attributes themselves and logic based on consuming them with reflection.

dave.dolan wrote:

like configuration is supposed to be

(Darn, now I have to contrive an example... )

using Prop=System.Collections.Generic.KeyValuePair<System.Reflection.PropertyInfo,object> ;
using Proptionary=System.Collections.Generic.Dictionary<System.Reflection.PropertyInfo,object> ;

public class ConfigValueAttribute : System.ComponentModel.DefaultValueAttribute
{
  private static readonly System.Collections.Generic.Dictionary<string,System.Xml.XmlDocument> doc ;
  private static readonly System.Collections.Generic.Dictionary<System.Type,Proptionary> typ ;

  static ConfigValueAttribute
  (
  )
  {
    doc = new System.Collections.Generic.Dictionary<string,System.Xml.XmlDocument>() ;
    typ = new System.Collections.Generic.Dictionary<System.Type,Proptionary>() ;
    return ;
  }

  public ConfigValueAttribute
  (
    string ConfigFilePath
  ,
    string XPath
  )
  : base
  (
    null
  )
  {
    string fil = System.Environment.ExpandEnvironmentVariables ( ConfigFilePath ) ;

    if ( !doc.ContainsKey ( fil ) )
    {
      System.Xml.XmlDocument temp = new System.Xml.XmlDocument() ;
      temp.Load ( fil ) ;
      doc [ fil ] = temp ;
    }

    System.Xml.XmlNode nod = doc [ fil ].SelectSingleNode ( XPath ) ;

    if ( nod is System.Xml.XmlAttribute )
    {
      this.SetValue ( nod.Value ) ;
    }
    else
    {
      this.SetValue ( nod.InnerText ) ;
    }
    return ;
  }

  public static T
  Apply<T>
  (
    T Source
  )
  {
    System.Type t = typeof(T) ;

    if ( !typ.ContainsKey ( t ) )
    {
      Proptionary props = new Proptionary() ;

      foreach ( System.Reflection.PropertyInfo pi in t.GetProperties() )
      {
        foreach ( ConfigValueAttribute att in pi.GetCustomAttributes ( typeof(ConfigValueAttribute) , false ) )
        {
          props [ pi ] = att.Value ;
        }
      }
      typ [ t ] = props ;
    }

    foreach ( Prop prop in typ [ t ] )
    {
      try
      {
        prop.Key.SetValue
        (
          Source
        ,
          System.Convert.ChangeType
          (
            prop.Value
          ,
            prop.Key.PropertyType
          )
        ,
          null
        ) ;
      }
      catch
      {
        /* Leave it at the default */
      }
    }
    return ( Source ) ;
  }
}

public class SomeClass
{
  [ConfigValueAttribute("ConfigValueAttributeTest.xml","/ConfigValueAttributeTest/StringValue")]
  public string StringValue { get ; private set ; }

  [ConfigValueAttribute("ConfigValueAttributeTest.xml","/ConfigValueAttributeTest/StringValue/@AttValue")]
  public string AttValue    { get ; private set ; }

  [ConfigValueAttribute("ConfigValueAttributeTest.xml","/ConfigValueAttributeTest/NumValue")]
  public int    IntValue    { get ; private set ; }

  [ConfigValueAttribute("ConfigValueAttributeTest.xml","/ConfigValueAttributeTest/NumValue")]
  public double DoubleValue { get ; private set ; }

  public SomeClass
  (
  )
  {
    ConfigValueAttribute.Apply ( this ) ;

    return ;
  }
}




SomeClass x = new SomeClass() ;

System.Console.WriteLine ( "StringValue = {0}" , x.StringValue ) ;
System.Console.WriteLine ( "AttValue    = {0}" , x.AttValue    ) ;
System.Console.WriteLine ( "IntValue    = {0}" , x.IntValue    ) ;
System.Console.WriteLine ( "DoubleValue = {0}" , x.DoubleValue ) ;




<ConfigValueAttributeTest>
  <StringValue AttValue='ATAT' >Test</StringValue>
  <NumValue>3.14</NumValue>
</ConfigValueAttributeTest>

Option Strict Off
Option Explicit On

Imports System.Reflection

Namespace Attributes

    <AttributeUsage(AttributeTargets.Field Or AttributeTargets.Property)> Public Class NotEmptyAttribute
        Inherits attribBase

        Implements ITest

        Private mstrDependantPropName As String

        Public Sub New(Optional ByVal strDependantPropName As String = "")
            mstrDependantPropName = strDependantPropName
        End Sub

        Public Function GetRule() As String Implements ITest.GetRule
            Return "The value cannot be a zero length (empty) string"
        End Function

        Public Function TestCondition(ByVal Value As Object, ByRef cls As Object) As Boolean Implements ITest.TestCondition

            If Value Is Nothing Then Return True

            Dim lStr As String = CType(Value, String)

            If Not lStr.Equals(String.Empty) Then Return False

            '--------------------------------------------------------------------------------------

            If mstrDependantPropName.Equals(String.Empty) Then
                Return True
            End If

            '--------------------------------------------------------------------------------------

            Dim lStrPropType As String = String.Empty
            Dim lObjVal As Object = Nothing

            If SetLocalObjects(mstrDependantPropName, cls, lStrPropType, lObjVal) = False Then Return False

            '--------------------------------------------------------------------------------------

            Return TestDependant(lStrPropType, lObjVal)

        End Function

    End Class

End Namespace

Option Strict Off
Option Explicit On

Imports System.Reflection

Namespace Attributes

    <AttributeUsage(AttributeTargets.Field Or AttributeTargets.Property)> Public Class attribBase
        Inherits System.Attribute

        Protected Overridable Function SetLocalObjects(ByVal propName As String, ByRef cls As Object, ByRef strPropType As String, ByRef objVal As Object) As Boolean

            Dim t As Type = cls.GetType
            Dim m As System.Reflection.MemberInfo() = t.GetMember(propName)

            If m.Length < 1 Then Return False

            Dim pi As PropertyInfo
            Dim fi As FieldInfo

            If TypeOf m(0) Is PropertyInfo Then
                pi = t.GetProperty(propName)
                strPropType = pi.PropertyType.ToString
                objVal = pi.GetValue(cls, Nothing)
            Else
                fi = t.GetField(propName)
                strPropType = fi.FieldType.ToString
                objVal = fi.GetValue(cls)
            End If

            Return True

        End Function

        Protected Overridable Function TestDependant(ByVal strPropType As String, ByVal objVal As Object) As Boolean

            Select Case strPropType
                Case GetType(Boolean).ToString
                    If CType(objVal, Boolean).Equals(False) Then Return False

                Case GetType(DateTime).ToString
                    If CType(objVal, DateTime).Equals(DateTime.MinValue) Then Return False

                Case GetType(String).ToString
                    If CType(objVal, String).Equals(String.Empty) Then Return False

                Case GetType(Guid).ToString
                    If CType(objVal, Guid).Equals(Guid.Empty) Then Return False

                Case GetType(Int32).ToString
                    If CType(objVal, Int32).Equals(CType(0, Int32)) Then Return False

                Case GetType(Int16).ToString
                    If CType(objVal, Int16).Equals(CType(0, Int16)) Then Return False

                Case GetType(Byte).ToString
                    If CType(objVal, Byte).Equals(CType(0, Byte)) Then Return False

            End Select

            Return True

        End Function

    End Class

End Namespace

[Table("MyFooTable")]
{

  [Column("ColumnName", DbType.Varchar, 255)]
  public string Bar {get; set}
  
  [Column]
  public string Baz {get; set}

}