Developer Stuff!

Learn jQuery with FireBug, jQuerify and SelectorGadget

2009-09-21T16:41:00.000-07:00

Learn how Dave Ward (@encosia) uses FireBug, jQuerify and SelectorGadget to learn jQuery and any other client-side technology. Hosted by Craig Shoemaker (@craigshoemaker) for the Polymorphic Podcast http://polymorphicpodcast.com/

LINQ: Building an IQueryable Provider - Part III

2009-09-02T20:45:00.001-07:00

This post is the third in a series of posts covering how to build a LINQ IQueryable provider. If you have not read the previous posts, please do so before proceeding.

Complete list of posts in the Building an IQueryable Provider series

Part III? Wasn’t I done in the last post? Didn’t I have the provider actually working, translating, executing and returning a sequence of objects?

Sure, that’s true, but only just so. The provider I built was really fragile. It only understood one major query operator and a few minor ones like comparison, etc. However, real providers are going to have to deal with many more operators and complicated interactions between them. For example, that provider did not even let you project the data into new shapes. How one goes about doing that is non-obvious.

Translating Local Variable References

string city = "London";
var query = db.Customers.Where(c => c.City == city);

What happens when we try to translate that? Go ahead try it. I’m waiting.

Bam! You get an exception, “The member 'city' is not supported.” What does that mean? I thought the ‘member’ city was one of the columns. Well, it is. What the exception is referring to is the local variable ‘city’. Yet, how is that a ‘member’?

Take a look at the ToString() translation of the expression tree.

Console.WriteLine(query.Expression.ToString());

Here’s what you get: SELECT * FROM Customers.Where(c => return (c.City = value(Sample.Program+<>c__DisplayClass0).city))

Aha! The c# compile has made a class to hold local variables that are being referenced in the lambda expression. This is the same thing it does when local variables are referenced inside an anonymous method. But you already knew that. Didn’t you? No? Regardless, if I want to have my provider work with references to local variables I’m going to have to deal with it. Maybe I can just recognize field references to these compiler generated types? How do I identify a compiler generated type? By name? What if the c# compiler changes how they name them? What if another language uses a different scheme? Are local variables the only interesting case? What about references to member variables in scope at the time? Those aren’t going to be encoded as values in the tree either are they? At best they will be a constant node referencing the instance the member is on and then a MemberAccess node that accesses the member off that instance. Can I just recognize any member access against a constant node and evaluated it by hand using reflection? Maybe. What if the compiler generates something more complicated? Okay, what I’m going to give you is a general purpose solution that will turn these compiler generated trees into something much more palatable, more like the trees you thought you were getting before I pointed out this mess. What I really want to do is identify sub-trees in the overall tree that can be immediately evaluated and turned into values. If I can do this, then the rest of the translator only needs to deal with these values. Thank goodness I already have the ExpressionVisitor defined. I can use that and invent a pretty simple rule to determine what is sub-tree that can be evaluated locally. Take a look at the code first and then I’ll explain how it does what it does.

public static class Evaluator
        {
            /// <summary>
            /// Performs evaluation & replacement of independent sub-trees
            /// </summary>
            /// <param name="expression">The root of the expression tree.</param>
            /// <param name="fnCanBeEvaluated">A function that decides whether a given expression node can be part of the local function.</param>
            /// <returns>A new tree with sub-trees evaluated and replaced.</returns>
            public static Expression PartialEval(Expression expression, Func<Expression, bool> fnCanBeEvaluated)
            {
                return new SubtreeEvaluator(new Nominator(fnCanBeEvaluated).Nominate(expression)).Eval(expression);
            }
            /// <summary>
            /// Performs evaluation & replacement of independent sub-trees
            /// </summary>
            /// <param name="expression">The root of the expression tree.</param>
            /// <returns>A new tree with sub-trees evaluated and replaced.</returns>
            public static Expression PartialEval(Expression expression)
            {
                return PartialEval(expression, Evaluator.CanBeEvaluatedLocally);
            }

            private static bool CanBeEvaluatedLocally(Expression expression)
            {
                return expression.NodeType != ExpressionType.Parameter;
            }

            /// <summary>
            /// Evaluates & replaces sub-trees when first candidate is reached (top-down)
            /// </summary>
            class SubtreeEvaluator : ExpressionVisitor
            {
                HashSet<Expression> candidates;
                internal SubtreeEvaluator(HashSet<Expression> candidates)
                {
                    this.candidates = candidates;
                }

                internal Expression Eval(Expression exp)
                {
                    return this.Visit(exp);
                }

                protected override Expression Visit(Expression exp)
                {
                    if (exp == null)
                    {
                        return null;
                    }
                    if (this.candidates.Contains(exp))
                    {
                        return this.Evaluate(exp);
                    }
                    return base.Visit(exp);
                }

                private Expression Evaluate(Expression e)
                {
                    if (e.NodeType == ExpressionType.Constant)
                    {
                        return e;
                    }
                    LambdaExpression lambda = Expression.Lambda(e);
                    Delegate fn = lambda.Compile();
                    return Expression.Constant(fn.DynamicInvoke(null), e.Type);
                }
            }

            /// <summary>
            /// Performs bottom-up analysis to determine which nodes can possibly
            /// be part of an evaluated sub-tree.
            /// </summary>
            class Nominator : ExpressionVisitor
            {
                Func<Expression, bool> fnCanBeEvaluated;
                HashSet<Expression> candidates;
                bool cannotBeEvaluated;

                internal Nominator(Func<Expression, bool> fnCanBeEvaluated)
                {
                    this.fnCanBeEvaluated = fnCanBeEvaluated;
                }

                internal HashSet<Expression> Nominate(Expression expression)
                {
                    this.candidates = new HashSet<Expression>();
                    this.Visit(expression);
                    return this.candidates;
                }

                protected override Expression Visit(Expression expression)
                {
                    if (expression != null)
                    {
                        bool saveCannotBeEvaluated = this.cannotBeEvaluated;
                        this.cannotBeEvaluated = false;
                        base.Visit(expression);
                        if (!this.cannotBeEvaluated)
                        {
                            if (this.fnCanBeEvaluated(expression))
                            {
                                this.candidates.Add(expression);
                            }
                            else
                            {
                                this.cannotBeEvaluated = true;
                            }
                        }
                        this.cannotBeEvaluated |= saveCannotBeEvaluated;
                    }
                    return expression;
                }
            }
        }

The Evaluator class exposes a static method ‘PartialEval’ that you can call to evaluate these sub-trees in your expression, leaving only constant nodes with actual values in their place.

The majority of this code is the demarking of maximal sub-trees that can be evaluated in isolation. The actual evaluation is trivial since the sub-trees can be ‘compiled’ using LambaExpression.Compile, turned into a delegate and then invoked. You can see this happening in the SubtreeVisitor.Evaluate method.

The process of determining maximal sub-trees happens in two steps. First by a bottom-up walk in the Nominator class that determines which nodes could possibly be evaluated in isolation and then a top-down walk in SubtreeEvaluator that finds highest nodes representing sub-trees that were nominated.

The Nominator is parameterized by a function that you supply that can employ whatever heuristics you want to determine if some given node can be evaluated in isolation. The default heuristic is that any node except ExpresssionType.Parameter can be evaluated in isolation. Beyond that, a general rule states that if a child node cannot be evaluated locally then the parent node cannot either. Therefore, any node upstream of a parameter cannot be evaluated and will remain in the tree. Everything else will be evaluated and replaced as constants.

Now that I have this class I can put it to work by using it whenever I go about translating expression trees. Fortunately, I already have this operation factored out into the ‘Translate’ method on the DbQueryProvider class.

public class DbQueryProvider : QueryProvider {
        private string Translate(Expression expression) {
        expression = Evaluator.PartialEval(expression);
        return new QueryTranslator().Translate(expression);

Now if we try the following code we get a better result:

string city = "London";
var query = db.Customers.Where(c => c.City == city);
Console.WriteLine("Query:\n{0}\n", query);

Which writes:

Query:
SELECT * FROM (SELECT * FROM Customers) AS T WHERE (City = 'London')

Exactly what I wanted. This provider is coming along nicely!

Maybe next time I’ll implement Select. J

Original post can be found here

LINQ: Building an IQueryable Provider - Part II

2009-09-01T19:13:00.001-07:00

This is the second post in a multi-post series on building LINQ providers using the IQueryable interface. If you are new to this series please read the following post before proceeding.

Complete list of posts in the Building an IQueryable Provider series

Now, that I’ve laid the groundwork defining a reusable version of IQueryable and IQueryProvider, namely Query<T> and QueryProvider, I’m going to build a provider that actually does something. As I said before, what a query provider really does is execute a little bit of ‘code’ defined as an expression tree instead of actual IL. Of course, it does not actually have to execute it in the traditional sense. For example, LINQ to SQL translates the query expression into SQL and sends it to the server to execute it.

My sample below is going to work much like LINQ to SQL in that it translates and executes a query against an ADO provider. However, I must add a disclaimer here, this sample is not a full-fledge provider in any sense. I’m only going to handle translating the ‘Where’ operation and I’m not even going to attempt to do anything more complicated than allow the predicate to contain a field reference and few simple operators. I may expand on this provider in the future, but for now it is mostly for illustrative purposes only. Please don’t cut and paste and expect to have ship-quality code.

The provider is going to basically do two things; 1) translate the query into a SQL command text and 2) translate the result of executing the command into objects.

The Query Translator

The query translator is going to simply visit each node in the query’s expression tree and translate the supported operations into text using a StringBuilder. For the sake of clarity assume there is a class called ExpressionVisitor that defines the base visitor pattern for Expression nodes. (I promise I’ll actually include the code for this at the end of the post but for now bear with me.)

internal class QueryTranslator : ExpressionVisitor
{
    StringBuilder sb;
    internal QueryTranslator()
    {
    }
    internal string Translate(Expression expression)
    {
        this.sb = new StringBuilder();
        this.Visit(expression);
        return this.sb.ToString();
    }

    private static Expression StripQuotes(Expression e)
    {
        while (e.NodeType == ExpressionType.Quote)
        {
            e = ((UnaryExpression)e).Operand;
        }
        return e;
    }

    protected override Expression VisitMethodCall(MethodCallExpression m)
    {
        if (m.Method.DeclaringType == typeof(Queryable) && m.Method.Name == "Where")
        {
            sb.Append("SELECT * FROM (");
            this.Visit(m.Arguments[0]);
            sb.Append(") AS T WHERE ");
            LambdaExpression lambda = (LambdaExpression)StripQuotes(m.Arguments[1]);
            this.Visit(lambda.Body);
            return m;
        }
        throw new NotSupportedException(string.Format("The method '{0}' is not supported", m.Method.Name));
    }

    protected override Expression VisitUnary(UnaryExpression u)
    {
        switch (u.NodeType)
        {
            case ExpressionType.Not:
                sb.Append(" NOT ");
                this.Visit(u.Operand);
                break;
            default:
                throw new NotSupportedException(string.Format("The unary operator '{0}' is not supported", u.NodeType));
        }
        return u;
    }

    protected override Expression VisitBinary(BinaryExpression b)
    {
        sb.Append("(");
        this.Visit(b.Left);
        switch (b.NodeType)
        {
            case ExpressionType.And:
                sb.Append(" AND ");
                break;
            case ExpressionType.Or:
                sb.Append(" OR");
                break;
            case ExpressionType.Equal:
                sb.Append(" = ");
                break;
            case ExpressionType.NotEqual:
                sb.Append(" <> ");
                break;
            case ExpressionType.LessThan:
                sb.Append(" < ");
                break;
            case ExpressionType.LessThanOrEqual:
                sb.Append(" <= ");
                break;
            case ExpressionType.GreaterThan:
                sb.Append(" > ");
                break;
            case ExpressionType.GreaterThanOrEqual:
                sb.Append(" >= ");
                break;
            default:
                throw new NotSupportedException(string.Format("The binary operator '{0}' is not supported", b.NodeType));
        }
        this.Visit(b.Right);
        sb.Append(")");
        return b;
    }

    protected override Expression VisitConstant(ConstantExpression c)
    {
        IQueryable q = c.Value as IQueryable;
        if (q != null)
        {
            // assume constant nodes w/ IQueryables are table references
            sb.Append("SELECT * FROM ");
            sb.Append(q.ElementType.Name);
        }
        else if (c.Value == null)
        {
            sb.Append("NULL");
        }
        else
        {
            switch (Type.GetTypeCode(c.Value.GetType()))
            {
                case TypeCode.Boolean:
                    sb.Append(((bool)c.Value) ? 1 : 0);
                    break;
                case TypeCode.String:
                    sb.Append("'");
                    sb.Append(c.Value);
                    sb.Append("'");
                    break;
                case TypeCode.Object:
                    throw new NotSupportedException(string.Format("The constant for '{0}' is not supported", c.Value));
                default:
                    sb.Append(c.Value);
                    break;
            }
        }
        return c;
    }

    protected override Expression VisitMemberAccess(MemberExpression m)
    {
        if (m.Expression != null && m.Expression.NodeType == ExpressionType.Parameter)
        {
            sb.Append(m.Member.Name);
            return m;
        }
        throw new NotSupportedException(string.Format("The member '{0}' is not supported", m.Member.Name));
    }
}

As you can see, there’s not much there and still it is rather complicated. What I’m expecting to see in the expression tree is at most a method call node with arguments referring to the source (argument 0) and the predicate (argument 1). Take a look at the VisitMethodCall method above. I explicitly handle the case of the Queryable.Where method, generating a “SELECT * FROM (“, recursively visiting the source and then appending “) AS T WHERE “, and then visiting the predicate. This allows for other query operators present in the source expression to be nested sub-queries. I don’t handle any other operators, but if more than one call to Where is used then I’m able to deal with that gracefully. It doesn’t matter what the table alias is that is used (I picked ‘T’) since I’m not going to generate references to it anyway. A more full-fledged provider would of course want to do this.

