Click here to Skip to main content
Click here to Skip to main content
Articles » Web Development » ASP.NET » General » Downloads
 
Add your own
alternative version
Go to top

Implementing Model-View-Presenter in ASP.NET

, 17 Nov 2007
Three implementations of Model-View-Presenter in ASP.NET 2.0.
MVPSampleApp.zip
MVP.SampleApp
Lib
Microsoft.Practices.EnterpriseLibrary.Common.dll
Microsoft.Practices.EnterpriseLibrary.Data.dll
MySql.Data.dll
nunit.framework.dll
Rhino.Mocks.dll
Model
Data
Interfaces
Properties
Presentation
Presentation.Tests
Properties
Interfaces
Properties
SubSonic
ActiveRecord
Builder
CodeGeneration
Templates
CodeLanguage
Configuration
Controls
Calendar
lang
skin
active-bg.gif
calendar.gif
dark-bg.gif
hover-bg.gif
menuarrow.gif
normal-bg.gif
rowhover-bg.gif
status-bg.gif
title-bg.gif
today-bg.gif
Resources
DataProviders
Properties
Sql Tools
SubSonic.snk
Sugar
WebApp
App_Data
Views
SQL2000SampleDb.zip
SQL2000SampleDb.msi
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Data;
using System.Text.RegularExpressions;
using SubSonic.Utilities;

namespace SubSonic
{
    [Serializable]
    public class TableSchema
    {
        [Serializable]
        public class ManyToManyDetailsCollection : List<ManyToManyDetails>
        {
        }

        [Serializable]
        public class ManyToManyDetails
        {
            private string linksToTable;

            public string LinksToTable
            {
                get { return linksToTable; }
                set { linksToTable = value; }
            }

            private string linksToColum;

            public string LinksToColumn
            {
                get { return linksToColum; }
                set { linksToColum = value; }
            }

            private string mapTableName;

            public string MapTableName
            {
                get { return mapTableName; }
                set { mapTableName = value; }
            }
        }

        [Serializable]
        public class ManyToManyRelationship : AbstractTableSchema
        {
            public ManyToManyRelationship(string tableName, DataProvider dataProvider)
            {
                Provider = dataProvider;
                mapTableName = tableName;
                Name = mapTableName;
                ClassName = TransformClassName(Name, false, TableType, Provider);
                ClassNamePlural = TransformClassName(Name, false, TableType, Provider);
                DisplayName = Utility.ParseCamelToProper(ClassName);
            }

            private string mapTableName;
            public string MapTableName
            {
                get { return mapTableName; }
                //set { mapTableName = value; }
            }

            private string mapTableLocalTableKeyColumn;
            public string MapTableLocalTableKeyColumn
            {
                get { return mapTableLocalTableKeyColumn; }
                set { mapTableLocalTableKeyColumn = value; }
            }

            private string mapTableForeignTableKeyColumn;
            public string MapTableForeignTableKeyColumn
            {
                get { return mapTableForeignTableKeyColumn; }
                set { mapTableForeignTableKeyColumn = value; }
            }

            private string foreignPrimaryKey;
            public string ForeignPrimaryKey
            {
                get { return foreignPrimaryKey; }
                set { foreignPrimaryKey = value; }
            }

            private string foreignTableName;
            public string ForeignTableName
            {
                get { return foreignTableName; }
                set
                {
                    foreignTableName = value;
                }
            }
        }

        [Serializable]
        public class ManyToManyRelationshipCollection : List<ManyToManyRelationship>
        {
        }

        [Serializable]
        public abstract class AbstractTableSchema
        {
            private DataProvider provider;
            public DataProvider Provider
            {
                get { return provider; }
                protected set { provider = value; }
            }
            
            private string _tableName;
            public string TableName
            {
                get { return _tableName; }
                set
                {
                    _tableName = value;
                    className = TransformClassName(Name, false, tableType, Provider);
                    classNamePlural = TransformClassName(Name, true, tableType, Provider);
                    displayName = Utility.ParseCamelToProper(ClassName);
                }
            }

            private TableType tableType;
            public TableType TableType
            {
                get { return tableType; }
                set { tableType = value; }
            }

            public string Name
            {
                get { return _tableName; }
                set { TableName = value;  }
            }

            private string className;
            public string ClassName
            {
                get { return className; }
                protected set { className = value; }
            }

            private string classNamePlural;
            public string ClassNamePlural
            {
                get { return classNamePlural; }
                protected set { classNamePlural = value; }
            }

            private string propertyName;
            public string PropertyName
            {
                get { return propertyName; }
                protected set { propertyName = value; }
            }

