CodeDOMコード生成を使用して反復パターンを実装する

private static Contact BuildContact(
   Contacts.ContactRow contactRow)
{
   Contact contact = null;         
   switch(contactRow.ContactType)
   {
      case 0:
         contact = new Contact();
         break;
      case 1:
         Employee asEmployee = new Employee();
         asEmployee.Salary = contactRow.Salary;
         asEmployee.EmployeeNumber = 
            contactRow.EmployeeNumber;
         asEmployee.MailStop = contactRow.MailStop;
         asEmployee.Title = (Employee.JobTitle) 
            contactRow.Title ;
         contact = asEmployee;
         break;
      default:
         throw new Exception("Unknown ContactType");
   }
   contact.BirthDate=contactRow.BirthDate;
   contact.FamilyName=contactRow.FamilyName;
   contact.GivenName=contactRow.GivenName;

   return contact;
}

private void EditContact(Contact contact)
{
   Employee employee = contact as Employee;
   bool isEmployee = employee != null;

   this.tbEmployeeNo.Enabled = isEmployee;
   this.tbMailStop.Enabled = isEmployee;
   this.nudSalary.Enabled = isEmployee;
   this.cbTitle.Enabled = isEmployee;

   this.tbGivenName.Text=contact.GivenName;
   this.tbFamilyName.Text=contact.FamilyName;
   this.dtpBirthDate.Value = contact.BirthDate;

   if(isEmployee)
   {
      this.tbEmployeeNo.Text = 
         employee.EmployeeNumber.ToString();
      this.tbMailStop.Text = employee.MailStop;
      this.cbTitle.SelectedItem = employee.Title;
      this.nudSalary.Value=employee.Salary;
   }
   return;
}

private static Contact BuildContact(
   Contacts.ContactRow contactRow)
{
   ContactPropertyUnion.TypeEnum type = 
      (ContactPropertyUnion.TypeEnum)
      contactRow.ContactType;
   ContactPropertyUnion union = new 
      ContactPropertyUnion(type);

   union.Salary = contactRow.Salary;
   union.EmployeeNumber = contactRow.EmployeeNumber;
   union.MailStop = contactRow.MailStop;
   union.Title = (Employee.JobTitle) 
      contactRow.Title ;
   union.BirthDate=contactRow.BirthDate;
   union.FamilyName=contactRow.FamilyName;
   union.GivenName=contactRow.GivenName;

   return union.Wrapped;
}

private void EditContact(Contact contact)
{
   ContactPropertyUnion wrapper = new 
      ContactPropertyUnion(contact);

   this.tbEmployeeNo.Enabled = 
      wrapper.HasEmployeeNumberGetter;
   this.tbMailStop.Enabled = 
      wrapper.HasMailStopGetter;
   this.nudSalary.Enabled = wrapper.HasSalaryGetter;
   this.cbTitle.Enabled = wrapper.HasTitleGetter;

   this.tbGivenName.Text=wrapper.GivenName;
   this.tbFamilyName.Text=wrapper.FamilyName;
   this.dtpBirthDate.Value = wrapper.BirthDate;
   this.tbEmployeeNo.Text = 
      wrapper.EmployeeNumber.ToString();
   this.tbMailStop.Text = wrapper.MailStop;
   this.cbTitle.SelectedItem = wrapper.Title; 
   this.nudSalary.Value=wrapper.Salary;

   return;
}

internal ContactPropertyUnion(TypeEnum toBuild)
{
   if (toBuild == TypeEnum.Contact)
   {
      this.wrapped = new Contact();
      return;
   }
   if (toBuild == TypeEnum.Employee)
   {
      this.wrapped = new Employee();
      return;
   }
   throw new ArgumentException("Unknown enum value.");
}

internal int EmployeeNumber
{
   get
   {
      int outVal = new int();
      if ( wrapped is Employee )
      {
         outVal = (wrapped as 
            Employee).EmployeeNumber;
      }
      return outVal;
   }
   set
   {
      if (wrapped is Employee)
      {
         (wrapped as Employee).EmployeeNumber = value;
      }
      return;
   }
}

internal bool HasEmployeeNumberGetter
{
   get
   {
       return wrapped is Employee;
   }
}

public class InheritanceTree
{