There’s a little helper method included called StripQutotes. Its job is to strip away any ExpressionType.Quote nodes on the method arguments (which may happen) so I can get at the pure lambda expression that I’m looking for.

The VisitUnary and VisitBinary methods are straightforward. They simply inject the correct text for the specific unary and binary operators I’ve chosen to support. The interesting bit of translation comes in the VisitConstant method. You see, table references in my world are just the root IQueryable’s. If a constant node holds one of my Query<T> instances then I’ll just assume it’s meant to represent the root table so I’ll append “SELECT * FROM” and then the name of the table which is simply the name of the element type of the query. The rest of the translation for constant nodes just deals with actual constants. Note these constants are added to the command text as literal values. There is nothing here to stop injection attacks that real providers need to deal with.

Finally, VisitMemberAccess assumes that all field or property accesses are meant to be column references in the command text. No checking is done to prove that this is true. The name of the field or property is assumed to match the name of the column in the database.

Given a class ‘Customers’ with fields matching the names of the columns in the Northwind sample database, this query translator will generate queries that look like this:

For the query:

Query<Customers> customers = ...;
    IQueryable<Customers> q = customers.Where(c => c.City == "London");

 è

“SELECT * FROM (SELECT *FROM Customers) AS T WHERE (city = ‘London’)”

The Object Reader

The job of the object reader is to turn the results of a SQL query into objects. I’m going to build a simple class that takes a DbDataReader and a type ‘T’ and I’ll make it implement IEnumerable<T>. There are no bells and whistles in this implementation. It will only work for writing into class fields via reflection. The names of the fields must match the names of the columns in the reader and the types must match whatever the DataReader thinks is the correct type.

internal class ObjectReader<T> : IEnumerable<T>, IEnumerable where T : class, new()
{
    Enumerator enumerator;
    internal ObjectReader(DbDataReader reader)
    {
        this.enumerator = new Enumerator(reader);
    }

    public IEnumerator<T> GetEnumerator()
    {
        Enumerator e = this.enumerator;
        if (e == null)
        {
            throw new InvalidOperationException("Cannot enumerate more than once");
        }
        this.enumerator = null;
        return e;
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }

    class Enumerator : IEnumerator<T>, IEnumerator, IDisposable
    {
        DbDataReader reader;
        FieldInfo[] fields;
        int[] fieldLookup;
        T current;

        internal Enumerator(DbDataReader reader)
        {
            this.reader = reader;
            this.fields = typeof(T).GetFields();
        }

        public T Current
        {
            get { return this.current; }
        }

        object IEnumerator.Current
        {
            get { return this.current; }
        }

        public bool MoveNext()
        {
            if (this.reader.Read())
            {
                if (this.fieldLookup == null)
                {
                    this.InitFieldLookup();
                }
                T instance = new T();
                for (int i = 0, n = this.fields.Length; i < n; i++)
                {
                    int index = this.fieldLookup[i];
                    if (index >= 0)
                    {
                        FieldInfo fi = this.fields[i];
                        if (this.reader.IsDBNull(index))
                        {
                            fi.SetValue(instance, null);
                        }
                        else
                        {
                            fi.SetValue(instance, this.reader.GetValue(index));
                        }
                    }
                }

                this.current = instance;
                return true;
            }
            return false;
        }

        public void Reset()
        {
        }

        public void Dispose()
        {
            this.reader.Dispose();
        }

        private void InitFieldLookup()
        {
            Dictionary<string, int> map = new Dictionary<string, int>(StringComparer.InvariantCultureIgnoreCase);
            for (int i = 0, n = this.reader.FieldCount; i < n; i++)
            {
                map.Add(this.reader.GetName(i), i);
            }
            this.fieldLookup = new int[this.fields.Length];
            for (int i = 0, n = this.fields.Length; i < n; i++)
           {
                int index;
                if (map.TryGetValue(this.fields[i].Name, out index))
                {
                    this.fieldLookup[i] = index;
                }
                else
                {
                    this.fieldLookup[i] = -1;
                }
            }
        }
    }
}

The ObjectReader creates a new instance of type ‘T’ for each row read by the DbDataReader. It uses the reflection API FieldInfo.SetValue to assign values to each field of the object. When the ObjectReader is first created it instantiates an instance of the nested Enumerator class. This enumerator is handed out when the GetEnumerator method is called. Since DataReader’s cannot reset and execute again, the enumerator can only be handed out once. If GetEnumerator is called a second time an exception is thrown.

The ObjectReader is lenient in the ordering of fields. Since the QueryTranslator builds queries using “SELECT *” this is a must because otherwise the code has no way of knowing which column will appear first in the results. Note that it is generally inadvisable to use “SELECT *” in production code. Remember this is just an illustrative sample to show how in general to put together a LINQ provider. In order to allow for different sequences of columns, the precise sequence is discovered at runtime when the first row is read for the DataReader. The InitFieldLookup function builds a map from column name to column ordinal and then assembles a lookup table ‘fieldLookup’ that maps between the object’s fields and the ordinals.

The Provider

Now that we have these two pieces (and the classes define in the prior post) it’s quite easy to combine them together to make an actual IQueryable LINQ provider.

public class DbQueryProvider : QueryProvider
{

    DbConnection connection;

    public DbQueryProvider(DbConnection connection)
    {
        this.connection = connection;
    }

    public override string GetQueryText(Expression expression)
    {
        return this.Translate(expression);
    }

    public override object Execute(Expression expression)
    {
        DbCommand cmd = this.connection.CreateCommand();
        cmd.CommandText = this.Translate(expression);
        DbDataReader reader = cmd.ExecuteReader();
        Type elementType = TypeSystem.GetElementType(expression.Type);
        return Activator.CreateInstance(
            typeof(ObjectReader<>).MakeGenericType(elementType),
            BindingFlags.Instance | BindingFlags.NonPublic, null,
            new object[] { reader },
            null);
    }

    private string Translate(Expression expression)
    {
        return new QueryTranslator().Translate(expression);
    }
}

As you can see, building a provider is now simply an exercise in combining these two pieces. The GetQueryText just needs to use the QueryTranslator to produce the command text. The Execute method uses both QueryTranslator and ObjectReader to build a DbCommand object, execute it and return the results as an IEnumerable.

Trying it Out

Now that we have our provider we can try it out. Since I’m basically following the LINQ to SQL model I’ll define a class for the Customers table, a ‘Context’ that holds onto the tables (root queries) and a little program that uses them.

public class Customers
{
    public string CustomerID;
    public string ContactName;
    public string Phone;
    public string City;
    public string Country;
}

public class Orders
{
    public int OrderID;
    public string CustomerID;
    public DateTime OrderDate;
}

public class Northwind
{
    public Query<Customers> Customers;
    public Query<Orders> Orders;

    public Northwind(DbConnection connection)
    {
        QueryProvider provider = new DbQueryProvider(connection);
        this.Customers = new Query<Customers>(provider);
        this.Orders = new Query<Orders>(provider);
    }
}

class Program
{
    static void Main(string[] args)
    {
        string constr = @"…";
        using (SqlConnection con = new SqlConnection(constr))
        {
            con.Open();
            Northwind db = new Northwind(con);
            IQueryable<Customers> query =
                 db.Customers.Where(c => c.City == "London");

            Console.WriteLine("Query:\n{0}\n", query);
            var list = query.ToList();
            foreach (var item in list)
            {
                Console.WriteLine("Name: {0}", item.ContactName);
            }

            Console.ReadLine();
        }
    }
}

Now if we run this we should get the following output: (Note that you will have to add your own connection string to the program above.)

Query:
SELECT * FROM (SELECT * FROM Customers) AS T WHERE (City = 'London')
Name: Thomas Hardy
Name: Victoria Ashworth
Name: Elizabeth Brown
Name: Ann Devon
Name: Simon Crowther
Name: Hari Kumar

Excellent, just what I wanted. I love it when a plan comes together. J

That’s it folks. That’s a LINQ IQueryable provider. Well, at least a crude facsimile of one. Of course, yours will do so much more than mine. It will handle all the edge cases and serve coffee.

But wait, there's more. Check out Part III

APPENDIX – The Expression Visitor

Now you are in for it. I think I’ve received about an order of magnitude more requests for this class than for help on building a query provider. There is an ExpressionVisitor class in System.Linq.Expressions, however it is internal so it’s not for your direct consumption as much as you’d like it to be. If you shout real loud you might convince us to make that one public in the next go ‘round.

This expression visitor is my take on the (classic) visitor pattern. In this variant there is only one visitor class that dispatches calls to the general Visit function out to specific VisitXXX methods corresponding to different node types. Note not every node type gets it own method, for example all binary operators are treated in one VisitBinary method. The nodes themselves do not directly participate in the visitation process. They are treated as just data. The reason for this is that the quantity of visitors is actually open ended. You can write your own. Therefore no semantics of visiting is coupled into the node classes. It’s all in the visitors. The default visit behavior for node XXX is baked into the base class’s version of VisitXXX.

Another variant is that all VisitXXX methods return a node. The Expression tree nodes are immutable. In order to change the tree you must construct a new one. The default VisitXXX methods will construct a new node if any of its sub-trees change. If no changes are made then the same node is returned. That way if you make a change to a node (by making a new node) deep down in a tree, the rest of the tree is rebuilt automatically for you.

Here’s the code. Enjoy. J

public abstract class ExpressionVisitor
{
    protected ExpressionVisitor()
    {
    }

    protected virtual Expression Visit(Expression exp)
    {
        if (exp == null)
            return exp;
        switch (exp.NodeType)
        {
            case ExpressionType.Negate:
            case ExpressionType.NegateChecked:
            case ExpressionType.Not:
            case ExpressionType.Convert:
            case ExpressionType.ConvertChecked:
            case ExpressionType.ArrayLength:
            case ExpressionType.Quote:
            case ExpressionType.TypeAs:
                return this.VisitUnary((UnaryExpression)exp);
            case ExpressionType.Add:
            case ExpressionType.AddChecked:
            case ExpressionType.Subtract:
            case ExpressionType.SubtractChecked:
            case ExpressionType.Multiply:
            case ExpressionType.MultiplyChecked:
            case ExpressionType.Divide:
            case ExpressionType.Modulo:
            case ExpressionType.And:
            case ExpressionType.AndAlso:
            case ExpressionType.Or:
            case ExpressionType.OrElse:
            case ExpressionType.LessThan:
            case ExpressionType.LessThanOrEqual:
            case ExpressionType.GreaterThan:
            case ExpressionType.GreaterThanOrEqual:
            case ExpressionType.Equal:
            case ExpressionType.NotEqual:
            case ExpressionType.Coalesce:
            case ExpressionType.ArrayIndex:
            case ExpressionType.RightShift:
            case ExpressionType.LeftShift:
            case ExpressionType.ExclusiveOr:
                return this.VisitBinary((BinaryExpression)exp);
            case ExpressionType.TypeIs:
                return this.VisitTypeIs((TypeBinaryExpression)exp);
            case ExpressionType.Conditional:
                return this.VisitConditional((ConditionalExpression)exp);
            case ExpressionType.Constant:
                return this.VisitConstant((ConstantExpression)exp);
            case ExpressionType.Parameter:
                return this.VisitParameter((ParameterExpression)exp);
            case ExpressionType.MemberAccess:
                return this.VisitMemberAccess((MemberExpression)exp);
            case ExpressionType.Call:
                return this.VisitMethodCall((MethodCallExpression)exp);
            case ExpressionType.Lambda:
                return this.VisitLambda((LambdaExpression)exp);
            case ExpressionType.New:
                return this.VisitNew((NewExpression)exp);
            case ExpressionType.NewArrayInit:
            case ExpressionType.NewArrayBounds:
                return this.VisitNewArray((NewArrayExpression)exp);
            case ExpressionType.Invoke:
                return this.VisitInvocation((InvocationExpression)exp);
            case ExpressionType.MemberInit:
                return this.VisitMemberInit((MemberInitExpression)exp);
            case ExpressionType.ListInit:
                return this.VisitListInit((ListInitExpression)exp);
            default:
                throw new Exception(string.Format("Unhandled expression type: '{0}'", exp.NodeType));
        }
    }

    protected virtual MemberBinding VisitBinding(MemberBinding binding)
    {
        switch (binding.BindingType)
        {
            case MemberBindingType.Assignment:
                return this.VisitMemberAssignment((MemberAssignment)binding);
            case MemberBindingType.MemberBinding:
                return this.VisitMemberMemberBinding((MemberMemberBinding)binding);
            case MemberBindingType.ListBinding:
                return this.VisitMemberListBinding((MemberListBinding)binding);
            default:
                throw new Exception(string.Format("Unhandled binding type '{0}'", binding.BindingType));
        }
    }

    protected virtual ElementInit VisitElementInitializer(ElementInit initializer)
    {
        ReadOnlyCollection<Expression> arguments = this.VisitExpressionList(initializer.Arguments);
        if (arguments != initializer.Arguments)
        {
            return Expression.ElementInit(initializer.AddMethod, arguments);
        }
        return initializer;
    }

    protected virtual Expression VisitUnary(UnaryExpression u)
    {
        Expression operand = this.Visit(u.Operand);
        if (operand != u.Operand)
        {
            return Expression.MakeUnary(u.NodeType, operand, u.Type, u.Method);
        }
        return u;
    }