            private string displayName;
            public string DisplayName
            {
                get { return displayName; }
                protected set { displayName = value; }
            }

            private string schemaName;
            public string SchemaName
            {
                get { return schemaName; }
                set { schemaName = value; }
            }

            private ExtendedPropertyCollection extendedProperties = new ExtendedPropertyCollection();
            public ExtendedPropertyCollection ExtendedProperties
            {
                get { return extendedProperties; }
                set { extendedProperties = value; }
            }

            public static string TransformClassName(string name, bool isPlural, TableType tableType, DataProvider provider)
            {
                if(String.IsNullOrEmpty(name))
                    return string.Empty;

                string newName = name;
                if (tableType == TableType.Table)
                {
                    newName = Utility.StripText(newName, provider.StripTableText);
                }
                else if (tableType == TableType.View)
                {
                    newName = Utility.StripText(newName, provider.StripViewText);
                }

                newName = Utility.RegexTransform(newName, provider);
                newName = Utility.GetProperName(newName, provider.RemoveUnderscores);
                newName = Utility.IsStringNumeric(newName) ? "_" + newName : newName;
                newName = Utility.StripNonAlphaNumeric(newName);
                newName = newName.Trim();

                if(!isPlural)
                {
                    newName = provider.FixPluralClassNames ? Utility.PluralToSingular(newName) : newName;
                }

                return Utility.KeyWordCheck(newName, String.Empty, provider);
            }

            public void ApplyExtendedProperties()
            {

                ExtendedProperty epClassName =  ExtendedProperty.GetExtendedProperty(ExtendedProperties, ExtendedPropertyName.SSX_TABLE_CLASS_NAME_SINGULAR);
                ExtendedProperty epClassNamePlural = ExtendedProperty.GetExtendedProperty(ExtendedProperties, ExtendedPropertyName.SSX_TABLE_CLASS_NAME_PLURAL);
                ExtendedProperty epDisplayName = ExtendedProperty.GetExtendedProperty(ExtendedProperties, ExtendedPropertyName.SSX_TABLE_DISPLAY_NAME);

                if (epClassName != null)
                    className = epClassName.PropertyValue;
                if (epClassNamePlural != null)
                    classNamePlural = epClassNamePlural.PropertyValue;
                if (epDisplayName != null)
                    displayName = epDisplayName.PropertyValue;
            }
        }

        [Serializable]
        public class PrimaryKeyTable : AbstractTableSchema
        {
            public PrimaryKeyTable(DataProvider dataProvider)
            {
                Provider = dataProvider;
            }

            private string _columnName;
            public string ColumnName
            {
                get { return _columnName; }
                set
                {
                    _columnName = value;
                    PropertyName = TableColumn.TransformPropertyName(_columnName, TableName, Provider);
                }
            }
        }

        public class PrimaryKeyTableCollection : List<PrimaryKeyTable>
        {
        }


        [Serializable]
        public class ForeignKeyTable : AbstractTableSchema
        {
            public ForeignKeyTable(DataProvider dataProvider)
            {
                Provider = dataProvider;
            }

            private string _columnName;
            public string ColumnName
            {
                get { return _columnName; }
                set
                {
                    _columnName = value;
                    PropertyName = TableColumn.TransformPropertyName(_columnName, TableName, Provider);
                }
            }
        }

        public class ForeignKeyTableCollection : List<ForeignKeyTable>
        {
        }

        [Serializable]
        public class TableColumnSettingCollection : KeyedCollection<string, TableColumnSetting>
        {
            public bool IsDirty
            {
                get
                {
                    foreach (TableColumnSetting setting in this)
                    {
                        if (setting.IsDirty)
                            return true;
                    }
                    return false;
                }
                set
                {
                    foreach (TableColumnSetting setting in this)
                    {
                        setting.IsDirty = value;
                    }                    
                }
            }

            protected override string GetKeyForItem(TableColumnSetting item)
            {
                return item.ColumnName;
            }

            public object GetValue(string columnName)
            {
                return this[columnName.ToLower()].CurrentValue;
            }

            public T GetValue<T>(string columnName)
            {
                columnName = columnName.ToLower();
                object oVal = null;
                try
                {
                    oVal = this[columnName].CurrentValue;
                }
                catch
                {
                    throw new Exception("There's no column called '" + columnName + "' for this object");
                }
                if(oVal == null || oVal == DBNull.Value)
                {
                    return default(T);
                }

                Type type = typeof(T);
                if(IsNullable(type) || type == typeof(object))
                {
                    return (T)oVal;
                }

                Type valType = oVal.GetType();
                if(valType == typeof(Byte[]))
                {
                    return (T)Convert.ChangeType(oVal, valType);
                }


                return (T)Convert.ChangeType(oVal, type);
            }