   /// <summary>
   /// Tree root.
   /// </summary>
   private Type root;
   
   
   /// <summary>
   /// Gets/Sets the tree root.
   /// </summary>
   /// <remarks>
   /// Throws an exception on set if the specified value isn’t a member of the tree.
   /// </remarks>
   public Type Root
   {
      get{return root;}
      set
      {
         foreach(Type leaf in leaves)
         {
            if( !leaf.IsSubclassOf(value) )
            {
               throw new ArgumentException("Root must be a supertype of all leaves.");
            }
         }  

         root = value;
      }
   }

   private TypeCollection leaves;

   /// <summary>
   /// Gets a collection of inheritance tree leaves.
   /// </summary>
   public TypeCollection Leaves
   {
      get{return this.leaves;}
   }

   /// <summary>
   /// Enumerates property types-- getter and setter.
   /// </summary>
   public enum PropertyType
   {
      Reader,
      Writer,
   }

   /// <summary>
   /// Gets a TypeCollection holding all types that implement a specified property.
   /// </summary>
   /// <param name="propertyName"></param>
   /// <param name="propertyType"></param>
   /// <returns></returns>
   public TypeCollection GetPropertyImplementers( string propertyName, PropertyType propertyType )
   {
      TypeCollection implementingTypes = new TypeCollection();
      foreach ( Type type in this.GetAllTypes() )
      {
         PropertyInfo prop = type.GetProperty(propertyName);
         if( prop!=null && 
               ((propertyType==PropertyType.Reader && prop.CanRead)  
               ||
               (propertyType==PropertyType.Writer && prop.CanWrite))
            )
         {
            implementingTypes.Add(type);
         }
      }
      return implementingTypes;
   }

   /// <summary>
   /// 
   /// </summary>
   /// <returns></returns>
   public PropertyInfo[] GetPropertyUnion()
   {
      ArrayList propertyInfos = new ArrayList();
      StringCollection propertyNames = new StringCollection();
      foreach( Type type in GetAllTypes() )
      {
         foreach( PropertyInfo property in type.GetProperties() )
         {
            //TODO: Worry about getters and setters.
            if( !propertyNames.Contains(property.Name) )
            {
               propertyInfos.Add(property);
               propertyNames.Add(property.Name);
            }
         }
      }
      PropertyInfo[] props = new PropertyInfo[propertyInfos.Count];
      propertyInfos.CopyTo(props);
      return props;
   }

   public TypeCollection GetAllTypes()
   {
      TypeCollection allTypes = new TypeCollection();
      allTypes.Add(this.root);
      foreach(Type type in this.leaves)
      {
         allTypes.Add(type);
      }
      return allTypes;
   }

   public InheritanceTree()
   {
      leaves = new TypeCollection();
      root = typeof(object);
      leaves.BeforeInsert+=new TypeCollection.InsertHandler(OnBeforeInsert);
      leaves.BeforeSet+=new TypeCollection.SetHandler(OnBeforeSet);
      return;
   }

   private void OnBeforeInsert(int index, Type value)
   {
      if( !value.IsSubclassOf(root) )
      {
         throw new ArgumentException("Specified leaf is not a subtype of the current tree.");
      }
      return;
   }

   private void OnBeforeSet(int index, Type oldValue, Type newValue)
   {
      if( !newValue.IsSubclassOf(root) )
      {
         throw new ArgumentException("Specified leaf is not a subtype of the current tree.");
      }
      return;
   }
}

new CodeAssignStatement(propRef, Build.Value);

new CodeAssignStatement(propRef, new 
   CodePropertySetValueReferenceExpression() );

someExpression = value;

TypeCollection allTypes = 
   inheritanceTree.GetAllTypes();
_typeEnum = new CodeTypeDeclaration( "TypeEnum" );
_typeEnum.IsEnum=true;

for(int i = 0; i<allTypes.Count; i++)
{
   Type t = allTypes[i];

   CodeMemberField field = new CodeMemberField();
   field.Name=t.Name;
   field.InitExpression= new 
      CodePrimitiveExpression(i);

   _typeEnum.Members.Add(field);
}

private CodeConstructor BuildDefaultCtor()
{
   CodeConstructor defaultConstructor = new 
      CodeConstructor();
   defaultConstructor.Attributes =
      MemberAttributes.Private;

   return defaultConstructor;
}

private ContactPropertyUnion()
{
}

private CodeConstructor BuildWrapperCtor()
{
   CodeConstructor wrapCtor = new CodeConstructor();
   wrapCtor.Attributes=defaultVisibility;
   
   //Setup the single parameter.
   CodeParameterDeclarationExpression toWrapParam = 
      new CodeParameterDeclarationExpression();
   toWrapParam.Name="toWrap";
   toWrapParam.Type = new CodeTypeReference( 
      inheritanceTree.Root );
   wrapCtor.Parameters.Add(toWrapParam);

   //Assign the parameter to the data member.
   CodeAssignStatement assign = new 
      CodeAssignStatement();
   assign.Left = WrappedFieldReference;
   assign.Right = new CodeVariableReferenceExpression(
      toWrapParam.Name);
   wrapCtor.Statements.Add(assign);

   return wrapCtor;
}