    protected virtual Expression VisitBinary(BinaryExpression b)
    {
        Expression left = this.Visit(b.Left);
        Expression right = this.Visit(b.Right);
        Expression conversion = this.Visit(b.Conversion);
        if (left != b.Left || right != b.Right || conversion != b.Conversion)
        {
            if (b.NodeType == ExpressionType.Coalesce && b.Conversion != null)
                return Expression.Coalesce(left, right, conversion as LambdaExpression);
            else
                return Expression.MakeBinary(b.NodeType, left, right, b.IsLiftedToNull, b.Method);
        }
        return b;
    }

    protected virtual Expression VisitTypeIs(TypeBinaryExpression b)
    {
        Expression expr = this.Visit(b.Expression);
        if (expr != b.Expression)
        {
            return Expression.TypeIs(expr, b.TypeOperand);
        }
        return b;
    }

    protected virtual Expression VisitConstant(ConstantExpression c)
    {
        return c;
    }

    protected virtual Expression VisitConditional(ConditionalExpression c)
    {
        Expression test = this.Visit(c.Test);
        Expression ifTrue = this.Visit(c.IfTrue);
        Expression ifFalse = this.Visit(c.IfFalse);
        if (test != c.Test || ifTrue != c.IfTrue || ifFalse != c.IfFalse)
        {
            return Expression.Condition(test, ifTrue, ifFalse);
        }
        return c;
    }

    protected virtual Expression VisitParameter(ParameterExpression p)
    {
        return p;
    }

    protected virtual Expression VisitMemberAccess(MemberExpression m)
    {
        Expression exp = this.Visit(m.Expression);
        if (exp != m.Expression)
        {
            return Expression.MakeMemberAccess(exp, m.Member);
        }
        return m;
    }

    protected virtual Expression VisitMethodCall(MethodCallExpression m)
    {
        Expression obj = this.Visit(m.Object);
        IEnumerable<Expression> args = this.VisitExpressionList(m.Arguments);
        if (obj != m.Object || args != m.Arguments)
        {
            return Expression.Call(obj, m.Method, args);
        }
        return m;
    }

    protected virtual ReadOnlyCollection<Expression> VisitExpressionList(ReadOnlyCollection<Expression> original)
    {
        List<Expression> list = null;
        for (int i = 0, n = original.Count; i < n; i++)
        {
            Expression p = this.Visit(original[i]);
            if (list != null)
            {
                list.Add(p);
            }
            else if (p != original[i])
            {
                list = new List<Expression>(n);
                for (int j = 0; j < i; j++)
                {
                    list.Add(original[j]);
                }
                list.Add(p);
            }
        }
        if (list != null)
        {
            return list.AsReadOnly();
        }
        return original;
    }

    protected virtual MemberAssignment VisitMemberAssignment(MemberAssignment assignment)
    {
        Expression e = this.Visit(assignment.Expression);
        if (e != assignment.Expression)
        {
            return Expression.Bind(assignment.Member, e);
        }
        return assignment;
    }



    protected virtual MemberMemberBinding VisitMemberMemberBinding(MemberMemberBinding binding)
    {
        IEnumerable<MemberBinding> bindings = this.VisitBindingList(binding.Bindings);
        if (bindings != binding.Bindings)
        {
            return Expression.MemberBind(binding.Member, bindings);
        }
        return binding;
    }

    protected virtual MemberListBinding VisitMemberListBinding(MemberListBinding binding)
    {
        IEnumerable<ElementInit> initializers = this.VisitElementInitializerList(binding.Initializers);
        if (initializers != binding.Initializers)
        {
            return Expression.ListBind(binding.Member, initializers);
        }
        return binding;
    }

    protected virtual IEnumerable<MemberBinding> VisitBindingList(ReadOnlyCollection<MemberBinding> original)
    {
        List<MemberBinding> list = null;
        for (int i = 0, n = original.Count; i < n; i++)
        {
            MemberBinding b = this.VisitBinding(original[i]);
            if (list != null)
            {
                list.Add(b);
            }
            else if (b != original[i])
            {
                list = new List<MemberBinding>(n);
                for (int j = 0; j < i; j++)
                {
                    list.Add(original[j]);
                }
                list.Add(b);
            }
        }
        if (list != null)
            return list;
        return original;
    }

    protected virtual IEnumerable<ElementInit> VisitElementInitializerList(ReadOnlyCollection<ElementInit> original)
    {
        List<ElementInit> list = null;
        for (int i = 0, n = original.Count; i < n; i++)
        {
            ElementInit init = this.VisitElementInitializer(original[i]);
            if (list != null)
            {
                list.Add(init);
            }
            else if (init != original[i])
            {
                list = new List<ElementInit>(n);
                for (int j = 0; j < i; j++)
                {
                    list.Add(original[j]);
                }
                list.Add(init);
            }
        }
        if (list != null)
            return list;
        return original;
    }

    protected virtual Expression VisitLambda(LambdaExpression lambda)
    {
        Expression body = this.Visit(lambda.Body);
        if (body != lambda.Body)
        {
            return Expression.Lambda(lambda.Type, body, lambda.Parameters);
        }
        return lambda;
    }

    protected virtual NewExpression VisitNew(NewExpression nex)
    {
        IEnumerable<Expression> args = this.VisitExpressionList(nex.Arguments);
        if (args != nex.Arguments)
        {
            if (nex.Members != null)
                return Expression.New(nex.Constructor, args, nex.Members);
            else
                return Expression.New(nex.Constructor, args);
        }
        return nex;
    }

    protected virtual Expression VisitMemberInit(MemberInitExpression init)
    {
        NewExpression n = this.VisitNew(init.NewExpression);
        IEnumerable<MemberBinding> bindings = this.VisitBindingList(init.Bindings);
        if (n != init.NewExpression || bindings != init.Bindings)
        {
            return Expression.MemberInit(n, bindings);
        }
        return init;
    }

    protected virtual Expression VisitListInit(ListInitExpression init)
    {
        NewExpression n = this.VisitNew(init.NewExpression);
        IEnumerable<ElementInit> initializers = this.VisitElementInitializerList(init.Initializers);
        if (n != init.NewExpression || initializers != init.Initializers)
        {
            return Expression.ListInit(n, initializers);
        }
        return init;
    }

    protected virtual Expression VisitNewArray(NewArrayExpression na)
    {
        IEnumerable<Expression> exprs = this.VisitExpressionList(na.Expressions);
        if (exprs != na.Expressions)
        {
            if (na.NodeType == ExpressionType.NewArrayInit)
            {
                return Expression.NewArrayInit(na.Type.GetElementType(), exprs);
            }
            else
            {
                return Expression.NewArrayBounds(na.Type.GetElementType(), exprs);
            }
        }
        return na;
    }

    protected virtual Expression VisitInvocation(InvocationExpression iv)
    {
        IEnumerable<Expression> args = this.VisitExpressionList(iv.Arguments);
        Expression expr = this.Visit(iv.Expression);
        if (args != iv.Arguments || expr != iv.Expression)
        {
            return Expression.Invoke(expr, args);
        }
        return iv;
    }
}

Original post can be found here

LINQ: Building an IQueryable Provider - Part I

2009-08-20T01:46:00.001-07:00

I’ve been meaning for a while to start up a series of posts that covers building LINQ providers using IQueryable. People have been asking me advice on doing this for quite some time now, whether through internal Microsoft email or questions on the forums or by cracking the encryption and mailing me directly. Of course, I’ve mostly replied with “I’m working on a sample that will show you everything” letting them know that soon all will be revealed. However, instead of just posting a full sample here I felt it prudent to go step by step so I can actual dive deep and explain everything that is going on instead of just dumping it all in your lap and letting you find your own way.

The first thing I ought to point out to you is that IQueryable has changed in Beta 2. It’s no longer just one interface, having been factored into two: IQueryable and IQueryProvider. Let’s just walk through these before we get to actually implementing them.

If you use Visual Studio to ‘go to definition’ you get something that looks like this:

public interface IQueryable : IEnumerable
{

    Type ElementType { get; }

    Expression Expression { get; }

    IQueryProvider Provider { get; }

}

public interface IQueryable<T> : IEnumerable<T>, IQueryable, IEnumerable
{

}

Of course, IQueryable no longer looks all that interesting; the good stuff has been pushed off into the new interface IQueryProvider. Yet before I get into that, IQueryable is still worth looking at. As you can see the only things IQueryable has are three read-only properties. The first one gives you the element type (or the ‘T’ in IQueryable<T>). It’s important to note that all classes that implement IQueryable must also implement IQueryable<T> for some T and vice versa. The generic IQueryable<T> is the one you use most often in method signatures and the like. The non-generic IQueryable exist primarily to give you a weakly typed entry point primarily for dynamic query building scenarios.

The second property gives you the expression that corresponds to the query. This is quintessential essence of IQueryable’s being. The actual ‘query’ underneath the hood of an IQueryable is an expression that represents the query as a tree of LINQ query operators/method calls. This is the part of the IQueryable that your provider must comprehend in order to do anything useful. If you look deeper you will see that the whole IQueryable infrastructure (including the System.Linq.Queryable version of LINQ standard query operators) is just a mechanism to auto-construct expression tree nodes for you. When you use the Queryable.Where method to apply a filter to an IQueryable, it simply builds you a new IQueryable adding a method-call expression node on top of the tree representing the call you just made to Queryable.Where. Don’t believe me? Try it yourself and see what it does.

Now that just leaves us with the last property that gives us an instance of this new interface IQueryProvider. What we’ve done is move all the methods that implement constructing new IQueryables and executing them off into a separate interface that more logically represents your true provider.

public interface IQueryProvider
{

    IQueryable CreateQuery(Expression expression);

    IQueryable<TElement> CreateQuery<TElement>(Expression expression);

    object Execute(Expression expression);

    TResult Execute<TResult>(Expression expression);

}

Looking at the IQueryProvider interface you might be thinking, “why all these methods?” The truth is that there are really only two operations, CreateQuery and Execute, we just have both a generic and a non-generic form of each. The generic forms are used most often when you write queries directly in the programming language and perform better since we can avoid using reflection to construct instances.

The CreateQuery method does exactly what it sounds like it does. It creates a new instance of an IQueryable query based on the specified expression tree. When someone calls this method they are basically asking your provider to build a new instance of an IQueryable that when enumerated will invoke your query provider and process this specific query expression. The Queryable form of the standard query operators use this method to construct new IQueryable’s that stay associated with your provider. Note the caller can pass any expression tree possible to this API. It may not even be a legal query for your provider. However, the only thing that must be true is that expression itself must be typed to return/produce a correctly typed IQueryable. You see the IQueryable contains an expression that represents a snippet of code that if turned into actual code and executed would reconstruct that very same IQueryable (or its equivalent).

The Execute method is the entry point into your provider for actually executing query expressions. Having an explicit execute instead of just relying on IEnumerable.GetEnumerator() is important because it allows execution of expressions that do not necessarily yield sequences. For example, the query “myquery.Count()” returns a single integer. The expression tree for this query is a method call to the Count method that returns the integer. The Queryable.Count method (as well as the other aggregates and the like) use this method to execute the query ‘right now’.

There, that doesn’t seem so frightening does it? You could implement all those methods easily, right? Sure you could, but why bother. I’ll do it for you. Well all except for the execute method. I’ll show you how to do that in a later post.

First let’s start with the IQuerayble. Since this interface has been split into two, it’s now possible to implement the IQueryable part just once and re-use it for any provider. I’ll implement a class called Query<T> that implements IQueryable<T> and all the rest.

public class Query<T> : IQueryable<T>, IQueryable, IEnumerable<T>, IEnumerable, IOrderedQueryable<T>, IOrderedQueryable
{

    QueryProvider provider;

    Expression expression;



    public Query(QueryProvider provider)
    {

        if (provider == null)
        {

            throw new ArgumentNullException("provider");

        }

        this.provider = provider;

        this.expression = Expression.Constant(this);

    }



    public Query(QueryProvider provider, Expression expression)
    {

        if (provider == null)
        {

            throw new ArgumentNullException("provider");

        }

        if (expression == null)
        {

            throw new ArgumentNullException("expression");

        }

        if (!typeof(IQueryable<T>).IsAssignableFrom(expression.Type))
        {

            throw new ArgumentOutOfRangeException("expression");

        }

        this.provider = provider;

        this.expression = expression;

    }



    Expression IQueryable.Expression
    {

        get { return this.expression; }

    }



    Type IQueryable.ElementType
    {

        get { return typeof(T); }

    }



    IQueryProvider IQueryable.Provider
    {

        get { return this.provider; }

    }



    public IEnumerator<T> GetEnumerator()
    {

        return ((IEnumerable<T>)this.provider.Execute(this.expression)).GetEnumerator();

    }



    IEnumerator IEnumerable.GetEnumerator()
    {

        return ((IEnumerable)this.provider.Execute(this.expression)).GetEnumerator();

    }



    public override string ToString()
    {

        return this.provider.GetQueryText(this.expression);

    }

}

As you can see now, the IQueryable implementation is straightforward. This little object really does just hold onto an expression tree and a provider instance. The provider is where it really gets juicy.

Okay, now I need some provider to show you. I’ve implemented an abstract base class called QueryProvider that Query<T> referred to above. A real provider can just derive from this class and implement the Execute method.

public abstract class QueryProvider : IQueryProvider
{

    protected QueryProvider()
    {

    }



    IQueryable<S> IQueryProvider.CreateQuery<S>(Expression expression)
    {

        return new Query<S>(this, expression);

    }



    IQueryable IQueryProvider.CreateQuery(Expression expression)
    {

        Type elementType = TypeSystem.GetElementType(expression.Type);

        try
        {

            return (IQueryable)Activator.CreateInstance(typeof(Query<>).MakeGenericType(elementType), new object[] { this, expression });

        }

        catch (TargetInvocationException tie)
        {

            throw tie.InnerException;

        }

    }



    S IQueryProvider.Execute<S>(Expression expression)
    {

        return (S)this.Execute(expression);

    }



    object IQueryProvider.Execute(Expression expression)
    {

        return this.Execute(expression);

    }



    public abstract string GetQueryText(Expression expression);

    public abstract object Execute(Expression expression);

}

I’ve implemented the IQueryProvider interface on my base class QueryProvider. The CreateQuery methods create new instances of Query<T> and the Execute methods forward execution to this great new and not-yet-implemented Execute method.

I suppose you can think of this as boilerplate code you have to write just to get started building a LINQ IQueryable provider. The real action happens inside the Execute method. That’s where your provider has the opportunity to make sense of the query by examining the expression tree.

And that’s what I’ll start showing next time.

UPDATE:

It looks like I’ve forget to define a little helper class my implementation was using, so here it is:

internal static class TypeSystem
{

    internal static Type GetElementType(Type seqType)
    {

        Type ienum = FindIEnumerable(seqType);

        if (ienum == null) return seqType;

        return ienum.GetGenericArguments()[0];

    }

    private static Type FindIEnumerable(Type seqType)
    {

        if (seqType == null || seqType == typeof(string))

            return null;

        if (seqType.IsArray)

            return typeof(IEnumerable<>).MakeGenericType(seqType.GetElementType());

        if (seqType.IsGenericType)
        {

            foreach (Type arg in seqType.GetGenericArguments())
            {

                Type ienum = typeof(IEnumerable<>).MakeGenericType(arg);

                if (ienum.IsAssignableFrom(seqType))
                {

                    return ienum;

                }

            }

        }

        Type[] ifaces = seqType.GetInterfaces();

        if (ifaces != null && ifaces.Length > 0)
        {

            foreach (Type iface in ifaces)
            {

                Type ienum = FindIEnumerable(iface);

                if (ienum != null) return ienum;

            }

        }

        if (seqType.BaseType != null && seqType.BaseType != typeof(object))
        {

            return FindIEnumerable(seqType.BaseType);

        }

        return null;

    }

}

Yah, I know. There’s more ‘code’ in this helper than in all the rest. Sigh. J

Original post can be found here

A Defense of Reflection in .NET

2009-08-16T22:09:00.001-07:00

A Defense of Reflection in .NET

13 August 2009

by Nick Harrison

The trouble with making general rules about programming practices is that one can miss out on many benefits of of a framework by following them too literally in every context. Everyone knows that one should watch for performance problems and security issues with reflection. It doesn't mean you shouldn't it, it just means you must test carefully, monitor performance, and assess risks. Nick Harrison illustrates the theme with a practical example.

Introduction

Reflection is one of the great marvels of modern programming environments. Being able to store meta data about our code, and retrieve it at run time, opens up a world of possibilities. Many developers and software designers have embraced reflection and sing its praises, but reflection is not without its critics.

Here we will explore some of the criticism of reflection, debunk some of the myths around its usage, and explore the benefits through some practical applications.

What's Wrong With Reflection

There are various complaints and cautionary warnings against using reflection. Some of these are valid risks that we need to be aware of; others are wild tales based on early-adopters not understanding what they were using. Some are valid only in certain circumstances, or valid in all but special cases. Here we will explore some of these complaints. You should always be wary of a technology that is new or not well understood, but do not let that stand in the way of making appropriate use of technology.

Performance

Everyone knows that reflection is slow. The web is full of well meaning warnings that one should not use Reflection if you care about performance. Retrieving the meta-data slows your application down: One is often reading advice that, If you care about performance, you should never use reflection.

This is a legitimate concern that should be taken seriously, but this is not a carte blanche reason not to ever use Reflection.

While you should always worry about performance, you should not let performance worries keep you from making appropriate use of new technology. Do your own timing studies in your own environment. If there are performance issues, there are ways to minimize the performance impact.

The DotNet framework itself uses reflection extensively. Reflection is being used whether we intend to or not. Take a look at the details in the Machine.Config file. Almost all that you see is providing details to open an Assembly and load a Type with Reflection to make the framework itself work. The DotNet framework is all about Reflection.

If performance worries still nag you, there are tweaks that you can make in your own code to improve performance.

If you are going to make repeated calls to the Properties of an object, cache the Properties in a Hash Table. Reference the hash table instead of repeated calls to GetProperty or GetProperties. The same is true for Methods, Types and Assemblies.

Get comfortable with the BindingFlags enumeration. Always specify BindingFlags. Never use the IgnoreCase flag. Limit the searches to Public. Limit the searches to Static or Instance as appropriate.

Don't just assume that performance will suffer. Embrace Reflection, but test it. There are various profiling tools, such as Red Gate's Ants Profiler. Use them to identify the true cause of a performance problem. If Reflection is the right tool, don't ignore it simply because someone told you that it will be slow. If it turns out be too slow for you, there are ways to optimize its usage.

Security

Reflection, it is said, poses an unacceptable security risk. The essence of most designs that leverage Reflection also incorporate the process of dynamically discovering new code and executing it. This opens up a risk that malicious code will be executing and compromising the entire system.

In the modern world of Malware and security threats, we are all concerned about security. The risk with Reflection is that malicious code may be substituted for your own code. Many reflective designs do, indeed, rely on loading new assemblies, discovering new types, and running discovered methods and properties on these new types. While this may lead many to steer clear of a reflective solution, don't run scared.

An intruder would need to physically place malicious code where your reflective code can find it. While this is not impossible, a good defense in depth design can mitigate this risk. Properly configured firewalls with processing servers behind the firewalls will help. Intrusion detection will alert administrators to servers that are being targeted, and properly patched servers will help eliminate known vulnerabilities.

Code Access Security, properly configured, can also limit the access that reflective code has. With Code Access Security, individual assemblies can run with fewer rights than the user running the assembly.

This article is not about configuring security settings but rather to assure you that there are counter measures to any security concern that you may have.

Confusion

Reflective code, so one hears, is very hard to follow. Developers new to the project will have difficulty learning the ropes. Anything that steepens the learning curve jeopardizes project time lines and should be avoided. If only a select group of developers can understand the reflective code then the project is overly dependent on this select group, and is doomed to fail.

This is also not a very legitimate concern. If every design decision is based on what the least experienced programmer can readily understand, our designs will be severely limited. Reflective code can, and should, be isolated. Daily development should not be modifying this code. Daily development should use the reflective methods to simplify daily development tasks.

We want our code to be easy to follow, and Reflective code is not always the most intuitive code to understand at first glance. Without a doubt the hard-coded option is easier to follow than the reflective version

Hard Coded

public void MapData(IEmployee first, IEmployee second)

{

    second.FirstName = first.FirstName;

    second.Address = first.Address;

    second.BranchLocation = first.BranchLocation;

. . .

}

Reflective

public static void MapData(object sourceObject,

    object targetObject)

{

    object[] value = new object[1];

    object[] param = new object[0];

    foreach (PropertyInfo propertyInfo

        in sourceObject.GetType().GetProperties())

    {

        PropertyInfo targetPropertyInfo =

            targetObject.GetType().

            GetProperty(propertyInfo.Name);

        if (targetPropertyInfo.CanWrite)

        {

            value[0] = propertyInfo.GetValue(sourceObject,

                BindingFlags.Public, null, null, null);

            targetPropertyInfo.SetValue

                (targetObject, value,null);

        }

    }

}

Anyone can look at the hard-coded version and immediately tell what is going on. The reflective version will probably take a senior developer a second look to figure out.

However, the hard-coded version is tedious code. Depending on the number of properties being mapped, more and more errors are likely to be introduced. In the long run, this results in more code that has to be hand written.

While the reflective code may be hard to follow, it does not need to be referenced very often to be useful.

With the hard-coded implementation, you have to write a similar method for every type that you want to map. This is a tedious proposition indeed! With the reflective implementation, this one method can handle the process of mapping any object in your system.

For the observant reader, this is far from the most optimized implementation for the reflective version. We will go over the reflective version in more detail later and discuss various ways to optimize.

Why Use Reflection?

Developer Performance

As mentioned earlier, the hard coded version is often tedious, and tedious code is often error-prone.

You can well imagine the potential for introducing bugs by having to iterate through, and explicitly set, each property in an object. This can quickly get out of hand. Bugs from assigning the wrong value to the wrong property are easy to introduce and difficult to track down.

It is much easier to write a single line of code to handle the mapping and then move on to more important tasks such as implementing business logic and meeting deadlines.

A call like DataMapper.CopyTo (data, ui) is easy to understand and quick to write. As long as the property names match and are of the same types, you don't have to worry about missing any assignments. As a developer, you implement a series of rather simple properties to handle validation, and you don't have to get bogged down in the details of the mapping logic.

Stability / Consistency

Not everyone will get reflective code right the first time, but this is the beauty of consistency. If the implementation that everyone is using is inefficient or has a logic problem, you have only to correct it in one place. If there are multiple hard coded implementations, some will, no doubt, be done as efficiently as possible. Some will, to be sure, be free from all logic problems, but at least some implementations will have problems that will need to be addressed.

Reflective code is much easier to reuse. If the code is widely reused, then we have fewer places to correct when there is a problem found.

This consistency improves the overall stability of the system.

Practical Applications

Tweaking Performance

Performance is always a concern. There are some simple steps that we can take to eke the best performance out of our reflective code.

Whenever you make a Reflection call, make it count. Cache the output so that it can be reused. Calls to GetProperty, LoadAssembly or GetType are expensive. If there is any chance that you are going to need a method or a property more than once, store the return value so that you can use it later without having to make the call again.

This is also an example where multi threading can give you the perception of performance improvement. This proves to be a nice option for batch application and for business / data servers. This does not provide any benefit for the web UI, but can be very beneficial for a traditional windows application.

CopyTo

CopyTo is the reflective MapData that we saw earlier. Let's discuss some strategies to get the basic method ready for prime-time. As we stated earlier, we don't want to throw away the return value of the GetProperty call. We also want to avoid calling GetProperty altogether when we are truly interested in every property.

We start by checking to see if our collection of properties has already been loaded into a hash table. If they have, then we use this previously-loaded list. If not, we go ahead and load the details into the hash table. This will allow us to avoid the GetProperty calls altogether. If we are copying from one object to another of the same type, we dramatically reduce the number of reflection calls. If we call this method multiple times with the same set of objects, we reduce the reflective even more.

Our caching logic could look similar to this:

private Hashtable properties;

private Hashtable Properties

{

  get

  {

      if (properties == null)

          properties = new Hashtable();

      return properties;

  }

}

 

private void LoadProperties(object targetObject, Type targetType)

{

    if (properties[targetType.FullName] != null)

    {

        List<PropertyInfo> propertyList = new List<PropertyInfo>();

        PropertyInfo[] objectProperties =

            targetType.GetProperties(BindingFlags.Public);

        foreach (PropertyInfo currentProperty in objectProperties)

        {

            propertyList.Add(currentProperty);

        }

        properties[targetObject] = propertyList;

    }

}

Here we first check to see if the Hash table already has a list of properties for our object. If it does then we have nothing to do. If not, we load the properties into a generic list to be added to the hash table.

Our optimized CopyTo function can now be rewritten as:

public  void CopyTo(object sourceObject, object targetObject)

{

  object[] value = new object[1];

  Type sourceType = sourceObject.GetType();

  Type targetType = targetObject.GetType();

 

  LoadProperties(sourceObject, sourceType);

  LoadProperties(targetObject, targetType);

  List<PropertyInfo> sourcePoperties =

      Properties[sourceType.FullName] as List<PropertyInfo>;

  List<PropertyInfo> targetProperties =

      Properties[targetType.FullName] as List<PropertyInfo>;

 

  foreach (PropertyInfo sourceProperty in sourcePoperties)

  {

      PropertyInfo targetPropertyInfo = targetProperties.

          Find(delegate(PropertyInfo prop)

           { return prop.Name == sourceProperty.Name ; });

      if (sourceProperty.CanRead)

      {

          if (targetPropertyInfo.CanWrite)

          {

              value[0] = sourceProperty.GetValue(sourceObject,

                    BindingFlags.Public, null, null, null);

              targetPropertyInfo.SetValue

                  (targetObject, value, null);

          }

      }

  }

}

The biggest change we have here is in the calls to the LoadProperties method. If the properties are already loaded, this will have no effect. If they are not, this method will load the properties for us. Once our properties are loaded into the hash table, we can safely pull them out of the generic list instead of making repeated calls to GetProperties or GetProperty.

Once we have our two properties, we make sure that the source can be read and that the target can be written to. Now we simply “get” the value from the source and “set” the value on the target.

MapDataToBusinessEntityCollection

MapDataToBusinessEntityCollection is a generic Reflective method. We pass in the data-type for the objects to be mapped as a generic parameter along with a data reader. We use reflection to find the properties in this type and we use the meta data in the DataReader to find the fields.

Whenever we find a field from the data reader that has a matching writable property in the generic type, we pull the value from the DataReader and assign it to a newly created object. Regardless of how many properties are in T, this method will map every property that has a matching field in the DataReader. Any properties that are not in the DataReader will be unmapped. Any fields in the data reader that do not have a matching property will be ignored. The validation logic is handled in the implementation of the properties in T.

public staticList<T> MapDataToBusinessEntityCollection<T>

(IDataReader dr)

   where T : new()

{

Type businessEntityType = typeof (T);

List<T> entitys = newList<T>();

Hashtable hashtable = newHashtable();

PropertyInfo[] properties = businessEntityType.GetProperties();

foreach (PropertyInfo info inproperties)

{

      hashtable[info.Name.ToUpper()] = info;

}

while(dr.Read())

{

      T newObject = newT();

      for(int index = 0; index < dr.FieldCount; index++)

      {

          PropertyInfo info = (PropertyInfo)

                              hashtable[dr.GetName(index).ToUpper()];

          if((info != null) && info.CanWrite)

          {

              info.SetValue(newObject, dr.GetValue(index), null);

          }

      }

      entitys.Add(newObject);

}

dr.Close();

returnentitys;

}

Timing Studies

To evaluate the performance implications of this approach, I set up a test-bed to perform my own timing studies. An ounce of testing is worth a pound of speculation.

In my test-bed, I defined an object to encapsulate the Employee table in the NorthWinds database. I loaded this table with 100,000 records and timed how long it took to retrieve records using various methods.

Hardcoded, is this case, is the worse way you can write a Hard-coded implementation, but it is also an approach that I have commonly seen followed.

private void HardCoded()

{

  System.DateTime start = DateTime.Now;

  System.Data.IDataReader dr = GetData(recordCount);

  while (dr.Read())

  {

      CustomTypes.Employees newEmployee =

          new CustomTypes.Employees();

      newEmployee.Address = dr["Address"].ToString();

      newEmployee.BirthDate =

          DateTime.Parse(dr["BirthDate"].ToString());

      newEmployee.City = dr["City"].ToString();

      newEmployee.Country = dr["Country"].ToString();

      newEmployee.EmployeeID = Int32.Parse(dr["EmployeeID"].ToString());

      newEmployee.Extension = dr["Extension"].ToString();

      newEmployee.FirstName = dr["FirstName"].ToString();

      newEmployee.HireDate = DateTime.Parse(dr["HireDate"].ToString());

      newEmployee.LastName = dr["LastName"].ToString();

      newEmployee.PostalCode = dr["PostalCode"].ToString();

      newEmployee.Region = dr["Region"].ToString();

      newEmployee.ReportsTo = Int32.Parse(dr["ReportsTo"].ToString());

      newEmployee.Title = dr["Title"].ToString();

      newEmployee.TitleOfCourtesy = dr["TitleOfCourtesy"].ToString();

      pgbHardCodedConversion.Increment(1);

  }

  dr.Close();

  System.DateTime stop = DateTime.Now;

  System.TimeSpan ts = new TimeSpan(stop.Ticks - start.Ticks);

  lblHardCodedConvertedTime.Text = "Finished in "

+ ts.TotalMilliseconds + " milliseconds";

}

This has several obvious problems, but since it has to be re coded for every data reader, it will often be done poorly.

Reflective Singleton is the same method outlined above, but without caching the PropertyInfo objects. Comparing the Reflective Singleton and the ReflectiveBatch shows the benefits of caching the PropertyInfo objects. I believe this to be a dramatic improvement.

Hard-Coded without Conversion is the same as the HardCoded implementation but skips the extra ToString and parsing operations which should never be performed anyway.

So why is the Reflective Batch implementation faster than the hard-coded version? Indexing into the DataReader by Name is also a slow operation. The Reflective implementation avoids this costly lookup.

Undoubtedly, caching the indexes into the DataReader will change the results. More properties in the test object will change the results, and there are probably more optimizations that could be done to the hard-coded implementation.

All of this reinforces the need to test in your own environment. Test for yourself. You may be surprised that a reflective solution probably will not ruin performance, and it will shorten your time to market.

Conclusion

Do not shy away from Reflection or any other technology just because of warnings that you hear. Always verify that the warnings apply to your project. Often times, they will not.

If you are worried about performance concerns, don’t blindly follow someone else’s opinion. Test it with your own application.

Above all don’t be afraid to learn something new!

Author profile: Nick Harrison

Nick Harrison is a Software Architect and .NET advocate in Columbia, SC. Nick has over 14 years experience in software developing, starting with Unix system programming and then progressing to the DotNet platform. You can read his blog as www.geekswithblogs.net/nharrison

Search for other articles by Nick Harrison

Free ebook on C# 3.0

2009-08-16T21:00:00.001-07:00

This book is for busy programmers who want a succinct and yet readable guide to C# 3.0 and LINQ.
C# 3.0 Pocket Reference, written by Joseph and Ben Albahari, tells you exactly what you need to know, without long introductions or bloated samples. Boost your C# expertise and keep ahead of your peers!

Boost your C# expertise:
Download your free ebook here
and keep ahead of the game.

Custom Persister to store the state in a backend database

2009-08-12T21:53:00.001-07:00

As requested in this post, following is an example of a way to store viewstate in a database on the server instead of the hidden form field on the page. The form only maintains a guid that is used to retrieve saved viewstate from the DB. This can reduce bandwidth considerably if viewstate is something that you can't or don't want to disable completely.

The following code snippets are included:

SamplePageStatePersister.cs - custom mechanism for loading and saving viewstate for the page.
SamplePageAdapter.cs - returns a new instance of SamplePageStatePersister (this is enlisted by the App.Browser file).
App.Browser - must be added to the web project and tells the web application to use our custom page adapter.
PageViewStateServices.cs - handles the interaction with the database via stored procedures to optimise performance.
PageViewState.sql - creates the table to hold the view state and the stored procedures to interact with the database. You will need to apply the appropriate permissions.
CleanupPageViewState.sql - deletes old view state to stop the database growing uncontrollably. Configure as a scheduled job and can be modified to extend or reduce the time window for view state being maintained in the database. Defaults to 4 hours.

NOTE: This current example will not work if you use Server.Transfer and carry across the form data in the transfer. In this case, the view state ID will be carried across too and then subsequent back navigation will result in an error.

SamplePageStatePersister.cs

using System;
using System.Globalization;
using System.IO;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;

/// <summary>
/// ---------------------------------------------------
/// This class is the page state persister for the application.
///
/// Created by Jason Hill on 26/6/2007.
/// ---------------------------------------------------
/// </summary>
public class SamplePageStatePersister : System.Web.UI.PageStatePersister
{

    private Page _page;

/// ---------------------------------------------------
    /// <summary>
    /// Constructor.
    /// </summary>
    /// <remarks>
    /// <author>jhill</author>
    /// <creation>Wednesday, 30 May 2007</creation>
    /// </remarks>
    /// <param name="page">Page.</param>
    /// -----------------------------------------------
    public SamplePageStatePersister(Page page)
        : base(page)
    {
        _page = page;
    }

    /// -----------------------------------------------    /// <summary>
    /// Get the unique ID for the view state.
    /// </summary>
    /// <remarks>
    /// <author>jhill</author>
    /// <creation>Wednesday, 30 May 2007</creation>
    /// </remarks>
    /// -----------------------------------------------

    private Guid GetViewStateID()
    {
        string viewStateKey;

        // Get the ID from the request
        viewStateKey = _page.Request["__VIEWSTATEID"];

        // Assign a new ID if we don't have one in the request
        if (string.IsNullOrEmpty(viewStateKey))
        {
            return Guid.NewGuid();
        }

        // Use the ID from the request if it is valid, else assign a new ID
        try
        {
            return new Guid(viewStateKey);
        }
        catch (FormatException)
        {
            return Guid.NewGuid();
        }

    }

    /// -----------------------------------------------
    /// <summary>
    /// Load the view state from persistent medium.
    /// </summary>
    /// <remarks>
    /// <author>jhill</author>
    /// <creation>Wednesday, 30 May 2007</creation>
    /// </remarks>
    /// -----------------------------------------------
    public override void Load()
    {

        // Load view state from DB
        string pageViewState = PageViewStateServices.GetByID(GetViewStateID());

        if (pageViewState == null)
        {
            ViewState = null;
            ControlState = null;
        }
        else
        {

            // Deserialize into a Pair of ViewState and ControlState objects
            IStateFormatter formatter = StateFormatter;
            Pair statePair = (Pair)formatter.Deserialize(pageViewState);

            // Update ViewState and ControlState
            ViewState = statePair.First;
            ControlState = statePair.Second;
        }

    }

    /// -----------------------------------------------
    /// <summary>
    /// Save the view state to persistent medium.
    /// </summary>
    /// <remarks>
    /// <author>jhill</author>
    /// <creation>Wednesday, 30 May 2007</creation>
    /// </remarks>
    /// <param name="viewState">View state to save.</param>
    /// -----------------------------------------------
    public override void Save()
    {

        // Create a pair for ViewState and ControlState
        Pair statePair = new Pair(ViewState, ControlState);
        IStateFormatter formatter = StateFormatter;

        // Save the view state
        Guid id = GetViewStateID();
        PageViewStateServices.Save(id, formatter.Serialize(statePair));

        // Store the ID of the view state in a hidden form field
        HtmlInputHidden control = _page.FindControl("__VIEWSTATEID") as HtmlInputHidden;
        if (control == null)
        {
            ScriptManager.RegisterHiddenField(_page, "__VIEWSTATEID", id.ToString());
        }
        else
        {
            control.Value = id.ToString();
        }

    }


}

SamplePageAdapter.cs

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;

/// <summary>
/// -----------------------------------------------
/// This class is the page adapter for the application.
/// 
/// Created by Jason Hill on 26/6/2007.
/// -----------------------------------------------
/// </summary>
public class SamplePageAdapter : System.Web.UI.Adapters.PageAdapter
{

    /// -------------------------------------------
    /// <summary>
    /// Gets the state persister for the page.
    /// </summary>
    /// <remarks>
    ///     <author>jhill</author>
    ///     <creation>Wednesday, 30 May 2007</creation>
    /// </remarks>
    /// -------------------------------------------
    public override PageStatePersister GetStatePersister()
    {
        return new SamplePageStatePersister(Page);
    }

}

App.Browser

<browsers>
  <browser refID="Default">
    <controlAdapters>
      <adapter controlType="System.Web.UI.Page" adapterType="SamplePageAdapter" />
    </controlAdapters>
  </browser>
</browsers>

PageViewStateServices.cs

using System;
using System.Data;
using System.Data.SqlClient;
using System.Collections;
using System.Text;

/// <summary>
/// --------------------------------------------------------
/// This class provides services for handling page view state.
/// 
/// Created by Jason Hill on 26/6/2007.
/// --------------------------------------------------------
/// </summary>
public static class PageViewStateServices
{

    /// ----------------------------------------------------
    /// <summary>
    /// Get a page view state by ID.
    /// </summary>
    /// <remarks>
    ///     <author>jhill</author>
    ///     <creation>Wednesday, 30 May 2007</creation>
    /// </remarks>
    /// <param name="id">ID.</param>
    /// ----------------------------------------------------
    public static string GetByID(Guid id)
    {

        using (SqlConnection connection = new SqlConnection(Common.PageViewStateConnectionString))
        {
            connection.Open();

            try
            {
                using (SqlCommand command = connection.CreateCommand())
                {
                    command.CommandType = CommandType.StoredProcedure;
                    command.CommandText = "GetByID";
                    command.Parameters.Add(new SqlParameter("@id", id));
                    return (string)command.ExecuteScalar();
                }
            }

            finally
            {
                connection.Close();
            }
        }

    }

    /// ----------------------------------------------
    /// <summary>
    /// Save the view state.
    /// </summary>
    /// <remarks>
    ///     <author>jhill</author>
    ///     <creation>Wednesday, 30 May 2007</creation>
    /// </remarks>
    /// <param name="id">Unique ID.</param>
    /// <param name="value">View state value.</param>
    /// ----------------------------------------------
    public static void Save(Guid id, string value)
    {

        using (SqlConnection connection = new SqlConnection(Common.PageViewStateConnectionString))
        {
            connection.Open();

            try
            {

                using (SqlCommand command = connection.CreateCommand())
                {
                    command.CommandType = CommandType.StoredProcedure;
                    command.CommandText = "SaveViewState";
                    command.Parameters.Add(new SqlParameter("@id", id));
                    command.Parameters.Add(new SqlParameter("@value", value));
                    command.ExecuteNonQuery();
                }

            }

            finally
            {
                connection.Close();
            }
        }

    }

}

PageViewState.sql
 
   1:  SET ANSI_NULLS ON
   2:  GO
   3:  SET QUOTED_IDENTIFIER ON
   4:  GO
   5:  CREATE TABLE [dbo].[PageViewState](
   6:      [ID] [uniqueidentifier] NOT NULL,
   7:      [Value] [text] NOT NULL,
   8:      [LastUpdatedOn] [datetime] NOT NULL,
   9:   CONSTRAINT [PK_PageViewState] PRIMARY KEY CLUSTERED 
  10:  (
  11:      [ID] ASC
  12:  )WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
  13:  ) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
  14:  GO
  15:   
  16:  SET ANSI_NULLS ON
  17:  GO
  18:  SET QUOTED_IDENTIFIER ON
  19:  GO
  20:  CREATE PROCEDURE [dbo].[GetByID] 
  21:      @id uniqueidentifier 
  22:  AS
  23:  BEGIN
  24:      SET NOCOUNT ON;
  25:      
  26:      select Value
  27:      from PageViewState
  28:      where ID = @id
  29:   
  30:  END
  31:   
  32:  GO
  33:  SET ANSI_NULLS ON
  34:  GO
  35:  SET QUOTED_IDENTIFIER ON
  36:  GO
  37:  CREATE PROCEDURE [dbo].[SaveViewState]
  38:      @id uniqueidentifier, 
  39:      @value text
  40:  AS
  41:  BEGIN
  42:      SET NOCOUNT ON;
  43:      
  44:      if (exists(select ID from PageViewState where ID = @id))
  45:          update PageViewState
  46:          set Value = @value, LastUpdatedOn = getdate()
  47:          where ID = @id
  48:      else
  49:          insert into PageViewState
  50:          (ID, Value, LastUpdatedOn)
  51:          values (@id, @value, getdate())
  52:   
  53:  END
  54:   
  55:   
 
 
CleanupPageViewState.sql
 
   1:  delete from PageViewState
   2:  where LastUpdatedOn < dateadd(minute, -240, current_timestamp)

Original post can be found here

.NET: Getting the Path of the Executing Assembly