            public static bool IsNullable(Type objType)
            {
                if(!objType.IsGenericType)
                {
                    return false;
                }
                return objType.GetGenericTypeDefinition().Equals(typeof(Nullable<>));
            }

            public void SetValue(string columnName, object oVal)
            {
                columnName = columnName.ToLower(); //EK: Why is this necessary? This method is the only place where ColumnName is set.
                if(!Contains(columnName))
                {
                    Add(new TableColumnSetting(columnName, oVal));
                }
                else
                {
                    this[columnName].CurrentValue = oVal;
                }
            }
        }


        /// <summary>
        /// This is an intermediary class that holds the current value of a table column
        /// for each object instance.
        /// </summary>
        [Serializable]
        public class TableColumnSetting
        {
            public TableColumnSetting(string columnName, object currentValue)
            {
                _columnName = columnName;
                _currentValue = currentValue;
            }

            private readonly string _columnName;
            public string ColumnName
            {
                get { return _columnName; }
            }

            private object _currentValue;

            public object CurrentValue
            {
                get { return _currentValue; }
                set {
                    if (value == null && _currentValue == null)
                        return;

                    if (value != null)
                    {
                        if (value.Equals(_currentValue))
                            return;                        
                    }

                    _currentValue = value;
                    _isDirty = true;
                }
            }

            private bool _isDirty = false;
            public bool IsDirty
            {
                get { return _isDirty; }
                set { _isDirty = value; }
            }
        }

        [Serializable]
        public class TableCollection : List<Table>
        {
            public Table this[string tableName]
            {
                get
                {
                    Table result = null;
                    foreach(Table tbl in this)
                    {
                        if(Utility.IsMatch(tbl.Name, tableName))
                        {
                            result = tbl;
                            break;
                        }
                    }
                    return result;
                }
                set
                {
                    int index = 0;
                    foreach(Table tbl in this)
                    {
                        if(Utility.IsMatch(tbl.Name, tableName))
                        {
                            this[index] = value;
                            break;
                        }
                        index++;
                    }
                }
            }
        }


        /// <summary>
        /// Holds information about the base table - this class should be 
        /// static for each object
        /// </summary>
        [Serializable]
        public class Table : AbstractTableSchema
        {
            public Table(DataProvider dataProvider)
            {
                Provider = dataProvider;
            }

            public Table(string tableName, TableType tblType, DataProvider dataProvider)
            {
                Provider = dataProvider;
                TableType = tblType;
                Name = tableName;
            }

            private ManyToManyRelationshipCollection manyToManys = new ManyToManyRelationshipCollection();
            public ManyToManyRelationshipCollection ManyToManys
            {
                get { return manyToManys; }
                set { manyToManys = value; }
            }

            private PrimaryKeyTableCollection _primaryKeys = new PrimaryKeyTableCollection();
            public PrimaryKeyTableCollection PrimaryKeyTables
            {
                get { return _primaryKeys; }
                set { _primaryKeys = value; }
            }

            private ForeignKeyTableCollection _foreignKeys = new ForeignKeyTableCollection();
            public ForeignKeyTableCollection ForeignKeys
            {
                get { return _foreignKeys; }
                set { _foreignKeys = value; }
            }

            public bool HasForeignKeys()
            {
                return ForeignKeys.Count > 0;
            }

            private bool _hasManyToMany = false;
            public bool HasManyToMany
            {
                get { return _hasManyToMany; }
                set { _hasManyToMany = value; }
            }

            private TableColumnCollection columns;
            public TableColumnCollection Columns
            {
                get { return columns; }
                set { columns = value; }
            }

            private TableColumn primaryKey;
            public TableColumn PrimaryKey
            {
                get
                {
                    if(columns != null)
                    {
                        primaryKey = columns.GetPrimaryKey();
                    }
                    return primaryKey;
                }
            }

            private TableColumn[] primaryKeys;
            public TableColumn[] PrimaryKeys
            {
                get
                {
                    if (columns != null)
                    {
                        primaryKeys = columns.GetPrimaryKeys();
                    }
                    return primaryKeys;
                }
            }

            public TableColumn GetColumn(string columnName)
            {
                TableColumn col = null;
                foreach(TableColumn column in Columns)
                {
                    if(Utility.IsMatch(column.ColumnName.Trim(), columnName.Trim()))
                    {
                        col = column;
                        break;
                    }
                }
                return col;
            }
        }