internal ContactPropertyUnion(Contact toWrap)
{
   wrapped=toWrap;
}

/// <summary>
/// Builds an property to access the 
/// specified property of the wrapped object. 
/// If the wrapped object doesn’t actually implement 
/// the specified property, then just return 
/// a default value.
/// </summary>
/// <param name="toWrap"></param>
/// <returns></returns>
private CodeMemberProperty BuildAccessor(PropertyInfo toWrap)
{
   CodeMemberProperty prop = new CodeMemberProperty();
   prop.Name=toWrap.Name;
   prop.HasGet=toWrap.CanRead;
   prop.HasSet=toWrap.CanWrite;
   prop.Type= new CodeTypeReference( toWrap.PropertyType );
   prop.Attributes = this.DefaultVisibility;

   if(toWrap.CanRead)
   {
      CodeVariableDeclarationStatement outValDeclaration = 
         new CodeVariableDeclarationStatement(
         prop.Type, "outVal");
      outValDeclaration.InitExpression = Build.Default(
         toWrap.PropertyType);
      prop.GetStatements.Add( outValDeclaration );

      TypeCollection implementers =
         this.InheritanceTree.GetPropertyImplementers(
         toWrap.Name, InheritanceTree.PropertyType.Reader);

      // Since CodeDOM can’t represent a switch statement,
      // we’ll have to get by with nested "if"s.
      CodeStatementCollection bigBucket = new 
         CodeStatementCollection();
      CodeStatementCollection currentBucket = bigBucket;
      foreach( Type implementer in implementers )
      {
         CodeConditionStatement ifStatement = new 
            CodeConditionStatement();
         currentBucket.Add(ifStatement);
         ifStatement.Condition = Build.Is(
            implementer, WrappedField.Name);
         CodeCastExpression caster 
            = Build.Cast( 
               Build.TypeRef(implementer), 
              WrappedFieldReference );
                  
         CodePropertyReferenceExpression propRef 
            = new CodePropertyReferenceExpression();
         propRef.TargetObject= caster;
         propRef.PropertyName=toWrap.Name;

         CodeAssignStatement assignPropRefToOutVal 
            = new CodeAssignStatement();
         assignPropRefToOutVal.Left = 
            Build.VarRef(outValDeclaration);
         assignPropRefToOutVal.Right = propRef;

         ifStatement.TrueStatements.Add(assignPropRefToOutVal);

         currentBucket = ifStatement.FalseStatements;

      }
      prop.GetStatements.AddRange(bigBucket);

      CodeMethodReturnStatement returnStatement = Build.Return;
      returnStatement.Expression= 
         new CodeVariableReferenceExpression(
            outValDeclaration.Name);
      prop.GetStatements.Add(returnStatement);
   }
   

   if(toWrap.CanWrite)
   {
      TypeCollection implementers =
         InheritanceTree.GetPropertyImplementers(toWrap.Name,            
         InheritanceTree.PropertyType.Reader);

      CodeStatementCollection bigBucket = 
         new CodeStatementCollection();
      CodeStatementCollection currentBucket = bigBucket;
      foreach( Type implementer in implementers )
      {
         CodeConditionStatement ifStatement = 
            new CodeConditionStatement();
         currentBucket.Add(ifStatement);

         ifStatement.Condition = 
             Build.Is(implementer, WrappedField.Name);
         CodeCastExpression caster = Build.Cast( 
            Build.TypeRef(implementer), WrappedFieldReference );
                  
         CodePropertyReferenceExpression propRef = new
            CodePropertyReferenceExpression();
         propRef.TargetObject= caster;
         propRef.PropertyName=toWrap.Name;

         CodeAssignStatement assignPropRefToOutVal 
            = new CodeAssignStatement();
         assignPropRefToOutVal.Left = propRef;
         assignPropRefToOutVal.Right = Build.Value;

         ifStatement.TrueStatements.Add(assignPropRefToOutVal);

         currentBucket = ifStatement.FalseStatements;

      }
      prop.SetStatements.AddRange(bigBucket);

      prop.SetStatements.Add(Build.Return);

   }

   return prop;
}