2009-08-10T23:04:00.001-07:00

To retrieve the path of the executing assembly (the VB 6.0 equivalent of App.Path), use the following code:

[C#]
String strPath = System.IO.Path.GetDirectoryName(
 System.Reflection.Assembly.GetExecutingAssembly().CodeBase);

[Visual Basic]
Dim strPath As String = System.IO.Path.GetDirectoryName( _
 System.Reflection.Assembly.GetExecutingAssembly().CodeBase)

Original post can be found here

.NET: Retrieving Assembly Attributes

2009-08-10T23:01:00.001-07:00

To retrieve the value set in the Assembly Attributes in the AssemblyInfo.cs or AssemblyInfo.vb file, use the code below. The example shows retrieving the AssemblyDescription attribute.

[C#]
private static readonly string strAssemblyDescription =
    ((AssemblyDescriptionAttribute) 
    Assembly.GetExecutingAssembly().GetCustomAttributes(
    typeof(AssemblyDescriptionAttribute), false)[0]).Description;

[Visual Basic]
Private ReadOnly strAssemblyDescription As String = _
    CType([Assembly].GetExecutingAssembly().GetCustomAttributes( _
    GetType(AssemblyDescriptionAttribute), False), _
    AssemblyDescriptionAttribute())(0).Description

Original post can be found here

SQL SERVER – Get Time in Hour:Minute Format from a Datetime – Get Date Part Only from Datetime

2009-08-05T23:46:00.001-07:00

I have seen scores of expert developers getting perplexed with SQL Server in finding time only from datetime datatype. Let us have a quick glance look at the solution.

SQL Server 2000/2005

   1:  SELECT

   2:  CONVERT(VARCHAR(8),GETDATE(),108) AS HourMinuteSecond,

   3:  CONVERT(VARCHAR(8),GETDATE(),101) AS DateOnly

   4:  GO

SQL Server 2008

   1:  SELECT

   2:  CONVERT(TIME,GETDATE()) AS HourMinuteSecond,

   3:  CONVERT(DATE,GETDATE(),101) AS DateOnly

   4:  GO

I hope the above solution is clear to you all.

Reference : Pinal Dave (http://blog.SQLAuthority.com)

Setting up Visual Studio Intellisense for jQuery

2009-07-30T06:20:00.001-07:00

by Ralph Whitbeck

In September 2008, at the jQuery Conference, it was announced that Microsoft would be shipping its upcoming releases of Visual Studio with jQuery built in. They would not fork or change the jQuery code but ship it as is. Microsoft also announced that they would distribute IntelliSense-annotated documentation JavaScript files for Visual Studio 2008 that developers can reference in their files to enable IntelliSense for jQuery. The following instructions will help you get started using this tool to make writing jQuery scripts faster than ever.

Setting up Your Files for jQuery IntelliSense

First, set up jQuery on your page by downloading the latest version from the jQuery site.

Next, you will need to download the jQuery Documentation file from the jQuery site.

Download the files and add them to your project.

IntelliSense in external JavaScript files

At the top of the JavaScript file in which you would like to have jQuery IntelliSense enabled, you will need to add a line to reference the documentation file:

/// <reference path="jquery-1.3.2-vsdoc2.js" />

IntelliSense inline on your ASPX page

There are a couple of scenarios that may affect if you include a reference to the VSDOC file or not. If in doubt, just add a reference to the documentation file.

If you are linking to jQuery by the Google Code AJAX Library or are linking to jQuery from anywhere outside of your project you will need to reference the documentation file.

From each ASPX page you want jQuery IntelliSense you’ll want to call the reference within a server-side conditional statement so that the documentation file will still load in Visual Studio but will not load at run-time. Add the following after your jQuery declaration:

PLAIN TEXT

ASP:

   1:  <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js" type="text/javascript"></script>

2:

   3:  <% if (false) { %>

4:

   5:    <script type="text/javascript" src="jquery-1.3.2-vsdoc2.js"></script>

6:

   7:  <% } %>

If you downloaded jQuery and saved it to your project Visual Studio will look for the vsdoc.js file automatically if the following conditions are met.

You've downloaded and installed the hotfix for Visual Studio.

jQuery and the documentation file need to be named the same with the exception that the documentation file end with -vsdoc.js. So when you add jQuery to your project make sure to rename them similarly. For instance, jquery-1.3.2.js is your jQuery library, Visual Studio will look for the documentation file at jquery-1.3.2-vsdoc.js and load it.

(Note: the jQuery 1.3.2 documentation file is named jquery-1.3.2-vsdoc2.js on the Download page so make sure you take out the 2 so that the file will be found by Visual Studio)

If you can't meet these conditions you'll need to reference the documentation file as shown above.

To test to make sure the documentation file loaded correctly, you can type $( and you should be presented with some documentation.

Additionally, you can type in $(document).r and you will be presented with a drop down of available options to choose from, one being "ready."

Now as you write your jQuery code, you'll be helped along by seeing what methods and properties are available to you.

Update

I've updated the post to reflect the hotfix for Visual Studio which enables Visual Studio to automatically load the documentation file for inline jQuery on ASPX pages if it's named similarly to the jQuery file. Thanks to Dave Ward for pointing this out in the comments.

Scripts Used on This Site

Original post can be found here...

Web Content Accessibility Guidelines (WCAG) 2.0

2009-07-29T22:12:00.000-07:00

Abstract

Web Content Accessibility Guidelines (WCAG) 2.0 covers a wide range of recommendations for making Web content more accessible. Following these guidelines will make content accessible to a wider range of people with disabilities, including blindness and low vision, deafness and hearing loss, learning disabilities, cognitive limitations, limited movement, speech disabilities, photosensitivity and combinations of these. Following these guidelines will also often make your Web content more usable to users in general.

WCAG 2.0 success criteria are written as testable statements that are not technology-specific. Guidance about satisfying the success criteria in specific technologies, as well as general information about interpreting the success criteria, is provided in separate documents. See Web Content Accessibility Guidelines (WCAG) Overview for an introduction and links to WCAG technical and educational material.

WCAG 2.0 succeeds Web Content Accessibility Guidelines 1.0 [WCAG10], which was published as a W3C Recommendation May 1999. Although it is possible to conform either to WCAG 1.0 or to WCAG 2.0 (or both), the W3C recommends that new and updated content use WCAG 2.0. The W3C also recommends that Web accessibility policies reference WCAG 2.0.

What is CSLA .NET?

2009-07-28T21:54:00.000-07:00

CSLA .NET is a software development framework that helps you build a powerful, maintainable business logic layer for Windows, Web, service-oriented and workflow applications.

There are many frameworks in the world. Most of them focus on the common issues of getting data into and out of the database or creating a flexible UI. What is typically missing is a focus on managing or implementing business logic. This puzzles me, because business logic is the centerpiece of a business application.

Helping to manage and implement this business logic is the purpose of my CSLA .NET framework and is the focus of my Expert Business Objects books.

CSLA .NET enables you to create an object-oriented business layer that abstracts and encapsulates your business logic and data. The framework ensures your business objects fully support data binding in WPF, Silverlight, ASP.NET Web Forms and Windows Forms. It also supports ASP.NET MVC, Windows Workflow Foundation, WCF and web services interfaces.

CSLA .NET simplifies and standarizes implementation of business logic, validation and authorization logic within your objects. The goal is to provide an easy and consistent coding pattern by which you can encapsulate all your business logic within your object-oriented business layer. The result is a business layer that can support all the interface types listed above, while remaining decoupled from any specific interface technology.

CSLA .NET includes a technology-neutral client/server abstraction, allowing you to build your application and then decide at deployment whether to use 2-tier or 3-tier client/server (and 4-tier with Silverlight). If you opt for 3-tier deployment, you can choose between WCF, .NET Remoting, Web Services or Enterprise Services as a network protocol. The key point here is that you can switch between 2-tier and any of these 3-tier networking options without changing your UI, business logic or data access code; all that changes is a configuration file (and of course deployment to both client and server).

Finally, CSLA .NET provides a clearly defined location in your architecture where you get data from or put data into the database. This is not the focus of CSLA .NET, and so the framework’s goal is to put you in charge. To give you optimum flexibility in how that data is managed and to enable decoupling of the data access from the business object and user interface or presentation layers.

CSLA stands for Component-based, Scalable Logical Architecture, and is the result of over 12 years worth of research and development. The .NET implementation of CSLA was started in 1999, and development continues today, with the addition of CSLA .NET for Silverlight and upcoming support for Silverlight 3.0 and Microsoft .NET 4.0.

(Updated 5/20/2009)

Original article can be found here

What makes a good Linux distribution?

2009-07-27T02:51:00.001-07:00

By Jack Wallen, Special to ZDNet Asia
Monday, July 27, 2009 12:38 PM

Take the proprietary driver system and installation tools of Ubuntu, add the desktop of Elive+Compiz, add the foundation of Debian, and the security of Bastille Linux and you would have one killer distribution.

Lately, I have written various articles that have stirred the pot regarding the various Linux distributions available. I have heard quite a bit of dislike for Ubuntu, GNOME, and KDE 4. In fact I have heard opinions from people that make me wonder why they even use Linux.

I have come across plenty of distributions that I will never use again. I have played with desktops that will only have ever graced my screen once or twice. But to say I hate them? No matter how much I dislike these tools, they are still a part of the Linux community and that at least gives them some credibility.

But this train of thought started my brain whirring around the idea of "what makes a good Linux distribution?" I thought, what better place to ask this question than here at Techrepublic! Naturally I can't just ask the question without offering up my own opinion on the subject as well.

Standards
I would have liked to think by now all Linux distributions would be following some semblance of standards. I don't find this to be the truth. And why? There';s an organization built around creating standards for Linux. The Linux Standards Base was created to try to set standards for which all distributions could follow. So far this has not paid off. I can understand the struggle, but how hard could it be to set smart guidelines and, if a distribution follows those guidelines, give them some seal of approval.

The Linux community has to understand if standards are set and followed, developement (and acceptance) for the operating system will be that much easier.

Drivers
In order for a distribution to be successful it has to include drivers for hardware to work. Yes this might mean that non-free drivers must be included. But that is a small price to pay for a Linux installation to work. The less distributions work out of the box, the less acceptance and use they will see. This is where the Ubuntu distribution shines. Adding proprietary drivers so that NVidia card will use the correct resolution, or that wireless card will work is simple. More distributions should follow this example.

Desktops
It is clear there are camps for every desktop available to the Linux operating system. And these camps are very vocal in their dislike of the other. GNOME hates KDE hates GNOME hates Enlightenment hates Fluxbox, etc. And it only makes sense that a distribution make a choice for a default. But that doesn't mean the distribution can not offer the other desktops to the user. This should be the case during installation--even with Live CDs.

The installation should ask the user if they want extra desktops installed, or a different desktop installed. Or if that's not the answer - then the installation of said desktops should be made simple with the help of tools like Synaptic. There should be a single check box to install the whole of KDE or GNOME or Enlightenment. Make it easy people! Give the users choice.

Remember the old days of Linux installation where you were asked which desktop you wanted to install? Bring that back. And standards should be followed. A KDE desktop should fundamentally look and feel like any other KDE desktop so users have a better chance of getting used to the Linux desktop.

Help system
For many users that are familiar with Linux, this really isn't an issue. But for new users a good help system is critical. Most help systems included with a distribution generally focus only on the desktop. Add to this some fundamental Linux help and you have a winner.

Make it all work
One of the reasons why the average user doesn't really think twice about their operating system is because when they fire up that PC for the first time everything just works. They don';t have to install a flash plugin or Java or a library so their iPod will connect or they can listen to MP3s. These should all be automatic on every distribution. Period. And the MP3 licensing issue - that needs to seriously go away. People use MP3s. How many times have you had to help someone roll MP3 support into Rhythmbox, Banshee, or XMMS?

Security
Most distributions have this inherent in their systems and subsystems. This could easily fall in line with standards. You have some distributions using SELinux and some not. You have some distributions adding a GUI firewall tool by default and some not. I am not the biggest fan of SELinux only because when it works its best, it can get in the way of applications running (have you had SELinux stop acroread from starting up?). I think the desktop standard should simply be iptables with policies set so that nothing can get in and normal services can get out.

Eye Candy
Let's face it--if you';ve got it, flaunt it. With the help of Compiz, Linux can have the most amazing desktop among all of the operating systems. But in most Compiz-enabled distribution installations I have seen, they have visual effects set to Normal. This leaves out the Compiz Cube, wobbly windows, and a number of other mind-blowing features.

If a machine's hardware can handle it, the default needs to be Extra or Custom. Out of the box (again, if the hardware supports it), all of the Compiz goodness should work. And the key combinations need to be standardized (there it is again!).

Final thoughts
Where do you stand? In your opinion, what makes a good Linux distribution? If you could roll in various aspects of any distro together what would your final results look like? Here';s what I would do:

Jack Wallen was a key player in the introduction of Linux to the original Techrepublic. Beginning with Red Hat 4.2 and a mighty soap box, Jack had found his escape from Windows. It was around Red Hat 6.0 that Jack landed in the hallowed halls of Techrepublic.

Original post can be found here

Simplify calling ASP.NET AJAX services from jQuery

2009-07-22T22:53:00.001-07:00

AJAX, ASP.NET, JavaScript, jQuery By Dave Ward on July 21st, 2009

As jQuery’s popularity in the .NET community has risen over the past year, one recurring theme I’ve seen is the desire to refactor away the details of using it to call ASP.NET AJAX services. Whether through helper function or specialized jQuery plugin, I’ve seen numerous methods proposed and/or in use.

Personally, the syntax never bothered me. The contentType parameter is ugly, but I have a Visual Studio code snippet for the $.ajax call and rarely think about it.

That came to an end earlier this year, when I started using dataFilter. I needed to isolate my code from the “.d” issue, and wanted to take advantage of browser-native JSON parsing in Firefox 3.5 and IE8, which required a bulky dataFilter.

Repeating that entire callback function in every $.ajax call was not acceptable. So, I was happy to learn that jQuery provides an excellent solution for consolidating settings to be used in multiple instances of $.ajax.

In this post, I’ll show you how to use that consolidation feature, and exactly how I am now using that to more simply call ASP.NET AJAX services with jQuery.

Configuring $.ajax’s default settings

Rather than wrapping the $.ajax call in a plugin or helper function, jQuery provides a built-in solution that I think is a better alternative: $.ajaxSetup.

$.ajaxSetup accepts an array of settings that allows you to supply defaults for any of the parameters that you would set in an $.ajax call. Settings like contentType, type, and dataFilter are all fair game, for example.

Using this function, it’s easy to set jQuery’s $.ajax defaults to match the refined settings that we worked out together last year:

   1:  $.ajaxSetup({

   2:    type: "POST",

   3:    contentType: "application/json; charset=utf-8",

   4:    data: "{}"

   5:  });

Because parameters to $.ajax override these defaults, presetting “data” to an empty JSON string is safe. Any $.ajax call that does specify a data parameter will function as expected, since the default will be ignored.

The particular issue caused by forgetting the empty data parameter can be difficult to track down, and only shows up after you’ve deployed your application to IIS. So, having the default as a safety net is recommended.

Adding JSON parsing improvements

Because $.ajaxSetup also supports setting a dataFilter, adding the “.d” isolation and browser-native JSON parsing from my last two posts is easy:

   1:  $.ajaxSetup({

   2:    type: "POST",

   3:    contentType: "application/json; charset=utf-8",

   4:    data: "{}",

   5:    dataFilter: function(data) {

   6:      var msg;   if (typeof (JSON) !== 'undefined' &&

   7:          typeof (JSON.parse) === 'function')

   8:        msg = JSON.parse(data);

   9:      else

  10:        msg = eval('(' + data + ')');   if (msg.hasOwnProperty('d'))

  11:        return msg.d;

  12:      else

  13:        return msg;

  14:    }

  15:  });

This dataFilter processing is actually what pushed me to start using $.ajaxSetup in all of my own projects. It was one thing to accept multiple contentType and method declarations, but repeating the dataFilter for every $.ajax call was more than I could handle.

Putting it to work

With the ASP.NET AJAX defaults set in $.ajaxSetup, all that’s required to call a “ScriptService” or page method is the URL and a success callback:

   1:  $.ajax({

   2:    url: "HelloWorld.asmx/Hello",

   3:    success: function(msg) {

   4:      console.log(msg);

   5:    }

   6:  });

In fact, even the success callback is optional. For example, if you were periodically pinging a “heartbeat” service to keep the user’s session alive, $.ajax would only need the service’s URI.

This more concise syntax makes your service calls far more readable, especially for developers who aren’t familiar with the content-type required by ASP.NET AJAX.

Caution: Sometimes it works too well

While this is a handy way to simplify calls to ASP.NET AJAX services, do understand that $.ajaxSetup applies to all of jQuery’s AJAX derivatives. Setting the default HTTP method and content-type may also impact code and plugins that use jQuery’s built-in communication functionality (e.g. $.getJSON, $.post, etc).

For example, I often use jTemplates as a client-side templating solution. Because its processTemplateURL routine relies on $.ajax to retrieve remote template files, setting the ASP.NET AJAX content-type and POST method in $.ajaxSetup breaks that functionality of jTemplates.

Fixing that problem wasn’t difficult, but it also wasn’t immediately obvious what had caused the issue in the first place. In my experience using this technique, the undesirable side effects are rare enough that it’s not a serious concern, but do be aware of the potential.

Conclusion

I’ve been using this in production for several months now, with great results. Users have noticed the increased speed that came with browser-native JSON parsing, the “.d” isolation has reduced regression errors due to some code we run on both 2.0 and 3.5 servers, and it requires less effort on my part to do all that.

What do you think? Is this helpful?

Would a Visual Studio template with this rolled in be something you would use?

Original post can be found here

Nested LEFT JOINs to link three or more tables

2009-07-21T03:26:00.001-07:00

Posted on Monday 2005.08.15 at 7:38 pm in Everything, Technology

By Ryan McElroy

Note: This post is over 3 years old. It may contain outdated information and broken links. Please temper your expectations accordingly.

I ran into another dilemma in SQL-land today. Working on a money-management application, I had three tables that I wanted to gather information from. This normally leads to some relatively straightforward SQL:
SELECT account.name, contact.name, date, amount, type FROM transactions, accounts, contacts WHERE account_id = accounts.id AND contact_id = contacts.id;
However, this returned results only for transactions that had both matching accounts and matching contacts, while what I wanted was a single record for each transaction, regardless of matching accounts or contacts. For two tables, this would be straightforward with a LEFT JOIN:
SELECT account.name, date, amount, type FROM transactions LEFT JOIN accounts ON account_id = accounts.id;
Which would return a row for every entry in the transactions table even if no matching account was found. I tried extrapolating that two three tables, like this:
SELECT account.name, contact.name, date, amount, type FROM FROM transactions LEFT JOIN accounts, contacts WHERE account_id = accounts.id AND contact_id = contacts.id;
However, this didn’t do what I wanted, and I was getting multiple entries for each transaction. So I googled for help, and Google delivered: Left Joins to link three or more tables. From the information in this article, I was able to develop the SQL code that did exactly what I wanted:
SELECT `accounts`.`name` AS account_name, `contacts`.`name` AS contact_name, `date`, `amount`, `type`, `detail`, `memo`, `cleared` FROM (`transactions` LEFT JOIN `accounts` ON `accounts`.`id` = `account_id`) LEFT JOIN `contacts` ON `contacts`.`id` = `contact_id` WHERE `parent_id` = 0
This returns a single row for each entry in transactions, even if matching accounts and contacts are not found. Esentially, it is a nested LEFT JOIN. First, MySQL left joins transactions and accounts, then it takes this result and similarly left joins contacts. This way, every row in the leftmost table (transactions) is preserved. I might have simply linked to the site, but I didn’t like the naming scheme in the examples on that site (crypic names like bdg and dom don’t earn accolades from me), and I came up with a better article title, “Nested”.

How To Create WordPress Themes From Scratch Part 1

2009-07-16T03:04:00.001-07:00

July 14th, 2008 by kailoon under Tips

I’m going to show you how to create a wordpress theme from scratch in these 3 parts of tutorial series. I will cover from Structuring, designing in Photoshop, slicing, coding into fully css based html, and finally wordpress implementation.

Table Of Content

Below is the index of the topics that we will go through:

Structuring, Designing in Photoshop.
Slicing and Coding.
WordPress Implementation.
1. header.php
2. sidebar.php
3. about.php – a custom file for the about section in the sidebar.
4. footer.php
5. index.php
6. featured-post.php – a custom file for the featured posts.
7. page.php
8. single.php
9. comments.php
10. archives.php, links.php
11. search.php, searchform.php
12. function.php
13. image.php

Structuring

This is a very important part in designing a web layout. We need to structure our layout before open Photoshop. The first thing is the purpose of the layout. In our case, this will be a blog layout for WordPress. So, below is what we have in a blog:

Header
Posting area
Sidebar
Single page
Comment
Feedback
Searching field
Page menu
RSS
Archives, Links and About Page

Something we need to keep in mind. We can’t put all things into one basket. So, we CANNOT:

Display too many things in one single page.
Use too many colors and font type.

In this sample, I also try to make is as simple as possible because the purpose of this series of tutorial is to give an example on how to create a wordpress theme. I am going to have a featured post section on the main page. Below is the Final image that we will create.

Final Result

Photoshop

Step 1

Create a new document with 1024px X 768px as we are going to create a layout which suit for 1024px resolution. Fill it the background layer with #eae8c6. Now, CTRL + R to bring out the ruler. Draw some guide line for the divine proportion we need. Before this, make sure it is snap. Go to View > snap (selected).

Step 2

Grab the rectangle tool and draw a header for it. The height, you have to estimate how much you want. Balance is the main thing you need to concern. Then, apply the blending option as shown below. A black to white gradient with soft light blend mode. Create another rectangle, apply gradient overlay with setting as shown below. Put it 1px below the green bar. It will make it more details. Then, draw a 1 pixel line and put it right above the gap between the two bars you created before. Give it a darker color.

Step 3

I use Myriad Pro. So, you guys can edit it by yourself later. Apply drop shadow with the setting shown below. Then, also apply Gradient Overlay with 12% opacity, black to white. For the white outline stroke. Simply hold the CTRL tab and click on the text layer to get the selection. Go to Select > Modify > Contract > 1px. After that, create a new layer. Go to Edit > Stroke > 1px, white, inside.

Step 4

Draw a rectangle, remember, the maximum width you can use is 600px. Ok, make its white color. Apply 1px inside white stroke. And, Gradient Overlay with the setting as shown below.

Step 5

The read more button is actually using the same technique where we used for the logo. This time, we apply Inner Glow with 8px size and 75% Opacity in Soft Light Blend Mode. Gradient Overlay with 70% opacity also in Soft Light Blend Mode. Finally, A 1px outside stroke with color #47670b. Then, for the 1px inside white stroke. It is same with what we did in step 3.

Step 6

Place in some dummy text and photo. You will have something like this. You can use a text generator for this.

Step 7

Put in some Dummy Text again. Try to use none anti-alias font for testing. Don’t forget what a wordpress theme needed. Post title, tags, post date, comments number. This time, I add in author photo part to be shown in every post.

Step 8

Place a RSS icon. I forgot where I downloaded it already…sorry about that… Then, For the search area, create a rounded rectangle with a maximum width of 330px. Fill it with black color and set it blend mode to soft light. Create another rounded rectangle inside. This will be our input field. Fill it with white color. Apply 1px inside stroke with color – #d0ceae. Then, apply inner Glow, with setting shown below. After that, place the searching icon.

Step 9

Draw a rounded rectangle and use the pen tool to draw a dialog box as shown below. You can refer to my previous tutorial in LoonDesign on how to create a custom shape in photoshop. Then, apply drop shadow on it. Use the rectangle tool to create the categories and links content box. The maximum width will be 160px. We need a 10px space in between them.

Step 10

We are almost there. Now, we will use the same technique we used to create the header part.

Conclusion

You may found that I do not mention about the page navigation part. I think it is too simple for you. Try it out yourself. If really can’t, I am also providing the source file for you here. Overall, there is several things we need to consider when creating a wordpress theme. In this example, we are creating for blogging purpose. So, the major section will be, categories, tagging, author photo, comments and also the RSS feed. I prefer to make things more organizes. So, you can found that all the layers in my psd file are well renamed and each section is well separated. This is for future modification purpose and also for my dear reader to modify it easily.

Single Page

As we are creating theme for wordpress, there must be a single page to display a post and comment section. Here is the final output.

Download and continue

Download Continue read on How To Create WordPress Themes From Scratch Part 2 – Slicing and CSS/XHTML Coding.

Original post can be found here

A Simple Guide to .Net Remoting

2009-07-09T02:32:00.001-07:00

By jamiemoffat

Remoting is .Net’s way to create and uses object instances on a remote machine, without any of the hassle of DCOM.
This guide provides a (very) quick guide to getting you up and running and calling across your network. Most of the examples that Microsoft provide use a console application to host your remote object, which wouldn’t be the way most of us will use the technology.
This tutorial will cover the most common hosting method, which is within IIS.
I haven’t gone too deep into all the settings that are available with .Net Remoting, I will cover those in a future article.
1) Create a C# class that inherits MarshalByRefObject: E.g.


public class myObj : MarshalByRefObject
{
    // ...
}

Add some classes, properties etc.
2) Compile it to produce myObj.dll
3) Now, the object needs to be hosted somewhere. The easiest way to do this is to host the object within IIS.
First of all though, we need to describe our object so it can be accessed. To this end, create a web.config file with the following text:
E.g.


<configuration>
  <system.runtime.remoting>
    <application>
      <service>
        <wellknown mode="SingleCall" type="myNamespace.myObj, myObj"
                        objectUri="myObj.soap" />
      </service>
    </application>
  </system.runtime.remoting>
</configuration>

In this XML:
type ="myNamespace.myObj, myObj" is the full type name, followed by the assembly name.
On the Remote Server:
1) Create a directory called “myRemoteObject”. Create a Bin directory beneath it.
2) Create a new IIS virtual Directory called myIISObj that points to the myRemoteObject directory.
3) Place your compiled versions of myObj.dll in the myRemoteObject \Bin directory
4) Place the Web.Config file in the myRemoteObject directory.
On the Client:
In your application set a reference to the local object on your client machine. This allows he CLR to pick up the meta data of the object so that we can create the object remotely (There is another way to generate the meta data without needing the actual object on the client, a utility called SoapSuds.exe, but I leave that for you to read about )
Now we need a client.config file analogous to the web.config file, which tells the CLR how to access (ie. where to access) the remote object.


<configuration>
  <system.runtime.remoting>
    <application name="Client">
      <client url="http://andy2k/myIISObj">
        <wellknown type="myNamespace.myObj, myObj"
                    url="http://andy2k/myIISObj/myObj.soap"/>
      </client>
      <channels>
        <channel ref="http" />
      </channels>
    </application>
  </system.runtime.remoting>
</configuration>

(Note: replace “andy2k” with the name of your remote server)
Now in the client code, simply create the object as usual but, first of all, load the config file.


//Load the Http Channel from the config file
try
{
    RemotingConfiguration.Configure("client.config");
}
catch{}

//instantiate the remote object on the server
//(this is really just a proxy object here)
myNamespace.myObj anObj = new myNamespace.myObj();

The .Net runtime picks up the fact that this is not a local object (because of the config file read in the previous line) and creates the object on the remote machine. You now access the object as if it was created locally, and .Net does the rest.
(if you’re not convinced, create a method in the class that simply returns a string representing the name of the local machine
Something like:


public string getCompName()
{
    return System.Environment.MachineName;
}

that should convince you that the object has been created on the remote machine)
And there you have it – you’ve just created a remote object!

Original post can be found here

Joining Multiple Tables with SQL Inner Join Statements

2009-07-08T23:02:00.001-07:00

You can use SQL JOIN statements to combine data from three or more tables. In an earlier article, we took a look at using inner joins and outer joins to combine data from two different tables. In many cases, you’ll want to take this a step further and combine data from three or more tables. Let's take a look at the SQL statements that allow you to accomplish this goal for an inner join.
You may recall from our basic inner join example that the SQL statement below combines data from the Drivers and Vehicles tables in cases where the driver and vehicle are located in the same city:

   1:  SELECT lastname, firstname, tag

   2:  FROM drivers, vehicles

   3:  WHERE drivers.location = vehicles.location

This query produced the following results:

lastname firstname tag
-------- --------- ---
Baker Roland H122JM
Smythe Michael D824HA
Smythe Michael P091YF
Jacobs Abraham J291QR
Jacobs Abraham L990MT

Ads by Nielsen Field

Now, let’s extend this example to include a third table. Imagine that you wanted to include only drivers and vehicles present at locations that are open on the weekend. You could bring a third table into your query by extending the JOIN statement as follows:

   1:  SELECT lastname, firstname, tag, open_weekends

   2:  FROM drivers, vehicles, locations

   3:  WHERE drivers.location = vehicles.location

   4:  AND vehicles.location = locations.location

   5:  AND locations.open_weekends = 'Yes'

lastname firstname tag open_weekends
-------- --------- --- -------------
Baker Roland H122JM yes
Jacobs Abraham J291QR yes
Jacobs Abraham L990MT yes

This powerful extension to the basic SQL JOIN statement allows you to combine data in a complex manner. In addition to combining tables with an inner join, you can also use this technique to combine multiple tables using an outer join. As you may recall, outer joins include results that exist in one table but do not have a corresponding match in the joined table.

nopCommerce Open Source E-Commerce Solution

2009-07-07T22:07:00.000-07:00

nopCommerce is an open source e-commerce solution that contains both a catalog frontend and an administration tool backend. nopCommerce is a fully customizable shopping cart. It's stable and highly usable. From downloads to documentation, nopCommerce.com offers a comprehensive base of information, resources, and support to the nopCommerce community.

nopCommerce is new but very popular open source e-commerce solution. nopCommerce is available for free. A solution with comprehensive features that is easy to use for new online businesses, yet powerful enough for the most demanding e-commerce expert. It’s a secure, scalable and extendable e-commerce platform.

Create and manage a professional online store with nopCommerce 1.20. Built-in shopping cart, catalog management, credit card processing, shipping calculation, template customization and other powerful tools come standard.

So join the community and see what you can learn and what you can share!

O'Reilly Webcast: Ten Things Every Software Architect Should Know

2009-07-07T02:31:00.001-07:00

This is the slide deck used in Richard Monson-Haefe more

O'Reilly Webcast: Ten Things Every Software Architect Should Know

View more documents from oreillymedia.

What is ASP.NET Dynamic Data?

2009-07-06T21:23:00.001-07:00

ASP.NET Dynamic Data is a technology from Microsoft that expands the toolset of ASP.NET starting with ASP.NET 3.5 SP1. Use it to build data entry web forms that interact with a database or classes that resemble a database.

s3Slider jQuery plugin

2009-07-01T21:56:00.001-07:00

ABOUT

The s3Slider jQuery plugin is made by example of jd`s smooth slide show script. I needed something like that for jQuery (for my web site kruskica.net). Since i didnt find it after a small research i decided to build it by my self.

HOW TO USE

It is very easy. First include the jQuery library then include the s3Slider javascript in the head of the page(s) where you want to use s3Slider.

jQuery can be download from jQuery`s homepage.

<script src="js/jquery.js" type="text/javascript"></script>

<script src="js/s3Slider.js" type="text/javascript"></script>

Important: For the script to work properly there is a set of rules that must be followed.

HTML

<div id="s3slider">

   <ul id="s3sliderContent">

      <li class="s3sliderImage">

          <img src="#" />

<span>Your text comes here</span>

      </li>

      <li class="s3sliderImage">

          <img src="#" />

<span>Your text comes here</span>

      </li>

      <div class="clear s3sliderImage"></div>

   </ul>

</div>

+ show all of the code

Explanation

If you set that main div id is s3slider as we did here, that is the name that must be prefix for all other classes and id`s for that specific gallery (slide show). For example, if you set an id for main div as your_name, the inner id must be your_nameContent and the class .your_nameImage like in example above.

The second thing is that every .your_nameImage element in it self must have span. Also, the last div with class clear must also have an class of image holder in this case .your_nameImage. if you dont put that, the last image will NOT be shown in the slide show.

CSS

#s3slider {

   width: 400px; /* important to be same as image width */

   height: 300px; /* important to be same as image height */

   position: relative; /* important */

   overflow: hidden; /* important */

#s3sliderContent {

   width: 400px; /* important to be same as image width or wider */

   position: absolute; /* important */

   top: 0; /* important */

   margin-left: 0; /* important */

.s3sliderImage {

   float: left; /* important */

   position: relative; /* important */

   display: none; /* important */

.s3sliderImage span {

   position: absolute; /* important */

   left: 0;

   font: 10px/15px Arial, Helvetica, sans-serif;

   padding: 10px 13px;

   width: 374px;

   background-color: #000;

   filter: alpha(opacity=70); /* here you can set the opacity of box with text */

   -moz-opacity: 0.7; /* here you can set the opacity of box with text */

   -khtml-opacity: 0.7; /* here you can set the opacity of box with text */

   opacity: 0.7; /* here you can set the opacity of box with text */

   color: #fff;

   display: none; /* important */

   top: 0;

/*

       if you put

       top: 0; -> the box with text will be shown at the top of the image

       if you put

       bottom: 0; -> the box with text will be shown at the bottom of the image

*/

.clear {

   clear: both;

+ show all of the code

Then you need to initalize s3Slider and set the duration of how long will one picture be shown on the page (value is in miliseconds).

JS

$(document).ready(function() {

   $('#s3slider').s3Slider({

      timeOut: 4000

});

});

Take a look at the live example.

COPYRIGHT

This script is licensed under Creative Commons Attribution 2.5. So you can use it in all you projects even commercial ones.

More example:

http://www.jsconf2009.com/

Kill Bugs Like a Frog

2009-06-30T21:34:00.001-07:00

GIBRALTAR is very cool! Learn more on their website.

Part logging tool, part application monitor, part profiler.All frog.

Gibraltar isn't really a frog, and it won't turn you into one, either. It just reminds us of one with its simple, natural bug-spotting powers. You can also think of Gibraltar as a flight recorder that monitors your .NET applications making it easier for you to test and support them.

We're proud of Gibraltar, and we'd like to tell you more about it. You can download a full-featured trial now, or check out this short video to learn how Gibraltar can streamline your software testing and support processes for any .NET application.

Gibraltar records and sends error and usage information to your support staff and provides powerful, yet simple analysis and visualization tools so you can triage customer issues faster, better optimize development priorities and continuously improve software quality.

With Gibraltar, you will find and kill software bugs faster and easier than ever before. You'll also provide more effective customer support and have new insights into how users interact with your applications.

So please, click the large triangular play button to the right and watch a short video demonstration of Gibraltar in action. Or click the links to learn more, or download a free trial.

Original post can be found here

Creational Patterns - Singleton

2009-06-26T08:24:00.001-07:00

By Susan Abraham May 31, 2005

Introduction

Most programming involves usage of Design Patterns in one form or other .There are around 23 Design Patterns that are available. They are categorized as given below:

I] Creational Patterns

Singleton
Factory
Abstract Factory
Builder
Prototype

II] Structural Patterns

Adapter
Bridge
Composite
Decorator
Facade
Flyweight
Proxy

III] Behavioral Pattern

Chain Of Responsibility
Command
Interpreter
Iterator
Mediator
Memento
Observer
State
Strategy
Template Method
Visitor

This paper discusses the implementation of the Singleton Design Pattern.

The Concept

Design patterns are commonly defined as time-tested solutions to recurring design problems.

The most striking benefits of Design Patterns are as follows:

They provide you with a way to solve issues related to software development using a proven solution. The solution facilitates the development of highly cohesive modules with minimal coupling. They isolate the variability that may exist in the system requirements, making the overall system easier to understand and maintain.
Design patterns make communication between designers more efficient. Software professionals can immediately picture the high-level design in their thoughts immediately the name of the pattern used to solve a particular issue when discussing system design

Singleton Pattern: In the Singleton Pattern we have at any given instance a single instance of the Singleton Class active. All instantiation of the Singleton Class references the same instance of the Class. The pattern also provides a global point of access to the sole instance of the class.

Class Diagram

Sequence Diagram

Implementation

Steps for implementing the Singleton Pattern:

Step1:
Create a project of type Console Application. Name it SingletonTest.

Step2:
Add a Class File named Singleton and add the following code

/// <summary>
/// Summary description for Singleton.
/// </summary>
public class Singleton
{
//Fields
private static Singleton instance;
/// <summary>
/// Standard default Constructor
/// </summary>
protected Singleton() {}
/// <summary>
/// Static method for creating the single instance
/// of the Constructor
/// </summary>
/// <returns></returns>
public static Singleton Instance()
{
// initialize if not already done
if( instance == null )
instance = new Singleton();
// return the initialized instance of the Singleton Class
return instance;
}
}

Step 3:
Create a Client class that would access the Singleton Class as follows :

/// <summary>
/// Summary description for Client.
/// </summary>
class Client
{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main(string[] args)
{
// Constructor is protected -- cannot use new
Singleton s1 = Singleton.Instance();
Singleton s2 = Singleton.Instance();
if( s1 == s2 )
Console.WriteLine( "The same instance" );
Console.ReadLine();
}
}

Step 4:
Run the Application it would display the following output:

Conclusion

Thus we have implemented the Singleton Design Pattern using the .Net framework.Like any Concepts/Theory Singleton Pattern also has its pros and cons.

Benefits of Singleton Pattern:

Instance control: Singleton prevents other objects from instantiating their own copies of the Singleton object, ensuring that all objects access the single instance.
Flexibility: Because the class controls the instantiation process, the class has the flexibility to change the instantiation process.

Drawbacks of Singleton Pattern:

Overhead. Although the amount is minuscule, there is some overhead involved in checking whether an instance of the class already exists every time an object requests a reference. This problem can be overcome by using static initialization.
Possible development confusion. When using a singleton object (especially one defined in a class library), developers must remember that they cannot use the new keyword to instantiate the object. Because application developers may not have access to the library source code, they may be surprised to find that they cannot instantiate this class directly.
Object lifetime. Singleton does not address the issue of deleting the single object. In languages that provide memory management (for example, languages based on the .NET Framework), only the Singleton class could cause the instance to be deallocated because it holds a private reference to the instance. In languages, such as C++, other classes could delete the object instance, but doing so would lead to a dangling reference inside the Singleton class.

Original Post can be found here

Developer Stuff!

Learn jQuery with FireBug, jQuerify and SelectorGadget

LINQ: Building an IQueryable Provider - Part III

LINQ: Building an IQueryable Provider - Part II

LINQ: Building an IQueryable Provider - Part I

A Defense of Reflection in .NET

Introduction

What's Wrong With Reflection

Performance

Security

Confusion

Why Use Reflection?

Developer Performance

Stability / Consistency

Practical Applications

Tweaking Performance

CopyTo

MapDataToBusinessEntityCollection

Timing Studies

Conclusion

Free ebook on C# 3.0

Custom Persister to store the state in a backend database

.NET: Getting the Path of the Executing Assembly

.NET: Retrieving Assembly Attributes

SQL SERVER – Get Time in Hour:Minute Format from a Datetime – Get Date Part Only from Datetime

Setting up Visual Studio Intellisense for jQuery

by Ralph Whitbeck

Setting up Your Files for jQuery IntelliSense

IntelliSense in external JavaScript files

IntelliSense inline on your ASPX page

Related Links

Update

Web Content Accessibility Guidelines (WCAG) 2.0

Abstract

What is CSLA .NET?

What makes a good Linux distribution?

Simplify calling ASP.NET AJAX services from jQuery

AJAX, ASP.NET, JavaScript, jQuery By Dave Ward on July 21st, 2009

Configuring $.ajax’s default settings

Adding JSON parsing improvements

Putting it to work

Caution: Sometimes it works too well

Conclusion

Nested LEFT JOINs to link three or more tables

Posted on Monday 2005.08.15 at 7:38 pm in Everything, Technology

How To Create WordPress Themes From Scratch Part 1

July 14th, 2008 by kailoon under Tips

Table Of Content

Structuring

Final Result

Photoshop

Step 1

Step 2

Step 3

Step 4

Step 5

Step 6

Step 7

Step 8

Step 9

Step 10

Conclusion

Single Page

Download and continue

Related Posts:

A Simple Guide to .Net Remoting

Joining Multiple Tables with SQL Inner Join Statements

Suggested Reading

nopCommerce Open Source E-Commerce Solution

O'Reilly Webcast: Ten Things Every Software Architect Should Know

What is ASP.NET Dynamic Data?

s3Slider jQuery plugin

ABOUT

HOW TO USE

HTML

Explanation

CSS

JS

COPYRIGHT

Kill Bugs Like a Frog