        [Serializable]
        public class TableColumnCollection : List<TableColumn>
        {
            #region Collection Methods

            public bool Contains(string columnName)
            {
                bool bOut = false;
                foreach(TableColumn col in this)
                {
                    if(Utility.IsMatch(col.ColumnName, columnName))
                    {
                        bOut = true;
                        break;
                    }
                }
                return bOut;
            }

            public void Add(Table tbl, string name, DbType dbType, bool isNullable, bool isPrimaryKey, bool isForeignKey)
            {
                TableColumn col = new TableColumn(tbl);
                col.IsPrimaryKey = isPrimaryKey;
                col.IsForeignKey = isForeignKey;
                col.IsNullable = isNullable;
                col.DataType = dbType;
                col.ColumnName = name;

                if(!Contains(name))
                {
                    Add(col);
                }
            }

            public void Add(Table tbl, string name, DbType dbType, bool isNullable)
            {
                Add(tbl, name, dbType, isNullable, false, false);
            }

            #endregion

            public TableColumn GetColumn(string columnName)
            {
                TableColumn coll = null;
                foreach(TableColumn child in this)
                {
                    if(Utility.IsMatch(child.ColumnName, columnName))
                    {
                        coll = child;
                        break;
                    }
                }
                return coll;
            }

            public TableColumn GetPrimaryKey()
            {
                TableColumn coll = null;
                foreach(TableColumn child in this)
                {
                    if(child.IsPrimaryKey)
                    {
                        coll = child;
                        break;
                    }
                }
                return coll;
            }

            public TableColumn[] GetPrimaryKeys()
            {
                List<TableColumn> list = new List<TableColumn>();
                foreach (TableColumn child in this)
                {
                    if (child.IsPrimaryKey)
                    {
                        list.Add(child);
                    }
                }

                return list.ToArray();
            }
        }

        /// <summary>
        /// A helper class to help define the columns in an underlying table
        /// </summary>
        [Serializable]
        public class TableColumn
        {
            public TableColumn(Table tableSchema)
            {
                table = tableSchema;
            }

            public Type GetPropertyType()
            {
                string systemType = Utility.GetSystemType(dbType);
                Type t = Type.GetType(systemType);
                return t;
            }

            private string defaultSetting;

            public string DefaultSetting {
                get { return defaultSetting; }
                set { defaultSetting = value; }
            }
	

            private Table table;
            public Table Table
            {
                get { return table; }
            }

            private bool isForeignKey;
            public bool IsForeignKey
            {
                get { return isForeignKey; }
                set { isForeignKey = value; }
            }

            private string foreignKeyTableName;
            public string ForeignKeyTableName
            {
                get { return foreignKeyTableName; }
                set { foreignKeyTableName = value; }
            }

            private string schemaName;
            public string SchemaName
            {
                get { return schemaName; }
                set { schemaName = value; }
            }

            private bool isPrimaryKey;
            public bool IsPrimaryKey
            {
                get { return isPrimaryKey; }
                set { isPrimaryKey = value; }
            }

            private bool isNullable;
            public bool IsNullable
            {
                get { return isNullable; }
                set { isNullable = value; }
            }

            private bool isReadOnly;
            public bool IsReadOnly
            {
                get { return isReadOnly; }
                set { isReadOnly = value; }
            }

            private DbType dbType;
            public DbType DataType
            {
                get { return dbType; }
                set { dbType = value; }
            }

            private int maxLength;
            public int MaxLength
            {
                get { return maxLength; }
                set { maxLength = value; }
            }
       
            private string columnName;
            public string ColumnName
            {
                get { return columnName; }
                set
                {
                    columnName = value;
                    string transformColumnName = columnName;

                    propertyName = TransformPropertyName(transformColumnName, Table.ClassName, table.Provider);
                    displayName = TransformPropertyName(transformColumnName, Table.ClassName, table.Provider);

                    displayName = Utility.ParseCamelToProper(displayName);
                    if((!Sugar.Validation.IsUpperCase(displayName)) && (IsPrimaryKey || IsForeignKey) && displayName.Length > 1)
                    {
                        string strEnd = displayName.Substring(displayName.Length - 2, 2);
                        if(Utility.IsMatch(strEnd, "id") && strEnd[0].ToString() == "I")
                        {
                            displayName = displayName.Substring(0, displayName.Length - 2);
                        }
                    }
                    parameterName = Utility.PrefixParameter(columnName, Table.Provider);
                    argumentName = "var" + propertyName;
                }
            }

            private string parameterName;   
            public string ParameterName
            {
                get { return parameterName; }
            }

            private string propertyName;
            public string PropertyName
            {
                get {
                    return propertyName; 
                
                }
            }

            private string displayName;
            public string DisplayName
            {
                get { return displayName; }
            }

            private string argumentName;
            public string ArgumentName
            {
                get { return argumentName; }
            }

            private bool autoIncrement;
            public bool AutoIncrement
            {
                get { return autoIncrement; }
                set { autoIncrement = value; }
            }

            private int numberScale;
            public int NumberScale
            {
                get { return numberScale; }
                set { numberScale = value; }
            }

            private int numberPrecision;
            public int NumberPrecision
            {
                get { return numberPrecision; }
                set { numberPrecision = value; }
            }

            public bool IsNumeric
            {
                get
                {
                    return DataType == DbType.Currency ||
                           DataType == DbType.Decimal ||
                           DataType == DbType.Double ||
                           DataType == DbType.Int16 ||
                           DataType == DbType.Int32 ||
                           DataType == DbType.Int64 ||
                           DataType == DbType.Single ||
                           DataType == DbType.UInt16 ||
                           DataType == DbType.UInt32 ||
                           DataType == DbType.UInt64 ||
                           DataType == DbType.VarNumeric;
                }
            }

            public bool IsDateTime
            {
                get
                {
                    return DataType == DbType.DateTime ||
                           DataType == DbType.Time ||
                           DataType == DbType.Date;
                }
            }

            public bool IsString
            {
                get
                {
                    return DataType == DbType.AnsiString ||
                           DataType == DbType.AnsiStringFixedLength ||
                           DataType == DbType.String ||
                           DataType == DbType.StringFixedLength;
                }
            }

            public static string TransformPropertyName(string name, string table, DataProvider provider)
            {
                if (String.IsNullOrEmpty(name))
                    return string.Empty;

                string newName = name;

                newName = Utility.StripText(newName, provider.StripColumnText);
                newName = Utility.RegexTransform(newName, provider);
                newName = Utility.GetProperName(newName, provider.RemoveUnderscores);
                newName = Utility.IsStringNumeric(newName) ? "_" + newName : newName;
                newName = Utility.StripNonAlphaNumeric(newName);
                newName = newName.Trim();
                return Utility.KeyWordCheck(newName, table, provider);
            }

            private ExtendedPropertyCollection extendedProperties = new ExtendedPropertyCollection();
            public ExtendedPropertyCollection ExtendedProperties
            {
                get { return extendedProperties; }
                set { extendedProperties = value; }
            }

            public void ApplyExtendedProperties()
            {

                ExtendedProperty epPropertyName = ExtendedProperty.GetExtendedProperty(ExtendedProperties, ExtendedPropertyName.SSX_COLUMN_PROPERTY_NAME);
                ExtendedProperty epDisplayName = ExtendedProperty.GetExtendedProperty(ExtendedProperties, ExtendedPropertyName.SSX_COLUMN_DISPLAY_NAME);

                if (epPropertyName != null)
                    propertyName = epPropertyName.PropertyValue;
                if (epDisplayName != null)
                    displayName = epDisplayName.PropertyValue;
            }
        }

        public class ExtendedPropertyCollection : KeyedCollection<string, ExtendedProperty>
        {
            protected override string GetKeyForItem(ExtendedProperty extendedProperty)
            {
                return extendedProperty.PropertyName;
            }
        }

        public class ExtendedProperty
        {
            public ExtendedProperty(string name, string value)
            {
                propertyName = name;
                propertyValue = value;
            }

            private string propertyName;
            public string PropertyName
            {
                get { return propertyName; }
                set { propertyName = value; }
            }

            private string propertyValue;
            public string PropertyValue
            {
                get { return propertyValue; }
                set { propertyValue = value; }
            }

            public static ExtendedProperty GetExtendedProperty(ExtendedPropertyCollection exPropCol, string extendedPropertyName)
            {
                ExtendedProperty exProperty = null;
                if (exPropCol.Contains(extendedPropertyName))
                {
                    exProperty = exPropCol[extendedPropertyName];
                    if (String.IsNullOrEmpty(exProperty.PropertyValue))
                    {
                        exProperty = null;
                    }
                }
                return exProperty;
            }

        }
    }
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Alex Mueller
Web Developer
United States United States
No Biography provided

You may also be interested in...

| Advertise | Privacy | Mobile
Web01 | 2.8.140916.1 | Last Updated 17 Nov 2007
Article Copyright 2007 by Alex Mueller
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid